@polymorphism-tech/morph-spec 4.12.0 → 4.14.0

package/framework/templates/code/dotnet/feature/entity.cs.hbs

@@ -0,0 +1,8 @@
+namespace {{pascalCase PROJECT_NAME}}.Entities
+{
+    public sealed class {{pascalCase FEATURE_NAME}}
+    {
+        public Guid Id { get; set; }
+        // TODO: Add entity properties
+    }
+}

package/framework/templates/code/dotnet/feature/errors.cs.hbs

@@ -0,0 +1,8 @@
+using {{pascalCase PROJECT_NAME}}.Abstractions.Errors;
+namespace {{pascalCase PROJECT_NAME}}.Features.{{pascalCase FEATURE_NAME}}Feature;
+
+public static class {{pascalCase FEATURE_NAME}}Errors
+{
+    public static Error NotFound(Guid id) =>
+        Error.NotFound("{{pascalCase FEATURE_NAME}}s.NotFound", $"The {{pascalCase FEATURE_NAME}} with Id '{id}' was not found");
+}

package/framework/templates/code/dotnet/feature/handler.cs.hbs

@@ -0,0 +1,24 @@
+namespace {{pascalCase PROJECT_NAME}}.Features.{{pascalCase FEATURE_NAME}}Feature.{{pascalCase SLICE_NAME}};
+
+using {{pascalCase PROJECT_NAME}}.Abstractions;
+using {{pascalCase PROJECT_NAME}}.Entities;
+using {{pascalCase PROJECT_NAME}}.Repository;
+
+public sealed class {{pascalCase SLICE_NAME}}Handler(
+    IRepository<{{pascalCase FEATURE_NAME}}> _repository,
+    IUnitOfWork _unitOfWork) : IHandler<{{pascalCase SLICE_NAME}}Request, Result<{{pascalCase SLICE_NAME}}Response>>
+{
+    public async Task<Result<{{pascalCase SLICE_NAME}}Response>> HandleAsync({{pascalCase SLICE_NAME}}Request command, CancellationToken cancellationToken)
+    {
+        var entity = new {{pascalCase FEATURE_NAME}}
+        {
+            Id = Guid.CreateVersion7(),
+            // TODO: Map command properties to entity
+        };
+
+        await _repository.AddAsync(entity, cancellationToken);
+        await _unitOfWork.CommitAsync(cancellationToken);
+
+        return Result.Success(new {{pascalCase SLICE_NAME}}Response(entity.Id));
+    }
+}

package/framework/templates/code/dotnet/feature/request.cs.hbs

@@ -0,0 +1,4 @@
+namespace {{pascalCase PROJECT_NAME}}.Features.{{pascalCase FEATURE_NAME}}Feature.{{pascalCase SLICE_NAME}};
+
+// TODO: Add properties matching the {{pascalCase SLICE_NAME}} command
+public sealed record {{pascalCase SLICE_NAME}}Request();

package/framework/templates/code/dotnet/feature/response.cs.hbs

@@ -0,0 +1,4 @@
+namespace {{pascalCase PROJECT_NAME}}.Features.{{pascalCase FEATURE_NAME}}Feature.{{pascalCase SLICE_NAME}};
+
+// TODO: Add properties matching the {{pascalCase SLICE_NAME}} response
+public sealed record {{pascalCase SLICE_NAME}}Response(Guid Id);

package/framework/templates/code/dotnet/feature/validator.cs.hbs

@@ -0,0 +1,15 @@
+using FluentValidation;
+
+namespace {{pascalCase PROJECT_NAME}}.Features.{{pascalCase FEATURE_NAME}}Feature.{{pascalCase SLICE_NAME}};
+
+public class {{pascalCase SLICE_NAME}}Validator : AbstractValidator<{{pascalCase SLICE_NAME}}Request>
+{
+    public {{pascalCase SLICE_NAME}}Validator()
+    {
+        // TODO: Add validation rules for {{pascalCase SLICE_NAME}}Request properties
+        // Example:
+        // RuleFor(c => c.Name)
+        //     .NotEmpty().WithMessage("Name is required")
+        //     .MaximumLength(200).WithMessage("Name must not exceed 200 characters");
+    }
+}

package/framework/templates/code/dotnet/jobs/job.cs

@@ -1,19 +1,22 @@
 // ============================================================
-// HANGFIRE JOB TEMPLATE
+// HANGFIRE JOB TEMPLATE (VSA Pattern — Repository + UnitOfWork)
 // Generated by MORPH Framework
 // ============================================================
 
 using Hangfire;
 using Microsoft.Extensions.Logging;
+using {{pascalCase PROJECT_NAME}}.Repository;
 
-namespace {{NAMESPACE}}.Application.Features.{{pascalCase FEATURE_NAME}}.Jobs;
+namespace {{pascalCase PROJECT_NAME}}.Features.{{pascalCase FEATURE_NAME}}.Jobs;
 
 /// <summary>
 /// Background job for processing {{pascalCase FEATURE_NAME}}.
 /// Uses Hangfire for scheduling and retry handling.
