@orthacms/content-server 0.0.0-reserve.0

package/dist/lib/entries/application/use-cases/publish-entry.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-entry.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/application/use-cases/publish-entry.use-case.ts"],"names":[],"mappings":"AAMA,OAAO,EAAe,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uDAAuD,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAE3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAI/D;;;;;;;;;;;GAWG;AACH,qBACa,mBAAmB;IAExB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAHV,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,sBAAsB;IAGjD,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM;IACnB;;;;OAIG;IACH,KAAK,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;IAC5C;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,WAAW,CAAC;IA2EvB,OAAO,CAAC,QAAQ;CAKnB"}

package/dist/lib/entries/application/use-cases/publish-entry.use-case.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublishEntryUseCase = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const database_1 = require("@orthacms/database");
+const entry_validation_service_1 = require("../../../validation/services/entry-validation.service");
+const entry_writer_service_1 = require("../../infrastructure/persistence/entry-writer.service");
+const entry_row_1 = require("../../infrastructure/persistence/entry-row");
+const entry_1 = require("../../domain/entry");
+const entry_publish_blocked_error_1 = require("../../domain/entry-publish-blocked.error");
+/**
+ * Publish one entry. Runs inside a {@link UnitOfWork} so the status write and
+ * the `entry.published` outbox event commit atomically. Re-validates the stored
+ * row against the publish gate (values via the kernel + required link-managed
+ * relations via persistence), lets the {@link Entry} domain model apply the
+ * `draft → published` transition, then re-stamps `status`/`published_at`.
+ *
+ * HTTP behavior is preserved: 400 on a non-publishable type, 404 on a missing
+ * live row, and `422 { message, issues }` when the gate fails — the value issues
+ * take precedence (relations aren't even counted when the values are invalid),
+ * exactly as the original service ordered its checks.
+ */
+let PublishEntryUseCase = class PublishEntryUseCase {
+    uow;
+    outbox;
+    writer;
+    validation;
+    constructor(uow, outbox, writer, validation) {
+        this.uow = uow;
+        this.outbox = outbox;
+        this.writer = writer;
+        this.validation = validation;
+    }
+    async execute(type, id, workspaceId, 
+    /**
+     * The acting user, merged onto the outbox events so the audit log can
+     * name who did this. Without it every content row in the activity log
+     * read "System".
+     */
+    actor, 
+    /**
+     * The version to mark live, when publishing a **specific** earlier one
+     * whose content the caller already re-applied to the live row. Omitted
+     * (the entry-level publish), the latest version is promoted — it is the
+     * row that was just published.
+     */
+    revisionNumber) {
+        if (!type.publishable) {
+            throw new common_1.BadRequestException(`Content type "${type.name}" is not publishable.`);
+        }
+        return this.uow.run(async () => {
+            const exec = this.uow.current();
+            const current = await this.writer.findLive(type, id, workspaceId, exec);
+            if (!current)
+                throw this.notFound(type, id);
+            const valueResult = this.validation.validate(type, (0, entry_row_1.toRecord)(type, current).values);
+            // Short-circuit exactly like the original: only count required links
+            // when the values already pass, so the 422's issue set matches.
+            const issues = valueResult.valid
+                ? await this.writer.requiredRelationIssues(exec, type, current, workspaceId)
+                : valueResult.issues;
+            const entry = entry_1.Entry.rehydrate({
+                id,
+                contentType: type.name,
+                status: current['status']
+            });
+            try {
+                entry.publish({ valid: issues.length === 0, issues });
+            }
+            catch (error) {
+                if (error instanceof entry_publish_blocked_error_1.EntryPublishBlockedError) {
+                    throw new common_1.UnprocessableEntityException({
+                        message: 'Entry validation failed',
+                        issues: error.issues
+                    });
+                }
+                throw error;
+            }
+            // Re-stamp unconditionally (an idempotent re-publish keeps the
+            // original behavior); 404 if the row vanished under us.
+            const updated = await this.writer.markPublished(exec, type, id, workspaceId);
+            if (!updated)
+                throw this.notFound(type, id);
+            // Promote the published revision to the live version so the history
+            // timeline reflects the publish (revisions are born drafts) — the
+            // caller's chosen version, else the latest.
+            await this.writer.markRevisionPublished(exec, id, workspaceId, revisionNumber);
+            await this.outbox.append(actor
+                ? (0, database_1.attachActor)(entry.pullEvents(), actor)
+                : entry.pullEvents());
+            return (0, entry_row_1.toRecord)(type, updated);
+        });
+    }
+    notFound(type, id) {
+        return new common_1.NotFoundException(`No entry "${id}" on content type "${type.name}".`);
+    }
+};
+exports.PublishEntryUseCase = PublishEntryUseCase;
+exports.PublishEntryUseCase = PublishEntryUseCase = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [database_1.UnitOfWork,
+        database_1.OutboxWriter,
+        entry_writer_service_1.EntryWriterService,
+        entry_validation_service_1.EntryValidationService])
+], PublishEntryUseCase);

