@orthacms/content-server 0.0.0-reserve.0

package/dist/lib/entries/domain/entry.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entry = void 0;
+const content_domain_1 = require("@orthacms/content-domain");
+const entry_events_1 = require("./events/entry-events");
+const entry_publish_blocked_error_1 = require("./entry-publish-blocked.error");
+/**
+ * The **focused domain model** for an entry's publish lifecycle. The entries
+ * engine is generic and registry-driven — one service backs every content type,
+ * with no per-aggregate table or fixed field set — so a full row⇄aggregate
+ * aggregate would fight the metamodel (ADR-0003: DDD where it pays). This models
+ * only the part with real invariants: the `draft ↔ published` state machine and
+ * the publish gate. It owns no columns; the application loads its status,
+ * applies a transition here (raising the domain event), and the infrastructure
+ * persists the new status.
+ *
+ * Framework-free: imports only `@orthacms/content-domain` (the pure kernel) and
+ * `@orthacms/database`'s framework-free `createDomainEvent`/`DomainEvent` —
+ * nothing from `@nestjs/*`, `drizzle-orm`, `class-validator`, or the
+ * infrastructure layer (ADR-0003's one hard rule).
+ */
+class Entry {
+    _id;
+    _contentType;
+    _status;
+    events = [];
+    constructor(_id, _contentType, _status) {
+        this._id = _id;
+        this._contentType = _contentType;
+        this._status = _status;
+    }
+    /** Reconstructs an entry from its persisted lifecycle state. */
+    static rehydrate(state) {
+        return new Entry(state.id, state.contentType, state.status);
+    }
+    /**
+     * Publish the entry. Rejects with {@link EntryPublishBlockedError} when the
+     * gate fails (mapped to 422 by the use-case) — checked first, so an
+     * already-published row whose stored values went invalid is still blocked,
+     * matching the original service. A `draft` transitions to `published` via
+     * {@link assertTransition} and raises `entry.published`; an already-published
+     * row is an idempotent re-publish that raises no event (the use-case still
+     * re-stamps `published_at`).
+     */
+    publish(gate) {
+        if (!gate.valid) {
+            throw new entry_publish_blocked_error_1.EntryPublishBlockedError(gate.issues);
+        }
+        if (this._status === content_domain_1.ENTRY_STATUS.Published) {
+            return; // idempotent re-publish
+        }
+        (0, content_domain_1.assertTransition)(this._status, content_domain_1.ENTRY_STATUS.Published);
+        this._status = content_domain_1.ENTRY_STATUS.Published;
+        this.raise(entry_events_1.ENTRY_EVENT_KINDS.PUBLISHED, {
+            contentType: this._contentType
+        });
+    }
+    /**
+     * Revert the entry to draft. A `published` row transitions to `draft` via
+     * {@link assertTransition} and raises `entry.unpublished`; an already-draft
+     * row is an idempotent no-op that raises no event (the use-case still
+     * performs the write, preserving the original unconditional behavior).
+     */
+    unpublish() {
+        if (this._status === content_domain_1.ENTRY_STATUS.Draft) {
+            return; // idempotent
+        }
+        (0, content_domain_1.assertTransition)(this._status, content_domain_1.ENTRY_STATUS.Draft);
+        this._status = content_domain_1.ENTRY_STATUS.Draft;
+        this.raise(entry_events_1.ENTRY_EVENT_KINDS.UNPUBLISHED, {
+            contentType: this._contentType
+        });
+    }
+    /** The entry id. */
+    get id() {
+        return this._id;
+    }
+    /** The current publish status. */
+    get status() {
+        return this._status;
+    }
+    /** Drains and returns the events raised since the last pull. */
+    pullEvents() {
+        return this.events.splice(0, this.events.length);
+    }
+    raise(kind, payload) {
+        this.events.push((0, entry_events_1.entryEvent)(kind, this._id, payload));
+    }
+}
+exports.Entry = Entry;

package/dist/lib/entries/domain/events/entry-events.d.ts

