@orthacms/content-server 0.0.0-reserve.0

package/dist/lib/entries/infrastructure/queries/entry-filter-surface.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEntryFilterSurface = buildEntryFilterSurface;
+const drizzle_orm_1 = require("drizzle-orm");
+const utils_server_1 = require("@orthacms/utils-server");
+const content_type_1 = require("../../../types/content-type");
+const fields_1 = require("../../../types/fields");
+// `scalarTypeFor` is the single scalar-coercion mapping — shared with the
+// sort whitelist (`isScalarField`), so "filterable" and "sortable" can't
+// disagree on which field types are backed by a comparable column.
+const entry_scalar_fields_1 = require("./entry-scalar-fields");
+/**
+ * Relation hops offered by default. 2 hops means `author.company.name` is
+ * reachable and `…company.country.name` is not. Each hop is an EXISTS
+ * subquery, so this directly bounds worst-case query cost. The engine's
+ * `maxDepth` counts path SEGMENTS (hops + 1), so it is derived as
+ * `hops + 1` below — raising one without the other would let the picker
+ * offer paths the parser rejects with a 400.
+ */
+const DEFAULT_RELATION_HOPS = 2;
+/** Humanize a field name — mirrors the admin's `fieldLabel` fallback. */
+function humanize(name) {
+    return name
+        .replace(/[_-]+/g, ' ')
+        .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+        .replace(/^\w/, (c) => c.toUpperCase());
+}
+/** A field's display label — its admin label, else a humanized name. */
+function fieldLabel(name, spec) {
+    const label = spec.admin?.label;
+    return typeof label === 'string' && label.length > 0
+        ? label
+        : humanize(name);
+}
+/**
+ * Resolve a column on a generated table by its JS property name.
+ *
+ * `Object.hasOwn`-guarded, and it throws rather than returning `undefined`.
+ * Every caller today passes a literal or a name off `Object.entries(type.fields)`,
+ * so nothing request-supplied reaches it — but drizzle's column map is a plain
+ * object, an unguarded lookup resolves `constructor`/`valueOf`/`toString` to
+ * truthy non-columns, and handing one of those to drizzle as a `Column` emits a
+ * broken fragment (a 500) rather than failing here. Its `utils-server`
+ * counterpart (`columnOf`) is guarded the same way, so the two helpers can't
+ * disagree about what a name means.
+ */
+function col(table, name) {
+    const cols = (0, drizzle_orm_1.getTableColumns)(table);
+    const column = Object.hasOwn(cols, name) ? cols[name] : undefined;
+    if (!column) {
+        throw new utils_server_1.FilterSchemaException(`column "${name}" does not exist on the generated table`);
+    }
+    return column;
+}
+/**
+ * The scope predicate for one target type: the workspace boundary plus the
+ * soft-delete guard, resolved against whatever table the translator queries
+ * (the physical target, or an alias for a self-relation). Without this a
+ * relation filter matches rows the root list itself excludes — a
+ * soft-deleted author would still match `author.name`.
+ *
+ * Publish status is deliberately NOT filtered here: an editor filtering
+ * articles by author expects to match a draft author, and hiding
+ * unpublished targets would silently drop rows. A published-only traversal
+ * is expressible as an explicit `author.status` rule instead.
+ */
+function scopeFor(target, workspaceId) {
+    return (tbl) => {
+        const cols = (0, drizzle_orm_1.getTableColumns)(tbl);
+        return (0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(cols['workspaceId'], workspaceId), target.paranoid ? (0, drizzle_orm_1.isNull)(cols['deletedAt']) : undefined);
+    };
+}
+/** The scalar (envelope + field) whitelist for one type at one level. */
+function scalarFieldsOf(type) {
+    const fields = {
+        // `id` so a relation's record picker (`author.id in (…)`) resolves,
+        // and the envelope timestamps so they stay API-filterable.
+        id: { type: utils_server_1.ScalarFieldType.Uuid },
+        createdAt: { type: utils_server_1.ScalarFieldType.Date },
+        updatedAt: { type: utils_server_1.ScalarFieldType.Date }
+    };
+    if (type.publishable) {
+        fields['status'] = {
+            type: utils_server_1.ScalarFieldType.Enum,
+            enumValues: [content_type_1.ENTRY_STATUS.Draft, content_type_1.ENTRY_STATUS.Published]
+        };
+        fields['publishedAt'] = { type: utils_server_1.ScalarFieldType.Date };
+    }
+    if (type.i18n) {
+        fields['locale'] = { type: utils_server_1.ScalarFieldType.String };
+        // The translation-group key, so a caller holding one row's group can
+        // ask for the group's row in another locale (`localeGroupId eq X` +
+        // `?locale=de`). Whitelisted for SQL only — `scalarWireOf` below builds
+        // the admin's filter *picker*, and this envelope column stays out of
+        // it, so the UI is unchanged.
+        fields['localeGroupId'] = { type: utils_server_1.ScalarFieldType.Uuid };
+    }
+    for (const [name, spec] of Object.entries(type.fields)) {
+        const scalar = (0, entry_scalar_fields_1.scalarTypeFor)(spec);
+        if (scalar)
+            fields[name] = scalar;
+    }
+    return fields;
+}
+/** The wire fields the picker shows at one level: user scalars + status. */
+function scalarWireOf(type, path, group, wire) {
+    if (type.publishable) {
+        wire.push({
+            path: [...path, 'status'].join('.'),
+            label: 'Status',
+            type: utils_server_1.ScalarFieldType.Enum,
+            enumValues: [content_type_1.ENTRY_STATUS.Draft, content_type_1.ENTRY_STATUS.Published],
+            group
+        });
+    }
+    for (const [name, spec] of Object.entries(type.fields)) {
+        const scalar = (0, entry_scalar_fields_1.scalarTypeFor)(spec);
+        if (!scalar)
+            continue;
+        wire.push({
+            path: [...path, name].join('.'),
+            label: fieldLabel(name, spec),
+            type: scalar.type,
+            enumValues: scalar.enumValues,
+            group
+        });
+    }
+}
+/**
+ * Build one relation's `RelationSchema`, recursing into the target's own
+ * relations while hops remain, and pushing the wire fields for the target
+ * level as it goes. Returns `null` to omit the relation entirely (ungranted
+ * target, a cycle back to an ancestor, or a self-referential shape not yet
+ * supported).
+ */
+function relationFor(name, spec, owner, path, group, hopsLeft, visited, ctx) {
+    const rel = spec.relation;
+    if (!rel)
+        return null;
+    // `to()` is the target for an owning side, the OWNER of the storage for
+    // an inverse — either way, the type this hop traverses to.
+    const target = rel.to();
+    if (ctx.grantedTypes && !ctx.grantedTypes.has(target.name))
+        return null;
+    const selfRef = target.name === owner.name;
+    // A cycle back to an ANCESTOR is never a filter a user wants. A
+    // self-reference is allowed (page trees) and bounded by hops instead.
+    if (!selfRef && visited.has(target.name))
+        return null;
+    const relLabel = fieldLabel(name, spec);
+    const nextPath = [...path, name];
+    const nextGroup = [...group, relLabel];
+    // The relation's record-picker entry: `author.id`, rendered as a picker
+    // over `target` rather than a raw uuid input.
+    ctx.wire.push({
+        path: [...nextPath, 'id'].join('.'),
+        label: relLabel,
+        type: utils_server_1.ScalarFieldType.Uuid,
+        group: nextGroup,
+        relationTarget: target.name
+    });
+    // The target's own scalar fields + (if hops remain) its relations. This
+    // is the SAME walk that emits the wire fields, so the SQL whitelist and
+    // the picker's field list are one traversal and cannot drift.
+    const nested = walk(target, nextPath, nextGroup, hopsLeft - 1, visited, ctx);
+    const common = {
+        fields: nested.fields,
+        relations: nested.relations,
+        scope: scopeFor(target, ctx.workspaceId)
+    };
+    const ownerT = owner.table;
+    const targetT = target.table;
+    // ---- inverse: storage lives on the owning side, reused swapped ----
+    if (rel.inverse) {
+        const ownerField = rel.inverse.field;
+        const ownerSpec = target.fields[ownerField];
+        if (!ownerSpec?.relation)
+            return null;
+        if (ownerSpec.relation.many) {
+            // Inverse of a many-to-many: OUR rows are the join's targets.
+            if (selfRef)
+                return null; // self many-to-many — not supported yet
+            const join = target.joinTables[ownerField];
+            if (!join)
+                return null;
+            return {
+                kind: utils_server_1.RelationKind.ManyToMany,
+                through: join,
+                fk: col(join, 'targetId'),
+                targetFk: col(join, 'sourceId'),
+                table: target.table,
+                parentKey: col(ownerT, 'id'),
+                targetKey: col(targetT, 'id'),
+                ...common
+            };
+        }
+        // Inverse of a single = one-to-many: the owner's FK points at us.
+        return {
+            kind: utils_server_1.RelationKind.OneToMany,
+            table: target.table,
+            fk: col(targetT, ownerField),
+            parentKey: col(ownerT, 'id'),
+            ...common
+        };
+    }
+    // ---- owning many-to-many ----
+    if (rel.many) {
+        if (selfRef)
+            return null; // self many-to-many — not supported yet
+        const join = owner.joinTables[name];
+        if (!join)
+            return null;
+        return {
+            kind: utils_server_1.RelationKind.ManyToMany,
+            through: join,
+            fk: col(join, 'sourceId'),
+            targetFk: col(join, 'targetId'),
+            table: target.table,
+            parentKey: col(ownerT, 'id'),
+            targetKey: col(targetT, 'id'),
+            ...common
+        };
+    }
+    // ---- owning single ----
+    if (selfRef) {
+        return {
+            kind: utils_server_1.RelationKind.SelfReferential,
+            table: target.table,
+            fk: col(ownerT, name),
+            // Unique per OCCURRENCE, not per relation: two rules on the same
+            // self-relation must not share a correlation name.
+            alias: `qb_${nextPath.join('__')}`,
+            ...common
+        };
+    }
+    return {
+        kind: utils_server_1.RelationKind.ManyToOne,
+        table: target.table,
+        fk: col(ownerT, name),
+        targetKey: col(targetT, 'id'),
+        ...common
+    };
+}
+/**
+ * One node of the surface: the scalar fields filterable at this level and
+ * the relations traversable from it. Emits the wire fields for this level
+ * as a side effect on `ctx.wire`, so the SQL whitelist (the return value)
+ * and the picker's field list (the accumulator) are produced by a single
+ * traversal.
+ */
+function walk(type, path, group, hopsLeft, visited, ctx) {
+    const fields = scalarFieldsOf(type);
+    scalarWireOf(type, path, group, ctx.wire);
+    if (hopsLeft <= 0)
+        return { fields };
+    const nextVisited = new Set([...visited, type.name]);
+    const relations = {};
+    for (const [name, spec] of Object.entries(type.fields)) {
+        if (spec.type !== fields_1.CONTENT_FIELD_TYPE.Relation)
+            continue;
+        const r = relationFor(name, spec, type, path, group, hopsLeft, nextVisited, ctx);
+        if (r)
+            relations[name] = r;
+    }
+    return {
+        fields,
+        relations: Object.keys(relations).length ? relations : undefined
+    };
+}
+/**
+ * The filterable surface for one content type: the Drizzle `FilterSchema`
+ * (the security boundary — only listed paths reach SQL) AND the flat
+ * `WireFilterField[]` the admin's query builder renders, produced by a
+ * single traversal so they cannot drift.
+ *
+ * `extensionFields` are virtual fields contributed by the bound
+ * `CONTENT_ENTRY_EXTENSION` (locale aggregates, …): they merge into the
+ * root `fields` (so the parser can coerce their values) and their names are
+ * registered on `extensionFields` (so the translator routes them to the
+ * extension's own SQL resolver). A real column always wins a name clash.
+ * They are NOT surfaced as wire fields here — a contributing plugin adds
+ * those via the admin's `RECORDS_FILTER_FIELDS_SLOT`, as today.
+ */
+function buildEntryFilterSurface(type, opts) {
+    const hops = opts.maxRelationHops ?? DEFAULT_RELATION_HOPS;
+    const ctx = {
+        workspaceId: opts.workspaceId,
+        grantedTypes: opts.grantedTypes,
+        wire: []
+    };
+    const root = walk(type, [], [], hops, new Set(), ctx);
+    const schema = {
+        fields: root.fields,
+        relations: root.relations,
+        // Path SEGMENTS = hops + 1 (`author.company.name` is 3 at 2 hops),
+        // so the engine cap must track the traversal cap or it silently
+        // rejects paths the picker offers.
+        maxDepth: hops + 1
+    };
+    if (opts.extensionFields) {
+        const merged = schema.fields ?? {};
+        const extra = Object.keys(opts.extensionFields).filter((n) => !(n in merged));
+        for (const n of extra)
+            merged[n] = opts.extensionFields[n];
+        schema.fields = merged;
+        if (extra.length)
+            schema.extensionFields = new Set(extra);
+    }
+    return { schema, fields: ctx.wire };
+}

