@orthacms/content-server 0.0.0-reserve.0

package/dist/lib/public-api/types/public-expansion.d.ts

@@ -0,0 +1,92 @@
+import type { PublicEntry } from './public-entry';
+/**
+ * Wire contracts for the public API's **relation** and **media** expansions.
+ * Separate from the admin's `RelationRef` / `MediaRef` for the same reason
+ * `PublicEntry` is separate from `EntryRecord`: this is a published contract,
+ * and it deliberately carries less.
+ */
+/**
+ * One relation field's links: a capped page of the linked entries, plus the
+ * true total.
+ *
+ * Each item is a **full {@link PublicEntry}** — the same shape the entry routes
+ * return, envelope and `values` alike — so a consumer renders a linked record
+ * with the code it already has instead of a second, ref-shaped model. Linked
+ * entries are **not themselves expanded**: their `relations` and `media` are
+ * absent, which is what stops one request walking the whole graph.
+ *
+ * Only published, non-deleted targets in the workspace appear. A target the
+ * caller may not see is **omitted and not counted**, rather than advertised as
+ * an unavailable record, so `total` is the number of links actually reachable.
+ */
+export interface PublicRelationFieldView {
+    items: PublicEntry[];
+    /** Visible links for this field, ignoring the page cap. */
+    total: number;
+}
+/**
+ * One media asset attached to an entry.
+ *
+ * The URLs point at `/api/v1/media/assets/:id/raw`, which takes the **same
+ * bearer token** as the read that produced them — so a server-side consumer can
+ * fetch the bytes with the credential it already has. They are still not public:
+ * a browser `<img src>` sends no `Authorization` header, so an anonymous visitor
+ * will not load one. Proxy them, or fetch and re-serve them, from whatever is
+ * holding the token. (Genuinely public, unauthenticated URLs would need signed
+ * links with an expiry, which do not exist yet.)
+ */
+export interface PublicMediaRef {
+    /** Asset id. */
+    id: string;
+    /** Display name — the original file name. */
+    name: string;
+    /** Route the bytes stream from. See the caveat above. */
+    url: string;
+    /** Route for the ~320px derivative, when one was generated. */
+    thumbUrl?: string;
+    /** Route for the ~1280px derivative, when one was generated. */
+    previewUrl?: string;
+    /** Coarse kind — image / video / audio / document / archive. */
+    kind: string;
+    /** MIME type, e.g. `image/png`. */
+    mimeType: string;
+    /**
+     * The text alternative for **this usage** — the entry value's own `alt`
+     * where it has one, the asset row's default otherwise, and `''` when the
+     * usage is {@link decorative}.
+     *
+     * `''` and `null` mean different things and a consumer should treat them
+     * differently: `''` is "render `alt=\"\"`, this image says nothing", while
+     * `null` is "nobody has supplied one" — which is a gap to report, not an
+     * instruction to hide the image from assistive tech (`ORT-83`).
+     */
+    alt: string | null;
+    /** The author marked this usage purely presentational. */
+    decorative?: true;
+    /**
+     * Timed-text tracks for a video or audio asset — everything a consumer
+     * needs to emit `<track>` elements. Empty for an image, and for a video
+     * nobody has captioned (`ORT-92`).
+     */
+    tracks: PublicMediaTrack[];
+}
+/** One timed-text track on a published video or audio asset. */
+export interface PublicMediaTrack {
+    /** `captions` / `subtitles` / `descriptions` / `chapters`. */
+    kind: string;
+    /** BCP-47 tag of the track's language. */
+    srclang: string;
+    /** The label a player shows in its track menu. */
+    label: string;
+    /** Route the WebVTT bytes stream from — same bearer token as the query. */
+    src: string;
+    /** Whether a player should enable this one by default. */
+    default?: boolean;
+}
+/** One media field's assets, in their stored order. */
+export interface PublicMediaFieldView {
+    items: PublicMediaRef[];
+    /** Assets attached to this field. */
+    total: number;
+}
+//# sourceMappingURL=public-expansion.d.ts.map