package/dist/lib/entries/application/use-cases/unpublish-entry.use-case.d.ts

@@ -0,0 +1,30 @@
+import { OutboxWriter, UnitOfWork } from '@orthacms/database';
+import type { AnyContentType } from '../../../types/content-type';
+import { EntryWriterService } from '../../infrastructure/persistence/entry-writer.service';
+import type { EntryRecord } from '../../types/entry-list-view';
+/**
+ * Revert one entry to draft. Runs inside a {@link UnitOfWork} so the status
+ * write and the `entry.unpublished` outbox event commit atomically. The
+ * {@link Entry} domain model applies the `published → draft` transition (an
+ * already-draft row is an idempotent no-op that raises no event). The write is
+ * unconditional, preserving the original behavior; 400 on a non-publishable
+ * type, 404 on a missing live row.
+ */
+export declare class UnpublishEntryUseCase {
+    private readonly uow;
+    private readonly outbox;
+    private readonly writer;
+    constructor(uow: UnitOfWork, outbox: OutboxWriter, writer: EntryWriterService);
+    execute(type: AnyContentType, id: string, workspaceId: string, 
+    /**
+     * The acting user, merged onto the outbox events so the audit log can
+     * name who did this. Without it every content row in the activity log
+     * read "System".
+     */
+    actor?: {
+        id: string;
+        email: string | null;
+    }): Promise<EntryRecord>;
+    private notFound;
+}
+//# sourceMappingURL=unpublish-entry.use-case.d.ts.map

package/dist/lib/entries/application/use-cases/unpublish-entry.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unpublish-entry.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/application/use-cases/unpublish-entry.use-case.ts"],"names":[],"mappings":"AAKA,OAAO,EAAe,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAE3F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG/D;;;;;;;GAOG;AACH,qBACa,qBAAqB;IAE1B,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAFN,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,kBAAkB;IAGzC,OAAO,CACT,IAAI,EAAE,cAAc,EACpB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM;IACnB;;;;OAIG;IACH,KAAK,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAC7C,OAAO,CAAC,WAAW,CAAC;IA0CvB,OAAO,CAAC,QAAQ;CAKnB"}

