@orthacms/content-server 0.0.0-reserve.0

package/dist/lib/extension/media-asset-resolver.d.ts

@@ -0,0 +1,85 @@
+/**
+ * The **media-asset resolver port** — the seam through which content-server
+ * checks that a media field's asset ids reference real assets in the workspace,
+ * and match the field's `accept` restriction, without depending on the media
+ * plugin. Content-server *declares* the port and consults it optionally
+ * (`@Optional()` injection) from {@link EntryWriterService}; the media plugin
+ * *binds* an implementation to {@link MEDIA_ASSET_RESOLVER} in its own module —
+ * the same inversion as {@link CONTENT_ENTRY_EXTENSION} and identity's
+ * `CONTENT_CATALOG`.
+ *
+ * When no implementation is bound (the media plugin isn't registered), media
+ * fields still shape-validate and store their ids — the existence and
+ * restriction checks are simply skipped, so content boots without media.
+ *
+ * NestJS-free on purpose (types + a Symbol + an inject helper): the
+ * implementation lives in another package.
+ */
+/** DI token the media plugin binds its {@link MediaAssetResolver} to. */
+export declare const MEDIA_ASSET_RESOLVER: unique symbol;
+/** Injects the optional media-asset resolver. Pair with `@Optional()`. */
+export declare const InjectMediaAssetResolver: () => ParameterDecorator;
+/**
+ * One timed-text track on a video or audio asset — what a consumer needs to
+ * emit a `<track>`.
+ *
+ * Declared here rather than imported from media-server because the dependency
+ * runs the other way: media binds this port, content declares it (`ORT-92`).
+ */
+export interface ResolvedMediaTrack {
+    /** `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. */
+    src: string;
+    /** Whether a player should enable this one by default. */
+    default?: boolean;
+}
+/** The subset of a media asset content-server needs to enforce a media field. */
+export interface ResolvedMediaAsset {
+    /** Asset id (uuid). */
+    id: string;
+    /** Coarse kind — image/video/audio/document/archive. */
+    kind: string;
+    /** MIME type, e.g. `image/png`. */
+    mimeType: string;
+    /** Display name (the original file name). */
+    name: string;
+    /** The route the browser fetches to stream the bytes. */
+    url: string;
+    /**
+     * Route for the small (~320px) derivative, when the media plugin generated
+     * one — what a field tile or a revision-preview chip should render instead
+     * of the full original. Absent for a non-image, an SVG, or an image too
+     * small to derive; the caller falls back to {@link url}.
+     */
+    thumbUrl?: string;
+    /** Route for the larger (~1280px) derivative, same caveats as {@link thumbUrl}. */
+    previewUrl?: string;
+    /** Alt text, when set. */
+    alt: string | null;
+    /**
+     * Timed-text tracks for a video or audio asset. Empty for everything else,
+     * and for a video nobody has captioned yet.
+     *
+     * Without these a published video had no caption track available **at any
+     * layer**, because the CMS could not represent one — WCAG 1.2.2 / 1.2.3,
+     * 508 503.4 (`ORT-92`).
+     */
+    tracks: ResolvedMediaTrack[];
+}
+/**
+ * Resolves media asset ids to the facts content-server needs. Workspace-scoped:
+ * an id that names no asset in `workspaceId` (missing, or belonging to another
+ * workspace) is simply **absent** from the returned map — the caller reads that
+ * as "does not exist" and reports a uniform validation issue, with no
+ * not-found-vs-forbidden enumeration signal.
+ */
+export interface MediaAssetResolver {
+    /** Batched, workspace-scoped lookup keyed by asset id. */
+    resolve(ids: readonly string[], workspaceId: string): Promise<Map<string, ResolvedMediaAsset>>;
+}
+//# sourceMappingURL=media-asset-resolver.d.ts.map

package/dist/lib/extension/media-asset-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-asset-resolver.d.ts","sourceRoot":"","sources":["../../../src/lib/extension/media-asset-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,yEAAyE;AACzE,eAAO,MAAM,oBAAoB,eAAiC,CAAC;AAEnE,0EAA0E;AAC1E,eAAO,MAAM,wBAAwB,QAAO,kBACZ,CAAC;AAEjC;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IAC/B,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,0DAA0D;IAC1D,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,iFAAiF;AACjF,MAAM,WAAW,kBAAkB;IAC/B,uBAAuB;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0BAA0B;IAC1B,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB;;;;;;;OAOG;IACH,MAAM,EAAE,kBAAkB,EAAE,CAAC;CAChC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IAC/B,0DAA0D;IAC1D,OAAO,CACH,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC;CAC/C"}