package/dist/lib/entries/infrastructure/queries/entry-scalar-fields.d.ts

@@ -0,0 +1,25 @@
+import { type ScalarFieldSchema } from '@orthacms/utils-server';
+import { type AnyFieldSpec } from '../../../types/fields';
+/**
+ * The filter scalar type for one content field, or `null` to leave it
+ * unfilterable. Mirrors the admin's `filterFieldsFromSchema`: text fields
+ * filter as strings, `select` as an enum of its options, numerics as numbers,
+ * dates as dates. `json`/`multiselect`/`media` have no scalar editor, and
+ * `relation` filtering (by raw FK uuid) has no UI yet — all skipped.
+ *
+ * `richtext` is skipped too, and deliberately: a body is a **document**, so
+ * `equals`/`starts with` over it would be comparing one serialization of a
+ * node tree against another rather than comparing prose. Free-text `?search=`
+ * still reaches it — see `isTextLike` — which is the question a reader
+ * actually asks of a body.
+ */
+export declare function scalarTypeFor(spec: AnyFieldSpec): ScalarFieldSchema | null;
+/**
+ * Whether a field is backed by a comparable scalar column — the single source of
+ * truth for "can this field be filtered or sorted". `richtext`/`json`/
+ * `multiselect` (jsonb) and `relation` (FK uuid / join table) are not: they have
+ * no scalar editor and ordering them is meaningless. The sort whitelist and the filter schema both
+ * derive from this, so the two can't drift apart.
+ */
+export declare function isScalarField(spec: AnyFieldSpec): boolean;
+//# sourceMappingURL=entry-scalar-fields.d.ts.map

