@orthacms/content-server 0.0.0-reserve.0

package/dist/lib/entries/infrastructure/persistence/field-selection.d.ts

@@ -0,0 +1,24 @@
+import type { AnyContentType } from '../../../types/content-type';
+/**
+ * The set of field names a `?fields=` list selects, or `undefined` when the
+ * caller asked for none (the default — the whole record).
+ */
+export type FieldSelection = ReadonlySet<string> | undefined;
+/**
+ * Parse `?fields=title,slug` into the set {@link toRecord} projects `values`
+ * down to. Only fields that carry a column are selectable — a many-relation or
+ * an inverse back-reference has no value on the row (its links live in a join
+ * table), so naming one is a client error, not a silently empty key.
+ *
+ * **Unknown names are rejected with a 400**, deliberately unlike
+ * `?relationFields=`, which drops them. That list is an internal rendering hint
+ * where a hidden column legitimately vanishes; this one is an external API
+ * contract, where silently honouring `?fields=titel` would return records with
+ * no fields and no explanation. Failing loudly makes the typo obvious.
+ *
+ * Envelope data (`id`, timestamps, `status`/`publishedAt`, `locale`) is **not**
+ * selectable and is always returned — it identifies the record rather than
+ * describing it, and callers can ignore what they don't need.
+ */
+export declare function parseFieldSelection(type: AnyContentType, raw: string | undefined): FieldSelection;
+//# sourceMappingURL=field-selection.d.ts.map

package/dist/lib/entries/infrastructure/persistence/field-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-selection.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/persistence/field-selection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAGlE;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;AAE7D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,MAAM,GAAG,SAAS,GACxB,cAAc,CAiBhB"}

package/dist/lib/entries/infrastructure/persistence/media-accept.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Pure matcher for a media field's `accept` restriction — shared by the write
+ * path's `assertMediaTargets` (and unit-tested in isolation). An asset passes
+ * when the field declares no restriction, or when it matches **any** allowed
+ * kind **or** any allowed MIME pattern. A MIME pattern is either exact
+ * (`application/pdf`) or a `type/*` wildcard (`image/*`).
+ */
+import type { MediaAccept } from '../../../types/fields';
+/**
+ * Whether an asset (its coarse `kind` + concrete `mimeType`) satisfies a media
+ * field's `accept`. An absent restriction, or one with neither list populated,
+ * accepts anything.
+ */
+export declare function acceptsAsset(accept: MediaAccept | undefined, asset: {
+    kind: string;
+    mimeType: string;
+}): boolean;
+/**
+ * A short human description of what a field accepts, for the validation issue
+ * message (e.g. `an image`, `a PDF (application/pdf)`, `an allowed asset`).
+ */
+export declare function describeAccept(accept: MediaAccept | undefined): string;
+//# sourceMappingURL=media-accept.d.ts.map

package/dist/lib/entries/infrastructure/persistence/media-accept.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-accept.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/persistence/media-accept.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAYzD;;;;GAIG;AACH,wBAAgB,YAAY,CACxB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC1C,OAAO,CAQT;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,CAQtE"}

