@orthacms/content-server 0.4.3 → 0.5.0

package/dist/lib/entries/services/entry-row.d.ts

@@ -1,56 +0,0 @@
-/**
- * Pure row ↔ entry mappers shared by the read ({@link EntriesService}) and write
- * ({@link EntryWriterService}) paths, so the wire shape and the column projection
- * have one definition each. No DB access, no NestJS — just shape translation.
- */
-import type { AnyContentType } from '../../types/content-type';
-import type { EntryRecord } from '../types/entry-list-view';
-/** A generated content table row seen as a bag of values by property name. */
-type Row = Record<string, unknown>;
-/**
- * Map a raw DB row to the admin {@link EntryRecord}: envelope fields plus a
- * `values` bag keyed by field name. `status` is emitted only for publishable
- * types. Relations that own no column — many-relations (their links live in join
- * tables) and inverse/back-references (they reuse the owning side's storage) —
- * aren't selected here; an owning single relation passes through as its FK uuid.
- */
-export declare function toRecord(type: AnyContentType, row: Row): EntryRecord;
-/**
- * Normalize the admin's (string-shaped) `values` bag to the proper JS types the
- * validator and storage expect — numbers parsed, JSON text parsed, empties
- * collapsed to null — keeping every field (so a many-relation array still
- * validates). The single coercion point: both {@link toColumns} (storage) and
- * the writer's validation run against the result, so they can't disagree on a
- * value's type. Datetime/date stay ISO strings (the validator accepts them;
- * {@link toColumns} converts datetime to `Date` for `timestamptz`).
- */
-export declare function coerceValues(type: AnyContentType, values: Record<string, unknown>): Record<string, unknown>;
-/**
- * Project a (coerced) `values` bag onto the columns of a generated table for an
- * insert/update. Includes only keys declared on the type (reserved envelope
- * columns — `status`/`published_at`/`deleted_at`/timestamps — are owned by the
- * service, never the client), skips relations that own no column (many-relations,
- * whose links live in join tables, and inverse/back-references, which reuse the
- * owning side's storage), collapses empties to `null`, converts a `datetime` to a `Date` for
- * the `timestamptz` column (guarding an invalid date to `null` rather than
- * letting `pg` throw), and drops a `NaN` number to `null`. A field absent from
- * `values` is written as `null` — the editor submits the full bag, so a write
- * replaces the whole document.
- */
-export declare function toColumns(type: AnyContentType, values: Record<string, unknown>): Record<string, unknown>;
-/**
- * A human display label for an entry — the first non-empty title-eligible field's
- * value (see {@link TITLE_FIELD_TYPES}), falling back to the id. Used to label
- * rows in the bulk-publish preview.
- */
-export declare function entryTitle(type: AnyContentType, row: Row): string;
-/**
- * The slug handle for an entry — the value of its **slug field**: the first
- * field flagged `admin.widget === 'slug'`, else a field literally named `slug`.
- * Returns the trimmed value when present and non-empty, otherwise `undefined`
- * (the type has no slug field, or the row's slug is blank). Used to give a
- * linked relation record a stable `/handle` in the admin.
- */
-export declare function entrySlug(type: AnyContentType, row: Row): string | undefined;
-export {};
-//# sourceMappingURL=entry-row.d.ts.map

package/dist/lib/entries/services/entry-row.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entry-row.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/services/entry-row.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE5D,8EAA8E;AAC9E,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnC;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,GAAG,GAAG,WAAW,CAwBpE;AAKD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CACxB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgCzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACrB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA0BzB;AAWD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,CAOjE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAS5E"}

package/dist/lib/entries/services/entry-writer.service.d.ts