package/dist/lib/entries/application/use-cases/unpublish-entry.use-case.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnpublishEntryUseCase = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const database_1 = require("@orthacms/database");
+const entry_writer_service_1 = require("../../infrastructure/persistence/entry-writer.service");
+const entry_row_1 = require("../../infrastructure/persistence/entry-row");
+const entry_1 = require("../../domain/entry");
+/**
+ * Revert one entry to draft. Runs inside a {@link UnitOfWork} so the status
+ * write and the `entry.unpublished` outbox event commit atomically. The
+ * {@link Entry} domain model applies the `published → draft` transition (an
+ * already-draft row is an idempotent no-op that raises no event). The write is
+ * unconditional, preserving the original behavior; 400 on a non-publishable
+ * type, 404 on a missing live row.
+ */
+let UnpublishEntryUseCase = class UnpublishEntryUseCase {
+    uow;
+    outbox;
+    writer;
+    constructor(uow, outbox, writer) {
+        this.uow = uow;
+        this.outbox = outbox;
+        this.writer = writer;
+    }
+    async execute(type, id, workspaceId, 
+    /**
+     * The acting user, merged onto the outbox events so the audit log can
+     * name who did this. Without it every content row in the activity log
+     * read "System".
+     */
+    actor) {
+        if (!type.publishable) {
+            throw new common_1.BadRequestException(`Content type "${type.name}" is not publishable.`);
+        }
+        return this.uow.run(async () => {
+            const exec = this.uow.current();
+            const current = await this.writer.findLive(type, id, workspaceId, exec);
+            if (!current)
+                throw this.notFound(type, id);
+            const entry = entry_1.Entry.rehydrate({
+                id,
+                contentType: type.name,
+                status: current['status']
+            });
+            entry.unpublish();
+            const updated = await this.writer.markDraft(exec, type, id, workspaceId);
+            if (!updated)
+                throw this.notFound(type, id);
+            // Revert the entry's published revision back to draft so the history
+            // timeline no longer shows a live version.
+            await this.writer.markRevisionUnpublished(exec, id, workspaceId);
+            await this.outbox.append(actor
+                ? (0, database_1.attachActor)(entry.pullEvents(), actor)
+                : entry.pullEvents());
+            return (0, entry_row_1.toRecord)(type, updated);
+        });
+    }
+    notFound(type, id) {
+        return new common_1.NotFoundException(`No entry "${id}" on content type "${type.name}".`);
+    }
+};
+exports.UnpublishEntryUseCase = UnpublishEntryUseCase;
+exports.UnpublishEntryUseCase = UnpublishEntryUseCase = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [database_1.UnitOfWork,
+        database_1.OutboxWriter,
+        entry_writer_service_1.EntryWriterService])
+], UnpublishEntryUseCase);

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

@@ -0,0 +1,26 @@
+import type { ContentTypeRegistry } from '../../registry/content-type-registry';
+import { EntryWriterService } from '../services/entry-writer.service';
+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;
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
+    /** 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): Promise<BulkActionResult>;
+    restore(typeName: string, body: BulkIdsDto, workspaceId: string): Promise<BulkActionResult>;
+    purge(typeName: string, body: BulkIdsDto, workspaceId: string): Promise<BulkActionResult>;
+}
+//# sourceMappingURL=bulk-entries.controller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-entries.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/bulk-entries.controller.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EACR,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACpB,MAAM,uBAAuB,CAAC;AAG/B;;;;;;;;GAQG;AACH,qBAEa,qBAAqB;IAG1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAG/C,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,GACxC,OAAO,CAAC,gBAAgB,CAAC;IAQ5B,OAAO,CACgB,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,gBAAgB,CAAC;IAQ5B,KAAK,CACkB,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,UAAU,EACJ,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,gBAAgB,CAAC;CAI/B"}

package/dist/lib/entries/controllers/create-entry.controller.d.ts

@@ -0,0 +1,20 @@
+import type { ContentTypeRegistry } from '../../registry/content-type-registry';
+import { EntryWriterService } from '../services/entry-writer.service';
+import { SaveEntryDto } from '../dto/save-entry.dto';
+import type { EntryRecord } from '../types/entry-list-view';
+/**
+ * `POST /api/content/:typeName` — create a draft entry from a validated values
+ * bag. The `:typeName` resolves via the registry (404 if unknown); the body is
+ * validated against the type's field specs (422 with the issue list on failure).
+ * `OriginGuard` defends this state-changing POST (CSRF); `WorkspaceGuard` scopes
+ * it to a workspace the caller belongs to; `content:create` gates it. The
+ * synchronous CSRF + permission guards run before `WorkspaceGuard` so a rejected
+ * request never incurs its membership DB probe.
+ */
+export declare class CreateEntryController {
+    private readonly registry;
+    private readonly writer;
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
+    create(typeName: string, body: SaveEntryDto, workspaceId: string): Promise<EntryRecord>;
+}
+//# sourceMappingURL=create-entry.controller.d.ts.map

