Release Codename 'Aragorn'

.github/workflows/dotnet-library.yml

@@ -1,7 +1,7 @@
 name: .NET Library CI/CD
 
 env:
-  PRERELEASE_BRANCHES: eventsource # Comma separated list of prerelease branch names. 'alpha,rc, ...'
+  PRERELEASE_BRANCHES: aragorn # Comma separated list of prerelease branch names. 'alpha,rc, ...'
   CASCADES: "" # Comma separated list of cascading repos. 'dolittle/DotNet.SDK,...'
   NUGET_OUTPUT: Artifacts/NuGet
   COVERAGE_FOLDER: Coverage
@@ -55,9 +55,18 @@ jobs:
           version: ${{ steps.context.outputs.current-version }}
           release-type: ${{ steps.context.outputs.release-type }}
 
+      - name: Create release notes
+        id: create-release-notes
+        if: ${{ steps.context.outputs.should-publish == 'true' }}
+        uses: dolittle/create-release-notes-action@v1
+        with:
+          body: ${{ steps.context.outputs.pr-body }}
+          version: ${{ steps.increment-version.outputs.next-version }}
+          changelog-url: https://github.com/dolittle/DotNET.SDK/blob/master/CHANGELOG.md
+          output-format: msbuild
       - name: Create packages
         if: ${{ steps.context.outputs.should-publish == 'true' }}
-        run: dotnet pack --no-build --configuration Release -o ${{ env.NUGET_OUTPUT }} -p:PackageVersion=${{ steps.increment-version.outputs.next-version }} -p:IncludeSymbols=true -p:SymbolPackageFormat=snupkg
+        run: dotnet pack --configuration Release -o ${{ env.NUGET_OUTPUT }} -p:Version=${{ steps.increment-version.outputs.next-version }} -p:PackageVersion=${{ steps.increment-version.outputs.next-version }} -p:IncludeSymbols=true -p:SymbolPackageFormat=snupkg -p:PackageReleaseNotes="${{ steps.create-release-notes.outputs.plaintext }}"
 
       - name: Prepend to Changelog
         if: ${{ steps.context.outputs.should-publish == 'true' && steps.context.outputs.release-type != 'prerelease' }}

Source/Aggregates/AggregateRootAlias.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Dolittle.SDK.Concepts;
+
+namespace Dolittle.SDK.Aggregates
+{
+    /// <summary>
+    /// Represents the alias of an event type.
+    /// </summary>
+    public class AggregateRootAlias : ConceptAs<string>
+    {
+        /// <summary>
+        /// Implicitly convert from a <see cref="string"/> to an <see cref="AggregateRootAlias"/>.
+        /// </summary>
+        /// <param name="alias">AggregateRootAlias as <see cref="string"/>.</param>
+        public static implicit operator AggregateRootAlias(string alias) => new AggregateRootAlias { Value = alias };
+    }
+}

Source/Aggregates/AggregateRootAttribute.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
+using Dolittle.SDK.Artifacts;
 using Dolittle.SDK.Events;
 
 namespace Dolittle.SDK.Aggregates
@@ -16,11 +17,15 @@ public class AggregateRootAttribute : Attribute
         /// Initializes a new instance of the <see cref="AggregateRootAttribute"/> class.
         /// </summary>
         /// <param name="id">The unique identifier.</param>
-        public AggregateRootAttribute(string id) => Id = id;
+        /// <param name="alias">The alias for the aggregate root.</param>
+        public AggregateRootAttribute(string id, string alias = default)
+        {
+            Type = new AggregateRootType(id, Generation.First, alias);
+        }
 
         /// <summary>
-        /// Gets the <see cref="AggregateRootId" />.
+        /// Gets the <see cref="AggregateRootType"/>.
         /// </summary>
-        public AggregateRootId Id { get; }
+        public AggregateRootType Type { get; }
     }
 }

Source/Aggregates/AggregateRootExtensions.cs

@@ -46,7 +46,7 @@ public static AggregateRootId GetAggregateRootId(this AggregateRoot aggregateRoo
             var aggregateRootType = aggregateRoot.GetType();
             var aggregateRootAttribute = aggregateRootType.GetCustomAttribute<AggregateRootAttribute>();
             if (aggregateRootAttribute == null) throw new MissingAggregateRootAttribute(aggregateRootType);
-            return aggregateRootAttribute.Id;
+            return aggregateRootAttribute.Type.Id;
         }
 
         static Dictionary<Type, MethodInfo> GetHandleMethodsFor(Type aggregateRootType)

Source/Aggregates/AggregateRootIdCannotBeNull.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using Dolittle.SDK.Events;
+
+namespace Dolittle.SDK.Aggregates
+{
+    /// <summary>
+    /// Exception that gets thrown when trying to construct an <see cref="AggregateRootType"/> without an <see cref="AggregateRootId"/>.
+    /// </summary>
+    public class AggregateRootIdCannotBeNull : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateRootIdCannotBeNull"/> class.
+        /// </summary>
+        public AggregateRootIdCannotBeNull()
+            : base($"The {nameof(AggregateRootId)} of an {nameof(AggregateRootType)} cannot be null")
+        {
+        }
+    }
+}

Source/Aggregates/AggregateRootType.cs

