evolution

Author: Glauco-Havan

RoyalCode.EnterprisePatterns/Directory.Build.props

@@ -1,16 +1,16 @@
 <Project>
 	<PropertyGroup>
-		<LibTargets>netstandard2.1;net8</LibTargets>
+		<LibTargets>net8</LibTargets>
 		<AspTargets>net8</AspTargets>
 		<MsgTargets>net8</MsgTargets>
 	</PropertyGroup>
 	<PropertyGroup>
 
 		<DomainVer>1.0.0</DomainVer>
-		<DomainPreview>-preview-6.0</DomainPreview>
+		<DomainPreview>-preview-7.0</DomainPreview>
 
 		<PersistVer>1.0.0</PersistVer>
-		<PersistPreview>-preview-6.0</PersistPreview>
+		<PersistPreview>-preview-7.0</PersistPreview>
 
 		<CommandVer>0.1.0</CommandVer>
 		<CommandPreview>-preview-1</CommandPreview>

RoyalCode.EnterprisePatterns/RoyalCode.Outbox.Api/OutboxApi.cs

@@ -17,24 +17,34 @@ public static class OutboxApi
     /// <summary>
     /// Adds/Maps the endpoints for reading the Outbox via HTTP.
     /// </summary>
-    /// <param name="group"></param>
-    public static void MapOutbox(this RouteGroupBuilder group)
+    /// <param name="app">Application endpoint router.</param>
+    /// <param name="groupPrefix">Optional, group prefix, default is 'outbox'.</param>
+    public static void MapOutbox(this IEndpointRouteBuilder app, string groupPrefix = "outbox")
     {
-        var outboxGroup = group.MapGroup("outbox")
+        var outboxGroup = app.MapGroup(groupPrefix)
             .WithName("outbox")
             .WithDescription("Outbox API");
 
-        outboxGroup.MapPost("consumer", RegisterConsumerAsync)
+        outboxGroup.MapOutbox();
+    }
+
+    /// <summary>
+    /// Adds/Maps the endpoints for reading the Outbox via HTTP.
+    /// </summary>
+    /// <param name="group">The RouteGroup.</param>
+    public static void MapOutbox(this RouteGroupBuilder group)
+    {
+        group.MapPost("consumer", RegisterConsumerAsync)
             .WithName("register-consumer")
             .WithDescription("Register a new outbox consumer")
             .WithOpenApi();
 
-        outboxGroup.MapGet("consumer/{consumer}/messages", GetConsumerMessagesAsync)
+        group.MapGet("consumer/{consumer}/messages", GetConsumerMessagesAsync)
             .WithName("get-outbox-messages")
             .WithDescription("get the outbox next messages for the consumer")
             .WithOpenApi();
 
-        outboxGroup.MapPost("consumer/{consumer}/commit", CommitConsumedAsync)
+        group.MapPost("consumer/{consumer}/commit", CommitConsumedAsync)
             .WithName("commit-consumed-outbox-messages")
             .WithDescription("Commit the consumed messages")
             .WithOpenApi();

RoyalCode.EnterprisePatterns/RoyalCode.Repositories.Abstractions/DataServices.cs

@@ -1,5 +1,6 @@
 
 using RoyalCode.Entities;
+using RoyalCode.SmartValidations.Entities;
 using System.Diagnostics.CodeAnalysis;
 
 namespace RoyalCode.Repositories.Abstractions;
@@ -17,6 +18,7 @@ namespace RoyalCode.Repositories.Abstractions;
 /// </remarks>
 /// <typeparam name="TEntity">The entity type.</typeparam>
 public interface IAdder<in TEntity>
+    where TEntity : class
 {
     /// <summary>
     /// <para>
@@ -33,6 +35,22 @@ public interface IAdder<in TEntity>
     /// <param name="entity">The new entity instance.</param>
     void Add(TEntity entity);
 
+    /// <summary>
+    /// <para>
+    ///     Adds a new entity to the repository to be persisted.
+    /// </para>
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    ///     When implemented together with the Unit Of Work pattern the entity 
+    ///     will not be persisted directly when calling this method, 
+    ///     it will be stored in memory until the completion of the unit of work.
+    /// </para>
+    /// </remarks>
+    /// <param name="entity">The new entity instance.</param>
+    /// <param name="token">Cancellation token.</param>
+    ValueTask AddAsync(TEntity entity, CancellationToken token = default);
+
     /// <summary>
     /// <para>
     ///     Adds a collection of new entities to the repository to be persisted.
@@ -56,6 +74,7 @@ public interface IAdder<in TEntity>
 /// </summary>
 /// <typeparam name="TEntity">The entity type.</typeparam>
 public interface IFinder<TEntity>
+    where TEntity : class
 {
     /// <summary>
     /// <para>
@@ -83,6 +102,21 @@ public interface IFinder<TEntity>
     /// </para>
     /// </returns>
     ValueTask<TEntity?> FindAsync(object id, CancellationToken token = default);
+
+    /// <summary>
+    /// <para>
+    ///     Try to find an existing entity through its unique identity (Id).
+    /// </para>
+    /// </summary>
+    /// <typeparam name="TId">The type o entity id.</typeparam>
+    /// <param name="id">The entity id.</param>
+    /// <param name="token">Cancellation token.</param>
+    /// <returns>
+    /// <para>
+    ///     An entry representing the entity record obtained from the database.
+    /// </para>
+    /// </returns>
+    ValueTask<Entry<TEntity, TId>> FindAsync<TId>(Id<TEntity, TId> id, CancellationToken token = default);
 }
 
 /// <summary>
@@ -99,7 +133,7 @@ public interface IFinder<TEntity>
 /// </remarks>
 /// <typeparam name="TEntity">The entity type.</typeparam>
 public interface IFinderByGuid<TEntity>
-    where TEntity : IHasGuid
+    where TEntity : class, IHasGuid
 {
     /// <summary>
     /// <para>
@@ -145,7 +179,7 @@ public interface IFinderByGuid<TEntity>
 /// <typeparam name="TEntity">The entity type.</typeparam>
 /// <typeparam name="TCode">The code type.</typeparam>
 public interface IFinderByCode<TEntity, in TCode>
-    where TEntity : IHasCode<TCode>
+    where TEntity : class, IHasCode<TCode>
 {
     /// <summary>
     /// <para>
@@ -190,6 +224,7 @@ public interface IFinderByCode<TEntity, in TCode>
 [SuppressMessage("Major Code Smell", "S2326:Unused type parameters should be removed", 
     Justification = "Update an entity, used to identify the entity")]
 public interface IUpdater<TEntity>
+    where TEntity : class
 {
     /// <summary>
     /// <para>
@@ -272,6 +307,37 @@ IEnumerable<bool> MergeRange<TId>(IEnumerable<IHasId<TId>> models)
     /// </returns>
     Task<bool> MergeAsync<TId>(IHasId<TId> model, CancellationToken token = default);
 
+    /// <summary>
+    /// <para>
+    ///     Operation to merge a data model to an existing entity.
+    /// </para>
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    ///     The data model should have an id, which will be used to get the entity from the database.
+    /// </para>
+    /// <para>
+    ///     The fields of the data model should be the same as the entity's fields.
+    /// </para>
+    /// <para>
+    ///     When implemented together with the Unit Of Work pattern the entity 
+    ///     will not be persisted directly when calling this method, 
+    ///     it will be stored in memory until the completion of the unit of work.
+    /// </para>
+    /// </remarks>
+    /// <typeparam name="TId">The Id type.</typeparam>
+    /// <typeparam name="TModel">The model with the data.</typeparam>
+    /// <param name="id">The id value.</param>
+    /// <param name="model">The model.</param>
+    /// <param name="token">Cancellation token.</param>
+    /// <returns>
+    /// <para>
+    ///     True if the entity exists and has been updated, false otherwise.
+    /// </para>
+    /// </returns>
+    Task<bool> MergeAsync<TId, TModel>(Id<TEntity, TId> id, TModel model, CancellationToken token = default)
+        where TModel : class;
+
     /// <summary>
     /// <para>
     ///     Operation to merge a data model to an existing entity.
@@ -315,6 +381,7 @@ async Task<IEnumerable<bool>> MergeRangeAsync<TId>(
 /// </remarks>
 /// <typeparam name="TEntity">Tipo da entidade.</typeparam>
 public interface IRemover<TEntity>
+    where TEntity : class
 {
     /// <summary>
     /// <para>

RoyalCode.EnterprisePatterns/RoyalCode.Repositories.Abstractions/Id.cs

@@ -0,0 +1,60 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+
+namespace RoyalCode.Repositories.Abstractions;
+
+/// <summary>
+/// Type to define the identity of an entity.
+/// </summary>
+/// <typeparam name="TEntity">Entity type.</typeparam>
+/// <typeparam name="TId">Type of identity value.</typeparam>
+public readonly struct Id<TEntity, TId>
+    where TEntity : class
+{
+    /// <summary>
+    /// Implicit operator to convert the identity value to the identity type.
+    /// </summary>
+    /// <param name="id"></param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator Id<TEntity, TId>(TId id) => new(id);
+
+    /// <summary>
+    /// Creates new value for the organisation's identity.
+    /// </summary>
+    /// <param name="value"></param>
+    public Id(TId value) => Value = value;
+
+    /// <summary>
+    /// The value of the entity's identity.
+    /// </summary>
+    public TId Value { get; }
+
+    /// <summary>
+    /// String parse for the entity's identity type.
+    /// </summary>
+    /// <param name="input">Input, in string format.</param>
+    /// <param name="id">Output, in the entity's identity type.</param>
+    /// <returns>True if the parse was possible, false otherwise.</returns>
+    public static bool TryParse(string? input, out Id<TEntity, TId> id)
+    {
+        if (input == null)
+        {
+            id = default;
+            return true;
+        }
+
+        try
+        {
+            var converter = TypeDescriptor.GetConverter(typeof(TId));
+            if (converter is not null && converter.CanConvertFrom(typeof(string)))
+            {
+                id = new Id<TEntity, TId>((TId)converter.ConvertFromString(input)!);
+                return true;
+            }
+        }
+        catch { /* Ignore exceptions, return false at the end. */ }
+
+        id = default;
+        return false;
+    }
+}