package/dist/lib/entries/controllers/create-entry.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-entry.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/create-entry.controller.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D;;;;;;;;GAQG;AACH,qBAGa,qBAAqB;IAG1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAI/C,MAAM,CACiB,QAAQ,EAAE,MAAM,EAC3B,IAAI,EAAE,YAAY,EACN,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC;CAW1B"}

package/dist/lib/entries/controllers/delete-entry.controller.d.ts

@@ -0,0 +1,24 @@
+import type { ContentTypeRegistry } from '../../registry/content-type-registry';
+import { EntryWriterService } from '../services/entry-writer.service';
+import type { EntryRecord } from '../types/entry-list-view';
+/**
+ * Single-entry removal lifecycle, all gated on `content:delete`:
+ * - `DELETE /api/content/:typeName/:id` — soft delete (stamp `deleted_at`) for a
+ *   paranoid type, hard delete otherwise; 204.
+ * - `POST   /api/content/:typeName/:id/restore` — clear the tombstone (paranoid
+ *   only); returns the restored record.
+ * - `DELETE /api/content/:typeName/:id/permanent` — permanently remove a
+ *   tombstoned row (paranoid only); 204.
+ *
+ * `OriginGuard` defends these state-changing writes; `WorkspaceGuard` scopes them
+ * to a workspace the caller belongs to.
+ */
+export declare class DeleteEntryController {
+    private readonly registry;
+    private readonly writer;
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
+    remove(typeName: string, id: string, workspaceId: string): Promise<void>;
+    restore(typeName: string, id: string, workspaceId: string): Promise<EntryRecord>;
+    purge(typeName: string, id: string, workspaceId: string): Promise<void>;
+}
+//# sourceMappingURL=delete-entry.controller.d.ts.map

package/dist/lib/entries/controllers/delete-entry.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-entry.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/delete-entry.controller.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D;;;;;;;;;;;GAWG;AACH,qBAGa,qBAAqB;IAG1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAKzC,MAAM,CACW,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,IAAI,CAAC;IAMhB,OAAO,CACgB,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC;IAOjB,KAAK,CACY,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,IAAI,CAAC;CAInB"}

package/dist/lib/entries/controllers/get-entry.controller.d.ts

@@ -0,0 +1,34 @@
+import type { ContentTypeRegistry } from '../../registry/content-type-registry';
+import { EntryWriterService } from '../services/entry-writer.service';
+import type { EntryRecord, EntryRelationsView, RelationFieldView } from '../types/entry-list-view';
+/**
+ * `GET /api/content/:typeName/:id` — one live entry by id (404 if unknown or
+ * soft-deleted), so the editor can open an entry by deep link without relying on
+ * the records-list cache. `WorkspaceGuard` scopes it to a workspace the caller
+ * belongs to; gated on `content:read`.
+ */
+export declare class GetEntryController {
+    private readonly registry;
+    private readonly writer;
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
+    getOne(typeName: string, id: string, workspaceId: string): Promise<EntryRecord>;
+    /**
+     * `GET /api/content/:typeName/:id/relations` — one entry's relation links,
+     * keyed by field name. Every relation field (owning single/many **and**
+     * inverse back-references) resolved to display-ready refs (id + title) in a
+     * bounded set of queries, so the editor can render assigned relations by
+     * title and seed the form value with their ids without a round-trip per
+     * link. 404 when the entry is missing or soft-deleted in this workspace.
+     */
+    getRelations(typeName: string, id: string, workspaceId: string): Promise<EntryRelationsView>;
+    /**
+     * `GET /api/content/:typeName/:id/relations/:field` — one page of a single
+     * relation field's links (`{ items, total }`), ordered by position. Drives
+     * the editor's infinite-scroll of a many/inverse relation, so a field with
+     * thousands of links is paged, never loaded whole. `?page=&pageSize=`
+     * (1-based; clamped). 400 if `field` isn't a relation; 404 if the entry is
+     * missing. `content:read`.
+     */
+    getRelationField(typeName: string, id: string, field: string, workspaceId: string, page?: string, pageSize?: string): Promise<RelationFieldView>;
+}
+//# sourceMappingURL=get-entry.controller.d.ts.map