@@ -0,0 +1,79 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Dolittle.SDK.Artifacts;
+using Dolittle.SDK.Events;
+
+namespace Dolittle.SDK.Aggregates
+{
+    /// <summary>
+    /// Represents the type of an event.
+    /// </summary>
+    public class AggregateRootType : Artifact<AggregateRootId>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateRootType"/> class.
+        /// </summary>
+        /// <param name="id">The <see cref="EventTypeId">unique identifier</see> of the <see cref="AggregateRootType"/>.</param>
+        public AggregateRootType(AggregateRootId id)
+            : this(id, alias: null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateRootType"/> class.
+        /// </summary>
+        /// <param name="id">The <see cref="EventTypeId">unique identifier</see> of the <see cref="AggregateRootType"/>.</param>
+        /// <param name="alias"><see cref="AggregateRootAlias">Alias</see> of the <see cref="AggregateRootType"/>.</param>
+        public AggregateRootType(AggregateRootId id, AggregateRootAlias alias)
+            : base(id)
+        {
+            ThrowIfAggregateRootTypeIdIsNull(id);
+            Alias = alias;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateRootType"/> class.
+        /// </summary>
+        /// <param name="id">The <see cref="EventTypeId">unique identifier</see> of the <see cref="AggregateRootType"/>.</param>
+        /// <param name="generation"><see cref="Generation">Generation</see> of the <see cref="AggregateRootType"/>.</param>
+        public AggregateRootType(AggregateRootId id, Generation generation)
+            : this(id, generation, null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateRootType"/> class.
+        /// </summary>
+        /// <param name="id">The <see cref="EventTypeId">unique identifier</see> of the <see cref="AggregateRootType"/>.</param>
+        /// <param name="generation"><see cref="Generation">Generation</see> of the <see cref="AggregateRootType"/>.</param>
+        /// <param name="alias"><see cref="AggregateRootAlias">Alias</see> of the <see cref="AggregateRootType"/>.</param>
+        public AggregateRootType(AggregateRootId id, Generation generation, AggregateRootAlias alias)
+            : base(id, generation)
+        {
+            ThrowIfAggregateRootTypeIdIsNull(id);
+            ThrowIfGenerationIsNull(generation);
+            Alias = alias;
+        }
+
+        /// <summary>
+        /// Gets the alias for the Event Type.
+        /// </summary>
+        public AggregateRootAlias Alias { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether the Event Type has an alias or not.
+        /// </summary>
+        public bool HasAlias => Alias?.Value != default;
+
+        static void ThrowIfAggregateRootTypeIdIsNull(AggregateRootId id)
+        {
+            if (id == null) throw new AggregateRootIdCannotBeNull();
+        }
+
+        static void ThrowIfGenerationIsNull(Generation generation)
+        {
+            if (generation == null) throw new AggregateRootTypeGenerationCannotBeNull();
+        }
+    }
+}

Source/Aggregates/AggregateRootTypeAssociatedWithType.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+
+namespace Dolittle.SDK.Aggregates
+{
+    /// <summary>
+    /// Exception that gets thrown when a <see cref="Type" /> does not have an <see cref="AggregateRootType"/> association.
+    /// </summary>
+    public class AggregateRootTypeAssociatedWithType : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateRootTypeAssociatedWithType"/> class.
+        /// </summary>
+        /// <param name="type">The <see cref="Type" /> that has a missing association.</param>
+        public AggregateRootTypeAssociatedWithType(Type type)
+            : base($"{type} is not associated with an EventType")
+        {
+        }
+    }
+}

Source/Aggregates/AggregateRootTypeGenerationCannotBeNull.cs

@@ -0,0 +1,22 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using Dolittle.SDK.Artifacts;
+
+namespace Dolittle.SDK.Aggregates
+{
+    /// <summary>
+    /// Exception that gets thrown when trying to construct an <see cref="AggregateRootType"/> with a <see cref="Generation"/> that is null.
+    /// </summary>
+    public class AggregateRootTypeGenerationCannotBeNull : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateRootTypeGenerationCannotBeNull"/> class.
+        /// </summary>
+        public AggregateRootTypeGenerationCannotBeNull()
+            : base($"The {nameof(Generation)} of an {nameof(AggregateRootType)} cannot be null")
+        {
+        }
+    }
+}

Source/Aggregates/AggregateRootTypes.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using Dolittle.SDK.Artifacts;
+using Dolittle.SDK.Events;
+using Microsoft.Extensions.Logging;
+
+namespace Dolittle.SDK.Aggregates
+{
+    /// <summary>
+    /// Represents an implementation of <see cref="IAggregateRootTypes" />.
+    /// </summary>
+    public class AggregateRootTypes : Artifacts<AggregateRootType, AggregateRootId>, IAggregateRootTypes
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateRootTypes"/> class.
+        /// </summary>
+        /// <param name="logger">The <see cref="ILogger" />.</param>
+        public AggregateRootTypes(ILogger logger)
+            : base(logger)
+        {
+        }
+
+        /// <inheritdoc/>
+        protected override Exception CreateNoArtifactAssociatedWithType(Type type)
+            => new AggregateRootTypeAssociatedWithType(type);
+
+        /// <inheritdoc/>
+        protected override Exception CreateNoTypeAssociatedWithArtifact(AggregateRootType artifact)
+            => new NoTypeAssociatedWithAggregateRootType(artifact);
+
+        /// <inheritdoc/>
+        protected override Exception CreateCannotAssociateMultipleArtifactsWithType(Type type, AggregateRootType artifact, AggregateRootType existing)
+            => new CannotAssociateMultipleAggregateRootTypesWithType(type, artifact, existing);
+
+        /// <inheritdoc/>
+        protected override Exception CreateCannotAssociateMultipleTypesWithArtifact(AggregateRootType artifact, Type type, Type existing)
+            => new CannotAssociateMultipleTypesWithAggregateRootType(artifact, type, existing);
+    }
+}

Source/Aggregates/Aggregates.csproj

@@ -4,6 +4,7 @@
 
   <PropertyGroup>
     <AssemblyName>Dolittle.SDK.Aggregates</AssemblyName>
+    <RootNamespace>Dolittle.SDK.Aggregates</RootNamespace>
   </PropertyGroup>
 
   <ItemGroup>