up

src/Concelier/__Libraries/StellaOps.Concelier.Storage.Postgres/Migrations/005_connector_state.sql

@@ -0,0 +1,69 @@
+-- Concelier Migration 005: Postgres equivalents for DTO, export, PSIRT/JP flags, and change history.
+
+CREATE SCHEMA IF NOT EXISTS concelier;
+
+CREATE TABLE IF NOT EXISTS concelier.dtos (
+    id UUID NOT NULL,
+    document_id UUID NOT NULL,
+    source_name TEXT NOT NULL,
+    format TEXT NOT NULL,
+    payload_json JSONB NOT NULL,
+    schema_version TEXT NOT NULL DEFAULT '',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    validated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    CONSTRAINT pk_concelier_dtos PRIMARY KEY (document_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_concelier_dtos_source ON concelier.dtos(source_name, created_at DESC);
+
+CREATE TABLE IF NOT EXISTS concelier.export_states (
+    id TEXT NOT NULL,
+    export_cursor TEXT NOT NULL,
+    last_full_digest TEXT,
+    last_delta_digest TEXT,
+    base_export_id TEXT,
+    base_digest TEXT,
+    target_repository TEXT,
+    files JSONB NOT NULL,
+    exporter_version TEXT NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    CONSTRAINT pk_concelier_export_states PRIMARY KEY (id)
+);
+
+CREATE TABLE IF NOT EXISTS concelier.psirt_flags (
+    advisory_id TEXT NOT NULL,
+    vendor TEXT NOT NULL,
+    source_name TEXT NOT NULL,
+    external_id TEXT,
+    recorded_at TIMESTAMPTZ NOT NULL,
+    CONSTRAINT pk_concelier_psirt_flags PRIMARY KEY (advisory_id, vendor)
+);
+
+CREATE INDEX IF NOT EXISTS idx_concelier_psirt_source ON concelier.psirt_flags(source_name, recorded_at DESC);
+
+CREATE TABLE IF NOT EXISTS concelier.jp_flags (
+    advisory_key TEXT NOT NULL,
+    source_name TEXT NOT NULL,
+    category TEXT NOT NULL,
+    vendor_status TEXT,
+    created_at TIMESTAMPTZ NOT NULL,
+    CONSTRAINT pk_concelier_jp_flags PRIMARY KEY (advisory_key)
+);
+
+CREATE TABLE IF NOT EXISTS concelier.change_history (
+    id UUID NOT NULL,
+    source_name TEXT NOT NULL,
+    advisory_key TEXT NOT NULL,
+    document_id UUID NOT NULL,
+    document_hash TEXT NOT NULL,
+    snapshot_hash TEXT NOT NULL,
+    previous_snapshot_hash TEXT,
+    snapshot JSONB NOT NULL,
+    previous_snapshot JSONB,
+    changes JSONB NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL,
+    CONSTRAINT pk_concelier_change_history PRIMARY KEY (id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_concelier_change_history_advisory
+    ON concelier.change_history(advisory_key, created_at DESC);

src/Concelier/__Libraries/StellaOps.Concelier.Storage.Postgres/Repositories/PostgresChangeHistoryStore.cs

@@ -0,0 +1,96 @@
+using System.Text.Json;
+using Dapper;
+using StellaOps.Concelier.Storage.Mongo.ChangeHistory;
+
+namespace StellaOps.Concelier.Storage.Postgres.Repositories;
+
+internal sealed class PostgresChangeHistoryStore : IChangeHistoryStore
+{
+    private readonly ConcelierDataSource _dataSource;
+    private readonly JsonSerializerOptions _jsonOptions = new(JsonSerializerDefaults.General)
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+    };
+
+    public PostgresChangeHistoryStore(ConcelierDataSource dataSource)
+    {
+        _dataSource = dataSource ?? throw new ArgumentNullException(nameof(dataSource));
+    }
+
+    public async Task AddAsync(ChangeHistoryRecord record, CancellationToken cancellationToken)
+    {
+        const string sql = """
+            INSERT INTO concelier.change_history
+            (id, source_name, advisory_key, document_id, document_hash, snapshot_hash, previous_snapshot_hash, snapshot, previous_snapshot, changes, created_at)
+            VALUES (@Id, @SourceName, @AdvisoryKey, @DocumentId, @DocumentHash, @SnapshotHash, @PreviousSnapshotHash, @Snapshot, @PreviousSnapshot, @Changes, @CreatedAt)
+            ON CONFLICT (id) DO NOTHING;
+            """;
+
+        await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
+        await connection.ExecuteAsync(new CommandDefinition(sql, new
+        {
+            record.Id,
+            record.SourceName,
+            record.AdvisoryKey,
+            record.DocumentId,
+            record.DocumentHash,
+            record.SnapshotHash,
+            record.PreviousSnapshotHash,
+            Snapshot = record.Snapshot,
+            PreviousSnapshot = record.PreviousSnapshot,
+            Changes = JsonSerializer.Serialize(record.Changes, _jsonOptions),
+            record.CreatedAt
+        }, cancellationToken: cancellationToken));
+    }
+
+    public async Task<IReadOnlyList<ChangeHistoryRecord>> GetRecentAsync(string sourceName, string advisoryKey, int limit, CancellationToken cancellationToken)
+    {
+        const string sql = """
+            SELECT id, source_name, advisory_key, document_id, document_hash, snapshot_hash, previous_snapshot_hash, snapshot, previous_snapshot, changes, created_at
+            FROM concelier.change_history
+            WHERE source_name = @SourceName AND advisory_key = @AdvisoryKey
+            ORDER BY created_at DESC
+            LIMIT @Limit;
+            """;
+
+        await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
+        var rows = await connection.QueryAsync<ChangeHistoryRow>(new CommandDefinition(sql, new
+        {
+            SourceName = sourceName,
+            AdvisoryKey = advisoryKey,
+            Limit = limit
+        }, cancellationToken: cancellationToken));
+
+        return rows.Select(ToRecord).ToArray();
+    }
+
+    private ChangeHistoryRecord ToRecord(ChangeHistoryRow row)
+    {
+        var changes = JsonSerializer.Deserialize<IReadOnlyList<ChangeHistoryFieldChange>>(row.Changes, _jsonOptions) ?? Array.Empty<ChangeHistoryFieldChange>();
+        return new ChangeHistoryRecord(
+            row.Id,
+            row.SourceName,
+            row.AdvisoryKey,
+            row.DocumentId,
+            row.DocumentHash,
+            row.SnapshotHash,
+            row.PreviousSnapshotHash ?? string.Empty,
+            row.Snapshot,
+            row.PreviousSnapshot ?? string.Empty,
+            changes,
+            row.CreatedAt);
+    }
+
+    private sealed record ChangeHistoryRow(
+        Guid Id,
+        string SourceName,
+        string AdvisoryKey,
+        Guid DocumentId,
+        string DocumentHash,
+        string SnapshotHash,
+        string? PreviousSnapshotHash,
+        string Snapshot,
+        string? PreviousSnapshot,
+        string Changes,
+        DateTimeOffset CreatedAt);
+}

src/Concelier/__Libraries/StellaOps.Concelier.Storage.Postgres/Repositories/PostgresDtoStore.cs

@@ -0,0 +1,104 @@
+using System.Text.Json;
+using Dapper;
+using StellaOps.Concelier.Storage.Mongo;
+
+namespace StellaOps.Concelier.Storage.Postgres.Repositories;
+
+internal sealed class PostgresDtoStore : IDtoStore
+{
+    private readonly ConcelierDataSource _dataSource;
+    private readonly JsonSerializerOptions _jsonOptions = new(JsonSerializerDefaults.General)
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+    };
+
+    public PostgresDtoStore(ConcelierDataSource dataSource)
+    {
+        _dataSource = dataSource ?? throw new ArgumentNullException(nameof(dataSource));
+    }
+
+    public async Task<DtoRecord> UpsertAsync(DtoRecord record, CancellationToken cancellationToken)
+    {
+        const string sql = """
+            INSERT INTO concelier.dtos (id, document_id, source_name, format, payload_json, schema_version, created_at, validated_at)
+            VALUES (@Id, @DocumentId, @SourceName, @Format, @PayloadJson, @SchemaVersion, @CreatedAt, @ValidatedAt)
+            ON CONFLICT (document_id) DO UPDATE
+            SET payload_json = EXCLUDED.payload_json,
+                schema_version = EXCLUDED.schema_version,
+                source_name = EXCLUDED.source_name,
+                format = EXCLUDED.format,
+                validated_at = EXCLUDED.validated_at
+            RETURNING id, document_id, source_name, format, payload_json, schema_version, created_at, validated_at;
+            """;
+
+        var payloadJson = record.Payload.ToJson();
+
+        await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
+        var row = await connection.QuerySingleAsync<DtoRow>(new CommandDefinition(sql, new
+        {
+            record.Id,
+            record.DocumentId,
+            record.SourceName,
+            record.Format,
+            PayloadJson = payloadJson,
+            record.SchemaVersion,
+            record.CreatedAt,
+            record.ValidatedAt
+        }, cancellationToken: cancellationToken));
+
+        return ToRecord(row);
+    }
+
+    public async Task<DtoRecord?> FindByDocumentIdAsync(Guid documentId, CancellationToken cancellationToken)
+    {
+        const string sql = """
+            SELECT id, document_id, source_name, format, payload_json, schema_version, created_at, validated_at
+            FROM concelier.dtos
+            WHERE document_id = @DocumentId
+            LIMIT 1;
+            """;
+
+        await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
+        var row = await connection.QuerySingleOrDefaultAsync<DtoRow>(new CommandDefinition(sql, new { DocumentId = documentId }, cancellationToken: cancellationToken));
+        return row is null ? null : ToRecord(row);
+    }
+
+    public async Task<IReadOnlyList<DtoRecord>> GetBySourceAsync(string sourceName, int limit, CancellationToken cancellationToken)
+    {
+        const string sql = """
+            SELECT id, document_id, source_name, format, payload_json, schema_version, created_at, validated_at
+            FROM concelier.dtos
+            WHERE source_name = @SourceName
+            ORDER BY created_at DESC
+            LIMIT @Limit;
+            """;
+
+        await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
+        var rows = await connection.QueryAsync<DtoRow>(new CommandDefinition(sql, new { SourceName = sourceName, Limit = limit }, cancellationToken: cancellationToken));
+        return rows.Select(ToRecord).ToArray();
+    }
+
+    private DtoRecord ToRecord(DtoRow row)
+    {
+        var payload = MongoDB.Bson.BsonDocument.Parse(row.PayloadJson);
+        return new DtoRecord(
+            row.Id,
+            row.DocumentId,
+            row.SourceName,
+            row.Format,
+            payload,
+            row.CreatedAt,
+            row.SchemaVersion,
+            row.ValidatedAt);
+    }
+
+    private sealed record DtoRow(
+        Guid Id,
+        Guid DocumentId,
+        string SourceName,
+        string Format,
+        string PayloadJson,
+        string SchemaVersion,
+        DateTimeOffset CreatedAt,
+        DateTimeOffset ValidatedAt);
+}

src/Concelier/__Libraries/StellaOps.Concelier.Storage.Postgres/Repositories/PostgresExportStateStore.cs

@@ -0,0 +1,119 @@
+using System.Text.Json;
+using Dapper;
+using StellaOps.Concelier.Storage.Mongo.Exporting;
+
+namespace StellaOps.Concelier.Storage.Postgres.Repositories;
+
+internal sealed class PostgresExportStateStore : IExportStateStore
+{
+    private readonly ConcelierDataSource _dataSource;
+    private readonly JsonSerializerOptions _jsonOptions = new(JsonSerializerDefaults.General)
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+    };
+
+    public PostgresExportStateStore(ConcelierDataSource dataSource)
+    {
+        _dataSource = dataSource ?? throw new ArgumentNullException(nameof(dataSource));
+    }
+
+    public async Task<ExportStateRecord?> FindAsync(string id, CancellationToken cancellationToken)
+    {
+        const string sql = """
+            SELECT id,
+                   export_cursor,
+                   last_full_digest,
+                   last_delta_digest,
+                   base_export_id,
+                   base_digest,
+                   target_repository,
+                   files,
+                   exporter_version,
+                   updated_at
+            FROM concelier.export_states
+            WHERE id = @Id
+            LIMIT 1;
+            """;
+
+        await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
+        var row = await connection.QuerySingleOrDefaultAsync<ExportStateRow>(new CommandDefinition(sql, new { Id = id }, cancellationToken: cancellationToken));
+        return row is null ? null : ToRecord(row);
+    }
+
+    public async Task<ExportStateRecord> UpsertAsync(ExportStateRecord record, CancellationToken cancellationToken)
+    {
+        const string sql = """
+            INSERT INTO concelier.export_states
+            (id, export_cursor, last_full_digest, last_delta_digest, base_export_id, base_digest, target_repository, files, exporter_version, updated_at)
+            VALUES (@Id, @ExportCursor, @LastFullDigest, @LastDeltaDigest, @BaseExportId, @BaseDigest, @TargetRepository, @Files, @ExporterVersion, @UpdatedAt)
+            ON CONFLICT (id) DO UPDATE
+            SET export_cursor = EXCLUDED.export_cursor,
+                last_full_digest = EXCLUDED.last_full_digest,
+                last_delta_digest = EXCLUDED.last_delta_digest,
+                base_export_id = EXCLUDED.base_export_id,
+                base_digest = EXCLUDED.base_digest,
+                target_repository = EXCLUDED.target_repository,
+                files = EXCLUDED.files,
+                exporter_version = EXCLUDED.exporter_version,
+                updated_at = EXCLUDED.updated_at
+            RETURNING id,
+                      export_cursor,
+                      last_full_digest,
+                      last_delta_digest,
+                      base_export_id,
+                      base_digest,
+                      target_repository,
+                      files,
+                      exporter_version,
+                      updated_at;
+            """;
+
+        var filesJson = JsonSerializer.Serialize(record.Files, _jsonOptions);
+
+        await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
+        var row = await connection.QuerySingleAsync<ExportStateRow>(new CommandDefinition(sql, new
+        {
+            record.Id,
+            record.ExportCursor,
+            record.LastFullDigest,
+            record.LastDeltaDigest,
+            record.BaseExportId,
+            record.BaseDigest,
+            record.TargetRepository,
+            Files = filesJson,
+            record.ExporterVersion,
+            record.UpdatedAt
+        }, cancellationToken: cancellationToken));
+
+        return ToRecord(row);
+    }
+
+    private ExportStateRecord ToRecord(ExportStateRow row)
+    {
+        var files = JsonSerializer.Deserialize<IReadOnlyList<ExportFileRecord>>(row.Files, _jsonOptions) ?? Array.Empty<ExportFileRecord>();
+
+        return new ExportStateRecord(
+            row.Id,
+            row.ExportCursor,
+            row.LastFullDigest,
+            row.LastDeltaDigest,
+            row.BaseExportId,
+            row.BaseDigest,
+            row.TargetRepository,
+            files,
+            row.ExporterVersion,
+            row.UpdatedAt);
+    }
+
+    private sealed record ExportStateRow(
+        string Id,
+        string ExportCursor,
+        string? LastFullDigest,
+        string? LastDeltaDigest,
+        string? BaseExportId,
+        string? BaseDigest,
+        string? TargetRepository,
+        string Files,
+        string ExporterVersion,
+        DateTimeOffset UpdatedAt);
+}

src/Concelier/__Libraries/StellaOps.Concelier.Storage.Postgres/Repositories/PostgresJpFlagStore.cs

@@ -0,0 +1,58 @@
+using Dapper;
+using StellaOps.Concelier.Storage.Mongo.JpFlags;
+
+namespace StellaOps.Concelier.Storage.Postgres.Repositories;
+
+internal sealed class PostgresJpFlagStore : IJpFlagStore
+{
+    private readonly ConcelierDataSource _dataSource;
+
+    public PostgresJpFlagStore(ConcelierDataSource dataSource)
+    {
+        _dataSource = dataSource ?? throw new ArgumentNullException(nameof(dataSource));
+    }
+
+    public async Task UpsertAsync(JpFlagRecord record, CancellationToken cancellationToken)
+    {
+        const string sql = """
+            INSERT INTO concelier.jp_flags (advisory_key, source_name, category, vendor_status, created_at)
+            VALUES (@AdvisoryKey, @SourceName, @Category, @VendorStatus, @CreatedAt)
+            ON CONFLICT (advisory_key) DO UPDATE
+            SET source_name = EXCLUDED.source_name,
+                category = EXCLUDED.category,
+                vendor_status = EXCLUDED.vendor_status,
+                created_at = EXCLUDED.created_at;
+            """;
+
+        await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
+        await connection.ExecuteAsync(new CommandDefinition(sql, new
+        {
+            record.AdvisoryKey,
+            record.SourceName,
+            record.Category,
+            record.VendorStatus,
+            record.CreatedAt
+        }, cancellationToken: cancellationToken));
+    }
+
+    public async Task<JpFlagRecord?> FindAsync(string advisoryKey, CancellationToken cancellationToken)
+    {
+        const string sql = """
+            SELECT advisory_key, source_name, category, vendor_status, created_at
+            FROM concelier.jp_flags
+            WHERE advisory_key = @AdvisoryKey
+            LIMIT 1;
+            """;
+
+        await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
+        var row = await connection.QuerySingleOrDefaultAsync<JpFlagRow>(new CommandDefinition(sql, new { AdvisoryKey = advisoryKey }, cancellationToken: cancellationToken));
+        return row is null ? null : new JpFlagRecord(row.AdvisoryKey, row.SourceName, row.Category, row.VendorStatus, row.CreatedAt);
+    }
+
+    private sealed record JpFlagRow(
+        string AdvisoryKey,
+        string SourceName,
+        string Category,
+        string? VendorStatus,
+        DateTimeOffset CreatedAt);
+}

src/Concelier/__Libraries/StellaOps.Concelier.Storage.Postgres/Repositories/PostgresPsirtFlagStore.cs

@@ -0,0 +1,76 @@
+using Dapper;
+using StellaOps.Concelier.Storage.Mongo.PsirtFlags;
+
+namespace StellaOps.Concelier.Storage.Postgres.Repositories;
+
+internal sealed class PostgresPsirtFlagStore : IPsirtFlagStore
+{
+    private readonly ConcelierDataSource _dataSource;
+
+    public PostgresPsirtFlagStore(ConcelierDataSource dataSource)
+    {
+        _dataSource = dataSource ?? throw new ArgumentNullException(nameof(dataSource));
+    }
+
+    public async Task UpsertAsync(PsirtFlagRecord flag, CancellationToken cancellationToken)
+    {
+        const string sql = """
+            INSERT INTO concelier.psirt_flags (advisory_id, vendor, source_name, external_id, recorded_at)
+            VALUES (@AdvisoryId, @Vendor, @SourceName, @ExternalId, @RecordedAt)
+            ON CONFLICT (advisory_id, vendor) DO UPDATE
+            SET source_name = EXCLUDED.source_name,
+                external_id = EXCLUDED.external_id,
+                recorded_at = EXCLUDED.recorded_at;
+            """;
+
+        await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
+        await connection.ExecuteAsync(new CommandDefinition(sql, new
+        {
+            flag.AdvisoryId,
+            flag.Vendor,
+            flag.SourceName,
+            flag.ExternalId,
+            flag.RecordedAt
+        }, cancellationToken: cancellationToken));
+    }
+
+    public async Task<IReadOnlyList<PsirtFlagRecord>> GetRecentAsync(string advisoryKey, int limit, CancellationToken cancellationToken)
+    {
+        const string sql = """
+            SELECT advisory_id, vendor, source_name, external_id, recorded_at
+            FROM concelier.psirt_flags
+            WHERE advisory_id = @AdvisoryId
+            ORDER BY recorded_at DESC
+            LIMIT @Limit;
+            """;
+
+        await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
+        var rows = await connection.QueryAsync<PsirtFlagRow>(new CommandDefinition(sql, new { AdvisoryId = advisoryKey, Limit = limit }, cancellationToken: cancellationToken));
+        return rows.Select(ToRecord).ToArray();
+    }
+
+    public async Task<PsirtFlagRecord?> FindAsync(string advisoryKey, CancellationToken cancellationToken)
+    {
+        const string sql = """
+            SELECT advisory_id, vendor, source_name, external_id, recorded_at
+            FROM concelier.psirt_flags
+            WHERE advisory_id = @AdvisoryId
+            ORDER BY recorded_at DESC
+            LIMIT 1;
+            """;
+
+        await using var connection = await _dataSource.OpenSystemConnectionAsync(cancellationToken);
+        var row = await connection.QuerySingleOrDefaultAsync<PsirtFlagRow>(new CommandDefinition(sql, new { AdvisoryId = advisoryKey }, cancellationToken: cancellationToken));
+        return row is null ? null : ToRecord(row);
+    }
+
+    private static PsirtFlagRecord ToRecord(PsirtFlagRow row) =>
+        new(row.AdvisoryId, row.Vendor, row.SourceName, row.ExternalId, row.RecordedAt);
+
+    private sealed record PsirtFlagRow(
+        string AdvisoryId,
+        string Vendor,
+        string SourceName,
+        string? ExternalId,
+        DateTimeOffset RecordedAt);
+}

src/Concelier/__Libraries/StellaOps.Concelier.Storage.Postgres/ServiceCollectionExtensions.cs

@@ -7,6 +7,10 @@ using StellaOps.Infrastructure.Postgres.Options;
 using StellaOps.Concelier.Core.Linksets;
 using MongoContracts = StellaOps.Concelier.Storage.Mongo;
 using MongoAdvisories = StellaOps.Concelier.Storage.Mongo.Advisories;
+using MongoExporting = StellaOps.Concelier.Storage.Mongo.Exporting;
+using MongoJpFlags = StellaOps.Concelier.Storage.Mongo.JpFlags;
+using MongoPsirt = StellaOps.Concelier.Storage.Mongo.PsirtFlags;
+using MongoHistory = StellaOps.Concelier.Storage.Mongo.ChangeHistory;
 
 namespace StellaOps.Concelier.Storage.Postgres;
 
@@ -51,6 +55,11 @@ public static class ServiceCollectionExtensions
         services.AddScoped<IAdvisoryLinksetStore, AdvisoryLinksetCacheRepository>();
         services.AddScoped<IAdvisoryLinksetLookup>(sp => sp.GetRequiredService<IAdvisoryLinksetStore>());
         services.AddScoped<MongoContracts.IDocumentStore, PostgresDocumentStore>();
+        services.AddScoped<MongoContracts.IDtoStore, PostgresDtoStore>();
+        services.AddScoped<MongoExporting.IExportStateStore, PostgresExportStateStore>();
+        services.AddScoped<MongoPsirt.IPsirtFlagStore, PostgresPsirtFlagStore>();
+        services.AddScoped<MongoJpFlags.IJpFlagStore, PostgresJpFlagStore>();
+        services.AddScoped<MongoHistory.IChangeHistoryStore, PostgresChangeHistoryStore>();
 
         return services;
     }
