@orthacms/content-server 0.4.2 → 0.5.0

package/dist/lib/entries/dto/bulk-ids.dto.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bulk-ids.dto.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/dto/bulk-ids.dto.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,qBAAa,UAAU;IACnB,2BAA2B;IAK3B,GAAG,EAAG,MAAM,EAAE,CAAC;CAClB"}

package/dist/lib/entries/dto/list-entries-query.dto.d.ts

@@ -1,46 +0,0 @@
-/** `?deleted=only` flips the list to the trash view (soft-deleted rows). */
-export declare const DELETED_ONLY = "only";
-/**
- * Query parameters for `GET /api/content/:typeName`. Pagination is 1-based; the
- * service applies the defaults (page 1, {@link DEFAULT_PAGE_SIZE}) so the
- * contract has one source of truth. `@Type` coerces the raw query strings — the
- * host's global `ValidationPipe` transforms but does not implicitly convert.
- */
-export declare class ListEntriesQueryDto {
-    /** Free-text search across the type's text-like columns (text/richtext/select). */
-    search?: string;
-    /**
-     * Structured filter tree as a JSON string (`?filter=<json>`), produced by
-     * the admin query builder and validated against the type's derived filter
-     * schema by `parseFilterTree`. Length-capped here as a first line of
-     * defence; the engine's node/depth caps bound the parsed shape.
-     */
-    filter?: string;
-    /** Sort spec: a column id (ascending) or `-`-prefixed (descending). */
-    sort?: string;
-    /** 1-based page number. */
-    page?: number;
-    /** Rows per page, capped at {@link MAX_PAGE_SIZE}. */
-    pageSize?: number;
-    /**
-     * `only` lists soft-deleted rows (the trash view) instead of live ones.
-     * Meaningful only for paranoid types; ignored otherwise. Absent (the
-     * default) lists live rows.
-     */
-    deleted?: typeof DELETED_ONLY;
-    /**
-     * Locale slug the list targets — an **extension-owned** param this package
-     * declares (the strict ValidationPipe rejects undeclared keys) but never
-     * interprets: it's forwarded to the bound `CONTENT_ENTRY_EXTENSION`, which
-     * validates and applies it. Ignored when no extension is bound or the type
-     * isn't localized.
-     */
-    locale?: string;
-    /**
-     * `default` widens the locale scope to fall back to the default locale
-     * where the requested one is missing (the relation picker's mode).
-     * Extension-owned, like {@link locale}.
-     */
-    localeFallback?: string;
-}
-//# sourceMappingURL=list-entries-query.dto.d.ts.map

package/dist/lib/entries/dto/list-entries-query.dto.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"list-entries-query.dto.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/dto/list-entries-query.dto.ts"],"names":[],"mappings":"AAYA,4EAA4E;AAC5E,eAAO,MAAM,YAAY,SAAS,CAAC;AAEnC;;;;;GAKG;AACH,qBAAa,mBAAmB;IAC5B,mFAAmF;IAInF,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;OAKG;IAIH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,uEAAuE;IAIvE,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,2BAA2B;IAK3B,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,sDAAsD;IAMtD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IAGH,OAAO,CAAC,EAAE,OAAO,YAAY,CAAC;IAE9B;;;;;;OAMG;IAIH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;IAGH,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B"}

package/dist/lib/entries/dto/relation-delta-map.validator.d.ts

@@ -1,19 +0,0 @@
-import { type ValidationOptions, type ValidatorConstraintInterface } from 'class-validator';
-/**
- * Validates the `relations` bag of {@link SaveEntryDto}: a map from field name to
- * `{ link?, unlink?, order? }`, each an array of uuid strings. class-validator
- * can't decorate a `Record`'s dynamic keys, so this constraint checks the shape
- * of every value — turning a malformed delta (a non-array `unlink`, a non-uuid
- * id, an unknown inner key, or an over-large array) into a clean **400** instead
- * of letting it reach `inArray(...)` against a `uuid` column and surface as a
- * 500. Unknown inner keys are rejected so the nested `Record` can't slip past
- * the app's `forbidNonWhitelisted` posture, and the id arrays and the map itself
- * are size-bounded so a single request can't carry an unbounded payload.
- */
-export declare class RelationDeltaMapConstraint implements ValidatorConstraintInterface {
-    validate(value: unknown): boolean;
-    defaultMessage(): string;
-}
-/** Property decorator applying {@link RelationDeltaMapConstraint}. */
-export declare function IsRelationDeltaMap(options?: ValidationOptions): (object: object, propertyName: string) => void;
-//# sourceMappingURL=relation-delta-map.validator.d.ts.map

package/dist/lib/entries/dto/relation-delta-map.validator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"relation-delta-map.validator.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/dto/relation-delta-map.validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,iBAAiB,EACtB,KAAK,4BAA4B,EACpC,MAAM,iBAAiB,CAAC;AAmCzB;;;;;;;;;;GAUG;AACH,qBACa,0BACT,YAAW,4BAA4B;IAEvC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAwBjC,cAAc,IAAI,MAAM;CAG3B;AAED,sEAAsE;AACtE,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,iBAAiB,IAClD,QAAQ,MAAM,EAAE,cAAc,MAAM,KAAG,IAAI,CAOtD"}