package/dist/lib/extension/media-asset-resolver.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * The **media-asset resolver port** — the seam through which content-server
+ * checks that a media field's asset ids reference real assets in the workspace,
+ * and match the field's `accept` restriction, without depending on the media
+ * plugin. Content-server *declares* the port and consults it optionally
+ * (`@Optional()` injection) from {@link EntryWriterService}; the media plugin
+ * *binds* an implementation to {@link MEDIA_ASSET_RESOLVER} in its own module —
+ * the same inversion as {@link CONTENT_ENTRY_EXTENSION} and identity's
+ * `CONTENT_CATALOG`.
+ *
+ * When no implementation is bound (the media plugin isn't registered), media
+ * fields still shape-validate and store their ids — the existence and
+ * restriction checks are simply skipped, so content boots without media.
+ *
+ * NestJS-free on purpose (types + a Symbol + an inject helper): the
+ * implementation lives in another package.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectMediaAssetResolver = exports.MEDIA_ASSET_RESOLVER = void 0;
+const common_1 = require("@nestjs/common");
+/** DI token the media plugin binds its {@link MediaAssetResolver} to. */
+exports.MEDIA_ASSET_RESOLVER = Symbol('MEDIA_ASSET_RESOLVER');
+/** Injects the optional media-asset resolver. Pair with `@Optional()`. */
+const InjectMediaAssetResolver = () => (0, common_1.Inject)(exports.MEDIA_ASSET_RESOLVER);
+exports.InjectMediaAssetResolver = InjectMediaAssetResolver;

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1 @@
+{"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"}

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

@@ -0,0 +1,62 @@
+import { type AnyFieldSpec } from '../types/fields';
+import type { AnyContentType } from '../types/content-type';
+/**
+ * How one relation field behaves across a translation group.
+ *
+ * The three values are not three author-facing options — the author sets one
+ * boolean (`syncAcrossLocales`). What splits `Shared` from `Mirrored` is the
+ * **target type**: a link to non-localized content is the same row for every
+ * language, while a link to localized content has to name that content's row
+ * *in each sibling's own locale* — a shared FK there would be a cross-locale
+ * link, which {@link assertSameLocale} rejects and nothing would ever repair.
+ */
+export declare const RELATION_LOCALE_SYNC: {
+    /** One target row for the whole group — the same id in every sibling. */
+    readonly Shared: "shared";
+    /** The target's translation *group*, resolved into each sibling's locale. */
+    readonly Mirrored: "mirrored";
+    /** Not propagated: each locale keeps its own links. */
+    readonly None: "none";
+};
+/** How a relation field propagates across a translation group. */
+export type RelationLocaleSync = (typeof RELATION_LOCALE_SYNC)[keyof typeof RELATION_LOCALE_SYNC];
+/**
+ * The propagation mode of one field on `owner` — **the** definition, consulted
+ * by the schema serializer, the i18n sibling sync, and the copilot's
+ * translation applier, so the three cannot drift.
+ *
+ * `None` for everything that has nothing to propagate: a non-relation, a
+ * non-`i18n` owner (no siblings), an inverse field (it reuses the owning side's
+ * storage, so syncing from both ends would write the same links twice), and any
+ * relation whose author set `syncAcrossLocales: false`.
+ *
+ * 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 relationLocaleSync(owner: AnyContentType, spec: AnyFieldSpec): RelationLocaleSync;
+/**
+ * Whether a field's stored value **varies from one locale row to the next** —
+ * what the schema serializer reports to the admin as `localized`, and what the
+ * translation prefill uses to decide a field is the translator's to fill in.
+ *
+ * True for an explicitly `localized` field, and for a relation that is either
+ * mirrored (each sibling stores its own locale's target id) or unsynced (each
+ * sibling stores whatever it was given). False for a **shared** relation, whose
+ * every sibling genuinely holds the same id.
+ *
+ * Note the difference from {@link relationLocaleSync}: a *mirrored* relation is
+ * both per-locale AND propagated — the value differs per row precisely so that
+ * every row points at the right translation.
+ */
+export declare function isPerLocaleField(owner: AnyContentType, spec: AnyFieldSpec): boolean;
+/**
+ * Whether a relation's links live in a join table (an owning many-to-many)
+ * rather than in a `<field>_id` column. The two storage forms are synced by
+ * different machinery — a column write vs. a join-row rewrite — so the sync
+ * pass splits on this.
+ *
+ * An **inverse** is excluded even though it is join-backed: it owns no writable
+ * link from its side.
+ */
+export declare function isJoinBackedRelation(spec: AnyFieldSpec): boolean;
+//# sourceMappingURL=relation-locale-sync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relation-locale-sync.d.ts","sourceRoot":"","sources":["../../../src/lib/extension/relation-locale-sync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB;IAC7B,yEAAyE;;IAEzE,6EAA6E;;IAE7E,uDAAuD;;CAEjD,CAAC;AAEX,kEAAkE;AAClE,MAAM,MAAM,kBAAkB,GAC1B,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAErE;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,YAAY,GACnB,kBAAkB,CASpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC5B,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,YAAY,GACnB,OAAO,CAMT;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAMhE"}

package/dist/lib/extension/relation-locale-sync.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RELATION_LOCALE_SYNC = void 0;
+exports.relationLocaleSync = relationLocaleSync;
+exports.isPerLocaleField = isPerLocaleField;
+exports.isJoinBackedRelation = isJoinBackedRelation;
+const fields_1 = require("../types/fields");
+/**
+ * How one relation field behaves across a translation group.
+ *
+ * The three values are not three author-facing options — the author sets one
+ * boolean (`syncAcrossLocales`). What splits `Shared` from `Mirrored` is the
+ * **target type**: a link to non-localized content is the same row for every
+ * language, while a link to localized content has to name that content's row
+ * *in each sibling's own locale* — a shared FK there would be a cross-locale
+ * link, which {@link assertSameLocale} rejects and nothing would ever repair.
+ */
+exports.RELATION_LOCALE_SYNC = {
+    /** One target row for the whole group — the same id in every sibling. */
+    Shared: 'shared',
+    /** The target's translation *group*, resolved into each sibling's locale. */
+    Mirrored: 'mirrored',
+    /** Not propagated: each locale keeps its own links. */
+    None: 'none'
+};
+/**
+ * The propagation mode of one field on `owner` — **the** definition, consulted
+ * by the schema serializer, the i18n sibling sync, and the copilot's
+ * translation applier, so the three cannot drift.
+ *
+ * `None` for everything that has nothing to propagate: a non-relation, a
+ * non-`i18n` owner (no siblings), an inverse field (it reuses the owning side's
+ * storage, so syncing from both ends would write the same links twice), and any
+ * relation whose author set `syncAcrossLocales: false`.
+ *
+ * The target's i18n-ness is read via the resolved thunk `spec.relation.to()` —
+ * safe because the registry resolves every relation target at boot.
+ */
+function relationLocaleSync(owner, spec) {
+    if (spec.type !== fields_1.CONTENT_FIELD_TYPE.Relation || !spec.relation)
+        return exports.RELATION_LOCALE_SYNC.None;
+    if (!owner.i18n)
+        return exports.RELATION_LOCALE_SYNC.None;
+    if (spec.relation.inverse)
+        return exports.RELATION_LOCALE_SYNC.None;
+    if (!spec.relation.syncAcrossLocales)
+        return exports.RELATION_LOCALE_SYNC.None;
+    return spec.relation.to().i18n
+        ? exports.RELATION_LOCALE_SYNC.Mirrored
+        : exports.RELATION_LOCALE_SYNC.Shared;
+}
+/**
+ * Whether a field's stored value **varies from one locale row to the next** —
+ * what the schema serializer reports to the admin as `localized`, and what the
+ * translation prefill uses to decide a field is the translator's to fill in.
+ *
+ * True for an explicitly `localized` field, and for a relation that is either
+ * mirrored (each sibling stores its own locale's target id) or unsynced (each
+ * sibling stores whatever it was given). False for a **shared** relation, whose
+ * every sibling genuinely holds the same id.
+ *
+ * Note the difference from {@link relationLocaleSync}: a *mirrored* relation is
+ * both per-locale AND propagated — the value differs per row precisely so that
+ * every row points at the right translation.
+ */
+function isPerLocaleField(owner, spec) {
+    if (spec.localized)
+        return true;
+    if (spec.type !== fields_1.CONTENT_FIELD_TYPE.Relation || !spec.relation)
+        return false;
+    if (!owner.i18n || spec.relation.inverse)
+        return false;
+    return relationLocaleSync(owner, spec) !== exports.RELATION_LOCALE_SYNC.Shared;
+}
+/**
+ * Whether a relation's links live in a join table (an owning many-to-many)
+ * rather than in a `<field>_id` column. The two storage forms are synced by
+ * different machinery — a column write vs. a join-row rewrite — so the sync
+ * pass splits on this.
+ *
+ * An **inverse** is excluded even though it is join-backed: it owns no writable
+ * link from its side.
+ */
+function isJoinBackedRelation(spec) {
+    return (spec.type === fields_1.CONTENT_FIELD_TYPE.Relation &&
+        !!spec.relation?.many &&
+        !spec.relation.inverse);
+}

package/dist/lib/fields/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Field builders — the `field.*` vocabulary used inside `collection()` /
+ * `single()` definitions. Each builder normalizes its options into a
+ * {@link FieldSpec} and carries the value type as a phantom generic so
+ * `InferEntry` can derive row types with correct nullability.
+ */
+import { type RichTextDocument } from '@orthacms/content-domain';
+import type { BaseFieldOptions, FieldSpec, MediaFieldOptions, MoneyFieldOptions, NumberFieldOptions, RelationFieldOptions, RelationInverseFieldOptions, RichTextFieldOptions, SelectFieldOptions, TextFieldOptions, WithRequired } from '../types/fields';
+/** Short text. Validation: minLength / maxLength / pattern. */
+declare function text<const O extends TextFieldOptions = TextFieldOptions>(options?: O): FieldSpec<'text', WithRequired<O, string>>;
+/**
+ * Long-form rich text — a **structured document**, not an HTML string.
+ *
+ * The value is the ProseMirror/TipTap node tree the admin editor produces, in
+ * a `jsonb` column, so heading order, table headers, link text and the
+ * language of a quoted passage are things the platform can express and check
+ * (WCAG 1.3.1 / 2.4.6 / 3.1.2) rather than characters inside an opaque blob.
+ * `minLength`/`maxLength` count the body's **text** for the same reason:
+ * bolding a word used to cost the author `<strong></strong>`.
+ *
+ * A body written before this change is an HTML string, and still reads and
+ * validates as one — see `@orthacms/content-domain`'s rich-text module. It is
+ * rewritten as a document the next time the record is saved through the editor.
+ */
+declare function richtext<const O extends RichTextFieldOptions = RichTextFieldOptions>(options?: O): FieldSpec<'richtext', WithRequired<O, RichTextDocument | string>>;
+/** Floating-point number (or integer with `integer: true`). */
+declare function number<const O extends NumberFieldOptions = NumberFieldOptions>(options?: O): FieldSpec<'number', WithRequired<O, number>>;
+/** Money in integer minor units (cents) — exact, no float drift. */
+declare function money<const O extends MoneyFieldOptions = MoneyFieldOptions>(options?: O): FieldSpec<'money', WithRequired<O, number>>;
+/** True/false. Stored NOT NULL with default false when `required`. */
+declare function boolean<const O extends BaseFieldOptions = BaseFieldOptions>(options?: O): FieldSpec<'boolean', WithRequired<O, boolean>>;
+/** Calendar date (no time of day), ISO `YYYY-MM-DD`. */
+declare function date<const O extends BaseFieldOptions = BaseFieldOptions>(options?: O): FieldSpec<'date', WithRequired<O, string>>;
+/** Point in time, stored as timestamptz. */
+declare function datetime<const O extends BaseFieldOptions = BaseFieldOptions>(options?: O): FieldSpec<'datetime', WithRequired<O, Date>>;
+/** One of a fixed set of strings. The value type narrows to the options. */
+declare function select<const O extends SelectFieldOptions>(options: O): FieldSpec<'select', WithRequired<O, O['options'][number]>>;
+/** Several of a fixed set of strings, stored as a jsonb array of options. */
+declare function multiselect<const O extends SelectFieldOptions>(options: O): FieldSpec<'multiselect', WithRequired<O, O['options'][number][]>>;
+/** Arbitrary JSON payload (jsonb). Escape hatch — prefer typed fields. */
+declare function json<const O extends BaseFieldOptions = BaseFieldOptions>(options?: O): FieldSpec<'json', WithRequired<O, unknown>>;
+/**
+ * Relation to another content type — a real Postgres foreign key.
+ * Single (`many: false`) becomes a `<field>_id` uuid FK column;
+ * `many: true` becomes a generated join table. `unique: true` adds a
+ * `UNIQUE` constraint to the single FK column for a one-to-one relation.
+ * `to` is a thunk so mutually-referencing collection files can import
+ * each other.
+ */
+declare function relation<const O extends RelationFieldOptions>(options: O): FieldSpec<'relation', O extends {
+    many: true;
+} ? string[] : WithRequired<O, string>>;
+/**
+ * The **inverse** side of a two-way relation — a back-reference to the storage
+ * owned by `of`'s `field`. Generates no column/table: it reads and writes the
+ * same link the owning relation does (source/target swapped), so editing either
+ * side stays in sync. `of` is a thunk so the two files can import each other.
+ *
+ * @example
+ *   // article.ts owns:  tags: field.relation({ to: () => tag, many: true })
+ *   // tag.ts mirrors:    articles: field.relationInverse({ of: () => article, field: 'tags' })
+ */
+declare function relationInverse<const O extends RelationInverseFieldOptions>(options: O): FieldSpec<'relation', O extends {
+    many: false;
+} ? string : string[]>;
+/**
+ * Attach one or more **Media Library** assets. Stores asset ids in the values
+ * bag — a single `uuid` column (`multiple: false`), or a `jsonb` array of ids
+ * (`multiple: true`), so media rides revisions and locale-sibling sync like any
+ * other field. Asset ids are plain uuids, not a Postgres FK: the assets live in
+ * the media plugin's own schema, so existence and the `accept` restriction are
+ * enforced by the server on save (via the media-asset resolver), not the DB.
+ */
+declare function media<const O extends MediaFieldOptions = MediaFieldOptions>(options?: O): FieldSpec<'media', O extends {
+    multiple: true;
+} ? string[] : WithRequired<O, string>>;
+/** The field-builder vocabulary: `field.text()`, `field.relation()`, … */
+export declare const field: {
+    text: typeof text;
+    richtext: typeof richtext;
+    number: typeof number;
+    money: typeof money;
+    boolean: typeof boolean;
+    date: typeof date;
+    datetime: typeof datetime;
+    select: typeof select;
+    multiselect: typeof multiselect;
+    json: typeof json;
+    relation: typeof relation;
+    relationInverse: typeof relationInverse;
+    media: typeof media;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/fields/index.d.ts.map

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

package/dist/lib/fields/index.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * Field builders — the `field.*` vocabulary used inside `collection()` /
+ * `single()` definitions. Each builder normalizes its options into a
+ * {@link FieldSpec} and carries the value type as a phantom generic so
+ * `InferEntry` can derive row types with correct nullability.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.field = void 0;
+const content_domain_1 = require("@orthacms/content-domain");
+const fields_1 = require("../types/fields");
+/** Builds the common part of every spec from the shared base options. */
+function base(type, options = {}, validation = {}) {
+    // A `lang` that no user agent can parse is worse than none — it tells
+    // assistive tech the content is in a language it cannot pronounce. Fail at
+    // definition time (boot) rather than shipping it into every entry.
+    if (options.lang !== undefined && !(0, content_domain_1.isWellFormedLanguageTag)(options.lang)) {
+        throw new Error(`Invalid BCP-47 language tag ${JSON.stringify(options.lang)} on a ` +
+            `${type} field. Expected something like "en", "en-GB" or "zh-Hans".`);
+    }
+    return {
+        type,
+        required: options.required ?? false,
+        // Omitted (not `false`) when unset, so serialized specs stay lean and
+        // the admin can treat presence as the flag.
+        ...(options.localized ? { localized: true } : {}),
+        ...(options.lang !== undefined ? { lang: options.lang } : {}),
+        validation,
+        admin: options.admin ?? {}
+    };
+}
+/** Short text. Validation: minLength / maxLength / pattern. */
+function text(options) {
+    const { minLength, maxLength, pattern } = options ?? {};
+    if (pattern !== undefined) {
+        // Fail at definition time (boot) rather than on the first value that
+        // hits validation, if the author wrote an unparseable pattern.
+        try {
+            new RegExp(pattern);
+        }
+        catch (cause) {
+            throw new Error(`Invalid regex pattern ${JSON.stringify(pattern)} on a text ` +
+                `field: ${cause.message}`);
+        }
+    }
+    return base(fields_1.CONTENT_FIELD_TYPE.Text, options, {
+        minLength,
+        maxLength,
+        pattern
+    });
+}
+/**
+ * Long-form rich text — a **structured document**, not an HTML string.
+ *
+ * The value is the ProseMirror/TipTap node tree the admin editor produces, in
+ * a `jsonb` column, so heading order, table headers, link text and the
+ * language of a quoted passage are things the platform can express and check
+ * (WCAG 1.3.1 / 2.4.6 / 3.1.2) rather than characters inside an opaque blob.
+ * `minLength`/`maxLength` count the body's **text** for the same reason:
+ * bolding a word used to cost the author `<strong></strong>`.
+ *
+ * A body written before this change is an HTML string, and still reads and
+ * validates as one — see `@orthacms/content-domain`'s rich-text module. It is
+ * rewritten as a document the next time the record is saved through the editor.
+ */
+function richtext(options) {
+    const { minLength, maxLength, structure } = options ?? {};
+    return base(fields_1.CONTENT_FIELD_TYPE.RichText, options, {
+        minLength,
+        maxLength,
+        ...(structure !== undefined ? { structure } : {})
+    });
+}
+/** Floating-point number (or integer with `integer: true`). */
+function number(options) {
+    const { min, max, integer } = options ?? {};
+    return base(fields_1.CONTENT_FIELD_TYPE.Number, options, { min, max, integer });
+}
+/** Money in integer minor units (cents) — exact, no float drift. */
+function money(options) {
+    const { min, max } = options ?? {};
+    return base(fields_1.CONTENT_FIELD_TYPE.Money, options, { min, max, integer: true });
+}
+/** True/false. Stored NOT NULL with default false when `required`. */
+function boolean(options) {
+    return base(fields_1.CONTENT_FIELD_TYPE.Boolean, options);
+}
+/** Calendar date (no time of day), ISO `YYYY-MM-DD`. */
+function date(options) {
+    return base(fields_1.CONTENT_FIELD_TYPE.Date, options);
+}
+/** Point in time, stored as timestamptz. */
+function datetime(options) {
+    return base(fields_1.CONTENT_FIELD_TYPE.Datetime, options);
+}
+/** One of a fixed set of strings. The value type narrows to the options. */
+function select(options) {
+    return {
+        ...base(fields_1.CONTENT_FIELD_TYPE.Select, options),
+        options: options.options
+    };
+}
+/** Several of a fixed set of strings, stored as a jsonb array of options. */
+function multiselect(options) {
+    return {
+        ...base(fields_1.CONTENT_FIELD_TYPE.Multiselect, options),
+        options: options.options
+    };
+}
+/** Arbitrary JSON payload (jsonb). Escape hatch — prefer typed fields. */
+function json(options) {
+    return base(fields_1.CONTENT_FIELD_TYPE.Json, options);
+}
+/**
+ * Relation to another content type — a real Postgres foreign key.
+ * Single (`many: false`) becomes a `<field>_id` uuid FK column;
+ * `many: true` becomes a generated join table. `unique: true` adds a
+ * `UNIQUE` constraint to the single FK column for a one-to-one relation.
+ * `to` is a thunk so mutually-referencing collection files can import
+ * each other.
+ */
+function relation(options) {
+    return {
+        ...base(fields_1.CONTENT_FIELD_TYPE.Relation, options),
+        relation: {
+            to: options.to,
+            many: options.many ?? false,
+            onDelete: options.onDelete ?? (options.required ? 'cascade' : 'set null'),
+            unique: options.unique ?? false,
+            // `localized: true` on a relation means "each locale keeps its own
+            // links", which is exactly `syncAcrossLocales: false` — so it sets
+            // the default rather than being a second, separately-honoured flag.
+            // Declaring both in contradiction is rejected at define time.
+            syncAcrossLocales: options.syncAcrossLocales ?? !(options.localized ?? false)
+        }
+    };
+}
+/**
+ * The **inverse** side of a two-way relation — a back-reference to the storage
+ * owned by `of`'s `field`. Generates no column/table: it reads and writes the
+ * same link the owning relation does (source/target swapped), so editing either
+ * side stays in sync. `of` is a thunk so the two files can import each other.
+ *
+ * @example
+ *   // article.ts owns:  tags: field.relation({ to: () => tag, many: true })
+ *   // tag.ts mirrors:    articles: field.relationInverse({ of: () => article, field: 'tags' })
+ */
+function relationInverse(options) {
+    return {
+        ...base(fields_1.CONTENT_FIELD_TYPE.Relation, options),
+        relation: {
+            to: options.of,
+            many: options.many ?? true,
+            onDelete: 'set null', // inert for a virtual (storage-less) field
+            unique: false,
+            // Inert too: an inverse reuses the owning side's FK/join rows, so
+            // syncing from both ends would write the same links twice.
+            syncAcrossLocales: false,
+            inverse: { field: options.field }
+        }
+    };
+}
+/**
+ * Attach one or more **Media Library** assets. Stores asset ids in the values
+ * bag — a single `uuid` column (`multiple: false`), or a `jsonb` array of ids
+ * (`multiple: true`), so media rides revisions and locale-sibling sync like any
+ * other field. Asset ids are plain uuids, not a Postgres FK: the assets live in
+ * the media plugin's own schema, so existence and the `accept` restriction are
+ * enforced by the server on save (via the media-asset resolver), not the DB.
+ */
+function media(options) {
+    const accept = options?.accept;
+    if (accept?.kinds) {
+        // Fail at boot on a typo'd kind rather than silently accepting nothing.
+        for (const kind of accept.kinds) {
+            if (!fields_1.MEDIA_KIND_VALUES.includes(kind)) {
+                throw new Error(`Invalid media kind ${JSON.stringify(kind)} on a media ` +
+                    `field: expected one of ${fields_1.MEDIA_KIND_VALUES.join(', ')}.`);
+            }
+        }
+    }
+    return {
+        ...base(fields_1.CONTENT_FIELD_TYPE.Media, options),
+        multiple: options?.multiple ?? false,
+        ...(accept ? { accept } : {})
+    };
+}
+/** The field-builder vocabulary: `field.text()`, `field.relation()`, … */
+exports.field = {
+    text,
+    richtext,
+    number,
+    money,
+    boolean,
+    date,
+    datetime,
+    select,
+    multiselect,
+    json,
+    relation,
+    relationInverse,
+    media
+};

package/dist/lib/insights/http/controllers/content-pipeline.controller.d.ts

@@ -0,0 +1,16 @@
+import { ContentInsightsQuery } from '../../infrastructure/queries/content-insights.query';
+import type { ContentPipelineView } from '../../types/content-insights-view';
+/**
+ * `GET /api/insights/content/pipeline` — the draft/published split for every
+ * content type that has at least one entry in the workspace.
+ *
+ * Takes no `?days=`: this is a snapshot of what exists now, not a flow over
+ * time. Filtering it by a window would answer a different and much less useful
+ * question ("what was created recently") under the same name.
+ */
+export declare class ContentPipelineController {
+    private readonly insights;
+    constructor(insights: ContentInsightsQuery);
+    pipeline(workspaceId: string): Promise<ContentPipelineView>;
+}
+//# sourceMappingURL=content-pipeline.controller.d.ts.map

package/dist/lib/insights/http/controllers/content-pipeline.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-pipeline.controller.d.ts","sourceRoot":"","sources":["../../../../../src/lib/insights/http/controllers/content-pipeline.controller.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qDAAqD,CAAC;AAC3F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAE7E;;;;;;;GAOG;AACH,qBAGa,yBAAyB;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,oBAAoB;IAG3D,QAAQ,CACgB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,mBAAmB,CAAC;CAGlC"}