using Titano.Data.Migrations; using Titano.Data.Repositories; using Titano.Data.Sqlite; namespace Titano.Data; /// The repositories of the Titano schema, bound either to the database (one session per call) or to one transaction. public abstract class TitanoRepositories { private protected TitanoRepositories(DbAccess access) { Archives = new ArchiveRepository(access); Sequences = new SequenceRepository(access); Frames = new FrameRepository(access); Renders = new RenderRepository(access); Jobs = new JobRepository(access); MediaCards = new MediaCardRepository(access); Users = new UserRepository(access); Tokens = new TokenRepository(access); RenderNodes = new RenderNodeRepository(access); Settings = new SettingsRepository(access); Tags = new TagRepository(access); Audit = new AuditRepository(access); Uploads = new UploadRepository(access); } public ArchiveRepository Archives { get; } public SequenceRepository Sequences { get; } public FrameRepository Frames { get; } public RenderRepository Renders { get; } public JobRepository Jobs { get; } public MediaCardRepository MediaCards { get; } public UserRepository Users { get; } public TokenRepository Tokens { get; } public RenderNodeRepository RenderNodes { get; } public SettingsRepository Settings { get; } public TagRepository Tags { get; } public AuditRepository Audit { get; } public UploadRepository Uploads { get; } } /// /// Entry point of the data layer: opens SQLite or PostgreSQL, migrates the schema and exposes the repositories. /// Each repository call borrows a pooled session; use to group calls atomically. /// /// /// /// await using var db = await TitanoDatabase.OpenAsync(DatabaseOptions.Parse(connectionString), ct); /// var page = await db.Sequences.ListAsync(new SequenceQuery { Year = 2026 }, ct); /// await using var tx = await db.BeginAsync(ct); /// await tx.Frames.InsertAsync(frame, ct); /// await tx.Sequences.RefreshStatsAsync(frame.SequenceId, ct); /// await tx.CommitAsync(ct); /// /// public sealed class TitanoDatabase : TitanoRepositories, IAsyncDisposable { private TitanoDatabase(IDatabase database, int schemaVersion) : base(new DbAccess(database)) { Database = database; SchemaVersion = schemaVersion; } /// The underlying engine, for raw sessions and engine-specific features (backups, LISTEN). public IDatabase Database { get; } public Dialect Dialect => Database.Dialect; /// Schema version after migration. public int SchemaVersion { get; private set; } /// /// Opens the database and applies pending migrations. Throws when a newer /// build already migrated it. /// public static async Task OpenAsync(DatabaseOptions options, CancellationToken cancellationToken = default) { var database = DatabaseFactory.Open(options); try { var version = await MigrationRunner.MigrateAsync(database, cancellationToken).ConfigureAwait(false); return new TitanoDatabase(database, version); } catch { await database.DisposeAsync().ConfigureAwait(false); throw; } } /// Starts a transaction whose repositories all run on it; dispose without committing to roll back. public async Task BeginAsync(CancellationToken cancellationToken = default) { var session = await Database.OpenAsync(cancellationToken).ConfigureAwait(false); try { return new TitanoTransaction(session, await session.BeginAsync(cancellationToken).ConfigureAwait(false)); } catch { await session.DisposeAsync().ConfigureAwait(false); throw; } } /// SQLite only: writes a VACUUM INTO copy into , keeping the newest . public Task BackupAsync(string directory, int keep = 3, CancellationToken cancellationToken = default) => AsSqlite().BackupAsync(directory, keep, cancellationToken); /// SQLite only: replaces the database with a backup, then migrates it to this build's schema. public async Task RestoreAsync(string backupPath, CancellationToken cancellationToken = default) { await AsSqlite().RestoreAsync(backupPath, cancellationToken).ConfigureAwait(false); SchemaVersion = await MigrationRunner.MigrateAsync(Database, cancellationToken).ConfigureAwait(false); } public ValueTask DisposeAsync() => Database.DisposeAsync(); private SqliteDatabase AsSqlite() => Database as SqliteDatabase ?? throw new NotSupportedException("Backups of a PostgreSQL database are made with the server's own tools."); } /// Repositories bound to one open transaction. public sealed class TitanoTransaction : TitanoRepositories, IAsyncDisposable { private readonly IDbTransaction _transaction; internal TitanoTransaction(IDbSession session, IDbTransaction transaction) : base(new DbAccess(session)) { Session = session; _transaction = transaction; } /// The session the transaction runs on, for statements of your own inside it. public IDbSession Session { get; } public Task CommitAsync(CancellationToken cancellationToken = default) => _transaction.CommitAsync(cancellationToken); public Task RollbackAsync(CancellationToken cancellationToken = default) => _transaction.RollbackAsync(cancellationToken); /// Rolls back unless committed, and returns the session to the pool. public async ValueTask DisposeAsync() { try { await _transaction.DisposeAsync().ConfigureAwait(false); } finally { await Session.DisposeAsync().ConfigureAwait(false); } } }