package/dist/lib/entries/infrastructure/queries/entry-scalar-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-scalar-fields.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/queries/entry-scalar-fields.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,KAAK,iBAAiB,EACzB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE9E;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,iBAAiB,GAAG,IAAI,CAqB1E;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAEzD"}

package/dist/lib/entries/infrastructure/queries/entry-scalar-fields.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scalarTypeFor = scalarTypeFor;
+exports.isScalarField = isScalarField;
+const utils_server_1 = require("@orthacms/utils-server");
+const fields_1 = require("../../../types/fields");
+/**
+ * The filter scalar type for one content field, or `null` to leave it
+ * unfilterable. Mirrors the admin's `filterFieldsFromSchema`: text fields
+ * filter as strings, `select` as an enum of its options, numerics as numbers,
+ * dates as dates. `json`/`multiselect`/`media` have no scalar editor, and
+ * `relation` filtering (by raw FK uuid) has no UI yet — all skipped.
+ *
+ * `richtext` is skipped too, and deliberately: a body is a **document**, so
+ * `equals`/`starts with` over it would be comparing one serialization of a
+ * node tree against another rather than comparing prose. Free-text `?search=`
+ * still reaches it — see `isTextLike` — which is the question a reader
+ * actually asks of a body.
+ */
+function scalarTypeFor(spec) {
+    switch (spec.type) {
+        case fields_1.CONTENT_FIELD_TYPE.Text:
+            return { type: utils_server_1.ScalarFieldType.String };
+        case fields_1.CONTENT_FIELD_TYPE.Select:
+            return {
+                type: utils_server_1.ScalarFieldType.Enum,
+                enumValues: spec.options ?? []
+            };
+        case fields_1.CONTENT_FIELD_TYPE.Number:
+        case fields_1.CONTENT_FIELD_TYPE.Money:
+            return { type: utils_server_1.ScalarFieldType.Number };
+        case fields_1.CONTENT_FIELD_TYPE.Boolean:
+            return { type: utils_server_1.ScalarFieldType.Boolean };
+        case fields_1.CONTENT_FIELD_TYPE.Date:
+        case fields_1.CONTENT_FIELD_TYPE.Datetime:
+            return { type: utils_server_1.ScalarFieldType.Date };
+        default:
+            // richtext / json / multiselect / media / relation
+            return null;
+    }
+}
+/**
+ * Whether a field is backed by a comparable scalar column — the single source of
+ * truth for "can this field be filtered or sorted". `richtext`/`json`/
+ * `multiselect` (jsonb) and `relation` (FK uuid / join table) are not: they have
+ * no scalar editor and ordering them is meaningless. The sort whitelist and the filter schema both
+ * derive from this, so the two can't drift apart.
+ */
+function isScalarField(spec) {
+    return scalarTypeFor(spec) !== null;
+}

