refactor(infra): migrate data access and identity impelementations to infrastructure

src/FiscalOS.Infra/Data/AppDbContext.cs

@@ -0,0 +1,64 @@
+using FiscalOS.Core.Data;
+
+namespace FiscalOS.Infra.Data;
+
+public sealed class AppDbContext(IOptions<AppDbContextOptions> ctxOptions) : DbContext
+{
+  private const string DataSourceKey = "Data Source=";
+  private readonly AppDbContextOptions _ctxOptions = ctxOptions.Value;
+
+  public DbSet<User> Users => Set<User>();
+  public DbSet<RefreshToken> RefreshTokens => Set<RefreshToken>();
+
+  protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+  {
+    var dbPath = _ctxOptions.GetFullyQualifiedDatabasePath();
+    var dbDirectory = Path.GetDirectoryName(dbPath) ?? throw new InvalidOperationException("Database directory path could not be determined.");
+
+    if (Directory.Exists(dbDirectory) is false)
+    {
+      Directory.CreateDirectory(dbDirectory);
+    }
+
+    var connectionString = $"{DataSourceKey}{dbPath}";
+
+    optionsBuilder.UseSqlite(connectionString)
+      .AddInterceptors(new TimestampInterceptor());
+  }
+
+  protected override void OnModelCreating(ModelBuilder modelBuilder)
+  {
+    base.OnModelCreating(modelBuilder);
+
+    var entityTypes = modelBuilder.Model.GetEntityTypes()
+      .Where(static e => typeof(Entity).IsAssignableFrom(e.ClrType));
+
+    foreach (var entityType in entityTypes)
+    {
+      modelBuilder.Entity(entityType.ClrType)
+          .HasKey(nameof(Entity.Id));
+
+      modelBuilder.Entity(entityType.ClrType)
+          .Property(nameof(Entity.CreatedAt));
+
+      modelBuilder.Entity(entityType.ClrType)
+          .Property(nameof(Entity.UpdatedAt));
+    }
+
+    modelBuilder.Entity<User>(static eb =>
+    {
+      eb.HasMany(static u => u.RefreshTokens)
+        .WithOne(static t => t.User)
+        .HasForeignKey(static t => t.UserId)
+        .OnDelete(DeleteBehavior.Cascade);
+
+      eb.Property(static u => u.Username);
+      eb.Property(static u => u.HashedPassword);
+    });
+
+    modelBuilder.Entity<RefreshToken>(static eb =>
+    {
+      eb.Property(static t => t.Id);
+    });
+  }
+}

src/FiscalOS.Infra/Data/AppDbContextOptions.cs

@@ -0,0 +1,26 @@
+namespace FiscalOS.Infra.Data;
+
+public sealed record AppDbContextOptions
+{
+  public string DatabaseFilePath { get; init; } = string.Empty;
+  public string GetFullyQualifiedDatabasePath()
+  {
+    return Path.GetFullPath(DatabaseFilePath, AppContext.BaseDirectory);
+  }
+}
+
+public sealed record AppDbContextOptionsSetup : IConfigureOptions<AppDbContextOptions>
+{
+  private const string SectionName = nameof(AppDbContextOptions);
+  private readonly IConfiguration _configuration;
+
+  public AppDbContextOptionsSetup(IConfiguration configuration)
+  {
+    _configuration = configuration;
+  }
+
+  public void Configure(AppDbContextOptions options)
+  {
+    _configuration.GetSection(SectionName).Bind(options);
+  }
+}

src/FiscalOS.Infra/Data/MigrationService.cs

@@ -0,0 +1,25 @@
+namespace FiscalOS.Infra.Data;
+
+internal sealed class MigrationService(
+  IServiceProvider serviceProvider,
+  ILogger<MigrationService> logger
+) : IHostedService
+{
+  private readonly IServiceProvider _serviceProvider = serviceProvider;
+
+  public async Task StartAsync(CancellationToken cancellationToken)
+  {
+    logger.LogInformation("Applying database migrations...");
+
+    using var scope = _serviceProvider.CreateScope();
+    var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
+    await context.Database.MigrateAsync(cancellationToken).ConfigureAwait(false);
+
+    logger.LogInformation("Database migrations applied.");
+  }
+
+  public Task StopAsync(CancellationToken cancellationToken)
+  {
+    return Task.CompletedTask;
+  }
+}

src/FiscalOS.Infra/Identity/PasswordHasher.cs

