Added defconventions for Commands to specify base types

Author: mjul

Diesel/CodeGeneration/CodeDomCompiler.cs

@@ -63,7 +63,7 @@ private static void Add(CodeCompileUnit codeCompileUnit, ConventionsDeclaration
 
         private static void Add(CodeNamespace ns, ConventionsDeclaration conventions, SemanticModel model, NamespaceName namespaceName, CommandDeclaration declaration)
         {
-            ns.Types.Add(CommandGenerator.CreateCommandDeclaration(model, namespaceName, declaration));
+            ns.Types.Add(CommandGenerator.CreateCommandDeclaration(model, namespaceName, declaration, conventions.CommandConventions));
         }
 
         private static void Add(CodeNamespace ns, ConventionsDeclaration conventions, SemanticModel model, NamespaceName namespaceName, DomainEventDeclaration declaration)

Diesel/CodeGeneration/CommandGenerator.cs

@@ -10,13 +10,24 @@ public class CommandGenerator : CodeDomGenerator
     {
         public static CodeTypeDeclaration CreateCommandDeclaration(
             SemanticModel model, NamespaceName namespaceName,
-            CommandDeclaration declaration)
+            CommandDeclaration declaration, 
+            CommandConventions conventions)
         {
-            return CreateTypeWithValueSemantics(
+            var type = CreateTypeWithValueSemantics(
                 ValueObjectSpecification.CreateClass(
                 namespaceName, declaration.Name, 
                 declaration.Properties.ToArray(), true, false),
                 model.KnownTypes);
-        } 
+            ApplyConventions(conventions, type);
+            return type;
+        }
+
+        private static void ApplyConventions(CommandConventions conventions, CodeTypeDeclaration typeDeclaration)
+        {
+            foreach (var typeName in conventions.BaseTypes.TypeNames)
+            {
+                typeDeclaration.BaseTypes.Add(typeName.Name);
+            }
+        }
     }
 }

README.md

@@ -144,6 +144,14 @@ and equals and equality operators are implemented with value semantics.
 Commands are DTOs (Data Transfer Objects), so they are also decorated with attributes
 to allow them to be serializable with the BinarySerializer and the DataContractSerializer.
 
+Command can be generated with base types, see `defconventions` for a description of 
+how to configure this. 
+
+Do note, however, that since Commands are contracts it is generally best to declare base
+ __interfaces__ only so that the risk of breaking contracts by modifying a base is 
+minimal.
+
+
 ## Example
 
     (defcommand ImportEmployee (int EmployeeNumber, string FirstName, string LastName, int? SourceId))
