Merge pull request #21 from altasoft/feature/transformation

Feature/transformation

Author: GregoryNikolaishvili

AltaSoft.DomainPrimitives.sln

@@ -31,6 +31,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "GitHubActions", "GitHubActi
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AltaSoft.DomainPrimitives.SwaggerExtensions", "src\AltaSoft.DomainPrimitives.SwaggerExtensions\AltaSoft.DomainPrimitives.SwaggerExtensions.csproj", "{289BC781-8B67-4A15-87A9-198EEA255160}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AltaSoft.DomainPrimitives.UnitTests", "tests\AltaSoft.DomainPrimitives.UnitTests\AltaSoft.DomainPrimitives.UnitTests.csproj", "{253F7819-7F69-9B49-8257-65A17B56DF55}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -61,6 +63,10 @@ Global
 		{289BC781-8B67-4A15-87A9-198EEA255160}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{289BC781-8B67-4A15-87A9-198EEA255160}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{289BC781-8B67-4A15-87A9-198EEA255160}.Release|Any CPU.Build.0 = Release|Any CPU
+		{253F7819-7F69-9B49-8257-65A17B56DF55}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{253F7819-7F69-9B49-8257-65A17B56DF55}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{253F7819-7F69-9B49-8257-65A17B56DF55}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{253F7819-7F69-9B49-8257-65A17B56DF55}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -69,6 +75,7 @@ Global
 		{A3D3536F-993E-4606-B9DF-A4C4B3E1AF69} = {09A03F75-1F18-45BC-9D0A-289AC607DAD0}
 		{E49201A0-DCC3-4ED2-A5A0-25DDD5E3D017} = {09A03F75-1F18-45BC-9D0A-289AC607DAD0}
 		{A7BFF96E-3DFF-4132-AD2B-7C529C14A3E8} = {BF9447CC-2D00-495A-A8C3-D4890EADB01B}
+		{253F7819-7F69-9B49-8257-65A17B56DF55} = {09A03F75-1F18-45BC-9D0A-289AC607DAD0}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {84804F7F-F00C-454C-A90E-4013B6EA6263}

Directory.Build.props

@@ -9,7 +9,7 @@
 	<Product>Domain Primitives</Product>
 	<Company>ALTA Software llc.</Company>
 	<Copyright>Copyright © 2024 ALTA Software llc.</Copyright>
-	<Version>5.1.3</Version>
+	<Version>6.0.0</Version>
   </PropertyGroup>
 
   <PropertyGroup>

README.md