@@ -0,0 +1,67 @@
+import { type DomainEvent } from '@orthacms/database';
+/**
+ * The domain-event kinds an entry's lifecycle raises, as dotted names.
+ *
+ * Two of them — `entry.published` / `entry.unpublished` — are **status
+ * transitions** and are raised by the {@link Entry} model, which owns the
+ * `draft ↔ published` invariants. The rest are the ordinary editing lifecycle:
+ * a row appearing, its values changing, it going to the trash, coming back, or
+ * being destroyed. Those carry no invariant of their own — nothing about
+ * "created" can be violated — so they are minted by the builders below and
+ * raised by the write path directly, rather than by fabricating an aggregate
+ * (and a publish status a non-publishable type does not have) around a fact.
+ *
+ * Until this set existed the audit log could answer "who did what, when" for
+ * accounts, workspaces, API tokens, the media library and content **publishes**
+ * — and not for the single most frequent action in a CMS. An editor could
+ * create, rewrite and delete every entry in the product and the log stayed
+ * silent, because there was nothing on the outbox for a subscriber to consume.
+ */
+export declare const ENTRY_EVENT_KINDS: {
+    readonly CREATED: "entry.created";
+    readonly UPDATED: "entry.updated";
+    readonly PUBLISHED: "entry.published";
+    readonly UNPUBLISHED: "entry.unpublished";
+    readonly DELETED: "entry.deleted";
+    readonly RESTORED: "entry.restored";
+    readonly PURGED: "entry.purged";
+};
+/**
+ * Builds an entry {@link DomainEvent} of `kind` for `entryId`, carrying
+ * `payload`. Keeps the domain model free of the event envelope's plumbing — the
+ * model names the fact and its data; this stamps the `aggregateType`/id.
+ */
+export declare function entryEvent(kind: string, entryId: string, payload: Record<string, unknown>): DomainEvent;
+/** A new entry exists. `contentType` is what lets the log name *what* was made. */
+export declare function entryCreated(entryId: string, contentType: string): DomainEvent;
+/**
+ * An entry's stored values changed, naming **which fields** did.
+ *
+ * The field list is the `workspace.updated` precedent (`{ fields }`), and it is
+ * what makes a row worth reading: "Ada edited Article X" is a fact, "Ada edited
+ * the title and body of Article X" is a review. It is computed by comparing the
+ * stored row against the written one, which also answers the volume question
+ * this event raises — a save that changes nothing (a re-submit, a reopened
+ * editor, a restore of the version already live) produces **no** field names
+ * and therefore no event at all, so the log records editorial changes rather
+ * than round trips.
+ */
+export declare function entryUpdated(entryId: string, contentType: string, fields: readonly string[]): DomainEvent;
+/**
+ * An entry was deleted. `soft` distinguishes the two very different facts the
+ * one route produces: a **paranoid** type is tombstoned and can be restored,
+ * while any other type is gone from the table the moment this commits, and a
+ * reviewer reading the log needs to know which happened.
+ */
+export declare function entryDeleted(entryId: string, contentType: string, soft: boolean): DomainEvent;
+/** A soft-deleted entry's tombstone was cleared. */
+export declare function entryRestored(entryId: string, contentType: string): DomainEvent;
+/**
+ * A tombstoned entry was destroyed permanently.
+ *
+ * Its own kind rather than a second `entry.deleted`: this is the one content
+ * action with nothing left behind to inspect afterwards, so it is exactly the
+ * one an audit trail has to record distinctly.
+ */
+export declare function entryPurged(entryId: string, contentType: string): DomainEvent;
+//# sourceMappingURL=entry-events.d.ts.map

package/dist/lib/entries/domain/events/entry-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-events.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/domain/events/entry-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEzE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;CAQpB,CAAC;AAKX;;;;GAIG;AACH,wBAAgB,UAAU,CACtB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,WAAW,CAOb;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CACxB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,GACpB,WAAW,CAEb;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CACxB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,SAAS,MAAM,EAAE,GAC1B,WAAW,CAKb;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CACxB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,OAAO,GACd,WAAW,CAKb;AAED,oDAAoD;AACpD,wBAAgB,aAAa,CACzB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,GACpB,WAAW,CAEb;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,WAAW,CAE7E"}