+/// Injects IRepository + IUnitOfWork directly (no service layer).
 /// </summary>
 public class {{pascalCase FEATURE_NAME}}ProcessorJob(
-    I{{pascalCase FEATURE_NAME}}Service service,
+    IRepository<{{pascalCase FEATURE_NAME}}> repository,
+    IUnitOfWork unitOfWork,
     I{{pascalCase FEATURE_NAME}}AnalyzerAgent analyzer,
     ILogger<{{pascalCase FEATURE_NAME}}ProcessorJob> logger) : I{{pascalCase FEATURE_NAME}}ProcessorJob
 {
@@ -31,32 +34,33 @@ public class {{pascalCase FEATURE_NAME}}ProcessorJob(
 
         try
         {
-            // Get the entity
-            var item = await service.GetByIdAsync(id, cancellationToken);
-            if (item is null)
+            // Get the entity directly from the repository
+            var entity = await repository.GetByIdAsync(id, cancellationToken);
+            if (entity is null)
             {
                 logger.LogWarning("{{pascalCase FEATURE_NAME}} with ID {Id} not found, skipping", id);
                 return;
             }
 
             // Check if already processed
-            if (item.Status == {{pascalCase FEATURE_NAME}}Status.Completed)
+            if (entity.Status == {{pascalCase FEATURE_NAME}}Status.Completed)
             {
                 logger.LogInformation("{{pascalCase FEATURE_NAME}} {Id} already completed, skipping", id);
                 return;
             }
 
-            // Perform analysis (if applicable)
-            var analysisData = new {{pascalCase FEATURE_NAME}}Data(item.Name);
+            // Perform MAF agent analysis (if applicable)
+            var analysisData = new {{pascalCase FEATURE_NAME}}Data(entity.Name);
             var analysis = await analyzer.AnalyzeAsync(analysisData, cancellationToken);
 
             logger.LogInformation(
                 "{{pascalCase FEATURE_NAME}} {Id} analyzed. Confidence: {Confidence:P0}",
                 id, analysis.ConfidenceScore);
 
-            // Update status
-            // Note: You might need to add a method to update with analysis results
-            // await service.CompleteWithAnalysisAsync(id, analysis, cancellationToken);
+            // Update entity directly via repository
+            entity.MarkAsCompleted(analysis);
+            await repository.UpdateAsync(entity, cancellationToken);
+            await unitOfWork.CommitAsync(cancellationToken);
 
             logger.LogInformation("Completed {{pascalCase FEATURE_NAME}} processing for ID {Id}", id);
         }
@@ -100,10 +104,10 @@ public class {{pascalCase FEATURE_NAME}}ProcessorJob(
 
 /// <summary>
 /// Batch job for processing multiple {{pascalCase FEATURE_NAME}}s.
+/// Queries pending items via IRepository and enqueues individual jobs.
 /// </summary>
 public class {{pascalCase FEATURE_NAME}}BatchProcessorJob(
-    I{{pascalCase FEATURE_NAME}}Service service,
-    I{{pascalCase FEATURE_NAME}}ProcessorJob itemProcessor,
+    IRepository<{{pascalCase FEATURE_NAME}}> repository,
     ILogger<{{pascalCase FEATURE_NAME}}BatchProcessorJob> logger)
 {
     /// <summary>
@@ -116,8 +120,8 @@ public class {{pascalCase FEATURE_NAME}}BatchProcessorJob(
     {
         logger.LogInformation("Starting batch processing for pending {{pascalCase FEATURE_NAME}}s");
 
-        var items = await service.GetAllAsync(cancellationToken);
-        var pending = items.Where(x => x.Status == {{pascalCase FEATURE_NAME}}Status.Pending).ToList();
+        var allItems = await repository.GetAllAsync(cancellationToken);
+        var pending = allItems.Where(x => x.Status == {{pascalCase FEATURE_NAME}}Status.Pending).ToList();
 
         logger.LogInformation("Found {Count} pending {{pascalCase FEATURE_NAME}}s to process", pending.Count);
 
@@ -158,7 +162,7 @@ public class {{pascalCase FEATURE_NAME}}BatchProcessorJob(
 //     options.WorkerCount = Environment.ProcessorCount * 2;
 // });
 //
-// // Register jobs
+// // Register jobs (repository + unit of work already registered)
 // builder.Services.AddScoped<I{{pascalCase FEATURE_NAME}}ProcessorJob, {{pascalCase FEATURE_NAME}}ProcessorJob>();
 // builder.Services.AddScoped<{{pascalCase FEATURE_NAME}}BatchProcessorJob>();
 //

package/framework/templates/code/dotnet/pipelines/logging-decorator.cs

@@ -0,0 +1,31 @@
+using {{pascalCase PROJECT_NAME}}.Abstractions;
+
+namespace {{pascalCase PROJECT_NAME}}.Pipelines;
+
+public sealed class LoggingDecorator<TRequest, TResponse>(
+    ILogger<LoggingDecorator<TRequest, TResponse>> logger,
+    IHandler<TRequest, TResponse> innerHandler) : IHandler<TRequest, TResponse>
+{
+    public async Task<TResponse> HandleAsync(TRequest command, CancellationToken cancellationToken)
+    {
+        var requestName = typeof(TRequest).Name;
+
+        logger.LogInformation("Handling request {RequestName}", requestName);
+
+        var response = await innerHandler.HandleAsync(command, cancellationToken);
+
+        if (response is Result result && result.IsFailure)
+        {
+            logger.LogWarning(
+                "Request {RequestName} failed with error code {ErrorCode}",
+                requestName,
+                result.Error.Code);
+        }
+        else
+        {
+            logger.LogInformation("Handled request {RequestName}", requestName);
+        }
+
+        return response;
+    }
+}

package/framework/templates/code/dotnet/pipelines/validation-decorator.cs

@@ -0,0 +1,97 @@
+using FluentValidation;
+using FluentValidation.Results;
+using {{pascalCase PROJECT_NAME}}.Abstractions;
+using {{pascalCase PROJECT_NAME}}.Abstractions.Errors;
+
+namespace {{pascalCase PROJECT_NAME}}.Pipelines;
+
+public sealed class ValidationDecorator<TRequest, TResponse>(
+    IEnumerable<IValidator<TRequest>> validators,
+    IHandler<TRequest, TResponse> innerHandler) : IHandler<TRequest, TResponse>
+{
+    public async Task<TResponse> HandleAsync(TRequest command, CancellationToken cancellationToken)
+    {
+        if (!validators.Any())
+        {
+            return await innerHandler.HandleAsync(command, cancellationToken);
+        }
+
+        var context = new ValidationContext<TRequest>(command);
+
+        ValidationFailure[] failures = (await Task.WhenAll(
+                validators.Select(v => v.ValidateAsync(context, cancellationToken))))
+            .SelectMany(r => r.Errors)
+            .Where(f => f is not null)
+            .ToArray();
+
+        if (failures.Length == 0)
+        {
+            return await innerHandler.HandleAsync(command, cancellationToken);
+        }
+
+        return CreateFailureResponse(failures);
+    }
+
+    private static TResponse CreateFailureResponse(ValidationFailure[] failures)
+    {
+        if (typeof(TResponse) == typeof(Result))
+        {
+            return (TResponse)(object)Result.Failure(CreateValidationError(failures));
+        }
+
+        if (typeof(TResponse).IsGenericType &&
+            typeof(TResponse).GetGenericTypeDefinition() == typeof(Result<>))
+        {
+            var valueType = typeof(TResponse).GetGenericArguments()[0];
+            var failureMethod = typeof(Result)
+                .GetMethods()
+                .First(m =>
+                    m.Name == nameof(Result.Failure) &&
+                    m.IsGenericMethodDefinition &&
+                    m.GetParameters().Length == 1);
+
+            var typedFailure = failureMethod
+                .MakeGenericMethod(valueType)
+                .Invoke(null, [CreateValidationError(failures)]);
+
+            return (TResponse)typedFailure!;
+        }
+
+        throw new InvalidOperationException(
+            $"ValidationDecorator supports only {nameof(Result)} and {nameof(Result<object>)} responses. " +
+            $"Received {typeof(TResponse).FullName}.");
+    }
+
+    private static TResponse CreateFailureResponse(Error error)
+    {
+        if (typeof(TResponse) == typeof(Result))
+        {
+            return (TResponse)(object)Result.Failure(error);
+        }
+
+        if (typeof(TResponse).IsGenericType &&
+            typeof(TResponse).GetGenericTypeDefinition() == typeof(Result<>))
+        {
+            var valueType = typeof(TResponse).GetGenericArguments()[0];
+            var failureMethod = typeof(Result)
+                .GetMethods()
+                .First(m =>
+                    m.Name == nameof(Result.Failure) &&
+                    m.IsGenericMethodDefinition &&
+                    m.GetParameters().Length == 1);
+
+            var typedFailure = failureMethod
+                .MakeGenericMethod(valueType)
+                .Invoke(null, [error]);
+
+            return (TResponse)typedFailure!;
+        }
+
+        throw new InvalidOperationException(
+            $"ValidationDecorator supports only {nameof(Result)} and {nameof(Result<object>)} responses. " +
+            $"Received {typeof(TResponse).FullName}.");
+    }
+
+    private static ValidationError CreateValidationError(ValidationFailure[] validationFailures) =>
+       new(validationFailures.Select(f => Error.Validation(f.ErrorCode, f.ErrorMessage)).ToArray());
+}