@@ -1,4 +1,4 @@
-# DomainPrimitives for C#  
+# DomainPrimitives for C#  
 
 [![Version](https://img.shields.io/nuget/v/AltaSoft.DomainPrimitives?label=Version&color=0c3c60&style=for-the-badge&logo=nuget)](https://www.nuget.org/profiles/AltaSoft)
 [![Dot NET 7+](https://img.shields.io/static/v1?label=DOTNET&message=7%2B&color=0c3c60&style=for-the-badge)](https://dotnet.microsoft.com)
@@ -14,6 +14,7 @@
 - [Installation](#installation)
 - [Creating your Domain type](#creating-your-domain-type)
 - [Json Conversion](#json-conversion)
+- [Transform Method](#transform-method)
 - [Contributions](#contributions)
 - [Contact](#contact)
 - [License](#license)
@@ -875,6 +876,51 @@ public static void JsonSerializationAndDeserialization()
 }
 ```
 
+
+# 🔄 Transform Method
+
+In `AltaSoft.DomainPrimitives`, you can optionally define a static method named `Transform` inside your domain primitive to automatically preprocess input values before validation or instantiation.
+
+## ✅ Signature
+```csharp
+public static T Transform(T value)  //
+```
+- `T` must match the value type of your domain primitive (e.g., `string`, `int`, etc.).
+- The method can be `private`, `internal`, or `public`.
+- It **must be static** and **accept a single parameter** of type `T`.
+
+## 🎯 When It's Invoked
+
+If present, the `Transform` method is automatically called before:
+
+- Running `Validate(value)`
+- Invoking the constructor or `TryCreate(...)` method
+
+This ensures the input is normalized consistently at the boundary of your domain object.
+
+## 📌 Example: `ToUpperString`
+
+```csharp
+public sealed partial class ToUpperString : IDomainValue<string>
+{
+    static PrimitiveValidationResult Validate(string value) =>
+        value.All(char.IsUpper) ? PrimitiveValidationResult.Ok : "Value must be all uppercase.";
+
+    // This method is automatically invoked before validation and construction.
+    static string Transform(string value) => value.ToUpperInvariant();
+
+    public ToUpperString(string value) : this(Transform(value), true) { }
+}
+```
+
+### What happens:
+
+- A user provides `"hello"` to `TryCreate("hello", out var result, out var error)`
+- `Transform("hello")` runs and returns `"HELLO"`
+- `"HELLO"` is then validated with `Validate(...)`
+---
+
+
 # Contributions 
 Contributions to AltaSoft.DomainPrimitives are welcome! Whether you have suggestions or wish to contribute code, feel free to submit a pull request or open an issue.
 

src/AltaSoft.DomainPrimitives.Generator/AltaSoft.DomainPrimitives.Generator.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
 		<TargetFramework>netstandard2.0</TargetFramework>
@@ -17,8 +17,8 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" PrivateAssets="all" />
-		<PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" PrivateAssets="all" />
+		<PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="4.14.0" PrivateAssets="all" />
+		<PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" PrivateAssets="all" />
 	</ItemGroup>
 
 	<ItemGroup>

src/AltaSoft.DomainPrimitives.Generator/Executor.cs

@@ -118,6 +118,12 @@ internal static void Execute(
 
         var hasOverridenHashCode = typeSymbol.GetMembersOfType<IMethodSymbol>().Any(x => string.Equals(x.OverriddenMethod?.Name, "GetHashCode", StringComparison.Ordinal));
 
+        var hasTransformMethod = typeSymbol.GetMembersOfType<IMethodSymbol>()
+            .Any(x =>
+                x is { Name: "Transform", IsStatic: true, Parameters.Length: 1 } &&
+                x.ReturnType.Equals(underlyingTypeSymbol, SymbolEqualityComparer.Default) &&
+                x.Parameters[0].Type.Equals(underlyingTypeSymbol, SymbolEqualityComparer.Default));
+
         var generatorData = new GeneratorData
         {
             FieldName = "_valueOrThrow",
@@ -129,7 +135,8 @@ internal static void Execute(
             Namespace = typeSymbol.ContainingNamespace.ToDisplayString(),
             GenerateImplicitOperators = true,
             ParentSymbols = parentSymbols,
-            GenerateConvertibles = underlyingType.IsIConvertible()
+            GenerateConvertibles = underlyingType.IsIConvertible(),
+            UseTransformMethod = hasTransformMethod
         };
 
         var attributes = typeSymbol.GetAttributes();
@@ -145,6 +152,17 @@ internal static void Execute(
             return null;
         }
 
+        if (underlyingType == DomainPrimitiveUnderlyingType.String && typeSymbol.TypeKind != TypeKind.Class)
+        {
+            context.ReportDiagnostic(DiagnosticHelper.InvalidClassTypeSpecified(typeSymbol.Locations.FirstOrDefault(), typeSymbol.Name));
+            return null;
+        }
+        if (underlyingType != DomainPrimitiveUnderlyingType.String && typeSymbol.TypeKind != TypeKind.Struct)
+        {
+            context.ReportDiagnostic(DiagnosticHelper.InvalidStructTypeSpecified(typeSymbol.Locations.FirstOrDefault(), underlyingType.ToString(), typeSymbol.Name));
+            return null;
+        }
+
         if (!isDateOrTime && serializationAttribute is not null)
         {
             context.ReportDiagnostic(DiagnosticHelper.TypeMustBeDateType(serializationAttribute.GetAttributeLocation(), typeSymbol.Name));
@@ -185,78 +203,6 @@ internal static void Execute(
         return generatorData;
     }
 
-    //private static bool DefaultPropertyReturnsDefaultValue(IPropertySymbol property, DomainPrimitiveUnderlyingType underlyingType)
-    //{
-    //    var syntaxRefs = property.GetMethod?.DeclaringSyntaxReferences;
-    //    if (syntaxRefs is null)
-    //    {
-    //        // If there are no syntax references, the property doesn't have a getter
-    //        return false;
-    //    }
-
-    //    ExpressionSyntax? returnExpression = null;
-
-    //    foreach (var syntaxRef in syntaxRefs)
-    //    {
-    //        var syntaxNode = syntaxRef.GetSyntax();
-
-    //        // Handle expression-bodied properties
-    //        if (syntaxNode is ArrowExpressionClauseSyntax arrowExpressionClauseSyntax)
-    //        {
-    //            returnExpression = arrowExpressionClauseSyntax.Expression;
-    //            break;
-    //        }
-
-    //        // Handle expression-bodied properties
-    //        if (syntaxNode is PropertyDeclarationSyntax { ExpressionBody: { } expressionBody })
-    //        {
-    //            returnExpression = expressionBody.Expression;
-    //            break;
-    //        }
-
-    //        // Handle properties with getters that have a body
-    //        if (syntaxNode is AccessorDeclarationSyntax { Body: not null } accessorDeclaration)
-    //        {
-    //            var returnExpressions = accessorDeclaration.Body.DescendantNodes()
-    //                .OfType<ReturnStatementSyntax>()
-    //                .Select(r => r.Expression)
-    //                .ToArray();
-
-    //            if (returnExpressions.Length != 1)
-    //                return false;
-
-    //            returnExpression = returnExpressions[0];
-    //            break;
-    //        }
-    //    }
-
-    //    // Check if the return expression is a default value for the type
-    //    switch (returnExpression)
-    //    {
-    //        case null:
-    //            return false;
-
-    //        case DefaultExpressionSyntax:
-    //            return true;
-
-    //        // Simplified check for literal or default expressions
-    //        case LiteralExpressionSyntax literal:
-    //            if (literal.IsKind(SyntaxKind.DefaultLiteralExpression))
-    //                return true;
-
-    //            // Determine the default value for the property's type
-    //            var defaultValue = underlyingType.GetDefaultValue();
-    //            if (defaultValue is null)
-    //                return literal.Token.Value is null;
-
-    //            return defaultValue.Equals(literal.Token.Value);
-
-    //        // For more complex expressions, additional analysis is required
-    //        default:
-    //            return false;
-    //    }
-    //}
-
     /// <summary>
     /// Retrieves the SupportedOperationsAttributeData for a specified class, considering inheritance.
     /// </summary>
@@ -784,7 +730,8 @@ private static bool ProcessConstructor(GeneratorData data, SourceCodeBuilder bui
         builder.AppendSummary($"Initializes a new instance of the <see cref=\"{type.Name}\"/> class by validating the specified <see cref=\"{underlyingTypeName}\"/> value using <see cref=\"Validate\"/> static method.");
         builder.AppendParamDescription("value", "The value to be validated.");
 
-        builder.AppendLine($"public {type.Name}({underlyingTypeName} value) : this(value, true)")
+        var ctorCall = data.UseTransformMethod ? "Transform(value)" : "value";
+        builder.AppendLine($"public {type.Name}({underlyingTypeName} value) : this({ctorCall}, true)")
             .OpenBracket()
             .CloseBracket()
             .NewLine();

src/AltaSoft.DomainPrimitives.Generator/Helpers/DiagnosticHelper.cs

@@ -1,5 +1,5 @@
-using Microsoft.CodeAnalysis;
-using System;
+using System;
+using Microsoft.CodeAnalysis;
 
 namespace AltaSoft.DomainPrimitives.Generator.Helpers;
 
@@ -10,23 +10,6 @@ internal static class DiagnosticHelper
 {
     private const string Category = "AltaSoft.DomainPrimitives.Generator";
 
-    ///// <summary>
-    ///// Creates a diagnostic indicating that the AltaSoft.DomainPrimitives.Generator has started.
-    ///// </summary>
-    ///// <returns>
-    ///// The created diagnostic.
-    ///// </returns>
-    //internal static Diagnostic GeneratorStarted()
-    //{
-    //    return Diagnostic.Create(new DiagnosticDescriptor(
-    //        "AL0000",
-    //        "AltaSoft.DomainPrimitives.Generator started",
-    //        "AltaSoft.DomainPrimitives.Generator started",
-    //        Category,
-    //        DiagnosticSeverity.Info,
-    //        isEnabledByDefault: true), null);
-    //}
-
     /// <summary>
     /// Creates a diagnostic for general error
     /// </summary>
@@ -206,4 +189,46 @@ internal static Diagnostic ClassHasDefaultConstructor(string className, Location
                 DiagnosticSeverity.Error,
                 isEnabledByDefault: true), location, className);
     }
+
+    /// <summary>
+    /// Creates a diagnostic indicating that the specified type must be a class 
+    /// to support domain primitive generation.
+    /// </summary>
+    /// <param name="location">The source location where the diagnostic should appear.</param>
+    /// <param name="className">The name of the type that is incorrectly used.</param>
+    /// <returns>
+    /// A diagnostic indicating that a domain primitive based on a string type must be a class.
+    /// </returns>
+    internal static Diagnostic InvalidClassTypeSpecified(Location? location, string className)
+    {
+        return Diagnostic.Create(
+            new DiagnosticDescriptor(
+                "AL1052",
+                "Domain primitive types based on string must be declared as classes",
+                "Type '{0}' must be declared as a class when using 'string' as the underlying domain primitive type.",
+                Category,
+                DiagnosticSeverity.Error,
+                isEnabledByDefault: true), location, className);
+    }
+    /// <summary>
+    /// Creates a diagnostic indicating that the specified type must be a struct 
+    /// to support domain primitive generation.
+    /// </summary>
+    /// <param name="location">The source location where the diagnostic should appear.</param>
+    /// <param name="typeName">The name of the underlying type used in the domain primitive.</param>
+    /// <param name="className">The name of the type that is incorrectly used.</param>
+    /// <returns>
+    /// A diagnostic indicating that a domain primitive based on <paramref name="typeName"/> must be a struct.
+    /// </returns>
+    internal static Diagnostic InvalidStructTypeSpecified(Location? location, string typeName, string className)
+    {
+        return Diagnostic.Create(
+            new DiagnosticDescriptor(
+                "AL1053",
+                $"Domain primitive types based on '{typeName}' must be declared as structs",
+                "Type '{0}' must be declared as a struct when using '{1}' as the underlying domain primitive type.",
+                Category,
+                DiagnosticSeverity.Error,
+                isEnabledByDefault: true), location, className, typeName);
+    }
 }

src/AltaSoft.DomainPrimitives.Generator/Helpers/MethodGeneratorHelper.cs

@@ -406,9 +406,15 @@ internal static void GenerateMandatoryMethods(GeneratorData data, SourceCodeBuil
             .AppendParamDescription("errorMessage", "When this method returns, contains the error message if the conversion failed; otherwise, null.")
             .AppendReturnsDescription("true if the conversion succeeded; otherwise, false.");
 
-        builder.Append("public static bool TryCreate(").Append(primitiveType).Append(" value,[NotNullWhen(true)]  out ").Append(data.ClassName)
+        builder.Append("public static bool TryCreate(").Append(primitiveType).Append(" value, [NotNullWhen(true)]  out ").Append(data.ClassName)
             .AppendLine("? result, [NotNullWhen(false)]  out string? errorMessage)")
             .OpenBracket();
+
+        if (data.UseTransformMethod)
+        {
+            builder.AppendLine("value = Transform(value);");
+        }
+
         AddStringLengthValidation(data, builder);
 
         builder.AppendLine("var validationResult = Validate(value);")

src/AltaSoft.DomainPrimitives.Generator/Models/GeneratorData.cs

@@ -122,4 +122,9 @@ internal sealed class GeneratorData
     /// if StringLengthAttribute validation is applied to a domain Primitive this will be used to determine the values and use them before calling validation method.
     /// </summary>
     public (int minLength, int maxLength)? StringLengthAttributeValidation { get; set; }
+
+    /// <summary>
+    /// Indicates whether the `Transform` method should be invoked before validation and instantiation.
+    /// </summary>
+    public bool UseTransformMethod { get; set; }
 }

src/AltaSoft.DomainPrimitives.SwaggerExtensions/AltaSoft.DomainPrimitives.SwaggerExtensions.csproj

@@ -25,7 +25,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
-	  <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" Version="7.0.0" />
+	  <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" Version="8.1.1" />
 	</ItemGroup>