Built-in template catalog

#nullable enable
namespace Socotra.Templates.Shared;

public abstract class BaseEntity
{
    public Guid Id { get; protected set; } = Guid.NewGuid();
    public DateTime CreatedAt { get; protected set; } = DateTime.UtcNow;
    public DateTime? UpdatedAt { get; protected set; }
}

#nullable enable
namespace Socotra.Templates.Shared;

public abstract class ValueObject : IEquatable<ValueObject>
{
    public abstract bool Equals(ValueObject? other);
    public abstract override int GetHashCode();

    public static bool operator ==(ValueObject? left, ValueObject? right)
    {
        if (left is null && right is null) return true;
        if (left is null || right is null) return false;
        return left.Equals(right);
    }

    public static bool operator !=(ValueObject? left, ValueObject? right) => !(left == right);
    public override bool Equals(object? obj) => Equals(obj as ValueObject);
}

#nullable enable
namespace Socotra.Templates.Shared;

public abstract class AggregateRoot : BaseEntity
{
    private readonly List<DomainEvent> _domainEvents = new();
    public IReadOnlyList<DomainEvent> DomainEvents => _domainEvents.AsReadOnly();

    protected void RaiseEvent(DomainEvent domainEvent) => _domainEvents.Add(domainEvent);
    public void ClearEvents() => _domainEvents.Clear();
}

#nullable enable
namespace Socotra.Templates.Shared;

public abstract record DomainEvent
{
    public DateTime OccurredAt { get; protected set; } = DateTime.UtcNow;
}

#nullable enable
namespace Socotra.Templates.Shared;

public interface ICommand { }

#nullable enable
namespace Socotra.Templates.Shared;

public interface IQuery { }

#nullable enable
namespace Socotra.Templates.Shared;

public interface IRepository<T> where T : class
{
    Task<T?> GetByIdAsync(Guid id, CancellationToken cancellationToken = default);
    Task<IReadOnlyList<T>> GetAllAsync(CancellationToken cancellationToken = default);
    Task AddAsync(T entity, CancellationToken cancellationToken = default);
    Task UpdateAsync(T entity, CancellationToken cancellationToken = default);
    Task DeleteAsync(T entity, CancellationToken cancellationToken = default);
}

#nullable enable
namespace Socotra.Templates.Shared;

public class Result
{
    public bool IsSuccess { get; }
    public bool IsFailure => !IsSuccess;
    public string? Error { get; }

    protected Result(bool isSuccess, string? error)
    {
        IsSuccess = isSuccess;
        Error = error;
    }

    public static Result Success() => new(true, null);
    public static Result Failure(string error) => new(false, error);
}

public class Result<T> : Result
{
    public T? Value { get; }
    protected Result(T value) : base(true, null) => Value = value;
    private Result(string error) : base(false, error) { }

    public static Result<T> Success(T value) => new(value);
    public static new Result<T> Failure(string error) => new(error);
}

#nullable enable
using Microsoft.EntityFrameworkCore;

namespace Socotra.Templates.Shared;

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
    }
}

#nullable enable
using Microsoft.Extensions.DependencyInjection;

namespace Socotra.Templates.Shared;

public static class DependencyInjection
{
    public static IServiceCollection AddInfrastructure(this IServiceCollection services)
    {
        return services;
    }
}