package/dist/lib/entries/dto/save-entry.dto.d.ts

@@ -1,46 +0,0 @@
-import type { RelationDelta } from '../types/entry-list-view';
-/**
- * Body for `POST /api/content/:typeName` (create) and
- * `PATCH /api/content/:typeName/:id` (update). The field `values` bag crosses the
- * wire, plus optional per-field relation **deltas** (`relations`) — the editor
- * stages its many-to-many / inverse link changes locally and sends them here
- * with the rest of the document, so a save persists everything in **one
- * transaction** without ever transmitting a huge relation whole.
- *
- * Reserved envelope columns (`status`/`published_at`/`deleted_at`) are owned by
- * the service and can't be set from here: `toColumns` projects only keys
- * declared on the type, so a reserved (or otherwise unknown) key in the bag is
- * silently dropped before storage; on a non-publishable type
- * `EntryValidationService` additionally flags unknown keys as a 422. The bag's
- * *contents* are validated against the type's field specs by that same service
- * (a dynamic, per-type contract class-validator can't express); the relation
- * deltas' ids are validated as existing workspace entries by
- * `RelationLinkService`. `values` is structurally only "an object" (its contents
- * are the per-type contract); the `relations` bag's *shape* — each value a
- * `{ link?, unlink?, order? }` of uuid arrays — is enforced here so a malformed
- * delta is a clean 400, not a 500 from a bad id hitting the query.
- */
-export declare class SaveEntryDto {
-    /** Field values keyed by field name. */
-    values: Record<string, unknown>;
-    /**
-     * Per-field relation deltas (`{ <field>: { link?, unlink?, order? } }`) —
-     * many/inverse relations only; a single relation is set through `values`.
-     */
-    relations?: Record<string, RelationDelta>;
-    /**
-     * Locale slug the entry is created in — an **extension-owned** param this
-     * package declares but never interprets (forwarded to the bound
-     * `CONTENT_ENTRY_EXTENSION`, which validates it and stamps the envelope
-     * column). Read on create only; an update never re-homes a row's locale.
-     */
-    locale?: string;
-    /**
-     * The existing translation group a created row joins (making it a sibling)
-     * — an **extension-owned**, opaque param, like {@link locale}. Absent → the
-     * row starts its own fresh group. The bound extension validates it against
-     * the workspace. Read on create only.
-     */
-    localeGroupId?: string;
-}
-//# sourceMappingURL=save-entry.dto.d.ts.map

package/dist/lib/entries/dto/save-entry.dto.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"save-entry.dto.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/dto/save-entry.dto.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAG9D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,YAAY;IACrB,wCAAwC;IAExC,MAAM,EAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEjC;;;OAGG;IAIH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAE1C;;;;;OAKG;IAIH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;OAKG;IAGH,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B"}

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

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

