Method eventStore.Events has 11 return statements (exceeds 4 allowed).

Open

func (s *eventStore) Events(ctx context.Context, globalSequenceNumber uint64) rangedb.RecordIterator {
    resultRecords := make(chan rangedb.ResultRecord)
 
    go func() {
        defer close(resultRecords)

Method eventStore.EventsByStream has 11 return statements (exceeds 4 allowed).

Open

func (s *eventStore) EventsByStream(ctx context.Context, streamSequenceNumber uint64, streamName string) rangedb.RecordIterator {
    resultRecords := make(chan rangedb.ResultRecord)
 
    go func() {
        defer close(resultRecords)

Method eventStore.saveEvents has 10 return statements (exceeds 4 allowed).

Open

func (s *eventStore) saveEvents(ctx context.Context, expectedStreamSequenceNumber *uint64, streamName string, eventRecords ...*rangedb.EventRecord) (uint64, error) {
    if len(eventRecords) < 1 {
        return 0, fmt.Errorf("missing events")
    }
 
 

Method remoteStore.OptimisticSave has 9 return statements (exceeds 4 allowed).

Open

func (s *remoteStore) OptimisticSave(ctx context.Context, expectedStreamSequenceNumber uint64, streamName string, eventRecords ...*rangedb.EventRecord) (uint64, error) {
    if len(eventRecords) < 1 {
        return 0, fmt.Errorf("missing events")
    }
 
 

Method eventStore.startSubscription has 8 return statements (exceeds 4 allowed).

Open

func (s *eventStore) startSubscription() {
    ctx := context.Background()
    opts := esdb.SubscribeToAllOptions{
        From: esdb.Start{},
    }

Method eventStore.EventsByAggregateTypes has 8 return statements (exceeds 4 allowed).

Open

func (s *eventStore) EventsByAggregateTypes(ctx context.Context, globalSequenceNumber uint64, aggregateTypes ...string) rangedb.RecordIterator {
    resultRecords := make(chan rangedb.ResultRecord)
 
    go func() {
        defer close(resultRecords)

Method remoteStore.Save has 8 return statements (exceeds 4 allowed).

Open

func (s *remoteStore) Save(ctx context.Context, streamName string, eventRecords ...*rangedb.EventRecord) (uint64, error) {
    if len(eventRecords) < 1 {
        return 0, fmt.Errorf("missing events")
    }
 
 

Method levelDbStore.OptimisticDeleteStream has 8 return statements (exceeds 4 allowed).

Open

func (s *levelDbStore) OptimisticDeleteStream(ctx context.Context, expectedStreamSequenceNumber uint64, streamName string) error {
    select {
    case <-ctx.Done():
        return context.Canceled
 
 

Method postgresStore.OptimisticDeleteStream has 7 return statements (exceeds 4 allowed).

Open

func (s *postgresStore) OptimisticDeleteStream(ctx context.Context, expectedStreamSequenceNumber uint64, streamName string) error {
    transaction, err := s.db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }

Function AggregateTypesConfig has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

func AggregateTypesConfig(ctx context.Context, store rangedb.Store, broadcaster broadcast.Broadcaster, bufferLength int, aggregateTypes []string, consumeRecord ConsumeRecordFunc) Config {

Method remoteStore.readRecords has a Cognitive Complexity of 23 (exceeds 20 allowed). Consider refactoring.

Open

func (s *remoteStore) readRecords(ctx context.Context, events PbRecordReceiver) rangedb.RecordIterator {
    resultRecords := make(chan rangedb.ResultRecord)
 
    go func() {
        defer close(resultRecords)

• Read up
  Read up

Method levelDbStore.saveEvents has 7 return statements (exceeds 4 allowed).

Open

func (s *levelDbStore) saveEvents(ctx context.Context, expectedStreamSequenceNumber *uint64, streamName string, eventRecords ...*rangedb.EventRecord) (uint64, error) {
    if len(eventRecords) < 1 {
        return 0, fmt.Errorf("missing events")
    }
 
 

Method hashicorpVaultKeyStore.Set has 7 return statements (exceeds 4 allowed).

Open

func (h *hashicorpVaultKeyStore) Set(subjectID, key string) error {
    if key == "" {
        return crypto.ErrInvalidKey
    }
 
 

Avoid deeply nested control flow statements.

Open

                        if serializedFields == nil {
                            serializedFields = make(map[string]string)
                        }

Method hashicorpVaultKeyStore.Get has 7 return statements (exceeds 4 allowed).

Open

func (h *hashicorpVaultKeyStore) Get(subjectID string) (string, error) {
    request, err := http.NewRequest(http.MethodGet, h.getPath(subjectID), nil)
    if err != nil {
        return "", err
    }

Method remoteStore.readRecords has 7 return statements (exceeds 4 allowed).

Open

func (s *remoteStore) readRecords(ctx context.Context, events PbRecordReceiver) rangedb.RecordIterator {
    resultRecords := make(chan rangedb.ResultRecord)
 
    go func() {
        defer close(resultRecords)

Method postgresStore.saveEvents has 6 return statements (exceeds 4 allowed).

Open

func (s *postgresStore) saveEvents(
    ctx context.Context,
    transaction *sql.Tx,
    expectedStreamSequenceNumber *uint64,
    streamName string,

Method eventStore.OptimisticDeleteStream has 6 return statements (exceeds 4 allowed).

Open

func (s *eventStore) OptimisticDeleteStream(ctx context.Context, expectedStreamSequenceNumber uint64, streamName string) error {
    versionedStreamName := s.streamName(streamName)
    tombstoneStreamOptions := esdb.TombstoneStreamOptions{
        ExpectedRevision: esdb.Revision(zeroBasedSequenceNumber(expectedStreamSequenceNumber)),
        Authenticated:    nil,

Method inMemoryStore.saveEvents has 6 return statements (exceeds 4 allowed).

Open

func (s *inMemoryStore) saveEvents(ctx context.Context, expectedStreamSequenceNumber *uint64, streamName string, eventRecords ...*rangedb.EventRecord) (uint64, error) {
    if len(eventRecords) < 1 {
        return 0, fmt.Errorf("missing events")
    }
 
 

Method eventStore.waitForScavenge has 6 return statements (exceeds 4 allowed).

Open

func (s *eventStore) waitForScavenge(ctx context.Context) {
    log.Print("starting scavenge")
    uri := "http://0.0.0.0:2113/admin/scavenge"
    req, err := http.NewRequestWithContext(ctx, http.MethodPost, uri, nil)
    if err != nil {