package/dist/lib/entries/domain/events/entry-events.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTRY_EVENT_KINDS = void 0;
+exports.entryEvent = entryEvent;
+exports.entryCreated = entryCreated;
+exports.entryUpdated = entryUpdated;
+exports.entryDeleted = entryDeleted;
+exports.entryRestored = entryRestored;
+exports.entryPurged = entryPurged;
+const database_1 = require("@orthacms/database");
+/**
+ * The domain-event kinds an entry's lifecycle raises, as dotted names.
+ *
+ * Two of them — `entry.published` / `entry.unpublished` — are **status
+ * transitions** and are raised by the {@link Entry} model, which owns the
+ * `draft ↔ published` invariants. The rest are the ordinary editing lifecycle:
+ * a row appearing, its values changing, it going to the trash, coming back, or
+ * being destroyed. Those carry no invariant of their own — nothing about
+ * "created" can be violated — so they are minted by the builders below and
+ * raised by the write path directly, rather than by fabricating an aggregate
+ * (and a publish status a non-publishable type does not have) around a fact.
+ *
+ * Until this set existed the audit log could answer "who did what, when" for
+ * accounts, workspaces, API tokens, the media library and content **publishes**
+ * — and not for the single most frequent action in a CMS. An editor could
+ * create, rewrite and delete every entry in the product and the log stayed
+ * silent, because there was nothing on the outbox for a subscriber to consume.
+ */
+exports.ENTRY_EVENT_KINDS = {
+    CREATED: 'entry.created',
+    UPDATED: 'entry.updated',
+    PUBLISHED: 'entry.published',
+    UNPUBLISHED: 'entry.unpublished',
+    DELETED: 'entry.deleted',
+    RESTORED: 'entry.restored',
+    PURGED: 'entry.purged'
+};
+/** The aggregate type stamped on every entry domain event. */
+const AGGREGATE_TYPE = 'content_entry';
+/**
+ * Builds an entry {@link DomainEvent} of `kind` for `entryId`, carrying
+ * `payload`. Keeps the domain model free of the event envelope's plumbing — the
+ * model names the fact and its data; this stamps the `aggregateType`/id.
+ */
+function entryEvent(kind, entryId, payload) {
+    return (0, database_1.createDomainEvent)({
+        kind,
+        aggregateType: AGGREGATE_TYPE,
+        aggregateId: entryId,
+        payload
+    });
+}
+/** A new entry exists. `contentType` is what lets the log name *what* was made. */
+function entryCreated(entryId, contentType) {
+    return entryEvent(exports.ENTRY_EVENT_KINDS.CREATED, entryId, { contentType });
+}
+/**
+ * An entry's stored values changed, naming **which fields** did.
+ *
+ * The field list is the `workspace.updated` precedent (`{ fields }`), and it is
+ * what makes a row worth reading: "Ada edited Article X" is a fact, "Ada edited
+ * the title and body of Article X" is a review. It is computed by comparing the
+ * stored row against the written one, which also answers the volume question
+ * this event raises — a save that changes nothing (a re-submit, a reopened
+ * editor, a restore of the version already live) produces **no** field names
+ * and therefore no event at all, so the log records editorial changes rather
+ * than round trips.
+ */
+function entryUpdated(entryId, contentType, fields) {
+    return entryEvent(exports.ENTRY_EVENT_KINDS.UPDATED, entryId, {
+        contentType,
+        fields: [...fields]
+    });
+}
+/**
+ * An entry was deleted. `soft` distinguishes the two very different facts the
+ * one route produces: a **paranoid** type is tombstoned and can be restored,
+ * while any other type is gone from the table the moment this commits, and a
+ * reviewer reading the log needs to know which happened.
+ */
+function entryDeleted(entryId, contentType, soft) {
+    return entryEvent(exports.ENTRY_EVENT_KINDS.DELETED, entryId, {
+        contentType,
+        soft
+    });
+}
+/** A soft-deleted entry's tombstone was cleared. */
+function entryRestored(entryId, contentType) {
+    return entryEvent(exports.ENTRY_EVENT_KINDS.RESTORED, entryId, { contentType });
+}
+/**
+ * A tombstoned entry was destroyed permanently.
+ *
+ * Its own kind rather than a second `entry.deleted`: this is the one content
+ * action with nothing left behind to inspect afterwards, so it is exactly the
+ * one an audit trail has to record distinctly.
+ */
+function entryPurged(entryId, contentType) {
+    return entryEvent(exports.ENTRY_EVENT_KINDS.PURGED, entryId, { contentType });
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Body for the bulk endpoints (`/bulk/publish`, `/bulk/unpublish`,
+ * `/bulk/delete`, `/bulk/restore`, and the publish dry run): the set of entry
+ * ids to act on. Non-empty, uuid-typed, and capped at {@link BULK_MAX_IDS} so a
+ * single request can't fan out unbounded work.
+ */
+export declare class BulkIdsDto {
+    /** Entry ids to act on. */
+    ids: string[];
+}
+//# sourceMappingURL=bulk-ids.dto.d.ts.map

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

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

@@ -0,0 +1,46 @@
+/** `?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

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

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

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

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

@@ -0,0 +1 @@
+{"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/entries.constants.d.ts

@@ -0,0 +1,19 @@
+/** Pagination + filter limits for the entries list endpoint. */
+/** Default rows per page when the client omits `pageSize`. */
+export declare const DEFAULT_PAGE_SIZE = 25;
+/** Hard cap on rows per page — bounds a single query's cost. */
+export declare const MAX_PAGE_SIZE = 100;
+/** Max length of the raw `?filter=` JSON (first line of defence before parsing). */
+export declare const FILTER_MAX_LENGTH = 4096;
+/** Max ids a single bulk action (`{ ids }`) may target — bounds the statement. */
+export declare const BULK_MAX_IDS = 100;
+/**
+ * Max items a single bulk **save** may carry.
+ *
+ * Lower than {@link BULK_MAX_IDS} on purpose: a bulk action ships a list of
+ * uuids, while a bulk save ships whole documents — rich-text bodies included —
+ * and then performs one write transaction per item. The cap bounds the request
+ * body and the time a single call can hold the workspace's content lock.
+ */
+export declare const BULK_MAX_SAVE_ITEMS = 50;
+//# sourceMappingURL=entries.constants.d.ts.map

package/dist/lib/entries/entries.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.constants.d.ts","sourceRoot":"","sources":["../../../src/lib/entries/entries.constants.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAEhE,8DAA8D;AAC9D,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,gEAAgE;AAChE,eAAO,MAAM,aAAa,MAAM,CAAC;AAEjC,oFAAoF;AACpF,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC,kFAAkF;AAClF,eAAO,MAAM,YAAY,MAAM,CAAC;AAEhC;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,KAAK,CAAC"}

package/dist/lib/entries/entries.constants.js

@@ -0,0 +1,21 @@
+"use strict";
+/** Pagination + filter limits for the entries list endpoint. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BULK_MAX_SAVE_ITEMS = exports.BULK_MAX_IDS = exports.FILTER_MAX_LENGTH = exports.MAX_PAGE_SIZE = exports.DEFAULT_PAGE_SIZE = void 0;
+/** Default rows per page when the client omits `pageSize`. */
+exports.DEFAULT_PAGE_SIZE = 25;
+/** Hard cap on rows per page — bounds a single query's cost. */
+exports.MAX_PAGE_SIZE = 100;
+/** Max length of the raw `?filter=` JSON (first line of defence before parsing). */
+exports.FILTER_MAX_LENGTH = 4096;
+/** Max ids a single bulk action (`{ ids }`) may target — bounds the statement. */
+exports.BULK_MAX_IDS = 100;
+/**
+ * Max items a single bulk **save** may carry.
+ *
+ * Lower than {@link BULK_MAX_IDS} on purpose: a bulk action ships a list of
+ * uuids, while a bulk save ships whole documents — rich-text bodies included —
+ * and then performs one write transaction per item. The cap bounds the request
+ * body and the time a single call can hold the workspace's content lock.
+ */
+exports.BULK_MAX_SAVE_ITEMS = 50;

package/dist/lib/entries/http/controllers/bulk-entries.controller.d.ts

@@ -0,0 +1,33 @@
+import { type PublicUser } from '@orthacms/identity-server';
+import type { ContentTypeRegistry } from '../../../registry/content-type-registry';
+import { EntryWriterService } from '../../infrastructure/persistence/entry-writer.service';
+import { BulkPublishPreviewQuery } from '../../infrastructure/queries/bulk-publish-preview.query';
+import { BulkPublishEntriesUseCase } from '../../application/use-cases/bulk-publish-entries.use-case';
+import { BulkUnpublishEntriesUseCase } from '../../application/use-cases/bulk-unpublish-entries.use-case';
+import { BulkIdsDto } from '../dto/bulk-ids.dto';
+import type { BulkActionResult, BulkPublishPreview, BulkPublishResult } from '../../types/bulk-publish';
+/**
+ * Bulk entry actions over a set of `{ ids }`. **Registered before the
+ * single-item controllers** (see `content.module.ts`): the literal `bulk`
+ * segment sits in the same slot as those controllers' `:id`, so it must match
+ * first — otherwise `/bulk/publish` would resolve as `:id='bulk'` (and trip the
+ * single-item `ParseUUIDPipe`). `WorkspaceGuard` scopes every action to a
+ * workspace the caller belongs to. Per-route permissions: publish/unpublish need
+ * `content:publish`, delete/restore need `content:delete`.
+ */
+export declare class BulkEntriesController {
+    private readonly registry;
+    private readonly writer;
+    private readonly bulkPublishPreview;
+    private readonly bulkPublishEntries;
+    private readonly bulkUnpublishEntries;
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService, bulkPublishPreview: BulkPublishPreviewQuery, bulkPublishEntries: BulkPublishEntriesUseCase, bulkUnpublishEntries: BulkUnpublishEntriesUseCase);
+    /** Dry run: validate each id and report a per-entry verdict. Writes nothing. */
+    previewPublish(typeName: string, body: BulkIdsDto, workspaceId: string): Promise<BulkPublishPreview>;
+    publish(typeName: string, body: BulkIdsDto, workspaceId: string): Promise<BulkPublishResult>;
+    unpublish(typeName: string, body: BulkIdsDto, workspaceId: string): Promise<BulkActionResult>;
+    remove(typeName: string, body: BulkIdsDto, workspaceId: string, user?: PublicUser): Promise<BulkActionResult>;
+    restore(typeName: string, body: BulkIdsDto, workspaceId: string, user?: PublicUser): Promise<BulkActionResult>;
+    purge(typeName: string, body: BulkIdsDto, workspaceId: string, user?: PublicUser): Promise<BulkActionResult>;
+}
+//# sourceMappingURL=bulk-entries.controller.d.ts.map

