@orthacms/content-server 0.0.0-reserve.0

package/dist/lib/revisions/infrastructure/persistence/drizzle-revision.store.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrizzleRevisionStore = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const drizzle_orm_1 = require("drizzle-orm");
+const database_1 = require("@orthacms/database");
+const revision_status_1 = require("../../domain/revision-status");
+const revision_table_1 = require("./revision-table");
+/**
+ * A private advisory-lock class namespacing the per-entry revision-append locks,
+ * so their hashed keys can't collide with any other advisory lock the app takes
+ * (identity's per-workspace lock, the relation-append locks). Arbitrary but fixed.
+ */
+const REVISION_APPEND_LOCK_CLASS = 0x5245; // 'RE'
+/**
+ * The Drizzle-backed {@link RevisionStore}. Writes are executor-parameterized so
+ * a snapshot commits atomically with the save it records (via the
+ * `EntryWriterService` transaction); reads run on the base connection.
+ */
+let DrizzleRevisionStore = class DrizzleRevisionStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async lockEntry(exec, entryId) {
+        await exec.execute((0, drizzle_orm_1.sql) `select pg_advisory_xact_lock(${REVISION_APPEND_LOCK_CLASS}, hashtext(${entryId}))`);
+    }
+    async nextNumber(exec, entryId) {
+        const [row] = await exec
+            .select({ max: (0, drizzle_orm_1.max)(revision_table_1.contentEntryRevisions.revisionNumber) })
+            .from(revision_table_1.contentEntryRevisions)
+            .where((0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.entryId, entryId));
+        const current = row?.max;
+        return current == null ? 1 : Number(current) + 1;
+    }
+    async append(exec, revision) {
+        const record = revision.toPersistence();
+        const [inserted] = await exec
+            .insert(revision_table_1.contentEntryRevisions)
+            .values({
+            contentType: record.contentType,
+            entryId: record.entryId,
+            workspaceId: record.workspaceId,
+            localeGroupId: record.localeGroupId,
+            locale: record.locale,
+            revisionNumber: record.revisionNumber,
+            status: record.status,
+            snapshot: record.snapshot,
+            createdBy: record.createdBy
+        })
+            .returning();
+        // A freshly appended draft is by construction the newest revision; it is
+        // never the published one (publish is a separate transition).
+        return this.toSummary(inserted, {
+            latestNumber: record.revisionNumber
+        });
+    }
+    async markPublished(exec, entryId, workspaceId, revisionNumber) {
+        const scope = (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.entryId, entryId), (0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.workspaceId, workspaceId));
+        let target = revisionNumber;
+        if (target == null) {
+            const [row] = await exec
+                .select({ max: (0, drizzle_orm_1.max)(revision_table_1.contentEntryRevisions.revisionNumber) })
+                .from(revision_table_1.contentEntryRevisions)
+                .where(scope);
+            target = row?.max == null ? 0 : Number(row.max);
+        }
+        if (target === 0)
+            return;
+        // Demote a previously-published version (there's at most one, and it
+        // isn't the one we're about to promote) so the timeline keeps a
+        // single live row. Its `published_at` is left as the historical record
+        // of when it was live.
+        await exec
+            .update(revision_table_1.contentEntryRevisions)
+            .set({ status: revision_status_1.REVISION_STATUS.Superseded })
+            .where((0, drizzle_orm_1.and)(scope, (0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.status, revision_status_1.REVISION_STATUS.Published), (0, drizzle_orm_1.ne)(revision_table_1.contentEntryRevisions.revisionNumber, target)));
+        // Promote the target version — its snapshot is exactly the live row that
+        // was just published (the latest after a save, or the earlier version
+        // whose content the publish just re-applied). Re-stamps on an idempotent
+        // re-publish, mirroring the entry row's `markPublished`.
+        await exec
+            .update(revision_table_1.contentEntryRevisions)
+            .set({
+            status: revision_status_1.REVISION_STATUS.Published,
+            publishedAt: new Date()
+        })
+            .where((0, drizzle_orm_1.and)(scope, (0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.revisionNumber, target)));
+    }
+    async markUnpublished(exec, entryId, workspaceId) {
+        await exec
+            .update(revision_table_1.contentEntryRevisions)
+            .set({ status: revision_status_1.REVISION_STATUS.Draft, publishedAt: null })
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.entryId, entryId), (0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.workspaceId, workspaceId), (0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.status, revision_status_1.REVISION_STATUS.Published)));
+    }
+    async list(contentType, entryId, workspaceId, page, pageSize) {
+        const where = this.scope(contentType, entryId, workspaceId);
+        const offset = (page - 1) * pageSize;
+        const [rows, [{ total }], latestNumber] = await Promise.all([
+            this.db
+                .select()
+                .from(revision_table_1.contentEntryRevisions)
+                .where(where)
+                .orderBy((0, drizzle_orm_1.desc)(revision_table_1.contentEntryRevisions.revisionNumber))
+                .limit(pageSize)
+                .offset(offset),
+            this.db.select({ total: (0, drizzle_orm_1.count)() }).from(revision_table_1.contentEntryRevisions).where(where),
+            this.latestNumber(contentType, entryId, workspaceId)
+        ]);
+        return {
+            items: rows.map((row) => this.toSummary(row, { latestNumber })),
+            total: Number(total)
+        };
+    }
+    async get(contentType, entryId, workspaceId, number) {
+        const [row, latestNumber] = await Promise.all([
+            this.db
+                .select()
+                .from(revision_table_1.contentEntryRevisions)
+                .where((0, drizzle_orm_1.and)(this.scope(contentType, entryId, workspaceId), (0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.revisionNumber, number)))
+                .limit(1)
+                .then((r) => r[0]),
+            this.latestNumber(contentType, entryId, workspaceId)
+        ]);
+        if (!row)
+            return undefined;
+        return {
+            ...this.toSummary(row, { latestNumber }),
+            snapshot: row.snapshot
+        };
+    }
+    /** The highest version number for an entry, or 0 if it has no revisions. */
+    async latestNumber(contentType, entryId, workspaceId) {
+        const [row] = await this.db
+            .select({ max: (0, drizzle_orm_1.max)(revision_table_1.contentEntryRevisions.revisionNumber) })
+            .from(revision_table_1.contentEntryRevisions)
+            .where(this.scope(contentType, entryId, workspaceId));
+        return row?.max == null ? 0 : Number(row.max);
+    }
+    /**
+     * The read scope every timeline query shares: one entry, in one workspace,
+     * **of one content type**. All types share `content_entry_revisions`, and
+     * the routes address an entry as `:typeName/:id` — so leaving the type out
+     * means the `:typeName` in the URL is never checked against the revision it
+     * returns, and any registered type name serves any entry's history.
+     */
+    scope(contentType, entryId, workspaceId) {
+        return (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.contentType, contentType), (0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.entryId, entryId), (0, drizzle_orm_1.eq)(revision_table_1.contentEntryRevisions.workspaceId, workspaceId));
+    }
+    /** Map a row to the metadata view, deriving the `isLatest`/`isPublished` flags. */
+    toSummary(row, ctx) {
+        const status = row.status;
+        const summary = {
+            id: row.id,
+            number: row.revisionNumber,
+            status,
+            isPublished: status === revision_status_1.REVISION_STATUS.Published,
+            isLatest: row.revisionNumber === ctx.latestNumber,
+            createdAt: row.createdAt.toISOString()
+        };
+        if (row.publishedAt)
+            summary.publishedAt = row.publishedAt.toISOString();
+        if (row.createdBy)
+            summary.authorId = row.createdBy;
+        return summary;
+    }
+};
+exports.DrizzleRevisionStore = DrizzleRevisionStore;
+exports.DrizzleRevisionStore = DrizzleRevisionStore = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, database_1.InjectDatabase)()),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], DrizzleRevisionStore);

