- Microsoft dependency injection / options

README.md

@@ -16,31 +16,24 @@ Start a new **Console Application** project called `RecallQuickstart` and select
 PM> Install-Package Shuttle.Recall.Sql.Storage
 ```
 
-Now we'll need select one of the [supported containers](https://shuttle.github.io/shuttle-core/container/shuttle-core-container.html#implementations):
+This provides a SQL-based store for doamin events.
 
-```
-PM> Install-Package Shuttle.Core.Ninject
-```
-
-Since we will be interacting with Sql Server we will be using the [Shuttle.Core.Data](https://shuttle.github.io/shuttle-core/data/shuttle-core-data.html) data access components as well as the `System.Data.Client` package:
+> Install the `System.Data.SqlClient` nuget package.
 
-```
-PM> Install-Package Shuttle.Core.Data
-PM> Install-Package System.Data.Client
-```
+This will provide a connection to our Sql Server.
 
 Now we'll define the domain event that will represent a state change in the `Name` attribute:
 
-``` c#
+```c#
 public class Renamed
 {
     public string Name { get; set; }
 }
 ```
 
-Next we'll create our `Aggregate Root` that will make use of an `EventStream` to save it's states:
+Next we'll create our `Aggregate Root`.  In a real-world scenario the aggregate in our domain would be something like `Customer`, `Member`, `Invoice`, and so forth.  The aggregate will make use of an `EventStream` to save the changes in the state:
 
-``` c#
+```c#
 using System;
 using System.Collections.Generic;
 
@@ -84,53 +77,41 @@ Create a new Sql Server database called `RecallQuickstart` to store our events a
 %userprofile%\.nuget\packages\shuttle.recall.sql.storage\{version}\scripts\System.Data.SqlClient\EventStoreCreate.sql
 ```
 
-Add the relevant `connectionString` to the `App.config` file:
-
-``` xml
-<configuration>
-  <connectionStrings>
-    <add 
-        name="EventStore" 
-        providerName="System.Data.SqlClient" 
-        connectionString="Data Source=.;Initial Catalog=RecallQuickstart;user id=sa;password=Pass!000" 
-    />
-  </connectionStrings>
-</configuration>
-```
-
 Next we'll use event sourcing to store an rehydrate our aggregate root from the `Main()` entry point:
 
 ``` c#
-using System;
 using System.Data.Common;
 using System.Data.SqlClient;
-using Ninject;
+using Microsoft.Extensions.DependencyInjection;
 using Shuttle.Core.Data;
-using Shuttle.Core.Ninject;
 using Shuttle.Recall;
 using Shuttle.Recall.Sql.Storage;
 
 namespace RecallQuickstart
 {
     internal class Program
     {
-        private static void Main()
+        static void Main(string[] args)
         {
             DbProviderFactories.RegisterFactory("System.Data.SqlClient", SqlClientFactory.Instance);
 
-            var container = new NinjectComponentContainer(new StandardKernel());
+            var services = new ServiceCollection();
+
+            services
+                .AddDataAccess(builder =>
+                {
+                    builder.AddConnectionString("EventStore", "System.Data.SqlClient",
+                        "Data Source=.;Initial Catalog=RecallQuickstart;user id=sa;password=Pass!000");
 
-            // This registers the event store dependencies provided by Shuttle.Recall
-            container.RegisterEventStore();
+                    builder.Options.DatabaseContextFactory.DefaultConnectionStringName = "EventStore";
+                })
+                .AddSqlEventStorage()
+                .AddEventStore();
 
-            // This registers the sql server implementations provided by Shuttle.Recall.Sql.Storage
-            container.RegisterEventStoreStorage();
-
-            // This registers the ado.net components provided by Shuttle.Core.Data
-            container.RegisterDataAccess();
+            var provider = services.BuildServiceProvider();
 
-            var databaseContextFactory = container.Resolve<IDatabaseContextFactory>();
-            var store = container.Resolve<IEventStore>();
+            var databaseContextFactory = provider.GetRequiredService<IDatabaseContextFactory>();
+            var store = provider.GetRequiredService<IEventStore>();
 
             var id = Guid.NewGuid();
 

Shuttle.Recall.Tests/ProjectionEventProviderFixture.cs

@@ -28,7 +28,7 @@ public void Should_be_able_to_use_provider()
 
             eventProcessor.Setup(m => m.GetProjectionAggregation(It.IsAny<Guid>())).Returns(projectionAggregation);
 
-            var provider = new ProjectionEventProvider(Options.Create(new EventStoreOptions()), eventProcessor.Object, GetRepository());
+            var provider = new ProjectionEventProvider(Options.Create(new EventStoreOptions()), eventProcessor.Object, GetQuery());
 
             ProjectionEvent projectionEvent;
 
@@ -57,9 +57,9 @@ public void Should_be_able_to_use_provider()
             Assert.That(projectionAggregation.IsEmpty, Is.True);
         }
 
-        private IPrimitiveEventRepository GetRepository()
+        private IPrimitiveEventQuery GetQuery()
         {
-            var repository = new Mock<IPrimitiveEventRepository>();
+            var query = new Mock<IPrimitiveEventQuery>();
             var events = new List<PrimitiveEvent>();
 
             for (int i = 0; i < 10; i++)
@@ -70,11 +70,11 @@ private IPrimitiveEventRepository GetRepository()
                 });
             }
 