package/dist/lib/entries/controllers/get-entry.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-entry.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/get-entry.controller.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EACR,WAAW,EACX,kBAAkB,EAClB,iBAAiB,EACpB,MAAM,0BAA0B,CAAC;AAIlC;;;;;GAKG;AACH,qBAGa,kBAAkB;IAGvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAI/C,MAAM,CACiB,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC;IAKvB;;;;;;;OAOG;IAEG,YAAY,CACK,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,kBAAkB,CAAC;IAO9B;;;;;;;OAOG;IAEH,gBAAgB,CACO,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,EACT,WAAW,EAAE,MAAM,EACxB,IAAI,CAAC,EAAE,MAAM,EACT,QAAQ,CAAC,EAAE,MAAM,GACrC,OAAO,CAAC,iBAAiB,CAAC;CAWhC"}

package/dist/lib/entries/controllers/list-entries.controller.d.ts

@@ -0,0 +1,20 @@
+import type { ContentTypeRegistry } from '../../registry/content-type-registry';
+import { EntriesService } from '../services/entries.service';
+import { ListEntriesQueryDto } from '../dto/list-entries-query.dto';
+import type { EntryListView } from '../types/entry-list-view';
+/**
+ * `GET /api/content/:typeName` — one page of a collection's entries, filtered/
+ * searched/sorted via query params (`?search=`, `?filter=`, `?sort=`, `?page=`,
+ * `?pageSize=`). The `:typeName` is resolved from the registry (404 if unknown),
+ * so this single route serves every collection; the service runs the generic SQL
+ * pipeline against the type's generated table. Authentication is enforced by the
+ * app-wide AuthGuard; `WorkspaceGuard` scopes the request to a workspace the
+ * caller belongs to; read access is gated on `content:read`.
+ */
+export declare class ListEntriesController {
+    private readonly registry;
+    private readonly entries;
+    constructor(registry: ContentTypeRegistry, entries: EntriesService);
+    list(typeName: string, query: ListEntriesQueryDto, workspaceId: string): Promise<EntryListView>;
+}
+//# sourceMappingURL=list-entries.controller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-entries.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/list-entries.controller.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D;;;;;;;;GAQG;AACH,qBAGa,qBAAqB;IAG1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE,cAAc;IAI5C,IAAI,CACmB,QAAQ,EAAE,MAAM,EAC1B,KAAK,EAAE,mBAAmB,EACf,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,aAAa,CAAC;CAO5B"}

package/dist/lib/entries/controllers/publish-entry.controller.d.ts