@@ -0,0 +1,58 @@
+namespace FiscalOS.Infra.Identity;
+
+public sealed class PasswordHasher : IPasswordHasher
+{
+  private const int SaltSize = 16;
+  private const int HashSize = 32;
+  private const int Iterations = 100_000;
+
+  private static readonly HashAlgorithmName HashAlgorithm = HashAlgorithmName.SHA512;
+
+  private PasswordHasher()
+  {
+  }
+
+  public static PasswordHasher New()
+  {
+    return new();
+  }
+
+  public string Hash(string password)
+  {
+    var salt = RandomNumberGenerator.GetBytes(SaltSize);
+    var hash = Rfc2898DeriveBytes.Pbkdf2(
+      password,
+      salt,
+      Iterations,
+      HashAlgorithm,
+      HashSize
+    );
+
+    var hashBytes = new byte[SaltSize + HashSize];
+    Array.Copy(salt, 0, hashBytes, 0, SaltSize);
+    Array.Copy(hash, 0, hashBytes, SaltSize, HashSize);
+
+    return Convert.ToBase64String(hashBytes);
+  }
+
+  public bool Verify(string providedPassword, string hashedPassword)
+  {
+    var hashBytes = Convert.FromBase64String(hashedPassword);
+
+    var salt = new byte[SaltSize];
+    Array.Copy(hashBytes, 0, salt, 0, SaltSize);
+
+    var storedHash = new byte[HashSize];
+    Array.Copy(hashBytes, SaltSize, storedHash, 0, HashSize);
+
+    var computedHash = Rfc2898DeriveBytes.Pbkdf2(
+      providedPassword,
+      salt,
+      Iterations,
+      HashAlgorithm,
+      HashSize
+    );
+
+    return CryptographicOperations.FixedTimeEquals(storedHash, computedHash);
+  }
+}

src/FiscalOS.Infra/Migrations/20260201115839_AddUsersAndRefreshTokens.Designer.cs

@@ -0,0 +1,47 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+  [DbContext(typeof(AppDbContext))]
+  [Migration("20260201115839_AddUsersAndRefreshTokens")]
+  partial class AddUsersAndRefreshTokens
+  {
+    /// <inheritdoc />
+    protected override void BuildTargetModel(ModelBuilder modelBuilder)
+    {
+#pragma warning disable 612, 618
+      modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+      modelBuilder.Entity("FiscalOS.API.Identity.RefreshToken", b =>
+          {
+            b.Property<Guid>("Id")
+                      .ValueGeneratedOnAdd()
+                      .HasColumnType("TEXT");
+
+            b.HasKey("Id");
+
+            b.ToTable("RefreshTokens");
+          });
+
+      modelBuilder.Entity("FiscalOS.API.Identity.User", b =>
+          {
+            b.Property<Guid>("Id")
+                      .ValueGeneratedOnAdd()
+                      .HasColumnType("TEXT");
+
+            b.HasKey("Id");
+
+            b.ToTable("Users");
+          });
+#pragma warning restore 612, 618
+    }
+  }
+}

src/FiscalOS.Infra/Migrations/20260201115839_AddUsersAndRefreshTokens.cs

@@ -0,0 +1,48 @@
+using System;
+
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+  /// <inheritdoc />
+  public partial class AddUsersAndRefreshTokens : Migration
+  {
+    /// <inheritdoc />
+    protected override void Up(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.CreateTable(
+          name: "RefreshTokens",
+          columns: table => new
+          {
+            Id = table.Column<Guid>(type: "TEXT", nullable: false)
+          },
+          constraints: table =>
+          {
+            table.PrimaryKey("PK_RefreshTokens", x => x.Id);
+          });
+
+      migrationBuilder.CreateTable(
+          name: "Users",
+          columns: table => new
+          {
+            Id = table.Column<Guid>(type: "TEXT", nullable: false)
+          },
+          constraints: table =>
+          {
+            table.PrimaryKey("PK_Users", x => x.Id);
+          });
+    }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.DropTable(
+          name: "RefreshTokens");
+
+      migrationBuilder.DropTable(
+          name: "Users");
+    }
+  }
+}

src/FiscalOS.Infra/Migrations/20260201125529_AddUsernameToUsers.Designer.cs

@@ -0,0 +1,72 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+  [DbContext(typeof(AppDbContext))]
+  [Migration("20260201125529_AddUsernameToUsers")]
+  partial class AddUsernameToUsers
+  {
+    /// <inheritdoc />
+    protected override void BuildTargetModel(ModelBuilder modelBuilder)
+    {
+#pragma warning disable 612, 618
+      modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+      modelBuilder.Entity("FiscalOS.API.Identity.RefreshToken", b =>
+          {
+            b.Property<Guid>("Id")
+                      .ValueGeneratedOnAdd()
+                      .HasColumnType("TEXT");
+
+            b.Property<Guid>("UserId")
+                      .HasColumnType("TEXT");
+
+            b.HasKey("Id");
+
+            b.HasIndex("UserId");
+
+            b.ToTable("RefreshTokens");
+          });
+
+      modelBuilder.Entity("FiscalOS.API.Identity.User", b =>
+          {
+            b.Property<Guid>("Id")
+                      .ValueGeneratedOnAdd()
+                      .HasColumnType("TEXT");
+
+            b.Property<string>("Username")
+                      .IsRequired()
+                      .HasColumnType("TEXT");
+
+            b.HasKey("Id");
+
+            b.ToTable("Users");
+          });
+
+      modelBuilder.Entity("FiscalOS.API.Identity.RefreshToken", b =>
+          {
+            b.HasOne("FiscalOS.API.Identity.User", "User")
+                      .WithMany("RefreshTokens")
+                      .HasForeignKey("UserId")
+                      .OnDelete(DeleteBehavior.Cascade)
+                      .IsRequired();
+
+            b.Navigation("User");
+          });
+
+      modelBuilder.Entity("FiscalOS.API.Identity.User", b =>
+          {
+            b.Navigation("RefreshTokens");
+          });
+#pragma warning restore 612, 618
+    }
+  }
+}