@@ -1,193 +0,0 @@
-import { type Database } from '@ortha-cms/database';
-import { type ContentEntryExtension } from '../../extension/entry-extension';
-import type { AnyContentType } from '../../types/content-type';
-import { EntryValidationService } from '../../validation/services/entry-validation.service';
-import type { EntryRecord, RelationDelta, RelationFieldView } from '../types/entry-list-view';
-import { type BulkActionResult, type BulkPublishPreview, type BulkPublishResult } from '../types/bulk-publish';
-import { RelationLinkService } from './relation-link.service';
-/**
- * The write half of the entries pipeline — create / read-one / update / publish
- * / unpublish / delete / restore / purge, plus their bulk variants. Generic over
- * the content type (like {@link EntriesService}): the physical table and its
- * envelope columns are derived from `type` at request time, so one service backs
- * every collection. {@link EntryValidationService} is the gate — nothing is
- * written or published without passing it.
- */
-export declare class EntryWriterService {
-    private readonly db;
-    private readonly validation;
-    private readonly relations;
-    private readonly extension?;
-    constructor(db: Database, validation: EntryValidationService, relations: RelationLinkService, extension?: ContentEntryExtension | undefined);
-    /**
-     * Create an entry **owned by `workspaceId`** (stamped onto the row so the
-     * reader's workspace filter and every later scoped write see it). A
-     * publishable type starts as a **draft** and may be incomplete — validation
-     * is deferred to publish. A non-publishable type is always live, so its
-     * values must validate now.
-     *
-     * The insert runs in a transaction that first takes the workspace's *shared*
-     * content lock ({@link lockWorkspaceShared}): it coordinates with the
-     * workspace delete / content-revoke guards (which take the lock exclusively),
-     * so a new entry can't land between their emptiness check and their mutation
-     * and be orphaned. Shared mode keeps concurrent creates non-blocking.
-     *
-     * `locale` / `localeGroupId` are opaque, extension-owned params: the bound
-     * extension validates them and stamps the envelope columns (a
-     * `localeGroupId` makes the row a **sibling** in that translation group). A
-     * duplicate `(group, locale)` surfaces as a **409** via {@link uniqueGuarded}.
-     */
-    create(type: AnyContentType, values: Record<string, unknown>, workspaceId: string, relations?: Record<string, RelationDelta>, locale?: string, localeGroupId?: string): Promise<EntryRecord>;
-    /**
-     * First page (+ total) of every relation field's links for one live entry,
-     * keyed by field name — what the editor loads on open. Each field is
-     * paginated, so a relation with many links contributes only its first page.
-     * 404 if the entry is missing (or soft-deleted) in this workspace.
-     */
-    getRelations(type: AnyContentType, id: string, workspaceId: string): Promise<Record<string, RelationFieldView>>;
-    /**
-     * One page of a single relation field's links (infinite-scroll for a
-     * many/inverse relation). 404 if the entry is missing; 400 if `field` isn't a
-     * relation on the type.
-     */
-    getRelationField(type: AnyContentType, id: string, field: string, page: number, pageSize: number, workspaceId: string): Promise<RelationFieldView>;
-    /**
-     * Apply the staged per-field relation deltas of a save, inside the entry's
-     * transaction — so the row and every link change commit or roll back as one.
-     * Each field must be a **many/inverse** relation (a single relation is set
-     * through `values`); a single-relation or unknown key is a 400. `applyDelta`
-     * validates the linked ids against the workspace (422 on a bad target).
-     */
-    private applyRelationDeltas;
-    /** Resolve a relation field spec on the type, or 400 if it isn't one. */
-    private relationSpec;
-    /** Read one live entry in the workspace, or 404. */
-    getOne(type: AnyContentType, id: string, workspaceId: string): Promise<EntryRecord>;
-    /**
-     * Replace a live entry's values, or 404. As with {@link create}, a
-     * publishable type's values aren't validated here (a draft may be saved
-     * incomplete; publish enforces the rules) — a non-publishable, always-live
-     * type validates now.
-     */
-    update(type: AnyContentType, id: string, values: Record<string, unknown>, workspaceId: string, relations?: Record<string, RelationDelta>): Promise<EntryRecord>;
-    /** Validate the stored row, then mark it published (publishable types only). */
-    publish(type: AnyContentType, id: string, workspaceId: string): Promise<EntryRecord>;
-    /** Revert a live entry to draft (publishable types only). */
-    unpublish(type: AnyContentType, id: string, workspaceId: string): Promise<EntryRecord>;
-    /**
-     * Delete an entry: soft (stamp `deleted_at`) for a paranoid type, hard
-     * `DELETE` otherwise. 404 if there's no live row to remove **in this
-     * workspace** — an id from another workspace is indistinguishable from a
-     * missing one.
-     */
-    remove(type: AnyContentType, id: string, workspaceId: string): Promise<void>;
-    /**
-     * Clear a soft-deleted entry's tombstone (paranoid types only), or 404.
-     * On an i18n type the restore can collide with a row created in the same
-     * (locale group, locale) slot after the soft delete — the partial unique
-     * index rejects it, surfaced as a 409 rather than a 500.
-     */
-    restore(type: AnyContentType, id: string, workspaceId: string): Promise<EntryRecord>;
-    /** Permanently delete a tombstoned entry (paranoid types only), or 404. */
-    purge(type: AnyContentType, id: string, workspaceId: string): Promise<void>;
-    /**
-     * Dry-run a publish over a set of ids: validate each live row and report a
-     * verdict (will-publish / already-published / blocked / not-found) in
-     * request order. Writes nothing.
-     */
-    previewBulkPublish(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkPublishPreview>;
-    /**
-     * Commit a bulk publish. The validation gate is **locked**: the candidate
-     * rows are selected `FOR UPDATE` and re-validated inside one transaction, so
-     * a concurrent edit can't invalidate a row between the dry run and the write
-     * (the single-statement preview-then-update split had that TOCTOU window).
-     * Publishes only the `publishable` ids, reporting which were skipped and why.
-     */
-    bulkPublish(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkPublishResult>;
-    /**
-     * Compute the per-entry publish verdict (will-publish / already-published /
-     * blocked / not-found) for `ids` in request order, given the live rows keyed
-     * by id. Pure — the dry run and the committed {@link bulkPublish} share it so
-     * they can't disagree on what's publishable.
-     */
-    private verdictsFor;
-    /**
-     * The per-field publish-gate checklist for one record: every required field
-     * plus any field that has an issue, each marked pass/fail. Mirrors the
-     * editor's Publish Gate so a row can show its passed fields, not just the
-     * failures.
-     */
-    private buildChecks;
-    /** Revert a set of live entries to draft. */
-    bulkUnpublish(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkActionResult>;
-    /** Delete a set of entries: soft for paranoid types, hard otherwise. */
-    bulkRemove(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkActionResult>;
-    /** Permanently delete a set of tombstoned entries (paranoid types only). */
-    bulkPurge(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkActionResult>;
-    /**
-     * Restore a set of soft-deleted entries (paranoid types only). As with
-     * {@link restore}, a restored row colliding with a live sibling in its
-     * (locale group, locale) slot is a 409 — the whole batch rolls back
-     * (single statement), so the caller can retry without the conflicting id.
-     */
-    bulkRestore(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkActionResult>;
-    /**
-     * Run a write, translating a Postgres unique violation (23505) into a 409.
-     * Only i18n types carry a restore-relevant unique index — the partial
-     * `(locale_group_id, locale)` one — so the mapping is scoped to them and
-     * any other type's violation still surfaces as the bug it is.
-     */
-    private uniqueGuarded;
-    /** The type's generated table seen as a column bag (envelope + fields). */
-    private columns;
-    /**
-     * `workspace_id = :workspaceId` — the ownership predicate every read and
-     * write AND-s in, so a request scoped to one workspace can neither see nor
-     * mutate another's rows.
-     */
-    private scope;
-    /**
-     * `id = :id` AND the workspace scope AND (for paranoid types)
-     * `deleted_at IS NULL`.
-     */
-    private liveWhere;
-    /** Fetch one live row by id in the workspace, or undefined. */
-    private findLive;
-    /** Fetch the workspace's live rows for a set of ids, keyed by id. */
-    private loadLiveByIds;
-    /**
-     * Verify every referenced relation target exists **in the same workspace** —
-     * single FKs, many-to-many links, and the inverse (back-reference) side of a
-     * two-way relation. Neither the FK column nor the join table has a workspace
-     * constraint of its own (the target table is workspace-scoped only at the app
-     * layer), so without this a caller could reference — or probe the existence
-     * of — an entry in another workspace. Batched one existence query per
-     * referenced target type; a missing or cross-workspace target surfaces as a
-     * uniform 422 validation issue (indistinguishable from a plain "invalid id",
-     * so no not-found-vs-forbidden enumeration signal). Runs on every
-     * create/update, draft or not, because links are written eagerly either way.
-     * An inverse-of-single (one-to-many) field owns no writable link from this
-     * side, so it's skipped.
-     */
-    private assertRelationTargets;
-    /**
-     * Enforce required **link-managed** relations (an owning many-to-many, or the
-     * inverse of one) against the entry's actual link set — the check
-     * {@link EntryValidationService} can't make, because those links never travel
-     * in the `values` bag it sees. A required such relation with zero links is a
-     * 422 `is required`, matching how a required scalar field reads. A single FK
-     * relation is validated in `values` already; an inverse-of-single owns no
-     * writable link from this side, so it's skipped (it can't be satisfied here).
-     * `exec` is the write transaction on create/update (so it counts the
-     * just-written, uncommitted rows) or the root client on publish (committed).
-     */
-    private assertRequiredRelations;
-    /** Throw 422 with the issue list when the values fail validation. */
-    private assertValid;
-    /** Reject publish/unpublish on a type with no publish workflow. */
-    private assertPublishable;
-    /** Reject restore/purge on a type without soft delete. */
-    private assertParanoid;
-    private notFound;
-}
-//# sourceMappingURL=entry-writer.service.d.ts.map

package/dist/lib/entries/services/entry-writer.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entry-writer.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/services/entry-writer.service.ts"],"names":[],"mappings":"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"}

package/dist/lib/entries/services/relation-link.service.d.ts

@@ -1,115 +0,0 @@
-import { type Database } from '@ortha-cms/database';
-import type { AnyContentType } from '../../types/content-type';
-import { type AnyFieldSpec } from '../../types/fields';
-import type { RelationDelta, RelationFieldView } from '../types/entry-list-view';
-/** A generated content row seen as a bag of values by property name. */
-type Row = Record<string, unknown>;
-/** Default links per page when the caller doesn't specify one. */
-export declare const RELATION_PAGE_SIZE = 20;
-/**
- * The transaction handle Drizzle hands the `db.transaction(tx => …)` callback —
- * derived from {@link Database} so link writes share the exact query surface of
- * the client without hard-coding the dialect's transaction type.
- */
-export type DbTransaction = Parameters<Parameters<Database['transaction']>[0]>[0];
-/**
- * Reads and writes the relation **links** an entry owns beyond its own columns:
- * many-to-many join rows and the inverse (back-reference) side of a two-way
- * relation. Owning **single** relations are plain `<field>_id` FK columns —
- * written by `toColumns`, read off the row — so they need no join plumbing.
- *
- * Everything is **paginated**: a relation can hold thousands of links, so reads
- * return one ordered page + a `total` (never every id), and writes apply an
- * incremental {@link RelationDelta} (link / unlink / reorder) inside a
- * transaction — so a huge relation never has to be sent or held in full.
- * Order is persisted in the join table's `position` column, owned by the
- * **source** side; the inverse reads by it (stable) but can't reorder it.
- */
-export declare class RelationLinkService {
-    private readonly db;
-    constructor(db: Database);
-    /**
-     * First page (+ total) of **every** relation field of `type` for one entry,
-     * keyed by field name — what the editor loads on open. Each field is read
-     * independently (paginated), so a relation with many links contributes only
-     * its first page, not every id.
-     */
-    readAll(type: AnyContentType, row: Row, workspaceId: string, pageSize?: number): Promise<Record<string, RelationFieldView>>;
-    /**
-     * One page of a single relation field's links, ordered by `position`
-     * (owning) and resolved to display-ready refs (id + title). `row` is the
-     * editing entry (its FK columns back a single relation); pass it to avoid a
-     * re-read. Returns `{ items, total }`.
-     */
-    readField(type: AnyContentType, row: Row, field: string, spec: AnyFieldSpec, page: number, pageSize: number, workspaceId: string): Promise<RelationFieldView>;
-    /**
-     * Apply an incremental {@link RelationDelta} to one many/inverse relation
-     * field inside `tx`: validate the linked targets are in the workspace, unlink
-     * the removed pairs, append the new ones (`position = max+1` for the source,
-     * `ON CONFLICT DO NOTHING`), then renumber to `order` (owning side only).
-     * A single relation or an inverse-of-single owns no delta-writable link, so
-     * it's a no-op. Returns nothing — read the field back for the new state.
-     */
-    applyDelta(tx: DbTransaction, type: AnyContentType, sourceId: string, field: string, delta: RelationDelta, workspaceId: string): Promise<void>;
-    /**
-     * Replace a many-relation's links with exactly `values[field]` (array),
-     * position = array index — the **whole-set** write used only when a caller
-     * genuinely submits a relation **array** in the entry body (legacy / bulk).
-     * The editor uses {@link applyDelta} instead. Runs inside the entry's
-     * transaction. **Only an array counts**: a field that's absent or `null`
-     * (`coerceValues` stamps `null` onto every unset field) is left untouched, so
-     * a save that manages a relation purely through deltas can never have its
-     * links cleared here.
-     */
-    writeLinks(tx: DbTransaction, type: AnyContentType, sourceId: string, values: Record<string, unknown>, workspaceId: string): Promise<void>;
-    /**
-     * Count the links of one join-backed relation field for an entry — the
-     * `total` a read would report, without fetching or resolving any page. Runs
-     * on the passed executor (the write transaction when validating a just-saved
-     * entry, so it sees the delta's uncommitted rows). Returns 0 for a relation
-     * that owns no writable links from this side (single FK / inverse-of-single).
-     */
-    countLinks(exec: Database | DbTransaction, type: AnyContentType, row: Row, field: string, spec: AnyFieldSpec, workspaceId: string): Promise<number>;
-    /**
-     * Take the transaction-scoped advisory lock for one physical source list
-     * (`<join table>:<sourceId>`), serializing every appender to that list so no
-     * two concurrent writes read the same `max(position)`. Auto-releases at
-     * commit/rollback. Keyed on the table name too, so distinct join tables that
-     * happen to share a source id don't falsely contend.
-     */
-    private lockSource;
-    /** Next append position for a source: `max(position) + 1`, else 0. */
-    private nextPosition;
-    /**
-     * Resolve `ids` (in order) to display-ready refs via one lookup on the target
-     * type, scoped to the workspace. Ids with no **live** row drop to an id-only
-     * ref — a soft-deleted (paranoid) target is excluded here just as it is on
-     * the inverse read side, so a trashed record never surfaces its title on the
-     * owning side while it's hidden on the other.
-     */
-    private refsFor;
-    /** Build a display ref from a full target row. */
-    private rowToRef;
-    /**
-     * Verify every id to be linked exists **in the same workspace** (the join FK
-     * has no workspace constraint of its own). A missing or cross-workspace id is
-     * a uniform 422 — indistinguishable from an invalid id, so no enumeration
-     * signal.
-     */
-    private assertTargets;
-    /**
-     * The join-table plan for a relation field, or `null` when it owns no join
-     * table (an owning single relation, or an inverse-of-single). An owning
-     * many-relation uses its own join table (`source→target`); an inverse of a
-     * many-to-many reuses the owning side's join table with the roles swapped.
-     */
-    private joinPlanFor;
-    /**
-     * The inverse-of-single (one-to-many) plan for a relation field, or `null`:
-     * it reads the owner rows whose FK points back at the editing record, and
-     * owns no writable link from this side.
-     */
-    private inversePlanFor;
-}
-export {};
-//# sourceMappingURL=relation-link.service.d.ts.map

package/dist/lib/entries/services/relation-link.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"relation-link.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/services/relation-link.service.ts"],"names":[],"mappings":"AAeA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,KAAK,EACR,aAAa,EACb,iBAAiB,EAEpB,MAAM,0BAA0B,CAAC;AAMlC,wEAAwE;AACxE,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnC,kEAAkE;AAClE,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAUrC;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,UAAU,CAClC,UAAU,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CACzC,CAAC,CAAC,CAAC,CAAC;AA0BL;;;;;;;;;;;;GAYG;AACH,qBACa,mBAAmB;IACE,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,QAAQ;IAI3D;;;;;OAKG;IACG,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,MAAM,EACnB,QAAQ,SAAqB,GAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAoB7C;;;;;OAKG;IACG,SAAS,CACX,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,iBAAiB,CAAC;IA0E7B;;;;;;;OAOG;IACG,UAAU,CACZ,EAAE,EAAE,aAAa,EACjB,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,aAAa,EACpB,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC;IA+FhB;;;;;;;;;OASG;IACG,UAAU,CACZ,EAAE,EAAE,aAAa,EACjB,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC;IAwChB;;;;;;OAMG;IACG,UAAU,CACZ,IAAI,EAAE,QAAQ,GAAG,aAAa,EAC9B,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,YAAY,EAClB,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,CAAC;IA8BlB;;;;;;OAMG;YACW,UAAU;IAWxB,sEAAsE;YACxD,YAAY;IAc1B;;;;;;OAMG;YACW,OAAO;IAuBrB,kDAAkD;IAClD,OAAO,CAAC,QAAQ;IAWhB;;;;;OAKG;YACW,aAAa;IAmC3B;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IA8BnB;;;;OAIG;IACH,OAAO,CAAC,cAAc;CAYzB"}

package/dist/lib/extension/entry-access-source.d.ts

@@ -1,112 +0,0 @@
-/**
- * The **entry-access description port** — the seam a downstream plugin uses to
- * tell a protocol adapter *that* an entry it just served is restricted, without
- * this package knowing what a restriction is.
- *
- * It is the read scope's opposite number and deliberately not the same thing.
- * `CONTENT_READ_SCOPE` decides which rows a reader gets; this describes the rows
- * they got. A scope can only subtract, so by the time an annotation is asked
- * for, the entry has already been admitted — which is why nothing here can
- * refuse anything, and why an implementation that returned nothing would be a
- * missing label rather than a leak.
- *
- * ## What it is for
- *
- * One thing, and it is worth being blunt about it: **a restricted entry must not
- * be cached as public.** A CDN, a shared HTTP cache or a client store that keeps
- * one reader's copy and hands it to the next turns a working entitlement into a
- * data leak, and nothing else in the response says the entry was reader-scoped —
- * it looks exactly like an open one. Everything else an implementation could
- * report (who exactly may read it, which segments) is a question for the admin
- * API, where the caller is a member of the workspace rather than a consumer of
- * its content.
- *
- * ## Why a registry rather than a DI token
- *
- * The same reason the read scope uses one: Nest has **no multi-provider**, so
- * two dynamic modules binding one token do not merge — the second silently
- * replaces the first. Here that would mean an entry that one plugin knows is
- * restricted reported as open because a second plugin was registered after it,
- * which is precisely the mislabelling this port exists to prevent. Registration
- * is a runtime `register(...)` call, the same shape as
- * {@link contentReadScopeRegistrar}.
- *
- * ## The batching constraint
- *
- * `describe` takes the whole page of entry ids, not one. A protocol adapter
- * resolves a list and then labels it; asking per entry would be a query per row
- * on a path whose cost is otherwise one page read. An implementation that cannot
- * answer for an id simply leaves it out of the map, and the caller reads a
- * missing key as unrestricted — the same default absence carries everywhere
- * else in this feature.
- */
-import { type Provider, type Type } from '@nestjs/common';
-/** What one entry's restriction looks like from outside the plugin that owns it. */
-export interface EntryAccessDescription {
-    /**
-     * Whether anything narrowed who may read this entry.
-     *
-     * `true` means the response is reader-specific and must not be stored in a
-     * shared cache without varying on whatever identifies the reader.
-     */
-    readonly restricted: boolean;
-    /**
-     * The axes that took part, as opaque keys (`org`, `plan`). A hint for a
-     * client deciding what to vary its own cache on — never the segments
-     * themselves, which would tell a consumer who *else* may read the entry.
-     */
-    readonly dimensions: readonly string[];
-}
-/** What a source is told about the page it is describing. */
-export interface EntryAccessQuery {
-    /** The workspace the entries were read in. */
-    readonly workspaceId: string;
-    /** The ids to describe. Never empty — the caller skips an empty page. */
-    readonly entryIds: readonly string[];
-}
-/**
- * One contributed description of what was served.
- *
- * Returning an empty map means "nothing to say about this page", which is what
- * an installed-but-unconfigured plugin returns and what every entry defaults to.
- */
-export interface EntryAccessSource {
-    /** Describes the given entries, keyed by entry id. Ids may be omitted. */
-    describe(query: EntryAccessQuery): Promise<ReadonlyMap<string, EntryAccessDescription>>;
-}
-/**
- * Every registered source, merged.
- *
- * The merge is a **union that can only tighten**: an entry is restricted if any
- * source says so, and the dimensions are the union of what each reported. Two
- * plugins narrowing reads for different reasons both need to be heard, and the
- * safe direction for a disagreement is the one that keeps a shared cache from
- * storing the entry.
- */
-export declare class EntryAccessSourceRegistry {
-    private readonly sources;
-    /** Adds a source. Registering the same instance twice is a no-op. */
-    register(source: EntryAccessSource): void;
-    /** Whether anything is registered — the cheap check before building a page. */
-    get active(): boolean;
-    /**
-     * Describes one page of entries.
-     *
-     * Returns an empty map when nothing is registered or the page is empty, so
-     * a caller on an installation with no scoping plugin does no work and every
-     * entry reads as unrestricted.
-     */
-    describe(query: EntryAccessQuery): Promise<ReadonlyMap<string, EntryAccessDescription>>;
-}
-/**
- * Builds the DI provider that registers `sources` with content's access-source
- * registry at bootstrap.
- *
- * A factory with an explicit `inject` list rather than a class with reflected
- * parameters, for the reason `contentReadScopeRegistrar` documents: an optional
- * dependency typed as `Foo | null` emits `Object` for `design:paramtypes`, Nest
- * injects `undefined` with no error, and the plugin ends up registering
- * nothing.
- */
-export declare function entryAccessSourceRegistrar(label: string, ...sources: Type<EntryAccessSource>[]): Provider;
-//# sourceMappingURL=entry-access-source.d.ts.map

package/dist/lib/extension/entry-access-source.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entry-access-source.d.ts","sourceRoot":"","sources":["../../../src/lib/extension/entry-access-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,EAIH,KAAK,QAAQ,EACb,KAAK,IAAI,EACZ,MAAM,gBAAgB,CAAC;AAExB,oFAAoF;AACpF,MAAM,WAAW,sBAAsB;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED,6DAA6D;AAC7D,MAAM,WAAW,gBAAgB;IAC7B,8CAA8C;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAC9B,0EAA0E;IAC1E,QAAQ,CACJ,KAAK,EAAE,gBAAgB,GACxB,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC,CAAC;CAC3D;AAED;;;;;;;;GAQG;AACH,qBACa,yBAAyB;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IAEnD,qEAAqE;IACrE,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAMzC,+EAA+E;IAC/E,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED;;;;;;OAMG;IACG,QAAQ,CACV,KAAK,EAAE,gBAAgB,GACxB,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;CAgC1D;AA4BD;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACtC,KAAK,EAAE,MAAM,EACb,GAAG,OAAO,EAAE,IAAI,CAAC,iBAAiB,CAAC,EAAE,GACtC,QAAQ,CAYV"}

package/dist/lib/extension/entry-write-hook.d.ts

@@ -1,98 +0,0 @@
-/**
- * The **entry write hook** — the seam a downstream plugin uses to do work
- * *inside* an entry's write transaction.
- *
- * The read-scope port's sibling, and it exists for the same reason the read one
- * does: a plugin that derives something from an entry has to derive it where the
- * entry is written, or the two can disagree. `@orthacms/segments-server` uses it
- * to write an entry's access projection, and the window between "the entry is
- * live" and "the rule that hides it is recorded" is exactly the window in which
- * restricted content is public.
- *
- * ## Why not `CONTENT_ENTRY_EXTENSION.afterUpdate`
- *
- * That hook does precisely this job and would need no new code — except that the
- * port is documented as a **single binding**, one provider per app, and i18n
- * holds it. Its own note suggests a composite for a second consumer, which is
- * fine when the two are peers; here they are not. i18n's implementation returns
- * the sibling rows it rewrote, and the writer snapshots a revision for each; a
- * composite would have to merge that return value with a second implementation
- * that has no opinion about it, and a mistake there writes the wrong revision
- * history. This port returns nothing and cannot participate in that decision.
- *
- * ## The contract
- *
- * **Runs in the write's own transaction.** The executor handed to the hook is
- * the transaction the row was written in, and a throw rolls the write back with
- * it. That is the guarantee the hook exists for: an entry and whatever a plugin
- * derives from it commit together or not at all.
- *
- * **Runs after the row and its relations are written**, so the hook sees the
- * entry in its final state — including any columns the entries extension
- * stamped or rewrote.
- *
- * **Must be cheap.** It is on the write path of every create and update, and it
- * holds the entry's advisory lock while it runs. Work that can wait for a
- * commit does not belong here; work that must not be observed separately from
- * the write does.
- *
- * **Deletes are not hooked.** A hard-deleted entry's derived rows are
- * unreachable — nothing joins to an id that no longer exists — so the cost of
- * leaving them is disk rather than correctness, and paying for a hook on every
- * delete to reclaim it is the wrong trade. A plugin that cares reclaims them on
- * its own schedule.
- */
-import { type Provider, type Type } from '@nestjs/common';
-import type { Database } from '@orthacms/database';
-import type { AnyContentType } from '../types/content-type';
-/** The executor the hook must use — the write's own transaction. */
-export type EntryWriteExecutor = Parameters<Parameters<Database['transaction']>[0]>[0];
-/** What a hook is told about the write it is running inside. */
-export interface ContentEntryWriteContext {
-    /** The write's transaction. Use this, never the shared connection. */
-    readonly tx: EntryWriteExecutor;
-    /** The content type written. */
-    readonly type: AnyContentType;
-    /** The entry's id. */
-    readonly entryId: string;
-    /** The workspace the entry belongs to. */
-    readonly workspaceId: string;
-    /** True when the row was just INSERTed; false on an update. */
-    readonly created: boolean;
-}
-/** One plugin's participation in an entry write. */
-export interface ContentEntryWriteHook {
-    /**
-     * Runs inside the write transaction, after the row and its relations.
-     *
-     * A throw rolls the entry write back. That is deliberate: a hook whose
-     * failure is swallowed would let the entry commit without whatever the hook
-     * was meant to derive from it.
-     */
-    afterWrite(context: ContentEntryWriteContext): Promise<void>;
-}
-/** Every registered write hook, in registration order. */
-export declare class ContentEntryWriteHookRegistry {
-    private readonly hooks;
-    /** Adds a hook. Registering the same instance twice is a no-op. */
-    register(hook: ContentEntryWriteHook): void;
-    /** Every registered hook. Empty on an installation with none. */
-    all(): readonly ContentEntryWriteHook[];
-    /**
-     * Runs every hook, in order, inside the caller's transaction.
-     *
-     * Sequential rather than concurrent: the hooks share one transaction, and a
-     * Postgres connection carries one statement at a time — firing them at once
-     * would only interleave their awaits onto the same connection.
-     */
-    run(context: ContentEntryWriteContext): Promise<void>;
-}
-/**
- * Builds the DI provider that registers `hooks` with content's write-hook
- * registry at bootstrap. The sibling of `contentReadScopeRegistrar`, and a
- * factory with an explicit `inject` list for the same reason: a reflected
- * `Foo | null` parameter type emits `Object`, Nest injects `undefined`, and the
- * plugin silently registers nothing.
- */
-export declare function contentEntryWriteHookRegistrar(label: string, ...hooks: Type<ContentEntryWriteHook>[]): Provider;
-//# sourceMappingURL=entry-write-hook.d.ts.map

package/dist/lib/extension/entry-write-hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entry-write-hook.d.ts","sourceRoot":"","sources":["../../../src/lib/extension/entry-write-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,EAIH,KAAK,QAAQ,EACb,KAAK,IAAI,EACZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,oEAAoE;AACpE,MAAM,MAAM,kBAAkB,GAAG,UAAU,CACvC,UAAU,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CACzC,CAAC,CAAC,CAAC,CAAC;AAEL,gEAAgE;AAChE,MAAM,WAAW,wBAAwB;IACrC,sEAAsE;IACtE,QAAQ,CAAC,EAAE,EAAE,kBAAkB,CAAC;IAChC,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,sBAAsB;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,0CAA0C;IAC1C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC7B;AAED,oDAAoD;AACpD,MAAM,WAAW,qBAAqB;IAClC;;;;;;OAMG;IACH,UAAU,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChE;AAED,0DAA0D;AAC1D,qBACa,6BAA6B;IACtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA+B;IAErD,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI;IAM3C,iEAAiE;IACjE,GAAG,IAAI,SAAS,qBAAqB,EAAE;IAIvC;;;;;;OAMG;IACG,GAAG,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC;CAK9D;AAyBD;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC1C,KAAK,EAAE,MAAM,EACb,GAAG,KAAK,EAAE,IAAI,CAAC,qBAAqB,CAAC,EAAE,GACxC,QAAQ,CAYV"}

package/dist/lib/extension/per-locale-relation.d.ts

@@ -1,18 +0,0 @@
-import { type AnyFieldSpec } from '../types/fields';
-import type { AnyContentType } from '../types/content-type';
-/**
- * Whether a field is a **per-locale relation** — a *single owning* relation
- * (`!many`, `!inverse`) on an **i18n** owner whose **target type is also i18n**.
- *
- * Such a relation can't be shared across a translation group: a shared FK would
- * point at one specific locale's row, i.e. a cross-locale link. So the platform
- * treats it as `localized` — not synced onto siblings, not copied into a
- * translation draft, and the picker offers only same-locale candidates. Both the
- * schema serializer (which stamps `localized` for the admin) and the i18n
- * sibling-sync consult this, so the rule lives in one place.
- *
- * The target's i18n-ness is read via the resolved thunk `spec.relation.to()` —
- * safe because the registry resolves every relation target at boot.
- */
-export declare function isPerLocaleRelation(owner: AnyContentType, spec: AnyFieldSpec): boolean;
-//# sourceMappingURL=per-locale-relation.d.ts.map

package/dist/lib/extension/per-locale-relation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"per-locale-relation.d.ts","sourceRoot":"","sources":["../../../src/lib/extension/per-locale-relation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAC/B,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,YAAY,GACnB,OAAO,CAQT"}