package/dist/lib/entries/infrastructure/queries/entry-search.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The free-text `?search=` predicate, shared by the admin entries list and the
+ * public content API so the two can't drift on which columns are searched or —
+ * more importantly — on how the needle is escaped.
+ */
+import { type SQL } from 'drizzle-orm';
+import type { AnyContentType } from '../../../types/content-type';
+import { type AnyFieldSpec } from '../../../types/fields';
+/** Columns the free-text search scans (they hold searchable textual content). */
+export declare function isTextLike(spec: AnyFieldSpec): boolean;
+/**
+ * Case-insensitive `ILIKE` across the type's text-like columns, OR-ed together;
+ * `undefined` when there is no search term (so it collapses out of an `and()`).
+ *
+ * The needle's LIKE metacharacters are escaped, so a literal `%` or `_`
+ * searches literally instead of turning the query into a wildcard scan.
+ */
+export declare function buildSearchPredicate(type: AnyContentType, search: string | undefined): SQL | undefined;
+//# sourceMappingURL=entry-search.d.ts.map

package/dist/lib/entries/infrastructure/queries/entry-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-search.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/queries/entry-search.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAkC,KAAK,GAAG,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAK9E,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAMtD;AAmBD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,GAAG,SAAS,GAC3B,GAAG,GAAG,SAAS,CAWjB"}

