neptuo / framework Goto Github PK

Currently, keys can be compared only using Equals method.
This is quite boring..

Remove our version of IDisposable.
Add extension method IsDisposed() which will try to cast a System.IDisposable to DisposableBase.

Loading aggregate state using constructor with enumeration of events doesn't set version property. This causes saving next produced events with wrong version.

We should consider supporting version defined in other way than using a Version property.

1. For some cases it could be detected from (type) name.

Add support for attributes in the TokenWriter. By using Format overload, which takes delegate with different argument, support attributes in the format string.

This way we can define template like "Hello, {Name DefaultValue=World!}". So if the name is specified, use it, other wise use default value attribute (this would be decided by the delegate passed to the Format method).

Add information about serialized/deserialized type + current value.

• Text readers.
• Tokenizers.
• Curly tokenizer.
• Curly nodes & builder.

IConverterRepository is great for single-use converting from/to different types. But when we want to convert from concrete type to concrete type multiple times, it can be quite slow, because of repetitive searching for converter.

We should introduce method GetConverter which would return Func<TSource, TTarget> or OutFunc<TSource, TTarget, bool> which could be used for multiple conversions.

The returned Func will behave just like the Converts.To and OutFunc like Converts.Try. We should also support for getting conversion (throws when to such converter) function and try-getting.

When the exception is raised during creation of aggregate root, there is no way to pair it with the posted command.

In a typical EventSourcing scenario, a command handler method a single line of code calling aggregate root method and passing in parameters.

So, we could simplify command handler implementation by registering a lambda method to execute.

These commands are persisted using ICommandStore.
We need a way to load them, remove a ExecuteAt from envelope and schedule them again.

The last step should check whether a ISchedulingContexts with a same Key are scheduled and if, remove them from the queue.
Then run those commands/events like new ones.

Timers doesn't support long term scheduling.

These commands should be stored in kind of queues checked periodically. So when scheduling command for 3 months, instead of creating Timer, place it in the queue that will be checked tomorrow.

Add a constructor overload with instance of the IConverterRepository.

This should be used in the default branch of early every enum switch operation.

We need a mechanism for transferring type (aka C# class) to IKey.Type and back.
Also this should be used to test if passed key is of required type.

We should support two scenarios, which share a common logic.

1. Live visualization of event stream.

• Best suited for rare cases.
• Need for enumeration of aggregates.

2. Build projection for stream visualization.

• Need for building separate projection.
• Performance agnostic.

In both modes, the outcome for every event should by a model with description and a list of properties, where each property has description and human readable (string) value.

IEventStore should support replaying events in an order of creation on particular event handler to support rebuilding new/updated read model.

For simple scenarios it should support passing in the event handler instance. The event store should find which events are handled by this handler and replay those.

Remove calling to System.GC.SuppressFinalize in javascript version of Neptuo.

• Remove CreateChild from IDependencyProvider. Move it to extension method resolving IDependencyContainerFactory with Create(string) method.
• Associate IDependencyCollection with concrete scope to add possibility to register "singletons" without explicitly passing current scope name.
• Update Unity implementation.
• Update Simple implementation.
• Fix tests.

Ensure.Positive missing support for decimal type

Like in the Neptuo.Queries, add AddAll method to the Neptuo.Commands and Neptuo.Events.

Consider replacing threads by tasks / task scheduler.

Add support for passing in a component that counts command execution duration.

We should support serialization on the side of store implementation.

Add support for passing in the generic converter ICoverterContext. It should contain instance of IConverterRepository.

When aggregates are public, they should not implement IEventHandler to support self events. This way someone can cast them and use PublishAsync method to change state.

We could use some conventions to find methods for apply state.

Add TwoWayConverter<T1, T2> for converters that support conversions from T1 to T2 and also from T2 to T1.

Store and load version property of every event.
Use this property for ordering events when loading aggregate state.

To solve #43 we would need a way to initialize default instance accessible from Converts.Repository.

We would provide static methods for passing in required parameters. If these methods will be called after initialization of repository instance, it will simply throw an exception.

Add optional ILog parameter and support logging.

We need to log every handled event and command on every handler, whether it failed or succeeded. It could be also be beneficial to log registrations.

Create infrastructure builder full of extension methods for instantiating CQRS infrastructure.

We could use IValidationDispatcher in the PersistentCommandDispatcher to validate command just before passing it the ICommnadHandler.

It not CQRS by nature, but we can benefit here in some scenarios.

1. Commands can be created directly from the client application.
2. Commands can be created as POCO and then validated.
3. Some of the logic currently placed in aggregates, can be moved here.

In the first two use-cases, the command validation can be run before placing command to the processing queue.
In the last one, the validation must be executed just before passing command to the handler.

Add support for snapshots of AggregateRoot state to prevent loading all events.

Stores must support optional transactions. Also, these transactions must be transferable to the handler implementations.

TODO

• Async variants.
• Class ReprocessAsync with delay and returning tasks in all methods.
• Unify interface for TryCatch and Reprocess.

AggregateRootException, as a base exception raising during command processing should contain AggregateRootKey (which will be Key.Empty for commands creating aggregates) and possibly also a CommandKey.

When processing commands from ProcessRoot, these commands are stored in the ICommandStore twice. First call is from the ProcessRootRepository where all pending commands are stored. The second one is from PersistentCommandDispatcher where each command is persisted.

There are two possible solutions. The first one is to leave this problem to the implementation of ICommandStore. Here's one problem with the doubled serialization of a command.

The second one is to pass some flag to the persistent dispatcher to skip persisting these commands. It could be through some parameter in the envelope.

Add method ThrowWhenDisposed to the DisposableBase. It is useful when inherited classes want to check whether it is or not disposed.

Because destructors move objects automatically into the Gen1, we should use them only when needed.

Add constructor parameter to the DefaultConveterRepository to catch all exceptions and mark such conversions as unsuccessful.

When calling generic method, parameter types can be omitted, which may shorten the written code quite a bit.

new GetterFactory<IRepository<User, IKey>>(CreateUserRepository) is long!

We should support stop propagation of exception to next handler in pipeline. As IExceptionHandler<T> is already defined and returns void, we could do it in a way Events and Commands does.

Add options for extending an Envelope metadata by useful auditing information.
This way we can opt-in an execution timestamp or user identifier of user who invoked the operation.

Consider adding a method for testing whether the converter from source to target is registered.

The exception messages are not easy to understand.

E.g.: Misspelled constructor parameter name when using convention-over-configuration.

IApplicationContext, aka returning to the Engine.Environment.

• General/framework classes must provide constructor with parameters.
• Optionally there would be a second constructor taking IApplicationContext.
• There must not be default constructor using static instance of the IApplicationContext (no static app context).

The Keys used in the extension methods must go from the most concrete to more general. E.g.: We can register "global" formatter under key "Formatter". Then, in the event sourcing, when we try to resolve formatter, we should search for "EventSourcing.Events.Formatter", then "EventSourcing.Formatter" and at last "Formatter". This way, we can create more and more specific services.

So the context must be hierarchical. Every level in the hierarchy will have reference for the parent and the service finding will probe to the higher levels until the service is found.