@polymorphism-tech/morph-spec 4.11.1 → 4.13.0

package/framework/templates/code/dotnet/abstractions/api-endpoint.cs

@@ -0,0 +1,7 @@
+namespace {{pascalCase PROJECT_NAME}}.Abstractions
+{
+    public interface IApiEndpoint
+    {
+       void MapEndpoint(WebApplication app);
+    }
+}

package/framework/templates/code/dotnet/abstractions/error.cs

@@ -0,0 +1,60 @@
+namespace {{pascalCase PROJECT_NAME}}.Abstractions.Errors;
+
+public record Error(string Code, string? Description = default, ErrorType Type = ErrorType.Failure)
+    {
+        public static readonly Error None = new(string.Empty);
+        public static readonly Error Null = new("Error.NullValue", "The specified result value is null.");
+
+        public static implicit operator Result(Error error) => Result.Failure(error);
+
+    public static Error Failure(string code, string description) =>
+        new(code, description, ErrorType.Failure);
+
+    public static Error Unexpected(string code, string description) =>
+        new(code, description, ErrorType.Unexpected);
+
+    public static Error Validation(string code, string description) =>
+        new(code, description, ErrorType.Validation);
+
+    public static Error Conflict(string code, string description) =>
+        new(code, description, ErrorType.Conflict);
+
+    public static Error NotFound(string code, string description) =>
+        new(code, description, ErrorType.NotFound);
+
+    public static Error Unauthorized(string code, string description) =>
+        new(code, description, ErrorType.Unauthorized);
+
+    public static Error Forbidden(string code, string description) =>
+        new(code, description, ErrorType.Forbidden);
+
+}
+
+public enum ErrorType
+    {
+        Failure,
+        Unexpected,
+        Validation,
+        Conflict,
+        NotFound,
+        Unauthorized,
+        Forbidden,
+        Custom
+    }
+
+public sealed record ValidationError : Error
+{
+    public ValidationError(Error[] errors)
+        : base(
+            "Validation.General",
+            "One or more validation errors occurred",
+            ErrorType.Validation)
+    {
+        Errors = errors;
+    }
+
+    public Error[] Errors { get; }
+
+    public static ValidationError FromResults(IEnumerable<Result> results) =>
+        new(results.Where(r => r.IsFailure).Select(r => r.Error).ToArray());
+}

package/framework/templates/code/dotnet/abstractions/handler.cs

@@ -0,0 +1,12 @@
+using Azure.Core;
+
+
+namespace {{pascalCase PROJECT_NAME}}.Abstractions
+{
+    public interface IHandler<in TRequest, TResponse>
+    {
+        Task<TResponse> HandleAsync(TRequest command, CancellationToken cancellationToken);
+    }
+
+
+}

package/framework/templates/code/dotnet/abstractions/result.cs

@@ -0,0 +1,74 @@
+
+using {{pascalCase PROJECT_NAME}}.Abstractions.Errors;
+
+namespace {{pascalCase PROJECT_NAME}}.Abstractions
+{
+    public class Result
+    {
+        protected internal Result(bool isSuccess, Error error)
+        {
+            if (isSuccess && error != Error.None ||
+                !isSuccess && error == Error.None)
+            {
+                throw new ArgumentException("Inavlid error", nameof(error));
+            }
+
+            IsSuccess = isSuccess;
+            Error = error;
+        }
+
+        public bool IsSuccess { get; }
+
+        public bool IsFailure => !IsSuccess;
+
+        public Error Error { get; }
+
+        public static Result Success()
+        {
+            return new(true, Error.None);
+        }
+
+        public static Result<TValue> Success<TValue>(TValue value)
+        {
+            return new(value, true, Error.None);
+        }
+
+        public static Result Failure(Error error)
+        {
+            return new(false, error);
+        }
+
+        public static Result<TValue> Failure<TValue>(Error error)
+        {
+            return new(default, false, error);
+        }
+
+        public static Result<TValue> Create<TValue>(TValue? value)
+        {
+            return value is not null ? Success(value) : Failure<TValue>(Error.Null);
+        }
+    }
+
+    public class Result<TValue> : Result
+    {
+        private readonly TValue? _value;
+
+        protected internal Result(TValue? value, bool isSuccess, Error error)
+            : base(isSuccess, error)
+        {
+            _value = value;
+        }
+
+        public TValue Value => IsSuccess
+            ? _value!
+            : throw new InvalidOperationException("The value of a failure result can not be accessed.");
+
+        // ✅ SUCCESS implicit conversion
+        public static implicit operator Result<TValue>(TValue? value) => Create(value);
+
+        // ✅ ADD THIS (Failure implicit conversion)
+        public static implicit operator Result<TValue>(Error error)
+            => Failure<TValue>(error);
+    }
+
+}

