File eventstore.go has 760 lines of code (exceeds 500 allowed). Consider refactoring.

Open

package eventstore
 
import (
    "bytes"
    "context"

Method eventStore.EventsByStream has a Cognitive Complexity of 49 (exceeds 20 allowed). Consider refactoring.

Open

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

• Read up
  Read up

Method eventStore.Events has a Cognitive Complexity of 46 (exceeds 20 allowed). Consider refactoring.

Open

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

• Read up
  Read up

Method eventStore.EventsByAggregateTypes has a Cognitive Complexity of 43 (exceeds 20 allowed). Consider refactoring.

Open

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

• Read up
  Read up

Method eventStore.EventsByStream has 100 lines of code (exceeds 50 allowed). Consider refactoring.

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.Events has 85 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

eventStore has 22 methods (exceeds 20 allowed). Consider refactoring.

Open

type eventStore struct {
    client              *esdb.Client
    clock               clock.Clock
    streamPrefixer      StreamPrefixer
    uuidGenerator       shortuuid.Generator

Method eventStore.EventsByAggregateTypes has 79 lines of code (exceeds 50 allowed). Consider refactoring.

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 eventStore.saveEvents has 77 lines of code (exceeds 50 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")
    }
 
 

Method eventStore.startSubscription has a Cognitive Complexity of 26 (exceeds 20 allowed). Consider refactoring.

Open

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

• Read up
  Read up

Method eventStore.startSubscription has 55 lines of code (exceeds 50 allowed). Consider refactoring.

Open

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

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

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

Open

func (s *eventStore) AggregateTypesSubscription(ctx context.Context, bufferSize int, subscriber rangedb.RecordSubscriber, aggregateTypes ...string) rangedb.RecordSubscription {
    return recordsubscriber.New(
        recordsubscriber.AggregateTypesConfig(ctx, s, s.broadcaster, bufferSize,
            aggregateTypes,
            func(record *rangedb.Record) error {

• Read up
  Read up

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

Open

func (s *eventStore) AllEventsSubscription(ctx context.Context, bufferSize int, subscriber rangedb.RecordSubscriber) rangedb.RecordSubscription {
    return recordsubscriber.New(
        recordsubscriber.AllEventsConfig(ctx, s, s.broadcaster, bufferSize,
            func(record *rangedb.Record) error {
                subscriber.Accept(record)

• Read up
  Read up