@@ -152,6 +160,27 @@ This generates a class with properties `EmployeeNumber`, `FirstName` and `LastNa
 Nullable types are supported in properties with C# short syntax, i.e. "int?" denotes a nullable Int32.
 
 
+## Adding Base Classes or Interfaces to Domain Events 
+
+The code generator reads conventions from the optional `defconventions` declaration
+at the top of the Diesel source file.
+
+You can use this to add base types to the generated Commands. 
+For example, to have all Commands derive from the `GreatApp.ICommand` interface, 
+just add this declaration:
+
+    (defconventions :commands {:inherit [GreatApp.IDomainEvent]})
+
+Note that since Commands are contracts it is generally best to 
+declare base __interfaces__ only so that the risk of breaking contracts by modifying a base is 
+minimal.
+
+See the section on defining conventions for a full description of `defconventions`.
+
+
+
+
+
 # Defining Domain Events
 
     (defdomainevent <typename> <properties>)
@@ -170,17 +199,23 @@ to allow them to be serializable with the BinarySerializer and the DataContractS
 This generates a class with properties `Id`, `EmployeeNumber`, `FirstName` and `LastName` and `SourceId`.
 
 
-## Adding Base Classes or Interfaces to Domain Events
+## Adding Base Classes or Interfaces to Domain Events 
 
 The code generator reads conventions from the optional `defconventions` declaration
 at the top of the Diesel source file.
 
-You can use this to add base types to the generated Domain Events.
+You can use this to add base types to the generated Domain Events. 
 For example, to have all Domain Events derive from the `GreatApp.IDomainEvent` interface, 
 just add this declaration:
 
     (defconventions :domainevents {:inherit [GreatApp.IDomainEvent]})
 
+Note that since Domain Events are contracts it is generally best to 
+declare base __interfaces__ only so that the risk of breaking contracts by modifying a base is 
+minimal.
+
+See the section on defining conventions for a full description of `defconventions`.
+
 
 # Defining Data Transfer Objects (DTOs)
 
@@ -269,18 +304,37 @@ and `Employees.EmployeeImported`.
 
 # Defining Conventions for Code-Generation
 
-    (defconventions :domainevents {:inherit <list-of-base-types>})
+    (defconventions :domainevents {:inherit <list-of-base-types>}
+                    :commands {:inherit <list-of-base-types>})
 
 The code-generation conventions can be controlled through the `defconventions` declaration.
-It must be placed first in the source file.
-For now, it only controls the list of interfaces and base classes for the Domain Events.
+For now, it only controls the list of interfaces and base classes for the Domain Events and Commands.
+
+The declaration must be placed first in the source file. The `:domainevents` and `:commands`
+declarations inside are both optional and can be in any order, but they can not occur more than
+once.
 
 ## Example
 
+    (defconventions :domainevents {:inherit [Test.Diesel.IDomainEvent]}
+                    :commands {:inherit [Test.Diesel.ICommand]})
+
+This causes the code generator to add the `Test.Diesel.IDomainEvent` interface 
+as a base on all Domain Events, and the `Test.Diesel.ICommand` interface to all Commands.
+
+
+## Example: Adding interfaces to Domain Events
+
     (defconventions :domainevents {:inherit [Test.Diesel.IDomainEvent]})
 
 This adds the `Test.Diesel.IDomainEvent` as a base on all generated Domain Events.
 
+## Example: Adding interfaces to Commands
+
+    (defconventions :commands {:inherit [Test.Diesel.ICommand]})
+
+This adds the `Test.Diesel.ICommand` as a base on all generated Domain Events.
+
 
 # Comments
 

Test/CodeGeneration/CodeDomCompilerTest.cs

@@ -165,6 +165,18 @@ public void CommandDeclaration_ValidDeclaration_ShouldAddDataContractAttribute()
             Assert.That(source, Is.StringContaining(@"DataContractAttribute(Name=""ImportEmployeeCommand"")"));
         }
 
+        [Test]
+        public void CommandDeclaration_WithConventionInheritICommand_ShouldProduceClassInheritingICommand()
+        {
+            var declaration = CreateImportEmployeeCommandDeclaration();
+            var conventions = new ConventionsDeclaration(
+                new DomainEventConventions(new BaseTypes(new TypeName[0])),
+                new CommandConventions(new BaseTypes(new[] { new TypeName("Test.Diesel.ICommand") })));
+            var model = CreateSemanticModelWith(conventions, declaration);
+            var source = CompileToSource(CodeDomCompiler.Compile(model));
+            Assert.That(source, Is.StringMatching(@"class ImportEmployeeCommand :.* Test.Diesel.ICommand \{"));
+        }
+
         private CodeCompileUnit CompileImportEmployeeCommand()
         {
             var commandDeclaration = new CommandDeclaration("ImportEmployeeCommand",

Test/Examples/DieselCompilerIntegrationTestCase.txt

@@ -1,4 +1,6 @@
-(defconventions :domainevents {:inherit [Test.Diesel.IDomainEvent]})
+(defconventions 
+	:domainevents {:inherit [Test.Diesel.IDomainEvent]}
+	:commands {:inherit [Test.Diesel.ICommand]})
 
 (namespace Employees
 	(defvaluetype EmployeeNumber int)

Test/Generated/Example.dsl

@@ -1,4 +1,6 @@
-(defconventions :domainevents {:inherit [Test.Diesel.IDomainEvent]})
+(defconventions 
+	:commands {:inherit [Test.Diesel.ICommand]}
+	:domainevents {:inherit [Test.Diesel.IDomainEvent]})
 
 (namespace Test.Diesel.Generated 
 

Test/Generated/GenerateExamples.cs

@@ -535,7 +535,7 @@ public partial interface IImportService {
 
     [System.Runtime.Serialization.DataContractAttribute(Name="ImportEmployee")]
     [System.SerializableAttribute()]
-    public partial class ImportEmployee : System.IEquatable<ImportEmployee> {
+    public partial class ImportEmployee : System.IEquatable<ImportEmployee>, Test.Diesel.ICommand {
 
         [System.Runtime.Serialization.DataMemberAttribute(Name="CommandId", Order=1)]
         private System.Guid _commandId;
@@ -629,7 +629,7 @@ public override bool Equals(object obj) {
 
     [System.Runtime.Serialization.DataContractAttribute(Name="ImportConsultant")]
     [System.SerializableAttribute()]
-    public partial class ImportConsultant : System.IEquatable<ImportConsultant> {
+    public partial class ImportConsultant : System.IEquatable<ImportConsultant>, Test.Diesel.ICommand {
 
         [System.Runtime.Serialization.DataMemberAttribute(Name="FirstName", Order=1)]
         private string _firstName;
@@ -699,7 +699,7 @@ public override bool Equals(object obj) {
 
     [System.Runtime.Serialization.DataContractAttribute(Name="ImportEmployeeNestedTypes")]
     [System.SerializableAttribute()]
-    public partial class ImportEmployeeNestedTypes : System.IEquatable<ImportEmployeeNestedTypes> {
+    public partial class ImportEmployeeNestedTypes : System.IEquatable<ImportEmployeeNestedTypes>, Test.Diesel.ICommand {
 
         [System.Runtime.Serialization.DataMemberAttribute(Name="CommandId", Order=1)]
         private System.Guid _commandId;

Test/GeneratedCommandTest.cs

@@ -105,5 +105,12 @@ private static object GetDataMemberAttributeOrderValue(FieldInfo[] fields, strin
                                                     .Single(a => a.AttributeType == typeof (DataMemberAttribute));
             return dataMemberAttribute.NamedArguments.Single(a => a.MemberName == "Order").TypedValue.Value;
         }
+
+        [Test]
+        public void Instance_WhenConventionsDeclareABaseInterface_MustImplementTheInterface()
+        {
+            var instance = new ImportEmployee(CommandId, EmployeeNumber, FirstName, Lastname, null);
+            Assert.That(instance, Is.AssignableTo<ICommand>());
+        }
     }
 }

Test/ICommand.cs

@@ -0,0 +1,6 @@
+namespace Test.Diesel
+{
+    public interface ICommand
+    {
+    }
+}

Test/Parsing/GrammarTest.cs

@@ -584,15 +584,31 @@ public void ConventionDeclarations_ValidWithCommandInheritance_ShouldParse()
         }
 
         [Test]
-        public void ConventionDeclarations_ValidWithEverything_ShouldParse()
+        public void ConventionDeclarations_DomainEventsThenCommands_SectionOrderShouldNotMatter()
         {
             var actual = Grammar.ConventionsDeclaration.Parse(
                     "(defconventions " +
                     "  :domainevents {:inherit [SomeNamespace.IDomainEvent]}" +
                     "  :commands {:inherit [SomeNamespace.ICommand]})");
             Assert.That(actual, Is.Not.Null);
-            Assert.That(actual.DomainEventConventions, Is.Not.Null);
-            Assert.That(actual.CommandConventions, Is.Not.Null);
+            Assert.That(actual.DomainEventConventions.BaseTypes.TypeNames.Single().Name,
+                        Is.EqualTo("SomeNamespace.IDomainEvent"));
+            Assert.That(actual.CommandConventions.BaseTypes.TypeNames.Single().Name,
+                        Is.EqualTo("SomeNamespace.ICommand"));
+        }
+
+        [Test]
+        public void ConventionDeclarations_CommandsThenDomainEvents_SectionOrderShouldNotMatter()
+        {
+            var actual = Grammar.ConventionsDeclaration.Parse(
+                "(defconventions " +
+                "  :commands {:inherit [SomeNamespace.ICommand]}" +
+                "  :domainevents {:inherit [SomeNamespace.IDomainEvent]})");
+            Assert.That(actual, Is.Not.Null);
+            Assert.That(actual.DomainEventConventions.BaseTypes.TypeNames.Single().Name,
+                        Is.EqualTo("SomeNamespace.IDomainEvent"));
+            Assert.That(actual.CommandConventions.BaseTypes.TypeNames.Single().Name,
+                        Is.EqualTo("SomeNamespace.ICommand"));
         }
 
         [Test]

Test/Test.csproj

@@ -74,6 +74,7 @@
       <DesignTime>True</DesignTime>
       <DependentUpon>GenerateExamples.tt</DependentUpon>
     </Compile>
+    <Compile Include="ICommand.cs" />
     <Compile Include="IDomainEvent.cs" />
     <Compile Include="ObjectMothers\CommandDeclarationObjectMother.cs" />
     <Compile Include="ObjectMothers\DomainEventDeclarationObjectMother.cs" />