@@ -1 +0,0 @@
-{"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/queries/entry-filter-schema.d.ts

@@ -1,40 +0,0 @@
-import { type FieldSchema, type FilterSchema, type ScalarFieldSchema } from '@ortha-cms/utils-server';
-import { type AnyContentType } from '../../../types/content-type';
-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-like fields
- * filter as strings, `select` as an enum of its options, numerics as numbers,
- * dates as dates. `json`/`multiselect` have no scalar editor, and `relation`
- * filtering (by raw FK uuid) has no UI yet — all skipped.
- */
-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". `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;
-/**
- * Build the query-builder `FilterSchema` for one content type at request time.
- * Whitelists the always-present envelope columns (`createdAt`/`updatedAt`),
- * plus `status`/`publishedAt` only on publishable types, plus `locale` on i18n
- * types, plus every filterable field (those `isScalarField` admits — the same
- * set the admin's `filterFieldsFromSchema` offers), keyed by the property
- * names the engine resolves to table columns. (`status` has a matching admin
- * filter; the timestamp envelopes like `publishedAt` are filterable via the
- * API but have no UI control yet.) This is the security boundary: only listed
- * fields/ops reach SQL, and the engine's depth/node caps bound payload
- * blow-up.
- *
- * `extensionFields` are **virtual** fields contributed by the bound
- * `CONTENT_ENTRY_EXTENSION` (e.g. locale aggregates): their declarations merge
- * into `fields` (so the parser can coerce values) and their names are
- * registered on the schema's `extensionFields` set, routing them to the
- * extension's own SQL resolver instead of a table column. A field column
- * always wins a name collision — an extension cannot shadow real data.
- */
-export declare function buildEntryFilterSchema(type: AnyContentType, extensionFields?: FieldSchema): FilterSchema;
-//# sourceMappingURL=entry-filter-schema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"entry-filter-schema.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/queries/entry-filter-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAChF,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE9E;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,iBAAiB,GAAG,IAAI,CAsB1E;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,cAAc,EACpB,eAAe,CAAC,EAAE,WAAW,GAC9B,YAAY,CAmCd"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"entries.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/services/entries.service.ts"],"names":[],"mappings":"AAcA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpE,OAAO,EAEH,KAAK,qBAAqB,EAC7B,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,EAEH,KAAK,mBAAmB,EAC3B,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAiB9D;;;;;;GAMG;AACH,qBACa,cAAc;IAED,OAAO,CAAC,QAAQ,CAAC,EAAE;IAKrC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;gBALQ,EAAE,EAAE,QAAQ,EAK9B,SAAS,CAAC,EAAE,qBAAqB,YAAA;IAGtD;;;;;;OAMG;IACG,IAAI,CACN,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,mBAAmB,EAC1B,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,aAAa,CAAC;IA8BzB;;;;;;;OAOG;YACW,SAAS;IAqCvB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAcvB;;;;;;;;;OASG;IACH,OAAO,CAAC,OAAO;CAsBlB"}

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

@@ -1,31 +0,0 @@
-import { type Database } from '@ortha-cms/database';
-import type { ContentEntryCounter } from '@ortha-cms/identity-server';
-import type { ContentTypeRegistry } from '../../registry/content-type-registry';
-/**
- * Implements identity's {@link ContentEntryCounter} port over the generated
- * `content_<name>` tables: counts how many entries of a content type a
- * workspace holds. Bound to `CONTENT_ENTRY_COUNTER` in {@link ContentModule},
- * so identity's "revoke a content-type grant only when empty" rule resolves
- * against the real stored entries.
- */
-export declare class EntryCounterService implements ContentEntryCounter {
-    private readonly db;
-    private readonly registry;
-    constructor(db: Database, registry: ContentTypeRegistry);
-    /**
-     * Every stored row of content type `slug` in `workspaceId`. Counts the
-     * whole workspace slice of the type's table — including soft-deleted rows
-     * for paranoid types (data that still exists must keep the grant). An
-     * unknown slug (no such content type) counts as `0`.
-     */
-    countEntries(workspaceId: string, slug: string): Promise<number>;
-    /**
-     * Every stored row the workspace holds across **all** content types —
-     * summed over each type's table. Backs the workspace-delete guard (delete is
-     * refused until this is zero). The per-type counts run concurrently.
-     */
-    countWorkspaceEntries(workspaceId: string): Promise<number>;
-    /** Counts a single content type's rows in a workspace. */
-    private countTable;
-}
-//# sourceMappingURL=entry-counter.service.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"entry-counter.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/services/entry-counter.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAMhF;;;;;;GAMG;AACH,qBACa,mBAAoB,YAAW,mBAAmB;IAErC,OAAO,CAAC,QAAQ,CAAC,EAAE;IACZ,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBADf,EAAE,EAAE,QAAQ,EACL,QAAQ,EAAE,mBAAmB;IAG3E;;;;;OAKG;IACG,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAMtE;;;;OAIG;IACG,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IASjE,0DAA0D;YAC5C,UAAU;CAW3B"}

package/dist/lib/entries/services/entry-filter-schema.d.ts

@@ -1,32 +0,0 @@
-import { type FieldSchema, type FilterSchema } from '@ortha-cms/utils-server';
-import { type AnyContentType } from '../../types/content-type';
-import { type AnyFieldSpec } from '../../types/fields';
-/**
- * Whether a field is backed by a comparable scalar column — the single source of
- * truth for "can this field be filtered or sorted". `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;
-/**
- * Build the query-builder `FilterSchema` for one content type at request time.
- * Whitelists the always-present envelope columns (`createdAt`/`updatedAt`),
- * plus `status`/`publishedAt` only on publishable types, plus `locale` on i18n
- * types, plus every filterable field (those `isScalarField` admits — the same
- * set the admin's `filterFieldsFromSchema` offers), keyed by the property
- * names the engine resolves to table columns. (`status` has a matching admin
- * filter; the timestamp envelopes like `publishedAt` are filterable via the
- * API but have no UI control yet.) This is the security boundary: only listed
- * fields/ops reach SQL, and the engine's depth/node caps bound payload
- * blow-up.
- *
- * `extensionFields` are **virtual** fields contributed by the bound
- * `CONTENT_ENTRY_EXTENSION` (e.g. locale aggregates): their declarations merge
- * into `fields` (so the parser can coerce values) and their names are
- * registered on the schema's `extensionFields` set, routing them to the
- * extension's own SQL resolver instead of a table column. A field column
- * always wins a name collision — an extension cannot shadow real data.
- */
-export declare function buildEntryFilterSchema(type: AnyContentType, extensionFields?: FieldSchema): FilterSchema;
-//# sourceMappingURL=entry-filter-schema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"entry-filter-schema.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/services/entry-filter-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,KAAK,WAAW,EAChB,KAAK,YAAY,EAEpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAiC3E;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,cAAc,EACpB,eAAe,CAAC,EAAE,WAAW,GAC9B,YAAY,CAmCd"}

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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"}