@@ -0,0 +1,19 @@
+import type { ContentTypeRegistry } from '../../registry/content-type-registry';
+import { EntryWriterService } from '../services/entry-writer.service';
+import type { EntryRecord } from '../types/entry-list-view';
+/**
+ * `POST /api/content/:typeName/:id/publish` and `.../unpublish` — the publish
+ * workflow for a single entry. Publish revalidates the stored row (a 422 if the
+ * draft no longer passes), then stamps `status='published'` + `published_at`;
+ * unpublish reverts to draft. Both 400 on a non-publishable type and 404 on a
+ * missing live row. `OriginGuard` defends the writes; `WorkspaceGuard` scopes
+ * them to a workspace the caller belongs to; `content:publish` gates them.
+ */
+export declare class PublishEntryController {
+    private readonly registry;
+    private readonly writer;
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
+    publish(typeName: string, id: string, workspaceId: string): Promise<EntryRecord>;
+    unpublish(typeName: string, id: string, workspaceId: string): Promise<EntryRecord>;
+}
+//# sourceMappingURL=publish-entry.controller.d.ts.map

package/dist/lib/entries/controllers/publish-entry.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-entry.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/publish-entry.controller.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D;;;;;;;GAOG;AACH,qBAGa,sBAAsB;IAG3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAI/C,OAAO,CACgB,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC;IAMvB,SAAS,CACc,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC;CAI1B"}

package/dist/lib/entries/controllers/resolve-type.d.ts

@@ -0,0 +1,9 @@
+import type { AnyContentType } from '../../types/content-type';
+import type { ContentTypeRegistry } from '../../registry/content-type-registry';
+/**
+ * Resolve a `:typeName` route param to a registered content type, or throw 404.
+ * Every entries controller routes one path per HTTP verb against the registry,
+ * so this single lookup keeps them thin and consistent.
+ */
+export declare function resolveType(registry: ContentTypeRegistry, typeName: string): AnyContentType;
+//# sourceMappingURL=resolve-type.d.ts.map

package/dist/lib/entries/controllers/resolve-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-type.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/resolve-type.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAEhF;;;;GAIG;AACH,wBAAgB,WAAW,CACvB,QAAQ,EAAE,mBAAmB,EAC7B,QAAQ,EAAE,MAAM,GACjB,cAAc,CAMhB"}

package/dist/lib/entries/controllers/update-entry.controller.d.ts

@@ -0,0 +1,18 @@
+import type { ContentTypeRegistry } from '../../registry/content-type-registry';
+import { EntryWriterService } from '../services/entry-writer.service';
+import { SaveEntryDto } from '../dto/save-entry.dto';
+import type { EntryRecord } from '../types/entry-list-view';
+/**
+ * `PATCH /api/content/:typeName/:id` — replace a live entry's values with a
+ * validated bag (the editor always submits the full document). 404 if there's no
+ * live row; 422 with the issue list on validation failure. `OriginGuard` defends
+ * this state-changing write; `WorkspaceGuard` scopes it to a workspace the caller
+ * belongs to; `content:update` gates it.
+ */
+export declare class UpdateEntryController {
+    private readonly registry;
+    private readonly writer;
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService);
+    update(typeName: string, id: string, body: SaveEntryDto, workspaceId: string): Promise<EntryRecord>;
+}
+//# sourceMappingURL=update-entry.controller.d.ts.map

package/dist/lib/entries/controllers/update-entry.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-entry.controller.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/controllers/update-entry.controller.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D;;;;;;GAMG;AACH,qBAGa,qBAAqB;IAG1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAI/C,MAAM,CACiB,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAC9B,IAAI,EAAE,YAAY,EACN,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,WAAW,CAAC;CAU1B"}

package/dist/lib/entries/domain/entry-publish-blocked.error.d.ts

@@ -0,0 +1,13 @@
+import type { ValidationIssue } from '@orthacms/content-domain';
+/**
+ * Raised by {@link Entry.publish} when the publish gate fails — the entry's
+ * stored values (and/or its required link-managed relations) don't yet satisfy
+ * the publish precondition. Transport-agnostic: it carries the {@link issues}
+ * so the application layer can map it to the plugin's existing `422
+ * { message, issues }` response without the domain knowing about HTTP.
+ */
+export declare class EntryPublishBlockedError extends Error {
+    readonly issues: ValidationIssue[];
+    constructor(issues: ValidationIssue[]);
+}
+//# sourceMappingURL=entry-publish-blocked.error.d.ts.map

