inklabs/rangedb

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
    }

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func (s *remoteStore) EventsByStream(ctx context.Context, streamSequenceNumber uint64, streamName string) rangedb.RecordIterator {
    request := &rangedbpb.EventsByStreamRequest{
        StreamName:           streamName,
        StreamSequenceNumber: streamSequenceNumber,
    }

• Read up
  Read up

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 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 hashicorpVaultKeyStore.Set has 7 return statements (exceeds 4 allowed).

Open

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

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)

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func (s *remoteStore) EventsByAggregateTypes(ctx context.Context, globalSequenceNumber uint64, aggregateTypes ...string) rangedb.RecordIterator {
    request := &rangedbpb.EventsByAggregateTypeRequest{
        AggregateTypes:       aggregateTypes,
        GlobalSequenceNumber: globalSequenceNumber,
    }

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

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

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 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 dynamoDBKeyStore.Get has 6 return statements (exceeds 4 allowed).

Open

func (d *dynamoDBKeyStore) Get(subjectID string) (string, error) {
    input := &dynamodb.GetItemInput{
        Key: map[string]*dynamodb.AttributeValue{
            "SubjectID": {
                S: aws.String(subjectID),

Method gcm.decrypt has 6 return statements (exceeds 4 allowed).

Open

func (e *gcm) decrypt(key, sealedCipherText []byte) ([]byte, error) {
    if len(sealedCipherText) == 0 {
        return nil, crypto.ErrInvalidCipherText
    }
 
 

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

Open

func (s *postgresStore) readResultRecords(ctx context.Context, rows *sql.Rows, resultRecords chan rangedb.ResultRecord) (int, error) {
    recordsRead := 0
    for rows.Next() {
        var (
            streamName           string

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 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.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 {

Method levelDbStore.saveEvent has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

func (s *levelDbStore) saveEvent(ctx context.Context, transaction *leveldb.Transaction, streamName, aggregateType, aggregateID, eventType, eventID string, expectedStreamSequenceNumber *uint64, event, metadata interface{}) ([]byte, uint64, error) {

Function AllEventsConfig has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

func AllEventsConfig(ctx context.Context, store rangedb.Store, broadcaster broadcast.Broadcaster, bufferLength int, consumeRecord ConsumeRecordFunc) Config {

Method postgresStore.saveEvents has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

    ctx context.Context,
    transaction *sql.Tx,
    expectedStreamSequenceNumber *uint64,
    streamName string,
    eventRecords []*rangedb.EventRecord,

Method rangeDBServer.EventsByStream has 5 return statements (exceeds 4 allowed).

Open

func (s *rangeDBServer) EventsByStream(req *rangedbpb.EventsByStreamRequest, stream rangedbpb.RangeDB_EventsByStreamServer) error {
    recordIterator := s.store.EventsByStream(stream.Context(), req.StreamSequenceNumber, req.StreamName)
 
    for recordIterator.Next() {
        if recordIterator.Err() != nil {