package/dist/lib/public-api/types/public-expansion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-expansion.d.ts","sourceRoot":"","sources":["../../../../src/lib/public-api/types/public-expansion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;GAKG;AAEH;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,uBAAuB;IACpC,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc;IAC3B,gBAAgB;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,GAAG,EAAE,MAAM,CAAC;IACZ,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;;;OASG;IACH,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,0DAA0D;IAC1D,UAAU,CAAC,EAAE,IAAI,CAAC;IAClB;;;;OAIG;IACH,MAAM,EAAE,gBAAgB,EAAE,CAAC;CAC9B;AAED,gEAAgE;AAChE,MAAM,WAAW,gBAAgB;IAC7B,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,GAAG,EAAE,MAAM,CAAC;IACZ,0DAA0D;IAC1D,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,uDAAuD;AACvD,MAAM,WAAW,oBAAoB;IACjC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,qCAAqC;IACrC,KAAK,EAAE,MAAM,CAAC;CACjB"}

package/dist/lib/public-api/types/public-expansion.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/registry/content-type-registry.d.ts

@@ -0,0 +1,103 @@
+/**
+ * The runtime registry of code-defined content types. Constructed once by
+ * the plugin factory, validated eagerly (duplicate names, unresolvable
+ * relation targets fail boot — not first request), and provided via DI so
+ * controllers, services, and other plugins can introspect the schema.
+ */
+import type { AnyContentType, ContentTypeKind } from '../types/content-type';
+import { type RelationLocaleSync } from '../extension/relation-locale-sync';
+/** Wire shape of a field, as served to the admin / frontends. */
+export interface SerializedField {
+    name: string;
+    type: string;
+    required: boolean;
+    /** Value differs per locale — present only when true (i18n types). */
+    localized?: boolean;
+    /**
+     * BCP-47 tag naming the language this field's content is written in, when
+     * it is not the entry's own (WCAG 3.1.2). Present only when the field
+     * declares one; the admin renders the control with it so the value is
+     * announced in the right language, and the kernel validates it.
+     */
+    lang?: string;
+    validation: Record<string, unknown>;
+    admin: Record<string, unknown>;
+    options?: readonly string[];
+    /**
+     * `onDelete` and `unique` describe the FK column of a single relation —
+     * meaningful only when `many` is false. For a many-relation the link lives
+     * in a join table whose rows always cascade and have no column to make
+     * unique, so both are omitted rather than reported as (inert) spec values.
+     */
+    relation?: {
+        to: string;
+        many: boolean;
+        onDelete?: string;
+        unique?: boolean;
+        /**
+         * How this link behaves across the record's locales — `shared` (one
+         * target for the whole group), `mirrored` (each locale links the
+         * target's own translation), or `none` (each locale keeps its own).
+         * Present only on a localized owner, where it is the difference between
+         * "editing this changes every language" and "this is yours alone".
+         */
+        localeSync?: RelationLocaleSync;
+        /** Present when this field is the inverse side of a two-way relation. */
+        inverse?: {
+            field: string;
+        };
+    };
+    /** Holds an ordered list of asset ids — present only on media fields. */
+    multiple?: boolean;
+    /**
+     * Accepted-asset restriction (kinds / MIME patterns) — media fields only,
+     * present only when the field sets one. The admin picker filters by it.
+     */
+    accept?: {
+        kinds?: readonly string[];
+        mimeTypes?: readonly string[];
+    };
+}
+/** Wire shape of a content type (summary, wizard-compatible). */
+export interface SerializedContentTypeSummary {
+    name: string;
+    kind: ContentTypeKind;
+    label: string;
+    description?: string;
+    path?: string;
+    /** Tracks publish time via a `publishedAt` envelope column. */
+    publishable: boolean;
+    /** Soft-deletes via a `deletedAt` envelope column. */
+    paranoid: boolean;
+    /** Row-per-locale via `locale` + `localeGroupId` envelope columns. */
+    i18n: boolean;
+}
+/** Wire shape of a content type with its full field schema. */
+export interface SerializedContentType extends SerializedContentTypeSummary {
+    fields: SerializedField[];
+}
+export declare class ContentTypeRegistry {
+    private readonly byName;
+    constructor(types: readonly AnyContentType[]);
+    /** All registered types, in registration order. */
+    all(): AnyContentType[];
+    /** A type by machine name, or undefined. */
+    get(name: string): AnyContentType | undefined;
+    /** The wizard-compatible summary of one type. */
+    private summaryOf;
+    /** The wire shape of one field spec. */
+    private serializeField;
+    /** Wizard-compatible summaries (matches `ContentTypeDescriptor`). */
+    summaries(): SerializedContentTypeSummary[];
+    /** Full serialized schema for one type, or undefined. */
+    serialize(name: string): SerializedContentType | undefined;
+    /**
+     * Full serialized schema for **every** registered type, in registration
+     * order — the whole model in one read, for a consumer describing the model
+     * itself rather than answering a request (e.g. the OpenAPI pass).
+     */
+    serializeAll(): SerializedContentType[];
+    /** Summary + fields of an already-resolved type. */
+    private serializeType;
+}
+//# sourceMappingURL=content-type-registry.d.ts.map