package/framework/templates/code/dotnet/backend/repository.cs

@@ -1,141 +1,148 @@
-// ============================================================
-// REPOSITORY TEMPLATE
-// Generated by MORPH Framework
-// ============================================================
-
-using Microsoft.EntityFrameworkCore;
-using {{NAMESPACE}}.Domain.Entities;
-
-namespace {{NAMESPACE}}.Infrastructure.Data.Repositories;
-
-/// <summary>
-/// Repository for {{pascalCase FEATURE_NAME}} data access.
-/// </summary>
-public class {{pascalCase FEATURE_NAME}}Repository(AppDbContext context) : I{{pascalCase FEATURE_NAME}}Repository
-{
-    private readonly DbSet<{{pascalCase FEATURE_NAME}}> _dbSet = context.Set<{{pascalCase FEATURE_NAME}}>();
-
-    /// <inheritdoc />
-    public async Task<{{pascalCase FEATURE_NAME}}?> GetByIdAsync(int id, CancellationToken cancellationToken = default)
-    {
-        return await _dbSet
-            .AsNoTracking()
-            .FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public async Task<List<{{pascalCase FEATURE_NAME}}>> GetAllAsync(CancellationToken cancellationToken = default)
-    {
-        return await _dbSet
-            .AsNoTracking()
-            .OrderByDescending(x => x.CreatedAt)
-            .ToListAsync(cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public async Task AddAsync({{pascalCase FEATURE_NAME}} entity, CancellationToken cancellationToken = default)
-    {
-        await _dbSet.AddAsync(entity, cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public void Update({{pascalCase FEATURE_NAME}} entity)
-    {
-        _dbSet.Update(entity);
-    }
-
-    /// <inheritdoc />
-    public void Remove({{pascalCase FEATURE_NAME}} entity)
-    {
-        _dbSet.Remove(entity);
-    }
-
-    /// <inheritdoc />
-    public async Task SaveChangesAsync(CancellationToken cancellationToken = default)
-    {
-        await context.SaveChangesAsync(cancellationToken);
-    }
-
-    #region Additional Query Methods
-
-    /// <summary>
-    /// Gets {{pascalCase FEATURE_NAME}}s by status.
-    /// </summary>
-    public async Task<List<{{pascalCase FEATURE_NAME}}>> GetByStatusAsync(
-        {{pascalCase FEATURE_NAME}}Status status,
-        CancellationToken cancellationToken = default)
-    {
-        return await _dbSet
-            .AsNoTracking()
-            .Where(x => x.Status == status)
-            .OrderByDescending(x => x.CreatedAt)
-            .ToListAsync(cancellationToken);
-    }
-
-    /// <summary>
-    /// Checks if a {{pascalCase FEATURE_NAME}} with the given name exists.
-    /// </summary>
-    public async Task<bool> ExistsByNameAsync(
-        string name,
-        CancellationToken cancellationToken = default)
-    {
-        return await _dbSet
-            .AsNoTracking()
-            .AnyAsync(x => x.Name == name, cancellationToken);
-    }
-
-    /// <summary>
-    /// Gets {{pascalCase FEATURE_NAME}}s with pagination.
-    /// </summary>
-    public async Task<(List<{{pascalCase FEATURE_NAME}}> Items, int TotalCount)> GetPagedAsync(
-        int page,
-        int pageSize,
-        CancellationToken cancellationToken = default)
-    {
-        var query = _dbSet.AsNoTracking();
-
-        var totalCount = await query.CountAsync(cancellationToken);
-
-        var items = await query
-            .OrderByDescending(x => x.CreatedAt)
-            .Skip((page - 1) * pageSize)
-            .Take(pageSize)
-            .ToListAsync(cancellationToken);
-
-        return (items, totalCount);
-    }
-
-    #endregion
-}
-
-// ============================================================
-// EF CORE CONFIGURATION
-// ============================================================
-
-public class {{pascalCase FEATURE_NAME}}Configuration : IEntityTypeConfiguration<{{pascalCase FEATURE_NAME}}>
-{
-    public void Configure(EntityTypeBuilder<{{pascalCase FEATURE_NAME}}> builder)
-    {
-        builder.ToTable("{{pascalCase FEATURE_NAME}}s");
-
-        builder.HasKey(x => x.Id);
-
-        builder.Property(x => x.Name)
-            .IsRequired()
-            .HasMaxLength(200);
-
-        builder.Property(x => x.Status)
-            .IsRequired()
-            .HasConversion<string>();
-
-        builder.Property(x => x.CreatedAt)
-            .IsRequired();
-
-        builder.Property(x => x.UpdatedAt);
-
-        // Indexes
-        builder.HasIndex(x => x.Name);
-        builder.HasIndex(x => x.Status);
-        builder.HasIndex(x => x.CreatedAt);
-    }
-}
+// ============================================================
+// REPOSITORY + UNIT OF WORK TEMPLATE (VSA Pattern)
+// Generated by MORPH Framework
+// ============================================================
+
+using System.Data.Common;
+using Microsoft.EntityFrameworkCore;
+using {{pascalCase PROJECT_NAME}}.Database;
+
+namespace {{pascalCase PROJECT_NAME}}.Repository;
+
+// ============================================================
+// IRepository<T> — Generic repository contract
+// ============================================================
+
+public interface IRepository<T> where T : class
+{
+    Task<IEnumerable<T>> GetAllAsync(CancellationToken cancellationToken = default);
+    Task<T?> GetByIdAsync(object id, CancellationToken cancellationToken = default);
+    Task<T> AddAsync(T entity, CancellationToken cancellationToken = default);
+    Task UpdateAsync(T entity, CancellationToken cancellationToken = default);
+    Task DeleteAsync(T entity, CancellationToken cancellationToken = default);
+    IEnumerable<T> ExecuteQuery(string query, DbParameter[] dbParams);
+    Task AddRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default);
+    void RemoveRange(IEnumerable<T> entities);
+}
+
+// ============================================================
+// IUnitOfWork — Transaction boundary contract
+// ============================================================
+
+public interface IUnitOfWork
+{
+    int Commit();
+    void Rollback();
+    Task<int> CommitAsync(CancellationToken cancellationToken = default);
+    Task RollbackAsync();
+}
+
+// ============================================================
+// Repository<T> — EF Core generic repository implementation
+// ============================================================
+
+public class Repository<T> : IRepository<T> where T : class
+{
+    private readonly ApplicationDbContext _context;
+    private readonly DbSet<T> _dbSet;
+
+    public Repository(ApplicationDbContext context)
+    {
+        _context = context;
+        _dbSet = _context.Set<T>();
+    }
+
+    public async Task<IEnumerable<T>> GetAllAsync(CancellationToken cancellationToken = default)
+    {
+        return await _dbSet.ToListAsync(cancellationToken);
+    }
+
+    public async Task<T?> GetByIdAsync(object id, CancellationToken cancellationToken = default)
+    {
+        return await _dbSet.FindAsync(new[] { id }, cancellationToken);
+    }
+
+    public async Task<T> AddAsync(T entity, CancellationToken cancellationToken = default)
+    {
+        await _dbSet.AddAsync(entity, cancellationToken);
+        return entity;
+    }
+
+    public Task UpdateAsync(T entity, CancellationToken cancellationToken = default)
+    {
+        _dbSet.Update(entity);
+        return Task.CompletedTask;
+    }
+
+    public Task DeleteAsync(T entity, CancellationToken cancellationToken = default)
+    {
+        _dbSet.Remove(entity);
+        return Task.CompletedTask;
+    }
+
+    public IEnumerable<T> ExecuteQuery(string query, DbParameter[] dbParams)
+    {
+        return _dbSet
+            .FromSqlRaw(query, dbParams)
+            .AsNoTracking()
+            .AsEnumerable();
+    }
+
+    public async Task AddRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default)
+    {
+        await _dbSet.AddRangeAsync(entities, cancellationToken);
+    }
+
+    public void RemoveRange(IEnumerable<T> entities)
+    {
+        _dbSet.RemoveRange(entities);
+    }
+}
+
+// ============================================================
+// UnitOfWork — EF Core transaction management
+// ============================================================
+
+public class UnitOfWork : IUnitOfWork
+{
+    private readonly ApplicationDbContext _dataContext;
+
+    public UnitOfWork(ApplicationDbContext dataContext)
+    {
+        _dataContext = dataContext;
+    }
+
+    public int Commit()
+    {
+        return _dataContext.SaveChanges();
+    }
+
+    public async Task<int> CommitAsync(CancellationToken cancellationToken = default)
+    {
+        return await _dataContext.SaveChangesAsync(cancellationToken);
+    }
+
+    public void Rollback()
+    {
+        _dataContext.Dispose();
+    }
+
+    public async Task RollbackAsync()
+    {
+        await _dataContext.DisposeAsync();
+    }
+}
+
+// ============================================================
+// DI REGISTRATION
+// ============================================================
+//
+// In Program.cs or a DI extension method:
+//
+// builder.Services.AddDbContext<ApplicationDbContext>(options =>
+//     options.UseSqlServer(connectionString));
+//
+// builder.Services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
+// builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
+//
+// ============================================================

package/framework/templates/code/dotnet/constants/api-tags.cs

@@ -0,0 +1,6 @@
+namespace {{pascalCase PROJECT_NAME}}.Constants;
+
+public static class ApiTags
+{
+    public const string {{pascalCase FEATURE_NAME}} = "{{pascalCase FEATURE_NAME}}";
+}

package/framework/templates/code/dotnet/exceptions/exception-handler.cs

@@ -0,0 +1,32 @@
+using Microsoft.AspNetCore.Diagnostics;
+using Microsoft.AspNetCore.Mvc;
+
+namespace {{pascalCase PROJECT_NAME}}.Exceptions
+{
+    public class CustomExceptionHandler : IExceptionHandler
+    {
+        public async ValueTask<bool> TryHandleAsync(HttpContext context, Exception exception, CancellationToken cancellationToken)
+        {
+            int statusCode = exception switch
+            {
+                UnauthorizedAccessException => StatusCodes.Status401Unauthorized,
+                ArgumentException => StatusCodes.Status400BadRequest,
+                _ => StatusCodes.Status500InternalServerError
+            };
+            context.Response.StatusCode = statusCode;
+
+            var problemDetails = new ProblemDetails
+            {
+                Status = statusCode,
+                Title = "An error occurred",
+                Type = exception.GetType().Name,
+                Detail = exception.Message,
+                Instance = context.Request.Path
+            };
+
+            await context.Response.WriteAsJsonAsync(problemDetails, cancellationToken);
+
+            return true;
+        }
+    }
+}

package/framework/templates/code/dotnet/extensions/database-extensions.cs

@@ -0,0 +1,20 @@
+using Microsoft.EntityFrameworkCore;
+using {{pascalCase PROJECT_NAME}}.Database;
+
+namespace {{pascalCase PROJECT_NAME}}.Extensions
+{
+    public static class DatabaseExtensions
+    {
+        public static IServiceCollection AddSQLDatabaseConfiguration(this IServiceCollection services,
+            IConfiguration configuration)
+        {
+
+            services.AddDbContext<ApplicationDbContext>(options =>
+            {
+                options.UseNpgsql(configuration.GetConnectionString("connection"));
+            });
+
+            return services;
+        }
+    }
+}

package/framework/templates/code/dotnet/extensions/handler-registration.cs

@@ -0,0 +1,38 @@
+using System.Reflection;
+using {{pascalCase PROJECT_NAME}}.Abstractions;
+using {{pascalCase PROJECT_NAME}}.Pipelines;
+
+public static class HandlerRegistrationExtensions
+{
+    public static IServiceCollection AddHandlersFromAssembly(
+    this IServiceCollection services,
+    Assembly assembly)
+    {
+        var handlerTypes = assembly.GetTypes()
+            .Where(t =>
+                t.IsClass &&
+                !t.IsAbstract &&
+                !t.ContainsGenericParameters)
+            .ToList();
+
+        foreach (var implementation in handlerTypes)
+        {
+            var handlerInterfaces = implementation
+                .GetInterfaces()
+                .Where(i =>
+                    i.IsGenericType &&
+                    i.GetGenericTypeDefinition() == typeof(IHandler<,>));
+
+            foreach (var handlerInterface in handlerInterfaces)
+            {
+                services.AddScoped(handlerInterface, implementation);
+            }
+        }
+
+        services.Decorate(typeof(IHandler<,>), typeof(ValidationDecorator<,>));
+        services.Decorate(typeof(IHandler<,>), typeof(LoggingDecorator<,>));
+
+
+        return services;
+    }
+}

package/framework/templates/code/dotnet/extensions/health-checks.cs

@@ -0,0 +1,24 @@
+using HealthChecks.UI.Client;
+using Microsoft.AspNetCore.Diagnostics.HealthChecks;
+using {{pascalCase PROJECT_NAME}}.Database;
+
+namespace {{pascalCase PROJECT_NAME}}.Extensions
+{
+    public static class HealthChecksExtensions
+    {
+        public static IServiceCollection AddHealthChecksConfiguration(this IServiceCollection services)
+        {
+            services.AddHealthChecks()
+                .AddDbContextCheck<ApplicationDbContext>();
+            return services;
+        }
+        public static IEndpointRouteBuilder UseHealthChecks(this IEndpointRouteBuilder app)
+        {
+            app.MapHealthChecks("health", new HealthCheckOptions
+            {
+                ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
+            });
+            return app;
+        }
+    }
+}

package/framework/templates/code/dotnet/extensions/map-endpoints.cs

@@ -0,0 +1,35 @@
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using System.Net;
+using System.Reflection;
+using {{pascalCase PROJECT_NAME}}.Abstractions;
+
+namespace {{pascalCase PROJECT_NAME}}.Extensions
+{
+    public static class MapEndpointExtensions
+    {
+        public static IServiceCollection RegisterApiEndpointsFromAssembly(this IServiceCollection services, Assembly assembly)
+        {
+            var endpointTypes = assembly.GetTypes()
+                .Where(t => t.IsAssignableTo(typeof(IApiEndpoint)) && t is { IsClass: true, IsAbstract: false, IsInterface: false });
+
+            var serviceDescriptors = endpointTypes
+                .Select(type => ServiceDescriptor.Transient(typeof(IApiEndpoint), type))
+                .ToArray();
+
+            services.TryAddEnumerable(serviceDescriptors);
+            return services;
+        }
+
+         public static WebApplication MapApiEndpoints(this WebApplication app)
+        {
+            var endpoints = app.Services.GetRequiredService<IEnumerable<IApiEndpoint>>();
+
+            foreach (var endpoint in endpoints)
+            {
+                endpoint.MapEndpoint(app);
+            }
+
+            return app;
+        }
+    }
+}

package/framework/templates/code/dotnet/extensions/result-extensions.cs

@@ -0,0 +1,29 @@
+using {{pascalCase PROJECT_NAME}}.Abstractions;
+using {{pascalCase PROJECT_NAME}}.Abstractions.Errors;
+
+namespace {{pascalCase PROJECT_NAME}}.Extensions;
+
+public static class ResultExtensions
+{
+    // For non-generic Result
+    public static TOut Match<TOut>(
+        this Result result,
+        Func<TOut> onSuccess,
+        Func<Error, TOut> onFailure)
+    {
+        return result.IsSuccess
+            ? onSuccess()
+            : onFailure(result.Error);
+    }
+
+    // 🔥 THIS is what your endpoint needs
+    public static TOut Match<TIn, TOut>(
+        this Result<TIn> result,
+        Func<TIn, TOut> onSuccess,
+        Func<Error, TOut> onFailure)
+    {
+        return result.IsSuccess
+            ? onSuccess(result.Value)
+            : onFailure(result.Error);
+    }
+}

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

@@ -0,0 +1,21 @@
+using {{pascalCase PROJECT_NAME}}.Abstractions;
+using {{pascalCase PROJECT_NAME}}.Constants;
+using {{pascalCase PROJECT_NAME}}.Extensions;
+namespace {{pascalCase PROJECT_NAME}}.Features.{{pascalCase FEATURE_NAME}}Feature.{{pascalCase SLICE_NAME}};
+
+internal sealed class {{pascalCase SLICE_NAME}}Endpoint : IApiEndpoint
+{
+    public void MapEndpoint(WebApplication app)
+    {
+        app.MapPost("{{kebabCase FEATURE_NAME}}s", async (IHandler<{{pascalCase SLICE_NAME}}Request, Result<{{pascalCase SLICE_NAME}}Response>> handler, {{pascalCase SLICE_NAME}}Request command, CancellationToken cancellationToken) =>
+        {
+            var result = await handler.HandleAsync(command, cancellationToken);
+            return result.Match(
+              onSuccess: () => Results.Ok(result.Value),
+              onFailure: error => Results.BadRequest(error));
+        })
+        .WithTags(ApiTags.{{pascalCase FEATURE_NAME}}s)
+        .Produces<{{pascalCase SLICE_NAME}}Response>(StatusCodes.Status200OK)
+        .Produces(StatusCodes.Status400BadRequest);
+    }
+}