package/dist/lib/revisions/infrastructure/persistence/revision-snapshot.d.ts

@@ -0,0 +1,17 @@
+import type { AnyContentType } from '../../../types/content-type';
+import type { RevisionSnapshot } from '../../types/revision-view';
+/** A generated content row seen as a bag of values by property name. */
+type Row = Record<string, unknown>;
+/**
+ * Build the immutable snapshot for a just-saved entry: its field `values` (the
+ * same bag the reader serves and the editor submits — scalars, localized +
+ * shared fields, and single-relation FK ids) plus the ordered target-id list of
+ * each join-backed relation field (owning many-to-many and the inverse of one).
+ *
+ * `relations` is read separately from the join tables — those links never travel
+ * in the `values` bag — inside the save transaction, so the snapshot reflects
+ * exactly what committed.
+ */
+export declare function buildSnapshot(type: AnyContentType, row: Row, relations: Record<string, string[]>): RevisionSnapshot;
+export {};
+//# sourceMappingURL=revision-snapshot.d.ts.map

package/dist/lib/revisions/infrastructure/persistence/revision-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revision-snapshot.d.ts","sourceRoot":"","sources":["../../../../../src/lib/revisions/infrastructure/persistence/revision-snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAElE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,wEAAwE;AACxE,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnC;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CACzB,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GACpC,gBAAgB,CAKlB"}