package/dist/lib/registry/content-type-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-type-registry.d.ts","sourceRoot":"","sources":["../../../src/lib/registry/content-type-registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7E,OAAO,EAGH,KAAK,kBAAkB,EAC1B,MAAM,mCAAmC,CAAC;AAE3C,iEAAiE;AACjE,MAAM,WAAW,eAAe;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,sEAAsE;IACtE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE;QACP,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,OAAO,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB;;;;;;WAMG;QACH,UAAU,CAAC,EAAE,kBAAkB,CAAC;QAChC,yEAAyE;QACzE,OAAO,CAAC,EAAE;YAAE,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC;KAC/B,CAAC;IACF,yEAAyE;IACzE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,MAAM,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,CAAC;CACzE;AAED,iEAAiE;AACjE,MAAM,WAAW,4BAA4B;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,WAAW,EAAE,OAAO,CAAC;IACrB,sDAAsD;IACtD,QAAQ,EAAE,OAAO,CAAC;IAClB,sEAAsE;IACtE,IAAI,EAAE,OAAO,CAAC;CACjB;AAED,+DAA+D;AAC/D,MAAM,WAAW,qBAAsB,SAAQ,4BAA4B;IACvE,MAAM,EAAE,eAAe,EAAE,CAAC;CAC7B;AAED,qBAAa,mBAAmB;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqC;gBAEhD,KAAK,EAAE,SAAS,cAAc,EAAE;IAoD5C,mDAAmD;IACnD,GAAG,IAAI,cAAc,EAAE;IAIvB,4CAA4C;IAC5C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAI7C,iDAAiD;IACjD,OAAO,CAAC,SAAS;IAajB,wCAAwC;IACxC,OAAO,CAAC,cAAc;IAyDtB,qEAAqE;IACrE,SAAS,IAAI,4BAA4B,EAAE;IAI3C,yDAAyD;IACzD,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS;IAM1D;;;;OAIG;IACH,YAAY,IAAI,qBAAqB,EAAE;IAIvC,oDAAoD;IACpD,OAAO,CAAC,aAAa;CAQxB"}