package/dist/lib/entries/infrastructure/queries/entry-search.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * The free-text `?search=` predicate, shared by the admin entries list and the
+ * public content API so the two can't drift on which columns are searched or —
+ * more importantly — on how the needle is escaped.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTextLike = isTextLike;
+exports.buildSearchPredicate = buildSearchPredicate;
+const drizzle_orm_1 = require("drizzle-orm");
+const fields_1 = require("../../../types/fields");
+/** Columns the free-text search scans (they hold searchable textual content). */
+function isTextLike(spec) {
+    return (spec.type === fields_1.CONTENT_FIELD_TYPE.Text ||
+        spec.type === fields_1.CONTENT_FIELD_TYPE.RichText ||
+        spec.type === fields_1.CONTENT_FIELD_TYPE.Select);
+}
+/**
+ * The expression a text-like column is matched against.
+ *
+ * A `richtext` body is a **document** in a `jsonb` column, and `ILIKE` has no
+ * meaning against `jsonb` — so it is cast to text and the search runs over the
+ * serialized tree. That reaches the words, which is what a reader is looking
+ * for; the cost is that a needle spelling one of the tree's own key names
+ * (`paragraph`, `heading`) can match a body that never says it. Searching the
+ * *text* properly wants a stored, indexed projection of it — worth doing when
+ * search is next revisited, and much more than a cast.
+ */
+function searchable(spec, column) {
+    return spec.type === fields_1.CONTENT_FIELD_TYPE.RichText
+        ? (0, drizzle_orm_1.sql) `${column}::text`
+        : column;
+}
+/**
+ * Case-insensitive `ILIKE` across the type's text-like columns, OR-ed together;
+ * `undefined` when there is no search term (so it collapses out of an `and()`).
+ *
+ * The needle's LIKE metacharacters are escaped, so a literal `%` or `_`
+ * searches literally instead of turning the query into a wildcard scan.
+ */
+function buildSearchPredicate(type, search) {
+    const needle = search?.trim();
+    if (!needle) {
+        return undefined;
+    }
+    const table = type.table;
+    const pattern = `%${needle.replace(/[\\%_]/g, '\\$&')}%`;
+    const clauses = Object.entries(type.fields)
+        .filter(([, spec]) => isTextLike(spec))
+        .map(([name, spec]) => (0, drizzle_orm_1.ilike)(searchable(spec, table[name]), pattern));
+    return clauses.length ? (0, drizzle_orm_1.or)(...clauses) : undefined;
+}