package/dist/lib/entries/infrastructure/persistence/media-accept.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Pure matcher for a media field's `accept` restriction — shared by the write
+ * path's `assertMediaTargets` (and unit-tested in isolation). An asset passes
+ * when the field declares no restriction, or when it matches **any** allowed
+ * kind **or** any allowed MIME pattern. A MIME pattern is either exact
+ * (`application/pdf`) or a `type/*` wildcard (`image/*`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acceptsAsset = acceptsAsset;
+exports.describeAccept = describeAccept;
+/** A MIME pattern matches a concrete MIME either exactly or as a `type/*` glob. */
+function mimeMatches(pattern, mimeType) {
+    if (pattern === mimeType)
+        return true;
+    if (pattern.endsWith('/*')) {
+        const prefix = pattern.slice(0, -1); // keep the trailing slash: "image/"
+        return mimeType.startsWith(prefix);
+    }
+    return false;
+}
+/**
+ * Whether an asset (its coarse `kind` + concrete `mimeType`) satisfies a media
+ * field's `accept`. An absent restriction, or one with neither list populated,
+ * accepts anything.
+ */
+function acceptsAsset(accept, asset) {
+    if (!accept)
+        return true;
+    const kinds = accept.kinds ?? [];
+    const mimeTypes = accept.mimeTypes ?? [];
+    if (!kinds.length && !mimeTypes.length)
+        return true;
+    if (kinds.includes(asset.kind))
+        return true;
+    if (mimeTypes.some((p) => mimeMatches(p, asset.mimeType)))
+        return true;
+    return false;
+}
+/**
+ * A short human description of what a field accepts, for the validation issue
+ * message (e.g. `an image`, `a PDF (application/pdf)`, `an allowed asset`).
+ */
+function describeAccept(accept) {
+    if (!accept)
+        return 'an allowed asset';
+    const parts = [];
+    if (accept.kinds?.length)
+        parts.push(accept.kinds.join(' / '));
+    if (accept.mimeTypes?.length)
+        parts.push(accept.mimeTypes.join(' / '));
+    return parts.length
+        ? `an allowed asset (${parts.join(', ')})`
+        : 'an allowed asset';
+}

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

@@ -0,0 +1,327 @@
+import { type Database } from '@orthacms/database';
+import { type AnyContentType } from '../../../types/content-type';
+import { type AnyFieldSpec } from '../../../types/fields';
+import type { RelationDelta, RelationFieldView, RelationRef } from '../../types/entry-list-view';
+/**
+ * Reject any target row that lives in a different locale from the source.
+ *
+ * Two **i18n** types must link inside one locale. A cross-locale link is a
+ * broken model rather than a preference: the English article would render the
+ * German tag, and since links are per-row rather than synced across a
+ * translation group, nothing later repairs it. The admin has always enforced
+ * this by only offering same-locale candidates in its relation picker; this is
+ * the same rule at the layer a direct API call cannot skip.
+ *
+ * A no-op unless BOTH sides are localized — `sourceLocale` is `undefined` for a
+ * non-i18n owner, and a non-i18n target has no locale to disagree about.
+ *
+ * Exported so `EntryWriterService` applies the identical rule to the owning
+ * **single** relations it validates itself (a `<field>_id` FK never reaches the
+ * join-table paths), instead of the two growing their own versions of it.
+ */
+export declare function assertSameLocale(rows: Row[], target: AnyContentType, field: string, sourceLocale: string | undefined): void;
+/** 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;
+/**
+ * Extra visibility applied to a relation's **targets**, on top of the workspace
+ * scope and soft-delete guard every read already applies.
+ *
+ * Exists for the public content API, which serves published entries only: a
+ * relation preview there must not surface a draft target's title, and must not
+ * *count* it either, or `total` would advertise links the caller can never see.
+ * Absent (the admin's every call site) nothing changes — an editor legitimately
+ * links to drafts and needs to see them.
+ */
+export interface RelationTargetVisibility {
+    /** Restrict targets to entries that are currently published. */
+    publishedOnly?: boolean;
+}
+/**
+ * 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];
+/**
+ * Anything that can run a SELECT — the pooled client or a transaction handle.
+ * Lets the locale-group resolver serve both the in-transaction link writes and
+ * the pre-transaction single-relation resolution without duplicating itself.
+ */
+export type QueryRunner = Pick<Database, 'select'>;
+/**
+ * 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.
+     *
+     * Admin-only, hence no {@link RelationTargetVisibility}: an editor must see
+     * the draft targets it may be about to publish. The public API reads links
+     * one field at a time through {@link readField}, which takes the flag.
+     */
+    readAll(type: AnyContentType, row: Row, workspaceId: string, pageSize?: number): Promise<Record<string, RelationFieldView>>;
+    /**
+     * A capped relation preview for a whole **page** of entries — what the
+     * records table's relation columns render. Returns, per entry id, a
+     * `{ items, total }` view for each requested field.
+     *
+     * The batching is the point: this issues a constant number of queries **per
+     * relation field**, spanning every row on the page (`inArray(ownCol, ids)`),
+     * never one query per row. Contrast {@link readAll}, which is scoped to a
+     * single entry (`eq(ownCol, row.id)`) because the editor opens one record —
+     * calling it in a loop over a page would be a textbook N+1 (a 50-row page
+     * with two relation columns would cost 300 queries; this costs a handful).
+     *
+     * Each field contributes at most `pageSize` refs plus its true `total`, so a
+     * record holding thousands of links reads exactly one page here — the
+     * dropdown pages through the rest via {@link readField}. Only `fields` are
+     * resolved (the table's visible columns), so a hidden relation column costs
+     * nothing.
+     */
+    previewForEntries(type: AnyContentType, fields: string[], rows: Row[], workspaceId: string, pageSize?: number, visibility?: RelationTargetVisibility): Promise<Map<string, Record<string, RelationFieldView>>>;
+    /**
+     * Preview one relation field across the page, dispatched by storage form —
+     * the same three shapes {@link readField} handles: an owning single relation
+     * (FK on the row), a join-backed relation (owning many-to-many or the
+     * inverse of one), and an inverse-of-single (the owner's FK points back).
+     */
+    private previewField;
+    /**
+     * Owning **single** relations: the FK already rides each page row, so this
+     * is one batched {@link refsFor} for every row's target at once — which also
+     * de-duplicates, so 50 posts sharing one author resolve that title once
+     * instead of 50 times.
+     */
+    private previewSingle;
+    /**
+     * Join-backed relations (owning many-to-many, or the inverse of one), ranked
+     * in a single windowed pass: `row_number()` applies the per-source page cap
+     * and `count(*)` the true total, both partitioned by the owning id. That is
+     * what keeps a 600-link record to `pageSize` rows read instead of 600.
+     */
+    private previewJoin;
+    /**
+     * Inverse-of-single (one-to-many): the links are the owner rows whose FK
+     * points back at each page row. Windowed the same way, and scoped to the
+     * workspace with the soft-delete guard the inverse read side already applies.
+     */
+    private previewInverse;
+    /**
+     * Fold ranked window rows (already ordered by owner, then rank) into one
+     * `{ items, total }` view per owning id, resolving each link through the
+     * batched `refs`. Shared by the join-backed and inverse previews.
+     */
+    private groupPreview;
+    /**
+     * 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, visibility?: RelationTargetVisibility): Promise<RelationFieldView>;
+    /**
+     * The **full** ordered target-id list of every join-backed relation field
+     * (owning many-to-many and the inverse of one) for one entry, keyed by field
+     * name — the relation half of a revision snapshot. Unlike {@link readAll}
+     * (one page + a `total`, for the editor), this reads every link, since a
+     * snapshot must reconstruct the whole set. Runs on the passed executor (the
+     * save transaction), so it captures exactly what committed. Owning single
+     * relations aren't included — their FK already rides the entry's `values`.
+     * The join rows belong to the owning entry (scoped by `row.id`), so no
+     * workspace filter is needed here — the same as the join read in
+     * {@link readField}.
+     */
+    snapshotLinks(exec: Database | DbTransaction, type: AnyContentType, row: Row): Promise<Record<string, string[]>>;
+    /**
+     * 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, sourceLocale?: 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, sourceLocale?: 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;
+    /**
+     * Public resolver for callers that hold **raw ids** rather than a live link
+     * set — the revision preview, which reads a historical snapshot's relation id
+     * lists and needs their display titles. Resolves the first `cap` ids (order
+     * preserved) via the same batched lookup as {@link refsFor}; the caller
+     * carries the true count separately and shows a "+N more" past the cap, so a
+     * relation with thousands of links is never resolved whole. A soft-deleted /
+     * foreign id yields a `missing` ref, never a title leak.
+     */
+    resolveRefs(target: AnyContentType, ids: readonly string[], workspaceId: string, cap: number): Promise<RelationRef[]>;
+    /**
+     * 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;
+    /**
+     * The visibility predicate applied to a relation's target rows: the
+     * workspace scope, the soft-delete guard, and — only when the caller asks
+     * for it — the published-only restriction. One definition, so the row read
+     * (`refsFor`) and the windowed link reads that must *count* correctly can't
+     * disagree on what a visible target is.
+     */
+    private targetVisibleWhere;
+    /**
+     * The id sub-select of a target's visible rows — how a link read that reads
+     * only the JOIN table (so has no target columns of its own) restricts to
+     * visible targets *inside* its window, keeping `total` honest. `undefined`
+     * when no extra restriction applies, so the predicate collapses away.
+     */
+    private visibleTargetIds;
+    /**
+     * `ref IN (visible target ids)`, or `undefined` when no restriction
+     * applies. Wraps {@link visibleTargetIds} for the join-table reads, whose
+     * only handle on the target is the id column in the join row.
+     */
+    private visibleTargetIdsPredicate;
+    /** Build a display ref from a full target row. */
+    private rowToRef;
+    /**
+     * Rewrite a delta's translation-group ids into entry ids, picking each
+     * group's row in the **source entry's own locale**.
+     *
+     * This is the half of the cross-locale rule that makes it usable rather than
+     * merely strict. A client that thinks in stories holds one group id per
+     * story, not one entry id per language; without this it would have to keep a
+     * per-locale id map and pick the right entry for every write — and picking
+     * wrong is exactly what the rule then rejects. Here the server picks, and it
+     * is the only party that knows the source row's locale for certain.
+     *
+     * A group with no row in this locale is a **422** naming the field: the
+     * caller asked to link a story that has not been translated into this
+     * language yet, which is a real content gap rather than a bad request.
+     */
+    resolveLocaleGroups(runner: QueryRunner, target: AnyContentType, groupIds: string[], workspaceId: string, field: string, sourceLocale: string | undefined): Promise<Map<string, string>>;
+    /**
+     * The **lenient** counterpart of {@link resolveLocaleGroups}: given target
+     * ids held by one row, find the equivalent id in each of `locales` — the
+     * row of the same translation group, in that language.
+     *
+     * Returns `locale → (given id → that locale's id)`. A pair with no row in a
+     * locale is simply **absent** rather than an error, which is the whole
+     * difference. `resolveLocaleGroups` answers an explicit API call naming a
+     * group, where a missing translation is a request to reject; this answers
+     * the implicit sibling sync, where it is a content gap on the *target* and
+     * failing would mean an English save could not be saved until somebody
+     * translated a tag.
+     *
+     * Two queries regardless of how many ids or locales are asked for: one to
+     * read the given ids' groups, one to read those groups' rows in the wanted
+     * locales. Soft-deleted rows are excluded from the **destination** side —
+     * required for determinism, since the `(locale_group_id, locale)` unique
+     * index is partial (`WHERE deleted_at IS NULL`) on a paranoid type, so
+     * trashed rows can legitimately repeat a pair. The source lookup is not
+     * filtered: a link to a trashed row still has a group, and dropping it
+     * would silently unlink siblings whenever a target went to the bin.
+     */
+    equivalentIdsByLocale(exec: QueryRunner, target: AnyContentType, ids: readonly string[], locales: readonly string[], workspaceId: string): Promise<Map<string, Map<string, string>>>;
+    /**
+     * Replace one join-backed relation field's links for `sourceId` with
+     * exactly `targetIds`, in order — the primitive the locale sibling sync
+     * writes through. Returns whether anything actually changed, so a caller
+     * can leave an already-correct sibling untouched (and unversioned).
+     *
+     * Deliberately **not** {@link applyDelta}: that is an incremental edit from
+     * a client that knows what it changed, while a sync knows only the desired
+     * end state. Deliberately not {@link writeLinks} either — that reads its ids
+     * out of a values bag and re-validates targets the caller may not have.
+     * Here the ids came from a sibling row that already passed those checks.
+     */
+    replaceLinks(tx: DbTransaction, type: AnyContentType, sourceId: string, field: string, targetIds: readonly string[]): Promise<boolean>;
+    /**
+     * The ordered link ids of **one** join-backed relation field, read on the
+     * passed executor. {@link snapshotLinks} reads every field at once for a
+     * revision; the sync needs one field at a time, and only the ones that
+     * actually propagate.
+     */
+    linkIdsOf(exec: Database | DbTransaction, type: AnyContentType, sourceId: string, field: string): Promise<string[]>;
+    /** {@link resolveLocaleGroups} applied to a delta's three id arrays. */
+    private resolveByLocaleGroup;
+    /**
+     * 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.
+     *
+     * When `sourceLocale` is given and the target type is localized, the link is
+     * additionally required to stay **inside one locale**. Two i18n types linked
+     * across locales is a broken model, not a preference: the English article
+     * would render the German tag, and because join links are per-row rather
+     * than synced across a translation group, nothing would ever repair it. The
+     * admin has always enforced this in its picker (which offers same-locale
+     * candidates only) — this is the same rule where it cannot be bypassed by
+     * talking to the API directly.
+     *
+     * The caller passes the **source row's own** locale, so the rule reads off
+     * the row being written rather than off a request parameter that may name a
+     * different one. `undefined` (a non-i18n owner) disables the check.
+     */
+    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/infrastructure/persistence/relation-link.service.d.ts.map

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