feat: Annotated agent signatures (#36)

Author: ellamosi

src/EntityDb.Abstractions/Annotations/IEntitiesAnnotation.cs

@@ -0,0 +1,31 @@
+using EntityDb.Abstractions.ValueObjects;
+
+namespace EntityDb.Abstractions.Annotations;
+
+/// <summary>
+///     Represents data for multiple entities that have already been committed, along with relevant information not contained
+///     in the data.
+/// </summary>
+/// <typeparam name="TData">The type of data.</typeparam>
+public interface IEntitiesAnnotation<out TData>
+{
+    /// <summary>
+    ///     The transaction id associated with the data.
+    /// </summary>
+    Id TransactionId { get; }
+
+    /// <summary>
+    ///     The transaction timestamp associated with the data.
+    /// </summary>
+    TimeStamp TransactionTimeStamp { get; }
+
+    /// <summary>
+    ///     The entity ids associated with the data.
+    /// </summary>
+    Id[] EntityIds { get; }
+
+    /// <summary>
+    ///     The data.
+    /// </summary>
+    TData Data { get; }
+}

src/EntityDb.Abstractions/Transactions/ITransactionRepository.cs

@@ -110,6 +110,14 @@ public interface ITransactionRepository : IDisposableResource
     /// <returns>The tags which are found by <paramref name="tagQuery" />.</returns>
     Task<ITag[]> GetTags(ITagQuery tagQuery, CancellationToken cancellationToken = default);
 
+    /// <summary>
+    ///     Returns the annotated agent signatures which are found by an agent signature query.
+    /// </summary>
+    /// <param name="agentSignatureQuery">The agent signature query.</param>
+    /// <param name="cancellationToken">A cancellation token.</param>
+    /// <returns>The annotated agent signatures which are found by <paramref name="agentSignatureQuery" />.</returns>
+    Task<IEntitiesAnnotation<object>[]> GetAnnotatedAgentSignatures(IAgentSignatureQuery agentSignatureQuery, CancellationToken cancellationToken = default);
+
     /// <summary>
     ///     Returns the annotated commands which are found by a command query.
     /// </summary>

src/EntityDb.Common/Annotations/EntitiesAnnotation.cs

@@ -0,0 +1,34 @@
+using EntityDb.Abstractions.Annotations;
+using EntityDb.Abstractions.ValueObjects;
+using System;
+
+namespace EntityDb.Common.Annotations;
+
+internal record EntitiesAnnotation<TData>
+(
+    Id TransactionId,
+    TimeStamp TransactionTimeStamp,
+    Id[] EntityIds,
+    TData Data
+) : IEntitiesAnnotation<TData>
+{
+    public static IEntitiesAnnotation<TData> CreateFromBoxedData
+    (
+        Id transactionId,
+        TimeStamp transactionTimeStamp,
+        Id[] entityIds,
+        object boxedData
+    )
+    {
+        var dataAnnotationType = typeof(EntitiesAnnotation<>).MakeGenericType(boxedData.GetType());
+
+        return (IEntitiesAnnotation<TData>)Activator.CreateInstance
+        (
+            dataAnnotationType,
+            transactionId,
+            transactionTimeStamp,
+            entityIds,
+            boxedData
+        )!;
+    }
+}

src/EntityDb.Common/Annotations/EntityAnnotation.cs

@@ -1,6 +1,4 @@
-using EntityDb.Abstractions.Annotations;
-using EntityDb.Abstractions.Transactions;
-using EntityDb.Abstractions.Transactions.Steps;
+using EntityDb.Abstractions.Annotations;
 using EntityDb.Abstractions.ValueObjects;
 using System;
 

src/EntityDb.Common/Transactions/TransactionRepositoryWrapper.cs

@@ -80,6 +80,11 @@ public Task<ITag[]> GetTags(ITagQuery tagQuery, CancellationToken cancellationTo
         return WrapQuery(() => _transactionRepository.GetTags(tagQuery, cancellationToken));
     }
 
+    public Task<IEntitiesAnnotation<object>[]> GetAnnotatedAgentSignatures(IAgentSignatureQuery agentSignatureQuery, CancellationToken cancellationToken = default)
+    {
+        return WrapQuery(() => _transactionRepository.GetAnnotatedAgentSignatures(agentSignatureQuery, cancellationToken));
+    }
+
     public Task<IEntityAnnotation<object>[]> GetAnnotatedCommands(ICommandQuery commandQuery, CancellationToken cancellationToken = default)
     {
         return WrapQuery(() => _transactionRepository.GetAnnotatedCommands(commandQuery, cancellationToken));

src/EntityDb.MongoDb/Extensions/DocumentQueryExtensions.cs

@@ -121,6 +121,29 @@ CancellationToken cancellationToken
             .ToArray();
     }
 
+    public static async Task<IEntitiesAnnotation<TData>[]> GetEntitiesAnnotation<TDocument, TData>
+    (
+        this DocumentQuery<TDocument> documentQuery,
+        IMongoSession mongoSession,
+        IEnvelopeService<BsonDocument> envelopeService,
+        CancellationToken cancellationToken
+    )
+        where TDocument : IEntitiesDocument
+        where TData : notnull
+    {
+        var documents = await documentQuery.Execute(mongoSession, NoDocumentIdProjection, cancellationToken);
+
+        return documents
+            .Select(document => EntitiesAnnotation<TData>.CreateFromBoxedData
+            (
+                document.TransactionId,
+                document.TransactionTimeStamp,
+                document.EntityIds,
+                envelopeService.Reconstruct<TData>(document.Data)
+            ))
+            .ToArray();
+    }
+
     public static async Task<TData[]> GetData<TDocument, TData>
     (
         this DocumentQuery<TDocument> documentQuery,

src/EntityDb.MongoDb/Transactions/MongoDbTransactionRepository.cs

@@ -117,6 +117,13 @@ public Task<ITag[]> GetTags(ITagQuery tagQuery, CancellationToken cancellationTo
             .GetData<TagDocument, ITag>(_mongoSession, _envelopeService, cancellationToken);
     }
 
+    public Task<IEntitiesAnnotation<object>[]> GetAnnotatedAgentSignatures(IAgentSignatureQuery agentSignatureQuery, CancellationToken cancellationToken = default)
+    {
+        return AgentSignatureDocument
+            .GetQuery(agentSignatureQuery)
+            .GetEntitiesAnnotation<AgentSignatureDocument, object>(_mongoSession, _envelopeService, cancellationToken);
+    }
+
     public Task<IEntityAnnotation<object>[]> GetAnnotatedCommands(ICommandQuery commandQuery, CancellationToken cancellationToken = default)
     {
         return CommandDocument

src/EntityDb.Void/Transactions/VoidTransactionRepository.cs

@@ -17,6 +17,7 @@ internal sealed class VoidTransactionRepository : DisposableResourceBaseClass, I
     private static readonly Task<object[]> EmptyObjectArrayTask = Task.FromResult(Array.Empty<object>());
     private static readonly Task<ILease[]> EmptyLeaseArrayTask = Task.FromResult(Array.Empty<ILease>());
     private static readonly Task<ITag[]> EmptyTagArrayTask = Task.FromResult(Array.Empty<ITag>());
+    private static readonly Task<IEntitiesAnnotation<object>[]> EmptyEntitiesAnnotationArrayTask = Task.FromResult(Array.Empty<IEntitiesAnnotation<object>>());
     private static readonly Task<IEntityAnnotation<object>[]> EmptyEntityAnnotationArrayTask = Task.FromResult(Array.Empty<IEntityAnnotation<object>>());
     private static readonly Task<bool> TrueBoolTask = Task.FromResult(true);
 
@@ -80,6 +81,11 @@ public Task<ITag[]> GetTags(ITagQuery tagQuery, CancellationToken cancellationTo
         return EmptyTagArrayTask.WaitAsync(cancellationToken);
     }
 
+    public Task<IEntitiesAnnotation<object>[]> GetAnnotatedAgentSignatures(IAgentSignatureQuery agentSignatureQuery, CancellationToken cancellationToken = default)
+    {
+        return EmptyEntitiesAnnotationArrayTask.WaitAsync(cancellationToken);
+    }
+
     public Task<IEntityAnnotation<object>[]> GetAnnotatedCommands(ICommandQuery commandQuery, CancellationToken cancellationToken = default)
     {
         return EmptyEntityAnnotationArrayTask.WaitAsync(cancellationToken);

test/EntityDb.Common.Tests/Transactions/TransactionTests.cs

@@ -755,6 +755,65 @@ public async Task GivenNonUniqueLeases_WhenInsertingLeaseDocuments_ThenReturnFal
         transactionInserted.ShouldBeFalse();
     }
 
+    [Theory]
+    [MemberData(nameof(AddTransactions))]
+    public async Task GivenCommandInserted_WhenGettingAnnotatedAgentSignature_ThenReturnAnnotatedAgentSignature(TransactionsAdder transactionsAdder)
+    {
+        // ARRANGE
+
+        const ulong expectedCount = 5;
+
+        using var serviceScope = CreateServiceScope(serviceCollection =>
+        {
+            transactionsAdder.Add(serviceCollection);
+        });
+
+        var transactionTimeStamp = TimeStamp.UtcNow;
+
+        var expectedTransactionId = Id.NewId();
+        var expectedEntityId = Id.NewId();
+        var expectedTransactionTimeStamps = new[]
+        {
+            transactionTimeStamp,
+
+            // A TimeStamp can be more precise than milliseconds.
+            // This allows for database types that cannot be more precise than milliseconds.
+            transactionTimeStamp.WithMillisecondPrecision()
+        };
+
+        var agentSignature = new CounterAgentSignature(123);
+
+        var transaction = BuildTransaction(serviceScope, expectedTransactionId, expectedEntityId,
+            new[] { expectedCount }, transactionTimeStamp, agentSignature);
+
+        await using var transactionRepository = await serviceScope.ServiceProvider
+            .GetRequiredService<ITransactionRepositoryFactory>()
+            .CreateRepository(TestSessionOptions.Write);
+
+        var transactionInserted = await transactionRepository.PutTransaction(transaction);
+
+        var agentSignatureQuery = new EntityIdQuery(expectedEntityId);
+
+        // ARRANGE ASSERTIONS
+
+        transactionInserted.ShouldBeTrue();
+
+        // ACT
+
+        var annotatedAgentSignatures = await transactionRepository.GetAnnotatedAgentSignatures(agentSignatureQuery);
+
+        // ASSERT
+
+        annotatedAgentSignatures.Length.ShouldBe(1);
+
+        annotatedAgentSignatures[0].TransactionId.ShouldBe(expectedTransactionId);
+        annotatedAgentSignatures[0].EntityIds.Length.ShouldBe(1);
+        annotatedAgentSignatures[0].EntityIds[0].ShouldBe(expectedEntityId);
+        annotatedAgentSignatures[0].Data.ShouldBe(agentSignature);
+
+        expectedTransactionTimeStamps.Contains(annotatedAgentSignatures[0].TransactionTimeStamp).ShouldBeTrue();
+    }
+
     [Theory]
     [MemberData(nameof(AddTransactions))]
     public async Task GivenCommandInserted_WhenGettingAnnotatedCommand_ThenReturnAnnotatedCommand(TransactionsAdder transactionsAdder)

test/EntityDb.Common.Tests/Transactions/TryCatchTransactionRepositoryTests.cs

@@ -74,6 +74,10 @@ public async Task GivenRepositoryAlwaysThrows_WhenExecutingAnyMethod_ThenExcepti
             .Setup(repository => repository.GetTags(It.IsAny<ITagQuery>(), It.IsAny<CancellationToken>()))
             .ThrowsAsync(new NotImplementedException());
 
+        transactionRepositoryMock
+            .Setup(repository => repository.GetAnnotatedAgentSignatures(It.IsAny<IAgentSignatureQuery>(), It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new NotImplementedException());
+
         transactionRepositoryMock
             .Setup(repository => repository.GetAnnotatedCommands(It.IsAny<ICommandQuery>(), It.IsAny<CancellationToken>()))
             .ThrowsAsync(new NotImplementedException());