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

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,

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 CustomerAddedBirth.Decrypt has 5 return statements (exceeds 4 allowed).

Open

func (e *CustomerAddedBirth) Decrypt(encryptor crypto.Encryptor) error {
    decryptedBirthMonth, err := encryptor.Decrypt(e.ID, e.BirthMonthEncrypted)
    if err != nil {
        if err == crypto.ErrKeyWasDeleted {
            e.redactPersonalData("")

Method levelDbStore.saveEvent has 5 return statements (exceeds 4 allowed).

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) {
 
    select {
    case <-ctx.Done():
        return nil, 0, context.Canceled

Method cbcPKCS5Padding.decrypt has 5 return statements (exceeds 4 allowed).

Open

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

Method postgresStore.eventRecordsToBatchRecords has 5 return statements (exceeds 4 allowed).

Open

func (s *postgresStore) eventRecordsToBatchRecords(eventRecords []*rangedb.EventRecord, streamName string, streamSequenceNumber uint64) ([]*batchSQLRecord, error) {
    aggregateType := eventRecords[0].Event.AggregateType()
    aggregateID := eventRecords[0].Event.AggregateID()
 
    var batchEvents []*batchSQLRecord

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 {

Method api.saveEvents has 5 return statements (exceeds 4 allowed).

Open

func (a *api) saveEvents(w http.ResponseWriter, r *http.Request) {
    if r.Header.Get("Content-Type") != "application/json" {
        http.Error(w, "invalid content type", http.StatusBadRequest)
        return
    }

Method postgresStore.transactionalSaveEvents has 5 return statements (exceeds 4 allowed).

Open

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

Method remoteStore.OptimisticDeleteStream has 5 return statements (exceeds 4 allowed).

Open

func (s *remoteStore) OptimisticDeleteStream(ctx context.Context, expectedStreamSequenceNumber uint64, streamName string) error {
    request := &rangedbpb.OptimisticDeleteStreamRequest{
        ExpectedStreamSequenceNumber: expectedStreamSequenceNumber,
        StreamName:                   streamName,
    }

Method eventStore.saveEvents has a Cognitive Complexity of 22 (exceeds 20 allowed). Consider refactoring.

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")
    }
 
 

• Read up
  Read up