package/dist/lib/registry/content-type-registry.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * The runtime registry of code-defined content types. Constructed once by
+ * the plugin factory, validated eagerly (duplicate names, unresolvable
+ * relation targets fail boot — not first request), and provided via DI so
+ * controllers, services, and other plugins can introspect the schema.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentTypeRegistry = void 0;
+const fields_1 = require("../types/fields");
+const relation_locale_sync_1 = require("../extension/relation-locale-sync");
+class ContentTypeRegistry {
+    byName = new Map();
+    constructor(types) {
+        for (const type of types) {
+            if (this.byName.has(type.name)) {
+                throw new Error(`Duplicate content type "${type.name}" — names must be unique.`);
+            }
+            this.byName.set(type.name, type);
+        }
+        // Resolve every relation thunk now: a typo'd target or a type
+        // missing from `ContentPlugin({ types })` should fail boot.
+        for (const type of types) {
+            for (const [fieldName, spec] of Object.entries(type.fields)) {
+                if (spec.type !== fields_1.CONTENT_FIELD_TYPE.Relation || !spec.relation)
+                    continue;
+                const target = spec.relation.to();
+                if (!this.byName.has(target.name)) {
+                    throw new Error(`Relation "${type.name}.${fieldName}" targets ` +
+                        `"${target.name}", which is not registered with ContentPlugin.`);
+                }
+                // An inverse must point at a real relation on the owning type
+                // (`target`) that in turn points back here — else the two sides
+                // would edit different links. Fail boot on a mismatch.
+                if (spec.relation.inverse) {
+                    const owningField = target.fields[spec.relation.inverse.field];
+                    if (!owningField ||
+                        owningField.type !== fields_1.CONTENT_FIELD_TYPE.Relation ||
+                        !owningField.relation ||
+                        owningField.relation.inverse) {
+                        throw new Error(`Inverse relation "${type.name}.${fieldName}" references ` +
+                            `"${target.name}.${spec.relation.inverse.field}", which is not ` +
+                            `a storage-owning relation field.`);
+                    }
+                    if (owningField.relation.to().name !== type.name) {
+                        throw new Error(`Inverse relation "${type.name}.${fieldName}" mirrors ` +
+                            `"${target.name}.${spec.relation.inverse.field}", but that field ` +
+                            `targets "${owningField.relation.to().name}", not "${type.name}".`);
+                    }
+                }
+            }
+        }
+    }
+    /** All registered types, in registration order. */
+    all() {
+        return [...this.byName.values()];
+    }
+    /** A type by machine name, or undefined. */
+    get(name) {
+        return this.byName.get(name);
+    }
+    /** The wizard-compatible summary of one type. */
+    summaryOf(type) {
+        return {
+            name: type.name,
+            kind: type.kind,
+            label: type.label,
+            ...(type.description ? { description: type.description } : {}),
+            ...(type.path ? { path: type.path } : {}),
+            publishable: type.publishable,
+            paranoid: type.paranoid,
+            i18n: type.i18n
+        };
+    }
+    /** The wire shape of one field spec. */
+    serializeField(type, fieldName, spec) {
+        // A relation whose stored id differs per locale row — mirrored (each
+        // sibling points at the target's own translation) or unsynced —
+        // serializes as `localized`, so the admin treats it like any other
+        // per-locale field. A *shared* relation does not: every sibling
+        // genuinely holds the same id.
+        const localized = (0, relation_locale_sync_1.isPerLocaleField)(type, spec);
+        return {
+            name: fieldName,
+            type: spec.type,
+            required: spec.required,
+            ...(localized ? { localized: true } : {}),
+            ...(spec.lang ? { lang: spec.lang } : {}),
+            validation: { ...spec.validation },
+            admin: { ...spec.admin },
+            ...(spec.options ? { options: spec.options } : {}),
+            ...(spec.type === fields_1.CONTENT_FIELD_TYPE.Media
+                ? {
+                    multiple: !!spec.multiple,
+                    ...(spec.accept ? { accept: spec.accept } : {})
+                }
+                : {}),
+            ...(spec.relation
+                ? {
+                    relation: {
+                        to: spec.relation.to().name,
+                        many: spec.relation.many,
+                        // Omitted off a localized type, where every relation
+                        // would report the inert `none` and the admin has no
+                        // locales to say anything about.
+                        ...(type.i18n
+                            ? { localeSync: (0, relation_locale_sync_1.relationLocaleSync)(type, spec) }
+                            : {}),
+                        // An inverse owns no column/table, so onDelete/unique
+                        // are inert — report the back-reference instead.
+                        ...(spec.relation.inverse
+                            ? {
+                                inverse: {
+                                    field: spec.relation.inverse.field
+                                }
+                            }
+                            : spec.relation.many
+                                ? {}
+                                : {
+                                    onDelete: spec.relation.onDelete,
+                                    unique: spec.relation.unique
+                                })
+                    }
+                }
+                : {})
+        };
+    }
+    /** Wizard-compatible summaries (matches `ContentTypeDescriptor`). */
+    summaries() {
+        return this.all().map((type) => this.summaryOf(type));
+    }
+    /** Full serialized schema for one type, or undefined. */
+    serialize(name) {
+        const type = this.get(name);
+        if (!type)
+            return undefined;
+        return this.serializeType(type);
+    }
+    /**
+     * Full serialized schema for **every** registered type, in registration
+     * order — the whole model in one read, for a consumer describing the model
+     * itself rather than answering a request (e.g. the OpenAPI pass).
+     */
+    serializeAll() {
+        return this.all().map((type) => this.serializeType(type));
+    }
+    /** Summary + fields of an already-resolved type. */
+    serializeType(type) {
+        return {
+            ...this.summaryOf(type),
+            fields: Object.entries(type.fields).map(([fieldName, spec]) => this.serializeField(type, fieldName, spec))
+        };
+    }
+}
+exports.ContentTypeRegistry = ContentTypeRegistry;