@@ -89,6 +98,11 @@ public static class ServiceCollectionExtensions
         services.AddScoped<IAdvisoryLinksetStore, AdvisoryLinksetCacheRepository>();
         services.AddScoped<IAdvisoryLinksetLookup>(sp => sp.GetRequiredService<IAdvisoryLinksetStore>());
         services.AddScoped<MongoContracts.IDocumentStore, PostgresDocumentStore>();
+        services.AddScoped<MongoContracts.IDtoStore, PostgresDtoStore>();
+        services.AddScoped<MongoExporting.IExportStateStore, PostgresExportStateStore>();
+        services.AddScoped<MongoPsirt.IPsirtFlagStore, PostgresPsirtFlagStore>();
+        services.AddScoped<MongoJpFlags.IJpFlagStore, PostgresJpFlagStore>();
+        services.AddScoped<MongoHistory.IChangeHistoryStore, PostgresChangeHistoryStore>();
 
         return services;
     }

src/Concelier/__Libraries/StellaOps.Concelier.Storage.Postgres/StellaOps.Concelier.Storage.Postgres.csproj

@@ -30,6 +30,7 @@
   <ItemGroup>
     <ProjectReference Include="..\..\..\__Libraries\StellaOps.Infrastructure.Postgres\StellaOps.Infrastructure.Postgres.csproj" />
     <ProjectReference Include="..\StellaOps.Concelier.Core\StellaOps.Concelier.Core.csproj" />
+    <ProjectReference Include="..\StellaOps.Concelier.Models\StellaOps.Concelier.Models.csproj" />
     <ProjectReference Include="..\..\..\__Libraries\StellaOps.DependencyInjection\StellaOps.DependencyInjection.csproj" />
   </ItemGroup>