package/dist/lib/revisions/infrastructure/persistence/revision-snapshot.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSnapshot = buildSnapshot;
+const entry_row_1 = require("../../../entries/infrastructure/persistence/entry-row");
+/**
+ * Build the immutable snapshot for a just-saved entry: its field `values` (the
+ * same bag the reader serves and the editor submits — scalars, localized +
+ * shared fields, and single-relation FK ids) plus the ordered target-id list of
+ * each join-backed relation field (owning many-to-many and the inverse of one).
+ *
+ * `relations` is read separately from the join tables — those links never travel
+ * in the `values` bag — inside the save transaction, so the snapshot reflects
+ * exactly what committed.
+ */
+function buildSnapshot(type, row, relations) {
+    return {
+        values: (0, entry_row_1.toRecord)(type, row).values,
+        relations
+    };
+}

package/dist/lib/revisions/infrastructure/persistence/revision-table.d.ts

@@ -0,0 +1,228 @@
+/**
+ * The **generic** entry-revision store — one immutable snapshot per save, for
+ * every content type (mirroring the generic `EntryWriterService` engine, which
+ * backs every type with no per-aggregate table). A revision captures the whole
+ * document — scalar values, localized + shared fields, single-relation FKs, and
+ * the ordered many/inverse link sets — as a JSON `snapshot`, so a version can be
+ * reconstructed or restored independently of the live `content_<name>` row.
+ *
+ * Like every `content_<name>` table, this is **HOST-owned**: content-server
+ * emits no migrations. The table is defined here (and re-exported from the
+ * decorator-free `@orthacms/content-server/define` barrel) so the host's
+ * drizzle-kit schema entry can re-export it into the migration diff, while the
+ * persistence layer imports the same object directly. It is scoped to a
+ * workspace and keyed **per-locale** (`entry_id` is the live row, one per
+ * locale), so each translation carries its own version timeline.
+ */
+export declare const contentEntryRevisions: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "content_entry_revisions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "content_entry_revisions";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "content_entry_revisions";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        contentType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "content_type";
+            tableName: "content_entry_revisions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entryId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entry_id";
+            tableName: "content_entry_revisions";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        localeGroupId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "locale_group_id";
+            tableName: "content_entry_revisions";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        locale: import("drizzle-orm/pg-core").PgColumn<{
+            name: "locale";
+            tableName: "content_entry_revisions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        revisionNumber: import("drizzle-orm/pg-core").PgColumn<{
+            name: "revision_number";
+            tableName: "content_entry_revisions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "content_entry_revisions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        snapshot: import("drizzle-orm/pg-core").PgColumn<{
+            name: "snapshot";
+            tableName: "content_entry_revisions";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_by";
+            tableName: "content_entry_revisions";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "content_entry_revisions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        publishedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "published_at";
+            tableName: "content_entry_revisions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=revision-table.d.ts.map

package/dist/lib/revisions/infrastructure/persistence/revision-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revision-table.d.ts","sourceRoot":"","sources":["../../../../../src/lib/revisions/infrastructure/persistence/revision-table.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDjC,CAAC"}

package/dist/lib/revisions/infrastructure/persistence/revision-table.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentEntryRevisions = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+/**
+ * The **generic** entry-revision store — one immutable snapshot per save, for
+ * every content type (mirroring the generic `EntryWriterService` engine, which
+ * backs every type with no per-aggregate table). A revision captures the whole
+ * document — scalar values, localized + shared fields, single-relation FKs, and
+ * the ordered many/inverse link sets — as a JSON `snapshot`, so a version can be
+ * reconstructed or restored independently of the live `content_<name>` row.
+ *
+ * Like every `content_<name>` table, this is **HOST-owned**: content-server
+ * emits no migrations. The table is defined here (and re-exported from the
+ * decorator-free `@orthacms/content-server/define` barrel) so the host's
+ * drizzle-kit schema entry can re-export it into the migration diff, while the
+ * persistence layer imports the same object directly. It is scoped to a
+ * workspace and keyed **per-locale** (`entry_id` is the live row, one per
+ * locale), so each translation carries its own version timeline.
+ */
+exports.contentEntryRevisions = (0, pg_core_1.pgTable)('content_entry_revisions', {
+    /** Revision id. */
+    id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
+    /** Owning workspace — every read/write AND-s it in. */
+    workspaceId: (0, pg_core_1.uuid)('workspace_id').notNull(),
+    /** The registry content-type machine name (`article`, `home_page`…). */
+    contentType: (0, pg_core_1.text)('content_type').notNull(),
+    /** The live `content_<name>` row this revision belongs to (per-locale). */
+    entryId: (0, pg_core_1.uuid)('entry_id').notNull(),
+    /** The row's translation-group id — null on non-i18n types. */
+    localeGroupId: (0, pg_core_1.uuid)('locale_group_id'),
+    /** The row's locale — null on non-i18n types. */
+    locale: (0, pg_core_1.text)('locale'),
+    /** Monotonic version number within one `entry_id` (1-based). */
+    revisionNumber: (0, pg_core_1.integer)('revision_number').notNull(),
+    /** `draft` · `published` · `superseded`. */
+    status: (0, pg_core_1.text)('status').notNull(),
+    /** The full document snapshot — `{ values, relations }`. */
+    snapshot: (0, pg_core_1.jsonb)('snapshot').notNull(),
+    /** The acting user's id (identity), or null when unknown. */
+    createdBy: (0, pg_core_1.uuid)('created_by'),
+    /** When the version was captured. */
+    createdAt: (0, pg_core_1.timestamp)('created_at', { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    /** When this revision was published; null until then. */
+    publishedAt: (0, pg_core_1.timestamp)('published_at', { withTimezone: true })
+}, (table) => [
+    // One number per entry — the store allocates `max + 1` under the
+    // entry's advisory lock, and this backstops a concurrent double-insert
+    // with a 23505 rather than a silent duplicate version.
+    (0, pg_core_1.unique)('content_entry_revisions_entry_number_uq').on(table.entryId, table.revisionNumber),
+    // The timeline read: newest-first for one entry.
+    (0, pg_core_1.index)('content_entry_revisions_entry_idx').on(table.entryId, table.revisionNumber),
+    // Workspace-scoped browsing across a type.
+    (0, pg_core_1.index)('content_entry_revisions_workspace_idx').on(table.workspaceId, table.contentType)
+]);

package/dist/lib/revisions/infrastructure/queries/revision-refs.query.d.ts

@@ -0,0 +1,22 @@
+import type { AnyContentType } from '../../../types/content-type';
+import { RelationLinkService } from '../../../entries/infrastructure/persistence/relation-link.service';
+import { MediaRefsQuery } from '../../../entries/infrastructure/queries/media-refs.query';
+import type { RevisionDetail } from '../../types/revision-view';
+/**
+ * Enriches a {@link RevisionDetail} with its relation fields resolved to display
+ * refs — the "exact list of linked records" the preview shows instead of raw
+ * uuids. A single (owning) relation resolves its FK id from `snapshot.values`; a
+ * join-backed relation (owning many-to-many, or an inverse) resolves its ordered
+ * id list from `snapshot.relations`. Each field is capped at
+ * {@link PREVIEW_RELATION_REF_CAP}; the true count rides in `relationTotals` so
+ * the UI can show a "+N more". Reuses {@link RelationLinkService.resolveRefs}, so
+ * a soft-deleted / cross-workspace target reads as a `missing` ref exactly as it
+ * does on the live relations read (no title leak, no enumeration signal).
+ */
+export declare class RevisionRefsQuery {
+    private readonly relations;
+    private readonly media;
+    constructor(relations: RelationLinkService, media: MediaRefsQuery);
+    enrich(type: AnyContentType, detail: RevisionDetail, workspaceId: string): Promise<RevisionDetail>;
+}
+//# sourceMappingURL=revision-refs.query.d.ts.map

package/dist/lib/revisions/infrastructure/queries/revision-refs.query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revision-refs.query.d.ts","sourceRoot":"","sources":["../../../../../src/lib/revisions/infrastructure/queries/revision-refs.query.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAElE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mEAAmE,CAAC;AACxG,OAAO,EAAE,cAAc,EAAE,MAAM,0DAA0D,CAAC;AAE1F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAGhE;;;;;;;;;;GAUG;AACH,qBACa,iBAAiB;IAEtB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAG1B,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAHL,SAAS,EAAE,mBAAmB,EAG9B,KAAK,EAAE,cAAc;IAGpC,MAAM,CACR,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,cAAc,EACtB,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,cAAc,CAAC;CAqC7B"}

package/dist/lib/revisions/infrastructure/queries/revision-refs.query.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevisionRefsQuery = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const fields_1 = require("../../../types/fields");
+const relation_link_service_1 = require("../../../entries/infrastructure/persistence/relation-link.service");
+const media_refs_query_1 = require("../../../entries/infrastructure/queries/media-refs.query");
+const revisions_constants_1 = require("../../revisions.constants");
+/**
+ * Enriches a {@link RevisionDetail} with its relation fields resolved to display
+ * refs — the "exact list of linked records" the preview shows instead of raw
+ * uuids. A single (owning) relation resolves its FK id from `snapshot.values`; a
+ * join-backed relation (owning many-to-many, or an inverse) resolves its ordered
+ * id list from `snapshot.relations`. Each field is capped at
+ * {@link PREVIEW_RELATION_REF_CAP}; the true count rides in `relationTotals` so
+ * the UI can show a "+N more". Reuses {@link RelationLinkService.resolveRefs}, so
+ * a soft-deleted / cross-workspace target reads as a `missing` ref exactly as it
+ * does on the live relations read (no title leak, no enumeration signal).
+ */
+let RevisionRefsQuery = class RevisionRefsQuery {
+    relations;
+    media;
+    constructor(relations, 
+    // Resolves a snapshot's media ids to display refs (thumbnails); no-ops
+    // when the media plugin isn't registered.
+    media) {
+        this.relations = relations;
+        this.media = media;
+    }
+    async enrich(type, detail, workspaceId) {
+        const relationRefs = {};
+        const relationTotals = {};
+        for (const [name, spec] of Object.entries(type.fields)) {
+            if (spec.type !== fields_1.CONTENT_FIELD_TYPE.Relation || !spec.relation) {
+                continue;
+            }
+            const relation = spec.relation;
+            const joinBacked = !!relation.many || !!relation.inverse;
+            const ids = joinBacked
+                ? (detail.snapshot.relations[name] ?? [])
+                : singleFkIds(detail.snapshot.values[name]);
+            if (!ids.length)
+                continue;
+            relationTotals[name] = ids.length;
+            relationRefs[name] = await this.relations.resolveRefs(relation.to(), ids, workspaceId, revisions_constants_1.PREVIEW_RELATION_REF_CAP);
+        }
+        const mediaRefs = await this.media.forValues(type, detail.snapshot.values, workspaceId);
+        return {
+            ...detail,
+            relationRefs,
+            relationTotals,
+            ...(Object.keys(mediaRefs).length ? { mediaRefs } : {})
+        };
+    }
+};
+exports.RevisionRefsQuery = RevisionRefsQuery;
+exports.RevisionRefsQuery = RevisionRefsQuery = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [relation_link_service_1.RelationLinkService,
+        media_refs_query_1.MediaRefsQuery])
+], RevisionRefsQuery);
+/** A single-relation FK value → a 0/1-length id list. */
+function singleFkIds(value) {
+    return typeof value === 'string' && value ? [value] : [];
+}

package/dist/lib/revisions/revisions.constants.d.ts

@@ -0,0 +1,10 @@
+/** Default page size for the entry revision timeline. */
+export declare const REVISIONS_PAGE_SIZE = 20;
+/**
+ * How many linked records the preview resolves to titles **per relation field**.
+ * The snapshot stores the full ordered id list, but a relation can hold
+ * thousands of links — the preview shows the first {@link PREVIEW_RELATION_REF_CAP}
+ * with a "+N more", so a single detail read never resolves a huge link set.
+ */
+export declare const PREVIEW_RELATION_REF_CAP = 50;
+//# sourceMappingURL=revisions.constants.d.ts.map

package/dist/lib/revisions/revisions.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revisions.constants.d.ts","sourceRoot":"","sources":["../../../src/lib/revisions/revisions.constants.ts"],"names":[],"mappings":"AAAA,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,KAAK,CAAC"}

package/dist/lib/revisions/revisions.constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREVIEW_RELATION_REF_CAP = exports.REVISIONS_PAGE_SIZE = void 0;
+/** Default page size for the entry revision timeline. */
+exports.REVISIONS_PAGE_SIZE = 20;
+/**
+ * How many linked records the preview resolves to titles **per relation field**.
+ * The snapshot stores the full ordered id list, but a relation can hold
+ * thousands of links — the preview shows the first {@link PREVIEW_RELATION_REF_CAP}
+ * with a "+N more", so a single detail read never resolves a huge link set.
+ */
+exports.PREVIEW_RELATION_REF_CAP = 50;