package/dist/lib/entries/domain/entry-publish-blocked.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-publish-blocked.error.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/domain/entry-publish-blocked.error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAEhE;;;;;;GAMG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;aACnB,MAAM,EAAE,eAAe,EAAE;gBAAzB,MAAM,EAAE,eAAe,EAAE;CAIxD"}

package/dist/lib/entries/domain/entry-publish-blocked.error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntryPublishBlockedError = void 0;
+/**
+ * Raised by {@link Entry.publish} when the publish gate fails — the entry's
+ * stored values (and/or its required link-managed relations) don't yet satisfy
+ * the publish precondition. Transport-agnostic: it carries the {@link issues}
+ * so the application layer can map it to the plugin's existing `422
+ * { message, issues }` response without the domain knowing about HTTP.
+ */
+class EntryPublishBlockedError extends Error {
+    issues;
+    constructor(issues) {
+        super('Entry validation failed');
+        this.issues = issues;
+        this.name = 'EntryPublishBlockedError';
+    }
+}
+exports.EntryPublishBlockedError = EntryPublishBlockedError;

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

@@ -0,0 +1,71 @@
+import type { DomainEvent } from '@orthacms/database';
+import { type EntryStatus, type ValidationIssue } from '@orthacms/content-domain';
+/** State the persistence layer hands {@link Entry.rehydrate} to reconstruct one. */
+export interface EntryState {
+    /** Entry id. */
+    id: string;
+    /** The content-type machine name — carried only for the event payload. */
+    contentType: string;
+    /** Current publish status of the stored row. */
+    status: EntryStatus;
+}
+/**
+ * The outcome of the publish precondition, computed by the use-case from the
+ * kernel's value validation plus the persistence layer's required-link check
+ * (which needs the DB). The model decides what to do with it.
+ */
+export interface PublishGate {
+    /** Whether the entry may publish. */
+    valid: boolean;
+    /** The blocking issues when `valid` is false. */
+    issues: ValidationIssue[];
+}
+/**
+ * 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).
+ */
+export declare class Entry {
+    private readonly _id;
+    private readonly _contentType;
+    private _status;
+    private readonly events;
+    private constructor();
+    /** Reconstructs an entry from its persisted lifecycle state. */
+    static rehydrate(state: EntryState): Entry;
+    /**
+     * 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: PublishGate): void;
+    /**
+     * 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(): void;
+    /** The entry id. */
+    get id(): string;
+    /** The current publish status. */
+    get status(): EntryStatus;
+    /** Drains and returns the events raised since the last pull. */
+    pullEvents(): DomainEvent[];
+    private raise;
+}
+//# sourceMappingURL=entry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../../../../src/lib/entries/domain/entry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAGH,KAAK,WAAW,EAChB,KAAK,eAAe,EACvB,MAAM,0BAA0B,CAAC;AAIlC,oFAAoF;AACpF,MAAM,WAAW,UAAU;IACvB,gBAAgB;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,0EAA0E;IAC1E,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,MAAM,EAAE,WAAW,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IACxB,qCAAqC;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,iDAAiD;IACjD,MAAM,EAAE,eAAe,EAAE,CAAC;CAC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,KAAK;IAIV,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,OAAO;IALnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAE5C,OAAO;IAMP,gEAAgE;IAChE,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK;IAI1C;;;;;;;;OAQG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAchC;;;;;OAKG;IACH,SAAS,IAAI,IAAI;IAWjB,oBAAoB;IACpB,IAAI,EAAE,IAAI,MAAM,CAEf;IAED,kCAAkC;IAClC,IAAI,MAAM,IAAI,WAAW,CAExB;IAED,gEAAgE;IAChE,UAAU,IAAI,WAAW,EAAE;IAI3B,OAAO,CAAC,KAAK;CAGhB"}