src/FiscalOS.Infra/Migrations/20260201125529_AddUsernameToUsers.cs

@@ -0,0 +1,63 @@
+using System;
+
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+  /// <inheritdoc />
+  public partial class AddUsernameToUsers : Migration
+  {
+    /// <inheritdoc />
+    protected override void Up(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.AddColumn<string>(
+          name: "Username",
+          table: "Users",
+          type: "TEXT",
+          nullable: false,
+          defaultValue: "");
+
+      migrationBuilder.AddColumn<Guid>(
+          name: "UserId",
+          table: "RefreshTokens",
+          type: "TEXT",
+          nullable: false,
+          defaultValue: new Guid("00000000-0000-0000-0000-000000000000"));
+
+      migrationBuilder.CreateIndex(
+          name: "IX_RefreshTokens_UserId",
+          table: "RefreshTokens",
+          column: "UserId");
+
+      migrationBuilder.AddForeignKey(
+          name: "FK_RefreshTokens_Users_UserId",
+          table: "RefreshTokens",
+          column: "UserId",
+          principalTable: "Users",
+          principalColumn: "Id",
+          onDelete: ReferentialAction.Cascade);
+    }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.DropForeignKey(
+          name: "FK_RefreshTokens_Users_UserId",
+          table: "RefreshTokens");
+
+      migrationBuilder.DropIndex(
+          name: "IX_RefreshTokens_UserId",
+          table: "RefreshTokens");
+
+      migrationBuilder.DropColumn(
+          name: "Username",
+          table: "Users");
+
+      migrationBuilder.DropColumn(
+          name: "UserId",
+          table: "RefreshTokens");
+    }
+  }
+}

src/FiscalOS.Infra/Migrations/20260202010259_AddTimestamps.Designer.cs

@@ -0,0 +1,88 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260202010259_AddTimestamps")]
+    partial class AddTimestamps
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("RefreshTokens");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/FiscalOS.Infra/Migrations/20260202010259_AddTimestamps.cs

@@ -0,0 +1,75 @@
+using System;
+
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+  /// <inheritdoc />
+  public partial class AddTimestamps : Migration
+  {
+    /// <inheritdoc />
+    protected override void Up(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.AddColumn<DateTimeOffset>(
+          name: "CreatedAt",
+          table: "Users",
+          type: "TEXT",
+          nullable: false,
+          defaultValue: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
+
+      migrationBuilder.AddColumn<string>(
+          name: "HashedPassword",
+          table: "Users",
+          type: "TEXT",
+          nullable: false,
+          defaultValue: "");
+
+      migrationBuilder.AddColumn<DateTimeOffset>(
+          name: "UpdatedAt",
+          table: "Users",
+          type: "TEXT",
+          nullable: false,
+          defaultValue: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
+
+      migrationBuilder.AddColumn<DateTimeOffset>(
+          name: "CreatedAt",
+          table: "RefreshTokens",
+          type: "TEXT",
+          nullable: false,
+          defaultValue: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
+
+      migrationBuilder.AddColumn<DateTimeOffset>(
+          name: "UpdatedAt",
+          table: "RefreshTokens",
+          type: "TEXT",
+          nullable: false,
+          defaultValue: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
+    }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.DropColumn(
+          name: "CreatedAt",
+          table: "Users");
+
+      migrationBuilder.DropColumn(
+          name: "HashedPassword",
+          table: "Users");
+
+      migrationBuilder.DropColumn(
+          name: "UpdatedAt",
+          table: "Users");
+
+      migrationBuilder.DropColumn(
+          name: "CreatedAt",
+          table: "RefreshTokens");
+
+      migrationBuilder.DropColumn(
+          name: "UpdatedAt",
+          table: "RefreshTokens");
+    }
+  }
+}

src/FiscalOS.Infra/Migrations/AppDbContextModelSnapshot.cs

@@ -0,0 +1,85 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    partial class AppDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("RefreshTokens");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/FiscalOS.Infra/Usings.cs

@@ -0,0 +1,13 @@
+global using System.Security.Cryptography;
+
+global using FiscalOS.Core.Identity;
+global using FiscalOS.Infra.Data;
+global using FiscalOS.Infra.Identity;
+
+global using Microsoft.EntityFrameworkCore;
+global using Microsoft.EntityFrameworkCore.Diagnostics;
+global using Microsoft.Extensions.Configuration;
+global using Microsoft.Extensions.DependencyInjection;
+global using Microsoft.Extensions.Hosting;
+global using Microsoft.Extensions.Logging;
+global using Microsoft.Extensions.Options;