package/dist/lib/revisions/application/ports/revision-store.d.ts

@@ -0,0 +1,71 @@
+import type { Database } from '@orthacms/database';
+import type { DbTransaction } from '../../../entries/infrastructure/persistence/relation-link.service';
+import type { Revision } from '../../domain/revision';
+import type { RevisionDetail, RevisionListView, RevisionSummary } from '../../types/revision-view';
+/** An executor that may be the base connection or an ambient transaction. */
+export type RevisionExecutor = Database | DbTransaction;
+/**
+ * The persistence port for entry revisions. Write primitives are
+ * **executor-parameterized** so `EntryWriterService` can append a revision on
+ * its own save transaction (atomic with the row + relation writes); reads run on
+ * the base connection.
+ */
+export interface RevisionStore {
+    /**
+     * The next version number for an entry: `max(revision_number) + 1`, else 1.
+     * Runs on the write executor so it sees the entry's own uncommitted rows.
+     * The caller serializes concurrent savers with an advisory lock so two
+     * appends can't allocate the same number.
+     */
+    nextNumber(exec: RevisionExecutor, entryId: string): Promise<number>;
+    /**
+     * Take the entry's transaction-scoped append lock, so concurrent saves of the
+     * same entry allocate distinct version numbers instead of colliding.
+     */
+    lockEntry(exec: RevisionExecutor, entryId: string): Promise<void>;
+    /** Insert a revision on `exec`, returning its summary view. */
+    append(exec: RevisionExecutor, revision: Revision): Promise<RevisionSummary>;
+    /**
+     * Promote one revision to `published` (stamping `published_at`) and demote
+     * any previously-published revision to `superseded`, on `exec`. This is the
+     * publish transition the snapshot-on-save defers — every revision is born a
+     * `draft`, so without it the timeline never shows a version as live.
+     * Idempotent, and a no-op for an entry with no revisions.
+     *
+     * `revisionNumber` names the version to promote; omitted, it targets the
+     * **latest**, which is exactly the just-published live row (every save
+     * appends one). It is passed only when publishing a *specific* earlier
+     * version, whose content the caller has already re-applied to the live row —
+     * that version becomes live in place instead of being copied to a new one.
+     */
+    markPublished(exec: RevisionExecutor, entryId: string, workspaceId: string, revisionNumber?: number): Promise<void>;
+    /**
+     * Demote the entry's currently-published revision back to `draft` (clearing
+     * `published_at`) on `exec` — the unpublish counterpart. At most one
+     * revision is published, so this transitions exactly that one; a no-op if
+     * none is.
+     */
+    markUnpublished(exec: RevisionExecutor, entryId: string, workspaceId: string): Promise<void>;
+    /**
+     * One page of an entry's revisions, newest first, scoped to the content
+     * type + entry + workspace.
+     *
+     * `contentType` is part of the key, not decoration: every content type's
+     * rows live in one shared `content_entry_revisions` table, so without it a
+     * caller who names a *different* registered type in the route
+     * (`GET /api/content/author/:articleId/revisions`) reads the entry's real
+     * history anyway — the route param would be checked against nothing.
+     */
+    list(contentType: string, entryId: string, workspaceId: string, page: number, pageSize: number): Promise<RevisionListView>;
+    /**
+     * One revision (with its snapshot) by version number, scoped to the content
+     * type + entry + workspace — or undefined if absent. See {@link list} for
+     * why `contentType` is part of the key.
+     */
+    get(contentType: string, entryId: string, workspaceId: string, number: number): Promise<RevisionDetail | undefined>;
+}
+/** DI token the {@link RevisionStore} is bound under. */
+export declare const REVISION_STORE: unique symbol;
+/** Injects the {@link RevisionStore}. */
+export declare const InjectRevisionStore: () => ParameterDecorator;
+//# sourceMappingURL=revision-store.d.ts.map