package/dist/lib/entries/http/controllers/bulk-entries.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-entries.controller.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/http/controllers/bulk-entries.controller.ts"],"names":[],"mappings":"AASA,OAAO,EAKH,KAAK,UAAU,EAElB,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAC3F,OAAO,EAAE,uBAAuB,EAAE,MAAM,yDAAyD,CAAC;AAClG,OAAO,EAAE,yBAAyB,EAAE,MAAM,2DAA2D,CAAC;AACtG,OAAO,EAAE,2BAA2B,EAAE,MAAM,6DAA6D,CAAC;AAC1G,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EACR,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACpB,MAAM,0BAA0B,CAAC;AAIlC;;;;;;;;GAQG;AACH,qBAEa,qBAAqB;IAG1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IACnC,OAAO,CAAC,QAAQ,CAAC,oBAAoB;gBAJpB,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB,EAC1B,kBAAkB,EAAE,uBAAuB,EAC3C,kBAAkB,EAAE,yBAAyB,EAC7C,oBAAoB,EAAE,2BAA2B;IAGtE,gFAAgF;IAIhF,cAAc,CACS,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,kBAAkB,CAAC;IAQ9B,OAAO,CACgB,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,iBAAiB,CAAC;IAQ7B,SAAS,CACc,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,gBAAgB,CAAC;IAQ5B,MAAM,CACiB,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,EACxB,IAAI,CAAC,EAAE,UAAU,GACjC,OAAO,CAAC,gBAAgB,CAAC;IAa5B,OAAO,CACgB,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,EACxB,IAAI,CAAC,EAAE,UAAU,GACjC,OAAO,CAAC,gBAAgB,CAAC;IAa5B,KAAK,CACkB,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,EACxB,IAAI,CAAC,EAAE,UAAU,GACjC,OAAO,CAAC,gBAAgB,CAAC;CAS/B"}