package/dist/lib/entries/infrastructure/queries/media-refs.query.d.ts

@@ -0,0 +1,21 @@
+import type { AnyContentType } from '../../../types/content-type';
+import { type MediaAssetResolver } from '../../../extension/media-asset-resolver';
+import type { MediaRef } from '../../types/entry-list-view';
+/**
+ * Resolves the media fields of a `values` bag to display refs — the assets the
+ * admin renders (name / thumbnail url / kind) instead of raw uuids. One batched
+ * resolver lookup across every media id; an asset that can't be resolved
+ * (deleted / cross-workspace) is kept **in order** as an id-only `missing` ref,
+ * so a `multiple` field's list never runs shorter than what was stored.
+ *
+ * Shared by the entry-editor read (`GET …/:id/media`, against the live row's
+ * values) and the revision preview (against a snapshot's values), so the two
+ * can't drift. A no-op returning `{}` when no media resolver is bound.
+ */
+export declare class MediaRefsQuery {
+    private readonly resolver?;
+    constructor(resolver?: MediaAssetResolver | undefined);
+    /** Resolve every media field's ids in `values` to ordered {@link MediaRef}s. */
+    forValues(type: AnyContentType, values: Record<string, unknown>, workspaceId: string): Promise<Record<string, MediaRef[]>>;
+}
+//# sourceMappingURL=media-refs.query.d.ts.map

package/dist/lib/entries/infrastructure/queries/media-refs.query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-refs.query.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/queries/media-refs.query.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAElE,OAAO,EAEH,KAAK,kBAAkB,EAC1B,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,qBACa,cAAc;IAInB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;gBAAT,QAAQ,CAAC,EAAE,kBAAkB,YAAA;IAGlD,gFAAgF;IAC1E,SAAS,CACX,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;CAkEzC"}