package/dist/lib/revisions/application/ports/revision-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"revision-store.d.ts","sourceRoot":"","sources":["../../../../../src/lib/revisions/application/ports/revision-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mEAAmE,CAAC;AACvG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EACR,cAAc,EACd,gBAAgB,EAChB,eAAe,EAClB,MAAM,2BAA2B,CAAC;AAEnC,6EAA6E;AAC7E,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,aAAa,CAAC;AAExD;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC1B;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAErE;;;OAGG;IACH,SAAS,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElE,+DAA+D;IAC/D,MAAM,CACF,IAAI,EAAE,gBAAgB,EACtB,QAAQ,EAAE,QAAQ,GACnB,OAAO,CAAC,eAAe,CAAC,CAAC;IAE5B;;;;;;;;;;;;OAYG;IACH,aAAa,CACT,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB;;;;;OAKG;IACH,eAAe,CACX,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB;;;;;;;;;OASG;IACH,IAAI,CACA,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACjB,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAE7B;;;;OAIG;IACH,GAAG,CACC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAAC;CAC1C;AAED,yDAAyD;AACzD,eAAO,MAAM,cAAc,eAA2B,CAAC;AAEvD,yCAAyC;AACzC,eAAO,MAAM,mBAAmB,QAAO,kBACb,CAAC"}

package/dist/lib/revisions/application/ports/revision-store.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectRevisionStore = exports.REVISION_STORE = void 0;
+const common_1 = require("@nestjs/common");
+/** DI token the {@link RevisionStore} is bound under. */
+exports.REVISION_STORE = Symbol('REVISION_STORE');
+/** Injects the {@link RevisionStore}. */
+const InjectRevisionStore = () => (0, common_1.Inject)(exports.REVISION_STORE);
+exports.InjectRevisionStore = InjectRevisionStore;

package/dist/lib/revisions/application/use-cases/publish-revision.use-case.d.ts

