dario-l/ses

SimpleEventStore is a simple event store library for .NET based on rdbms persistance.

**Ses is dead. Long live https://github.com/getmanta/manta ** ...but is still used in production code.

SimpleEventStore

SimpleEventStore

SimpleEventStore.Abstracts

SimpleEventStore.Domain

SimpleEventStore.MsSql

SimpleEventStore.Subscriptions

SimpleEventStore.Subscriptions.MsSql

SimpleEventStore is a simple event store library for .NET based on rdbms persistance.

Main goals

• Async all the way down (sync methods also available)
• No external dependencies
• Pluggable persistance storage
• Support optimistic (and pesimistic for special cases) concurrency with conflict resolver mechanism
• Support any kind of serialization through ISerializer interface
• Support any kind of loggers through ILogger interface
• Support up-conversion of events/snapshots to the newest version
• Subscriptions to one or many event stream sources for processmanagers/projections/others (with pluggable stream pollers)
• Built-in implementation for: MS SQL Server, InMemory
• Built-in single-writer pattern for MS SQL Server implementation (Linearizer)

Basic example of usage

var options = new TransactionOptions {IsolationLevel = IsolationLevel.ReadCommitted};
using (var scope = new TransactionScope(TransactionScopeOption.RequiresNew, options, TransactionScopeAsyncFlowOption.Enabled))
{
    var aggregate = new ShoppingCart();
    aggregate.AddItem(SequentalGuid.NewGuid(), name: "Product 1", quantity: 3);


    var stream = new EventStream(id, aggregate.TakeUncommittedEvents());

    // Adding metadata item (key, value)
    stream.Metadata = new Dictionary<string, object>
    {
        { "RequestIP", "0.0.0.0" },
        { "User", "John Doe" }
    };

    var expectedVersion = aggregate.CommittedVersion + stream.Events.Count;
    await _store.SaveChangesAsync(aggregate.Id, expectedVersion, stream);

    scope.Complete();
}

Using repository pattern:

// Usually transaction scope will be hidden somewhere in infrastructural part of code
using (var scope = new TransactionScope(TransactionScopeOption.RequiresNew, options, TransactionScopeAsyncFlowOption.Enabled))
{
    using (var repo = new SourcedRepo<ShoppingCart>(store))
    {
        // Open stream and restore aggregate from history
        var aggregate = await repo.LoadAsync(id);

        aggregate.AddItem(Guid.NewGuid(), "Product 1", 3);

        await repo.SaveChangesAsync(aggregate);
    }
    scope.Complete();
}

It is working on production already

SimpleEventStore has used in commercial project https://timeharmony.pl already.

ses's Issues

Needs for documentation

Exceptions clean up

Improve internal logging

Use ILogger

IEventStreamPersistor.Load(Async) should return raw data from the store

Loading methods should read all required data from the store and close immediately connection.

Introduce CommitMetadata and StreamMetadata

CommitMetadata
Each metadata of this type should be correlated with persisted commit (one transaction = one commit).

Example:

{
    "UserId": "9023hdf9238h203h",
    "RequestIp": "127.0.0.1"
}

Currently CommitMetadata is (badly) named StreamMetadata.

StreamMetadata
This type of metadata should be correlated with whole stream of events for all commits.

Example:

{
    "AggregateClrType": "Namespace.TypeName",
    "MaxAge": "14days"
}

New ideas

This issue is for writing some new ideas for next version:

• stream id as char(60)
• state of aggregate is not the same as the snapshot (!!!)
• different metadata (stored separately - no duplication every row)
  • stream metadata
  • commit metadata
• truncating streams
  • by id
  • before event id
  • max date
  • max count
• statistics
• interceptors (eg: caching)
• performance (!?)
  • single round-trip to the database server (TVP is no-no, too sloooooow)
  • optimized and fine tuned indexes
• deleted stream should discard all events and publish StreamDeletedEvent instead (to inform subscribers)
  • truncating should do the same, that is publish StreamTruncatedEvent
• should have an option to make stream read-only
• no sprocs (tests shows that is not needed)
• projections
  • projector should not update checkpoint in datastore when event is not handled by projection
  • subscribing should be more explicit
  • replaying projections needs more love (eg: waiting for catching up)
• tracking (metadata or dedicated columns in MsSql implementation ?)
  • eventId
  • correlationId
  • causationId

Introduce projection retries

MsSql implementation needs a little polish

• count(1) replace with exists()
• replace static numbers with named constants

Implement conflict resolver

Idnetifiers should be strings not just guids

Sometimes you know upfront how identifier is created and you can store it as some joined elements of string.

Destroy script is not working

Droping index IX_Streams_EventId_InternalId DML has no table specified.

Repository Load should return null when aggregate not exists

Currently when loading non-existent stream repository throws. Better approach is when repository return null. Consumer can decide what to do further.

Returning pollers state

AggregateSnapshot should return State as IMemento

Current implementation of AggregateSnapshot do not allow to replace snapshot instance. Aggregate should have possibility to return any type of IMemento implementation.

public override IAggregateSnapshot GetSnapshot()
{
    return new AggregateSnapshot(CurrentVersion, new MyNewSnapshot());
}

Things to do:

• AggregateSnapshot class should be public
• AggregateSnapshot should not be generic
• AggregateSnapshot should return State as IMemento