package/dist/lib/entries/infrastructure/queries/media-refs.query.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaRefsQuery = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const content_domain_1 = require("@orthacms/content-domain");
+const fields_1 = require("../../../types/fields");
+const media_asset_resolver_1 = require("../../../extension/media-asset-resolver");
+/**
+ * Resolves the media fields of a `values` bag to display refs — the assets the
+ * admin renders (name / thumbnail url / kind) instead of raw uuids. One batched
+ * resolver lookup across every media id; an asset that can't be resolved
+ * (deleted / cross-workspace) is kept **in order** as an id-only `missing` ref,
+ * so a `multiple` field's list never runs shorter than what was stored.
+ *
+ * Shared by the entry-editor read (`GET …/:id/media`, against the live row's
+ * values) and the revision preview (against a snapshot's values), so the two
+ * can't drift. A no-op returning `{}` when no media resolver is bound.
+ */
+let MediaRefsQuery = class MediaRefsQuery {
+    resolver;
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    /** Resolve every media field's ids in `values` to ordered {@link MediaRef}s. */
+    async forValues(type, values, workspaceId) {
+        const out = {};
+        if (!this.resolver)
+            return out;
+        // The **refs**, not just the ids: a media value has carried a
+        // per-usage `alt` and a `decorative` flag since `ORT-83`, and the whole
+        // point of putting them on the value is that they override the asset
+        // row's own description for *this* usage.
+        const byField = {};
+        const all = new Set();
+        for (const [name, spec] of Object.entries(type.fields)) {
+            if (spec.type !== fields_1.CONTENT_FIELD_TYPE.Media)
+                continue;
+            const value = values[name];
+            const refs = (Array.isArray(value) ? value : [value])
+                .map(content_domain_1.toMediaValueRef)
+                .filter((ref) => ref !== null && !!ref.id);
+            if (!refs.length)
+                continue;
+            byField[name] = refs;
+            for (const ref of refs)
+                all.add(ref.id);
+        }
+        if (!all.size)
+            return out;
+        const resolved = await this.resolver.resolve([...all], workspaceId);
+        for (const [name, refs] of Object.entries(byField)) {
+            out[name] = refs.map((ref) => {
+                const id = ref.id;
+                const asset = resolved.get(id);
+                return asset
+                    ? {
+                        id: asset.id,
+                        name: asset.name,
+                        url: asset.url,
+                        // Only when the resolver has them — an asset with no
+                        // derivative keeps the ref clean rather than carrying
+                        // an undefined the admin has to test twice.
+                        ...(asset.thumbUrl
+                            ? { thumbUrl: asset.thumbUrl }
+                            : {}),
+                        ...(asset.previewUrl
+                            ? { previewUrl: asset.previewUrl }
+                            : {}),
+                        kind: asset.kind,
+                        mimeType: asset.mimeType,
+                        // Per-usage wins over the asset's default, and
+                        // `decorative` beats both: an image the author marked
+                        // presentational *here* publishes with an empty `alt`
+                        // however it is described in the library.
+                        alt: usageAlt(ref, asset.alt),
+                        ...(ref.decorative === true
+                            ? { decorative: true }
+                            : {})
+                    }
+                    : {
+                        id,
+                        name: id,
+                        url: '',
+                        kind: '',
+                        mimeType: '',
+                        missing: true
+                    };
+            });
+        }
+        return out;
+    }
+};
+exports.MediaRefsQuery = MediaRefsQuery;
+exports.MediaRefsQuery = MediaRefsQuery = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, common_1.Optional)()),
+    tslib_1.__param(0, (0, media_asset_resolver_1.InjectMediaAssetResolver)()),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], MediaRefsQuery);
+/**
+ * The alt text this usage should publish with.
+ *
+ * `decorative` wins outright and resolves to an empty string — the value an
+ * `<img alt="">` needs to be skipped by a screen reader, which is a different
+ * claim from having no `alt` attribute at all. Otherwise a per-usage `alt`
+ * overrides the asset row's default, and a usage that said nothing falls back to
+ * it. Alt text is per usage, not per asset: the same logo is "Acme logo" in a
+ * header and decorative in a footer strip (`ORT-83`).
+ */
+function usageAlt(ref, assetAlt) {
+    if (ref.decorative === true)
+        return '';
+    if (typeof ref.alt === 'string' && ref.alt.trim() !== '')
+        return ref.alt;
+    return assetAlt;
+}