@@ -0,0 +1,40 @@
+import type { EventActor } from '@orthacms/database';
+import type { AnyContentType } from '../../../types/content-type';
+import { PublishEntryUseCase } from '../../../entries/application/use-cases/publish-entry.use-case';
+import type { EntryRecord } from '../../../entries/types/entry-list-view';
+import { type RevisionStore } from '../ports/revision-store';
+import { RestoreRevisionUseCase } from './restore-revision.use-case';
+/**
+ * **Publish a specific version** — make any version the entry's live one, so an
+ * editor can switch back to an earlier version and publish it (not only the
+ * newest draft).
+ *
+ * Publishing marks the **chosen version itself** live: it is flipped to
+ * `published` in place and the previously-published one to `superseded` (via
+ * {@link PublishEntryUseCase}). Publishing an **earlier** version first
+ * re-applies its content onto the live row (through
+ * {@link RestoreRevisionUseCase}, with `appendRevision: false`) so the live
+ * document matches what is published — but records **no new version** for it.
+ * Publishing v2 therefore leaves the timeline at its existing length with v2
+ * marked live, rather than minting a v6 copy of v2 on every publish.
+ *
+ * History is still never rewritten or deleted — only version *statuses* move,
+ * which is what publish means. One consequence to know: after publishing an
+ * earlier version the **latest** version is no longer the live content (it is a
+ * newer draft that was not published). The timeline distinguishes the two —
+ * "Live" marks the published version, "Current" the newest one — and the next
+ * save appends a version equal to the live row again.
+ *
+ * Publishing re-validates through the publish gate, so an incomplete old version
+ * surfaces the same `422 { issues }` a normal publish would (the content has
+ * already been re-applied in that case, leaving it live as a draft — a
+ * deliberate, recoverable state, not a rewrite of history).
+ */
+export declare class PublishRevisionUseCase {
+    private readonly restoreRevision;
+    private readonly publishEntry;
+    private readonly store;
+    constructor(restoreRevision: RestoreRevisionUseCase, publishEntry: PublishEntryUseCase, store: RevisionStore);
+    execute(type: AnyContentType, id: string, number: number, workspaceId: string, actor: EventActor | null): Promise<EntryRecord>;
+}
+//# sourceMappingURL=publish-revision.use-case.d.ts.map

package/dist/lib/revisions/application/use-cases/publish-revision.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-revision.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/revisions/application/use-cases/publish-revision.use-case.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+DAA+D,CAAC;AACpG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AAC1E,OAAO,EAEH,KAAK,aAAa,EACrB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBACa,sBAAsB;IAE3B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY;IACN,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAF5B,eAAe,EAAE,sBAAsB,EACvC,YAAY,EAAE,mBAAmB,EACV,KAAK,EAAE,aAAa;IAG1D,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,UAAU,GAAG,IAAI,GACzB,OAAO,CAAC,WAAW,CAAC;CA8B1B"}

package/dist/lib/revisions/application/use-cases/publish-revision.use-case.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublishRevisionUseCase = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const publish_entry_use_case_1 = require("../../../entries/application/use-cases/publish-entry.use-case");
+const revision_store_1 = require("../ports/revision-store");
+const restore_revision_use_case_1 = require("./restore-revision.use-case");
+/**
+ * **Publish a specific version** — make any version the entry's live one, so an
+ * editor can switch back to an earlier version and publish it (not only the
+ * newest draft).
+ *
+ * Publishing marks the **chosen version itself** live: it is flipped to
+ * `published` in place and the previously-published one to `superseded` (via
+ * {@link PublishEntryUseCase}). Publishing an **earlier** version first
+ * re-applies its content onto the live row (through
+ * {@link RestoreRevisionUseCase}, with `appendRevision: false`) so the live
+ * document matches what is published — but records **no new version** for it.
+ * Publishing v2 therefore leaves the timeline at its existing length with v2
+ * marked live, rather than minting a v6 copy of v2 on every publish.
+ *
+ * History is still never rewritten or deleted — only version *statuses* move,
+ * which is what publish means. One consequence to know: after publishing an
+ * earlier version the **latest** version is no longer the live content (it is a
+ * newer draft that was not published). The timeline distinguishes the two —
+ * "Live" marks the published version, "Current" the newest one — and the next
+ * save appends a version equal to the live row again.
+ *
+ * Publishing re-validates through the publish gate, so an incomplete old version
+ * surfaces the same `422 { issues }` a normal publish would (the content has
+ * already been re-applied in that case, leaving it live as a draft — a
+ * deliberate, recoverable state, not a rewrite of history).
+ */
+let PublishRevisionUseCase = class PublishRevisionUseCase {
+    restoreRevision;
+    publishEntry;
+    store;
+    constructor(restoreRevision, publishEntry, store) {
+        this.restoreRevision = restoreRevision;
+        this.publishEntry = publishEntry;
+        this.store = store;
+    }
+    async execute(type, id, number, workspaceId, actor) {
+        const detail = await this.store.get(type.name, id, workspaceId, number);
+        if (!detail) {
+            throw new common_1.NotFoundException(`No revision #${number} for entry "${id}" on "${type.name}".`);
+        }
+        // Only re-apply an *earlier* version; the latest is already the live row.
+        // `appendRevision: false` — this version already exists in the timeline
+        // and is about to be marked live, so a copy of it would be noise.
+        if (!detail.isLatest) {
+            await this.restoreRevision.execute(type, id, number, workspaceId, actor, { appendRevision: false });
+        }
+        // Mark *this* version live (not merely "the latest"), now that the live
+        // row carries its content.
+        return this.publishEntry.execute(type, id, workspaceId, actor ?? undefined, number);
+    }
+};
+exports.PublishRevisionUseCase = PublishRevisionUseCase;
+exports.PublishRevisionUseCase = PublishRevisionUseCase = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(2, (0, revision_store_1.InjectRevisionStore)()),
+    tslib_1.__metadata("design:paramtypes", [restore_revision_use_case_1.RestoreRevisionUseCase,
+        publish_entry_use_case_1.PublishEntryUseCase, Object])
+], PublishRevisionUseCase);