package/dist/lib/entries/http/controllers/bulk-entries.controller.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkEntriesController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const identity_server_1 = require("@orthacms/identity-server");
+const workspaces_server_1 = require("@orthacms/workspaces-server");
+const content_grant_guard_1 = require("../guards/content-grant.guard");
+const content_tokens_1 = require("../../../content.tokens");
+const entry_writer_service_1 = require("../../infrastructure/persistence/entry-writer.service");
+const bulk_publish_preview_query_1 = require("../../infrastructure/queries/bulk-publish-preview.query");
+const bulk_publish_entries_use_case_1 = require("../../application/use-cases/bulk-publish-entries.use-case");
+const bulk_unpublish_entries_use_case_1 = require("../../application/use-cases/bulk-unpublish-entries.use-case");
+const bulk_ids_dto_1 = require("../dto/bulk-ids.dto");
+const resolve_type_1 = require("./resolve-type");
+const to_actor_1 = require("./to-actor");
+/**
+ * Bulk entry actions over a set of `{ ids }`. **Registered before the
+ * single-item controllers** (see `content.module.ts`): the literal `bulk`
+ * segment sits in the same slot as those controllers' `:id`, so it must match
+ * first — otherwise `/bulk/publish` would resolve as `:id='bulk'` (and trip the
+ * single-item `ParseUUIDPipe`). `WorkspaceGuard` scopes every action to a
+ * workspace the caller belongs to. Per-route permissions: publish/unpublish need
+ * `content:publish`, delete/restore need `content:delete`.
+ */
+let BulkEntriesController = class BulkEntriesController {
+    registry;
+    writer;
+    bulkPublishPreview;
+    bulkPublishEntries;
+    bulkUnpublishEntries;
+    constructor(registry, writer, bulkPublishPreview, bulkPublishEntries, bulkUnpublishEntries) {
+        this.registry = registry;
+        this.writer = writer;
+        this.bulkPublishPreview = bulkPublishPreview;
+        this.bulkPublishEntries = bulkPublishEntries;
+        this.bulkUnpublishEntries = bulkUnpublishEntries;
+    }
+    /** Dry run: validate each id and report a per-entry verdict. Writes nothing. */
+    previewPublish(typeName, body, workspaceId) {
+        const type = (0, resolve_type_1.resolveType)(this.registry, typeName);
+        return this.bulkPublishPreview.preview(type, body.ids, workspaceId);
+    }
+    publish(typeName, body, workspaceId) {
+        const type = (0, resolve_type_1.resolveType)(this.registry, typeName);
+        return this.bulkPublishEntries.execute(type, body.ids, workspaceId);
+    }
+    unpublish(typeName, body, workspaceId) {
+        const type = (0, resolve_type_1.resolveType)(this.registry, typeName);
+        return this.bulkUnpublishEntries.execute(type, body.ids, workspaceId);
+    }
+    remove(typeName, body, workspaceId, user) {
+        const type = (0, resolve_type_1.resolveType)(this.registry, typeName);
+        return this.writer.bulkRemove(type, body.ids, workspaceId, (0, to_actor_1.toActor)(user));
+    }
+    restore(typeName, body, workspaceId, user) {
+        const type = (0, resolve_type_1.resolveType)(this.registry, typeName);
+        return this.writer.bulkRestore(type, body.ids, workspaceId, (0, to_actor_1.toActor)(user));
+    }
+    purge(typeName, body, workspaceId, user) {
+        const type = (0, resolve_type_1.resolveType)(this.registry, typeName);
+        return this.writer.bulkPurge(type, body.ids, workspaceId, (0, to_actor_1.toActor)(user));
+    }
+};
+exports.BulkEntriesController = BulkEntriesController;
+tslib_1.__decorate([
+    (0, common_1.Post)(':typeName/bulk/publish/preview'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.OK),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.CONTENT_PUBLISH),
+    tslib_1.__param(0, (0, common_1.Param)('typeName')),
+    tslib_1.__param(1, (0, common_1.Body)()),
+    tslib_1.__param(2, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, bulk_ids_dto_1.BulkIdsDto, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], BulkEntriesController.prototype, "previewPublish", null);
+tslib_1.__decorate([
+    (0, common_1.Post)(':typeName/bulk/publish'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.OK),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.CONTENT_PUBLISH),
+    tslib_1.__param(0, (0, common_1.Param)('typeName')),
+    tslib_1.__param(1, (0, common_1.Body)()),
+    tslib_1.__param(2, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, bulk_ids_dto_1.BulkIdsDto, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], BulkEntriesController.prototype, "publish", null);
+tslib_1.__decorate([
+    (0, common_1.Post)(':typeName/bulk/unpublish'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.OK),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.CONTENT_PUBLISH),
+    tslib_1.__param(0, (0, common_1.Param)('typeName')),
+    tslib_1.__param(1, (0, common_1.Body)()),
+    tslib_1.__param(2, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, bulk_ids_dto_1.BulkIdsDto, String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], BulkEntriesController.prototype, "unpublish", null);
+tslib_1.__decorate([
+    (0, common_1.Post)(':typeName/bulk/delete'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.OK),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.CONTENT_DELETE),
+    tslib_1.__param(0, (0, common_1.Param)('typeName')),
+    tslib_1.__param(1, (0, common_1.Body)()),
+    tslib_1.__param(2, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__param(3, (0, identity_server_1.CurrentUser)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, bulk_ids_dto_1.BulkIdsDto, String, Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], BulkEntriesController.prototype, "remove", null);
+tslib_1.__decorate([
+    (0, common_1.Post)(':typeName/bulk/restore'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.OK),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.CONTENT_DELETE),
+    tslib_1.__param(0, (0, common_1.Param)('typeName')),
+    tslib_1.__param(1, (0, common_1.Body)()),
+    tslib_1.__param(2, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__param(3, (0, identity_server_1.CurrentUser)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, bulk_ids_dto_1.BulkIdsDto, String, Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], BulkEntriesController.prototype, "restore", null);
+tslib_1.__decorate([
+    (0, common_1.Post)(':typeName/bulk/purge'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.OK),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.CONTENT_DELETE),
+    tslib_1.__param(0, (0, common_1.Param)('typeName')),
+    tslib_1.__param(1, (0, common_1.Body)()),
+    tslib_1.__param(2, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__param(3, (0, identity_server_1.CurrentUser)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, bulk_ids_dto_1.BulkIdsDto, String, Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], BulkEntriesController.prototype, "purge", null);
+exports.BulkEntriesController = BulkEntriesController = tslib_1.__decorate([
+    (0, common_1.UseGuards)(identity_server_1.OriginGuard, identity_server_1.PermissionsGuard, workspaces_server_1.WorkspaceGuard, content_grant_guard_1.ContentGrantGuard),
+    (0, common_1.Controller)('content'),
+    tslib_1.__param(0, (0, content_tokens_1.InjectContentRegistry)()),
+    tslib_1.__metadata("design:paramtypes", [Function, entry_writer_service_1.EntryWriterService,
+        bulk_publish_preview_query_1.BulkPublishPreviewQuery,
+        bulk_publish_entries_use_case_1.BulkPublishEntriesUseCase,
+        bulk_unpublish_entries_use_case_1.BulkUnpublishEntriesUseCase])
+], BulkEntriesController);