package/dist/lib/entries/services/entries.service.d.ts

@@ -0,0 +1,59 @@
+import { type Database } from '@ortha-cms/database';
+import { type ContentEntryExtension } from '../../extension/entry-extension';
+import type { AnyContentType } from '../../types/content-type';
+import { type ListEntriesQueryDto } from '../dto/list-entries-query.dto';
+import type { EntryListView } from '../types/entry-list-view';
+/**
+ * Reads a collection's entries. Generic over the content type: the physical
+ * table, the filterable columns, the searchable columns, and the sort whitelist
+ * are all derived from `type` at request time, so one service backs every
+ * collection. Owns no schema of its own — it queries the HOST-owned generated
+ * `content_<name>` tables through the shared Drizzle client.
+ */
+export declare class EntriesService {
+    private readonly db;
+    private readonly extension?;
+    constructor(db: Database, extension?: ContentEntryExtension | undefined);
+    /**
+     * One page of a collection's entries: search → filter → sort → paginate, run
+     * in SQL against the type's generated table, returned as the
+     * `{ items, total, page, pageSize }` envelope the admin records table renders.
+     * Scoped to `workspaceId` — only the calling workspace's entries are counted
+     * or listed.
+     */
+    list(type: AnyContentType, query: ListEntriesQueryDto, workspaceId: string): Promise<EntryListView>;
+    /**
+     * The full WHERE: the workspace scope AND free-text search AND the
+     * query-builder `?filter=` tree AND (for paranoid types) the not-deleted
+     * guard. `and(undefined, …)` collapses empties, so an unfiltered list still
+     * scans the workspace's whole table. The workspace predicate is always
+     * present, so an entry never leaks across workspaces. A malformed filter
+     * throws a `FilterException` (HTTP 400).
+     */
+    private listWhere;
+    /**
+     * The soft-delete guard for paranoid types: the default list excludes
+     * tombstoned rows (`deleted_at IS NULL`); `?deleted=only` flips to the trash
+     * view (`deleted_at IS NOT NULL`). A non-paranoid type has no `deleted_at`,
+     * so the predicate collapses to `undefined`.
+     */
+    private deletedPredicate;
+    /**
+     * Case-insensitive `ILIKE` across the type's text-like columns, OR-ed
+     * together; `undefined` when there's no search term. The needle's LIKE
+     * metacharacters are escaped so a literal `%`/`_` searches literally.
+     */
+    private searchPredicate;
+    /**
+     * Translate the `?sort=` spec (`col` asc, `-col` desc) into an ORDER BY,
+     * always with an `id` tiebreaker so pagination is stable across requests.
+     * Sortable = the always-present envelope columns + `status` (publishable
+     * only) + the type's **scalar** fields. Non-scalar fields (`json`/
+     * `multiselect`, single/many `relation`) are excluded — a many-relation has
+     * no column on the main table at all, so ordering by it would pass
+     * `undefined` to `asc`/`desc`; the others have no meaningful order. An
+     * unknown or excluded column falls back to `updatedAt` desc.
+     */
+    private orderBy;
+}
+//# sourceMappingURL=entries.service.d.ts.map