package/dist/lib/revisions/application/use-cases/restore-revision.use-case.d.ts

@@ -0,0 +1,36 @@
+import type { EventActor } from '@orthacms/database';
+import type { AnyContentType } from '../../../types/content-type';
+import { EntryWriterService } from '../../../entries/infrastructure/persistence/entry-writer.service';
+import type { EntryRecord } from '../../../entries/types/entry-list-view';
+import { type RevisionStore } from '../ports/revision-store';
+/**
+ * Restore an entry to an earlier revision. History is **append-only** — a
+ * restore never rewrites or deletes past versions: it applies the chosen
+ * snapshot back onto the live row through the normal save path, which in turn
+ * records the restore as a **new** draft revision (so v5 restoring v2 yields a
+ * fresh v6 equal to v2). The snapshot's `values` (scalars, localized + shared
+ * fields, single-relation FKs) and its owning many-to-many link sets are
+ * re-applied; inverse relations mirror their owning side and aren't written from
+ * here.
+ */
+export declare class RestoreRevisionUseCase {
+    private readonly writer;
+    private readonly store;
+    constructor(writer: EntryWriterService, store: RevisionStore);
+    execute(type: AnyContentType, id: string, number: number, workspaceId: string, 
+    /**
+     * The acting user — stamped on the new revision and on the
+     * `entry.updated` event the underlying save raises, so a restore is
+     * attributable in the audit log like any other edit.
+     */
+    actor: EventActor | null, options?: {
+        /**
+         * Whether this restore records a new version (default `true` — the
+         * append-only Restore action). {@link PublishRevisionUseCase} passes
+         * `false`: it re-applies the snapshot only so the chosen version's
+         * content is live, then marks *that* version published in place.
+         */
+        appendRevision?: boolean;
+    }): Promise<EntryRecord>;
+}
+//# sourceMappingURL=restore-revision.use-case.d.ts.map

package/dist/lib/revisions/application/use-cases/restore-revision.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restore-revision.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/revisions/application/use-cases/restore-revision.use-case.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAElE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kEAAkE,CAAC;AACtG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AAC1E,OAAO,EAEH,KAAK,aAAa,EACrB,MAAM,yBAAyB,CAAC;AAEjC;;;;;;;;;GASG;AACH,qBACa,sBAAsB;IAE3B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACA,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAD5B,MAAM,EAAE,kBAAkB,EACH,KAAK,EAAE,aAAa;IAG1D,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM;IACnB;;;;OAIG;IACH,KAAK,EAAE,UAAU,GAAG,IAAI,EACxB,OAAO,CAAC,EAAE;QACN;;;;;WAKG;QACH,cAAc,CAAC,EAAE,OAAO,CAAC;KAC5B,GACF,OAAO,CAAC,WAAW,CAAC;CA+B1B"}