-            repository.SetupSequence(m => m.Fetch(It.IsAny<long>(), It.IsAny<int>(), It.IsAny<IEnumerable<Type>>()))
+            query.SetupSequence(m => m.Search(It.IsAny<PrimitiveEvent.Specification>()))
                 .Returns(events)
                 .Returns(new List<PrimitiveEvent>());
 
-            return repository.Object;
+            return query.Object;
         }
 
         public void ProcessEvent(IEventHandlerContext<TestEvent> context)

Shuttle.Recall/EventEnvelopeConfigurator.cs → Shuttle.Recall/EventEnvelopeBuilder.cs

@@ -1,33 +1,33 @@
-using System;
-using System.Collections.Generic;
-using Shuttle.Core.Contract;
-
-namespace Shuttle.Recall
-{
-    public class EventEnvelopeConfigurator
-    {
-        public EventEnvelopeConfigurator()
-        {
-            Headers = new List<EnvelopeHeader>();
-        }
-
-        public List<EnvelopeHeader> Headers { get; set; }
-
-        public EventEnvelope EventEnvelope(object @event, string encryptionAlgorithm, string compressionAlgorithm)
-        {
-            Guard.AgainstNull(@event, nameof(@event));
-
-            var result = new EventEnvelope
-            {
-                AssemblyQualifiedName = @event.GetType().AssemblyQualifiedName,
-                EncryptionAlgorithm = encryptionAlgorithm,
-                CompressionAlgorithm = compressionAlgorithm,
-                EventDate = DateTime.UtcNow
-            };
-
-            result.Headers.Merge(Headers);
-
-            return result;
-        }
-    }
+using System;
+using System.Collections.Generic;
+using Shuttle.Core.Contract;
+
+namespace Shuttle.Recall
+{
+    public class EventEnvelopeBuilder
+    {
+        public EventEnvelopeBuilder()
+        {
+            Headers = new List<EnvelopeHeader>();
+        }
+
+        public List<EnvelopeHeader> Headers { get; set; }
+
+        public EventEnvelope EventEnvelope(object @event, string encryptionAlgorithm, string compressionAlgorithm)
+        {
+            Guard.AgainstNull(@event, nameof(@event));
+
+            var result = new EventEnvelope
+            {
+                AssemblyQualifiedName = @event.GetType().AssemblyQualifiedName,
+                EncryptionAlgorithm = encryptionAlgorithm,
+                CompressionAlgorithm = compressionAlgorithm,
+                EventDate = DateTime.UtcNow
+            };
+
+            result.Headers.Merge(Headers);
+
+            return result;
+        }
+    }
 }

Shuttle.Recall/EventProcessing/ProjectionEventProvider.cs

@@ -7,21 +7,20 @@ namespace Shuttle.Recall
     public class ProjectionEventProvider : IProjectionEventProvider
     {
         private readonly IEventProcessor _eventProcessor;
-        private readonly IPrimitiveEventRepository _repository;
+        private readonly IPrimitiveEventQuery _query;
         private readonly EventStoreOptions _eventStoreOptions;
         private long _sequenceNumberHead;
 
-        public ProjectionEventProvider(IOptions<EventStoreOptions> eventStoreOptions, IEventProcessor eventProcessor,
-            IPrimitiveEventRepository repository)
+        public ProjectionEventProvider(IOptions<EventStoreOptions> eventStoreOptions, IEventProcessor eventProcessor, IPrimitiveEventQuery query)
         {
             Guard.AgainstNull(eventStoreOptions, nameof(eventStoreOptions));
             Guard.AgainstNull(eventStoreOptions.Value, nameof(eventStoreOptions.Value));
             Guard.AgainstNull(eventProcessor, nameof(eventProcessor));
-            Guard.AgainstNull(repository, nameof(repository));
+            Guard.AgainstNull(query, nameof(query));
 
             _eventStoreOptions = eventStoreOptions.Value;
             _eventProcessor = eventProcessor;
-            _repository = repository;
+            _query = query;
         }
 
         public ProjectionEvent Get(Projection projection)
@@ -43,7 +42,7 @@ public ProjectionEvent Get(Projection projection)
 
                 if (!projectionAggregation.ContainsPrimitiveEvent(sequenceNumber))
                 {
-                    foreach (var primitiveEvent in _repository.Fetch(sequenceNumber, _eventStoreOptions.ProjectionEventFetchCount,  projectionAggregation.EventTypes))
+                    foreach (var primitiveEvent in _query.Search(new PrimitiveEvent.Specification().WithRange(sequenceNumber, _eventStoreOptions.ProjectionEventFetchCount).AddEventTypes(projectionAggregation.EventTypes)))
                     {
                         projectionAggregation.AddPrimitiveEvent(primitiveEvent);
 

Shuttle.Recall/EventStore.cs

@@ -44,7 +44,7 @@ public long Save(EventStream eventStream)
             return Save(eventStream, null);
         }
 
-        public long Save(EventStream eventStream, Action<EventEnvelopeConfigurator> configure)
+        public long Save(EventStream eventStream, Action<EventEnvelopeBuilder> builder)
         {
             Guard.AgainstNull(eventStream, nameof(eventStream));
 
@@ -64,9 +64,9 @@ public long Save(EventStream eventStream, Action<EventEnvelopeConfigurator> conf
 
             try
             {
-                var configurator = new EventEnvelopeConfigurator();
+                var configurator = new EventEnvelopeBuilder();
 
-                configure?.Invoke(configurator);
+                builder?.Invoke(configurator);
 
                 pipeline.Execute(eventStream, configurator);
 

Shuttle.Recall/EventStream.cs

@@ -47,7 +47,7 @@ public EventStream(Guid id, int version, IEnumerable<DomainEvent> events, IEvent
         public int Version { get; }
         public object Snapshot { get; private set; }
 
-        public int Count => (_events?.Count() ?? 0) + _appendedEvents.Count;
+        public int Count => (_events?.Count ?? 0) + _appendedEvents.Count;
 
         public bool IsEmpty => Count == 0;
 

Shuttle.Recall/IEventStore.cs

@@ -8,7 +8,7 @@ public interface IEventStore
         EventStream CreateEventStream();
         EventStream Get(Guid id);
         long Save(EventStream eventStream);
-        long Save(EventStream eventStream, Action<EventEnvelopeConfigurator> configurator);
+        long Save(EventStream eventStream, Action<EventEnvelopeBuilder> builder);
         void Remove(Guid id);
     }
 }

Shuttle.Recall/IPrimitiveEventQuery.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+namespace Shuttle.Recall
+{
+    public interface IPrimitiveEventQuery
+    {
+        IEnumerable<PrimitiveEvent> Search(PrimitiveEvent.Specification specification);
+    }
+}

Shuttle.Recall/IPrimitiveEventRepository.cs

@@ -7,7 +7,6 @@ public interface IPrimitiveEventRepository
     {
         void Remove(Guid id);
         IEnumerable<PrimitiveEvent> Get(Guid id);
-        IEnumerable<PrimitiveEvent> Fetch(long fromSequenceNumber, int count, IEnumerable<Type> eventTypes);
         long Save(PrimitiveEvent primitiveEvent);
         long GetSequenceNumber(Guid id);
     }

Shuttle.Recall/Pipeline/PipelineStateExtensions.cs

@@ -67,14 +67,14 @@ public static EventStream GetEventStream(this IState state)
             return state.Get<EventStream>(StateKeys.EventStream);
         }
 
-        public static void SetEventEnvelopeConfigurator(this IState state, EventEnvelopeConfigurator value)
+        public static void SetEventEnvelopeConfigurator(this IState state, EventEnvelopeBuilder value)
         {
             state.Replace(StateKeys.EventEnvelopeConfigurator, value);
         }
 
-        public static EventEnvelopeConfigurator GetEventEnvelopeConfigurator(this IState state)
+        public static EventEnvelopeBuilder GetEventEnvelopeConfigurator(this IState state)
         {
-            return state.Get<EventEnvelopeConfigurator>(StateKeys.EventEnvelopeConfigurator);
+            return state.Get<EventEnvelopeBuilder>(StateKeys.EventEnvelopeConfigurator);
         }
 
         public static void SetEvents(this IState state, IEnumerable<DomainEvent> value)

Shuttle.Recall/Pipeline/Pipelines/SaveEventStreamPipeline.cs

@@ -25,12 +25,12 @@ public SaveEventStreamPipeline(IAssembleEventEnvelopesObserver assembleEventEnve
             RegisterObserver(eventStreamObserver);
         }
 
-        public void Execute(EventStream eventStream, EventEnvelopeConfigurator configurator)
+        public void Execute(EventStream eventStream, EventEnvelopeBuilder builder)
         {
             Guard.AgainstNull(eventStream, nameof(eventStream));
 
             State.SetEventStream(eventStream);
-            State.SetEventEnvelopeConfigurator(configurator);
+            State.SetEventEnvelopeConfigurator(builder);
 
             Execute();
         }