@orthacms/content-server 0.0.0-reserve.0

package/dist/lib/docs/describe-content-api.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * The content plugin's pass over the host's OpenAPI document.
+ *
+ * `@nestjs/swagger` reflects static TypeScript, and this plugin's contract is
+ * runtime data: one generic controller set serves **every** code-defined
+ * content type, so the scanner sees `/content/{typeName}` with an opaque string
+ * param and no response shape at all. This pass fills both gaps from the
+ * registry — the real type names as an enum, and a typed entry/list schema per
+ * type — so a reader of the reference sees `article` and `home_page`, not
+ * "some object".
+ *
+ * Pure: it takes the document and the serialized types, and mutates only the
+ * paths this plugin owns.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeContentApi = describeContentApi;
+const content_schemas_1 = require("./content-schemas");
+/** The entry read/write shorthands, since most operations return one. */
+const ENTRY = { response: { kind: 'entry' } };
+const VALIDATED_ENTRY = {
+    response: { kind: 'entry' },
+    validated: true
+};
+const EMPTY = { response: { kind: 'empty' } };
+/** An operation returning one of the fixed shared schemas. */
+function shared(name) {
+    return { response: { kind: 'schema', name } };
+}
+/** Entry routes, keyed by what follows `/content/{typeName}`. */
+const ENTRY_ROUTES = {
+    '': { get: { response: { kind: 'listPage' } }, post: VALIDATED_ENTRY },
+    '/{id}': { get: ENTRY, patch: VALIDATED_ENTRY, delete: EMPTY },
+    '/{id}/media': { get: shared('EntryMedia') },
+    '/{id}/relations': { get: shared('EntryRelations') },
+    '/{id}/relations/{field}': { get: shared('RelationFieldPage') },
+    '/{id}/publish': { post: VALIDATED_ENTRY },
+    '/{id}/unpublish': { post: ENTRY },
+    '/{id}/restore': { post: ENTRY },
+    '/{id}/permanent': { delete: EMPTY },
+    '/{id}/revisions': { get: shared('RevisionList') },
+    '/{id}/revisions/{number}': { get: shared('RevisionDetail') },
+    '/{id}/revisions/{number}/restore': { post: VALIDATED_ENTRY },
+    '/{id}/revisions/{number}/publish': { post: VALIDATED_ENTRY },
+    '/bulk': { post: shared('BulkSaveResult') },
+    '/bulk/publish/preview': { post: shared('BulkPublishPreview') },
+    '/bulk/publish': {
+        post: { response: { kind: 'schema', name: 'BulkPublishResult' } }
+    },
+    '/bulk/unpublish': { post: shared('BulkActionResult') },
+    '/bulk/delete': { post: shared('BulkActionResult') },
+    '/bulk/restore': { post: shared('BulkActionResult') },
+    '/bulk/purge': { post: shared('BulkActionResult') }
+};
+/** Schema routes, keyed by what follows `/content-schema`. */
+const SCHEMA_ROUTES = {
+    '': { get: shared('ContentTypeSummaryList') },
+    '/{name}': { get: shared('ContentTypeSchema') },
+    '/{name}/filter-fields': { get: shared('FilterFields') }
+};
+/** Matches `<prefix>/content/{typeName}<rest>`. */
+const ENTRY_ROUTE_RE = /\/content\/\{typeName\}(.*)$/;
+/** Matches `<prefix>/content-schema<rest>`. */
+const SCHEMA_ROUTE_RE = /\/content-schema(.*)$/;
+/**
+ * Writes a success response's schema onto whichever 2xx key the scanner already
+ * emitted (Nest's default is 201 for `@Post`, 200 elsewhere, and a `@HttpCode`
+ * moves it), so this never invents a status code the API doesn't return.
+ */
+function setSuccessResponse(operation, schema, description) {
+    const responses = operation.responses ?? {};
+    const key = Object.keys(responses).find((code) => /^2\d\d$/.test(code));
+    if (!key || key === '204') {
+        return;
+    }
+    responses[key] = {
+        description,
+        content: { 'application/json': { schema } }
+    };
+    operation.responses = responses;
+}
+/** Adds a documented failure response, leaving any existing one alone. */
+function addErrorResponse(operation, code, description, schema) {
+    const responses = operation.responses ?? {};
+    if (responses[code]) {
+        return;
+    }
+    responses[code] = {
+        description,
+        ...(schema ? { content: { 'application/json': { schema } } } : {})
+    };
+    operation.responses = responses;
+}
+/** Constrains the `typeName` path param to the registered type names. */
+function describeTypeNameParam(operation, typeNames) {
+    const parameter = operation.parameters?.find((candidate) => candidate.name === 'typeName' && candidate.in === 'path');
+    if (!parameter) {
+        return;
+    }
+    parameter.schema = { type: 'string', enum: typeNames };
+    parameter.description =
+        'Machine name of the content type. Unknown (or not granted to the workspace) is a 404.';
+}
+/**
+ * `oneOf` the per-type schemas — the response shape depends on `typeName`,
+ * which OpenAPI can't express as a dependency, so the alternatives are listed.
+ * A single registered type needs no union.
+ */
+function unionOf(names) {
+    return names.length === 1
+        ? (0, content_schemas_1.ref)(names[0])
+        : { oneOf: names.map((name) => (0, content_schemas_1.ref)(name)) };
+}
+/**
+ * Adds this plugin's schemas to `document` and describes its own operations:
+ * the `typeName` enum, per-type response schemas, and the documented failures.
+ */
+function describeContentApi(document, types) {
+    document.components ??= {};
+    document.components.schemas ??= {};
+    Object.assign(document.components.schemas, (0, content_schemas_1.buildContentSchemas)(types));
+    const typeNames = types.map((type) => type.name);
+    const entryUnion = unionOf(types.map((type) => (0, content_schemas_1.schemaNamesOf)(type).entry));
+    const listUnion = unionOf(types.map((type) => (0, content_schemas_1.schemaNamesOf)(type).listPage));
+    for (const [route, item] of Object.entries(document.paths)) {
+        const entryMatch = ENTRY_ROUTE_RE.exec(route);
+        const schemaMatch = SCHEMA_ROUTE_RE.exec(route);
+        const rest = (entryMatch ?? schemaMatch)?.[1];
+        if (rest === undefined) {
+            continue;
+        }
+        const routes = entryMatch ? ENTRY_ROUTES : SCHEMA_ROUTES;
+        const byMethod = routes[rest];
+        if (!byMethod) {
+            continue;
+        }
+        for (const [method, operation] of Object.entries(item)) {
+            const spec = byMethod[method];
+            if (!spec || !operation || typeof operation !== 'object') {
+                continue;
+            }
+            if (entryMatch) {
+                describeTypeNameParam(operation, typeNames);
+                addErrorResponse(operation, '404', 'Unknown content type, or no entry with this id in the workspace.');
+                if (spec.validated) {
+                    addErrorResponse(operation, '422', 'The values failed the content type’s field validation.', {
+                        type: 'object',
+                        properties: {
+                            message: { type: 'string' },
+                            issues: {
+                                type: 'array',
+                                items: (0, content_schemas_1.ref)('ValidationIssue')
+                            }
+                        },
+                        required: ['message', 'issues']
+                    });
+                }
+            }
+            // With no registered types there is no entry shape to describe —
+            // and every one of these routes 404s anyway.
+            const { response } = spec;
+            if (response.kind === 'entry' && typeNames.length) {
+                setSuccessResponse(operation, entryUnion, 'The entry.');
+            }
+            else if (response.kind === 'listPage' && typeNames.length) {
+                setSuccessResponse(operation, listUnion, 'One page of entries.');
+            }
+            else if (response.kind === 'schema') {
+                setSuccessResponse(operation, (0, content_schemas_1.ref)(response.name), 'OK.');
+            }
+        }
+    }
+}

package/dist/lib/docs/field-schema.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Field spec → JSON Schema. The pure half of the OpenAPI description: given one
+ * serialized field, produce the schema its value takes on the wire.
+ *
+ * No NestJS, no registry, no document — just the mapping, so the table below is
+ * unit-testable on its own.
+ */
+import type { SerializedField } from '../registry/content-type-registry';
+/** A JSON Schema fragment, as it appears in the OpenAPI document. */
+export type OpenApiSchema = Record<string, unknown>;
+/**
+ * Whether the field's value travels in the `values` bag at all. A many-relation
+ * and an inverse back-reference own no column — their links live in join tables
+ * and are read through the relation routes — so they are absent from a record's
+ * `values`, exactly as `toRecord` builds it.
+ */
+export declare function isValueField(field: SerializedField): boolean;
+/**
+ * The documented schema of one field: its value schema plus the presentation
+ * facts a reader needs — the admin label as `title`, help text and the
+ * relation/localization notes as `description`.
+ *
+ * Every property is `nullable`: an unset field reads back as `null`, and on a
+ * publishable type even a required one may legitimately be empty in a draft
+ * (required means "required *to publish*").
+ */
+export declare function fieldSchema(field: SerializedField): OpenApiSchema;
+//# sourceMappingURL=field-schema.d.ts.map

package/dist/lib/docs/field-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/docs/field-schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE,qEAAqE;AACrE,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAyJpD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAK5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,eAAe,GAAG,aAAa,CA0DjE"}

package/dist/lib/docs/field-schema.js

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * Field spec → JSON Schema. The pure half of the OpenAPI description: given one
+ * serialized field, produce the schema its value takes on the wire.
+ *
+ * No NestJS, no registry, no document — just the mapping, so the table below is
+ * unit-testable on its own.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValueField = isValueField;
+exports.fieldSchema = fieldSchema;
+const fields_1 = require("../types/fields");
+/** The `uuid`-shaped string every id value takes. */
+const UUID_SCHEMA = { type: 'string', format: 'uuid' };
+/**
+ * A rich-text body: the **document** the editor produces, or — for a body
+ * written before rich text became structured, and not yet re-saved — the HTML
+ * string it is still stored as. Both are accepted on a write and either may
+ * come back on a read, which is what `oneOf` says here.
+ *
+ * The node tree is described one level deep and left open (`additionalProperties`
+ * on `attrs`, a self-`$ref`-free `content`): the node vocabulary is the
+ * editor's, not this schema's, and pinning it here would make every editor
+ * extension a change to the published API description.
+ *
+ * `minLength`/`maxLength` are deliberately **not** copied onto it. They are
+ * real rules, but they count the body's *text*, and a JSON Schema `maxLength`
+ * on this value would be read as a bound on the serialized document — a
+ * different, wrong promise. The field's description carries them in words.
+ */
+const RICH_TEXT_SCHEMA = {
+    oneOf: [
+        {
+            type: 'object',
+            title: 'RichTextDocument',
+            required: ['type'],
+            properties: {
+                type: { type: 'string', enum: ['doc'] },
+                content: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        required: ['type'],
+                        properties: {
+                            type: { type: 'string' },
+                            attrs: {
+                                type: 'object',
+                                additionalProperties: true
+                            },
+                            marks: { type: 'array', items: { type: 'object' } },
+                            text: { type: 'string' },
+                            content: {
+                                type: 'array',
+                                items: { type: 'object' }
+                            }
+                        },
+                        additionalProperties: true
+                    }
+                }
+            },
+            additionalProperties: true
+        },
+        { type: 'string', description: 'Legacy HTML body (read-compatible).' }
+    ]
+};
+/**
+ * The schema of a field's **value**, before the nullability and description
+ * wrapping {@link fieldSchema} adds.
+ *
+ * A `json` field deliberately produces `{}` — "any JSON" — rather than
+ * `type: 'object'`: the column holds whatever the author stores, arrays and
+ * scalars included.
+ */
+function valueSchema(field) {
+    const { validation } = field;
+    switch (field.type) {
+        case fields_1.CONTENT_FIELD_TYPE.Text:
+            return {
+                type: 'string',
+                ...pick(validation, ['minLength', 'maxLength']),
+                ...(typeof validation['pattern'] === 'string'
+                    ? { pattern: validation['pattern'] }
+                    : {})
+            };
+        case fields_1.CONTENT_FIELD_TYPE.RichText:
+            return RICH_TEXT_SCHEMA;
+        case fields_1.CONTENT_FIELD_TYPE.Number:
+            return {
+                type: validation['integer'] === true ? 'integer' : 'number',
+                ...renameBounds(validation)
+            };
+        case fields_1.CONTENT_FIELD_TYPE.Money:
+            return { type: 'number', ...renameBounds(validation) };
+        case fields_1.CONTENT_FIELD_TYPE.Boolean:
+            return { type: 'boolean' };
+        case fields_1.CONTENT_FIELD_TYPE.Date:
+            return { type: 'string', format: 'date' };
+        case fields_1.CONTENT_FIELD_TYPE.Datetime:
+            return { type: 'string', format: 'date-time' };
+        case fields_1.CONTENT_FIELD_TYPE.Select:
+            return {
+                type: 'string',
+                ...(field.options ? { enum: [...field.options] } : {})
+            };
+        case fields_1.CONTENT_FIELD_TYPE.Multiselect:
+            return {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    ...(field.options ? { enum: [...field.options] } : {})
+                }
+            };
+        case fields_1.CONTENT_FIELD_TYPE.Json:
+            return {};
+        case fields_1.CONTENT_FIELD_TYPE.Relation:
+            // Only an owning **single** relation rides the values bag, as its
+            // raw FK; the join-backed kinds never reach here (the caller drops
+            // them, mirroring `toRecord`).
+            return UUID_SCHEMA;
+        case fields_1.CONTENT_FIELD_TYPE.Media:
+            return field.multiple
+                ? { type: 'array', items: UUID_SCHEMA }
+                : UUID_SCHEMA;
+        default:
+            return {};
+    }
+}
+/** Copies the listed numeric validation keys through, when present. */
+function pick(validation, keys) {
+    const out = {};
+    for (const key of keys) {
+        if (typeof validation[key] === 'number') {
+            out[key] = validation[key];
+        }
+    }
+    return out;
+}
+/** One numeric validation rule off a field, when it has one. */
+function validationNumber(field, key) {
+    const value = field.validation[key];
+    return typeof value === 'number' ? value : undefined;
+}
+/** `min`/`max` are JSON Schema's `minimum`/`maximum`. */
+function renameBounds(validation) {
+    const out = {};
+    if (typeof validation['min'] === 'number')
+        out['minimum'] = validation['min'];
+    if (typeof validation['max'] === 'number')
+        out['maximum'] = validation['max'];
+    return out;
+}
+/**
+ * Whether the field's value travels in the `values` bag at all. A many-relation
+ * and an inverse back-reference own no column — their links live in join tables
+ * and are read through the relation routes — so they are absent from a record's
+ * `values`, exactly as `toRecord` builds it.
+ */
+function isValueField(field) {
+    return !(field.type === fields_1.CONTENT_FIELD_TYPE.Relation &&
+        (field.relation?.many || field.relation?.inverse));
+}
+/**
+ * The documented schema of one field: its value schema plus the presentation
+ * facts a reader needs — the admin label as `title`, help text and the
+ * relation/localization notes as `description`.
+ *
+ * Every property is `nullable`: an unset field reads back as `null`, and on a
+ * publishable type even a required one may legitimately be empty in a draft
+ * (required means "required *to publish*").
+ */
+function fieldSchema(field) {
+    const notes = [];
+    if (typeof field.admin['description'] === 'string') {
+        notes.push(field.admin['description']);
+    }
+    if (field.relation) {
+        notes.push(`Id of the related \`${field.relation.to}\` entry${field.relation.unique ? ' (one-to-one)' : ''}.`);
+    }
+    if (field.type === fields_1.CONTENT_FIELD_TYPE.Media) {
+        notes.push(field.multiple
+            ? 'Ordered media-asset ids.'
+            : 'Media-asset id (`GET /api/media/assets/{id}/raw` serves the bytes).');
+    }
+    if (field.localized) {
+        notes.push('Localized — varies per locale row.');
+    }
+    if (field.type === fields_1.CONTENT_FIELD_TYPE.Json) {
+        notes.push('Arbitrary JSON.');
+    }
+    if (field.type === fields_1.CONTENT_FIELD_TYPE.RichText) {
+        notes.push('Rich text as a structured document (ProseMirror/TipTap JSON); a ' +
+            'legacy HTML string is still accepted and still read back until ' +
+            'the entry is next saved from the editor.');
+        const min = validationNumber(field, 'minLength');
+        const max = validationNumber(field, 'maxLength');
+        if (min !== undefined || max !== undefined) {
+            // Said in words rather than as a JSON Schema `maxLength`, which
+            // would bound the serialized document instead of the prose.
+            notes.push(`Length rules count the body's text, not its markup${min !== undefined ? `; at least ${min} characters` : ''}${max !== undefined ? `; at most ${max} characters` : ''}.`);
+        }
+    }
+    if (field.lang) {
+        notes.push(`Written in \`${field.lang}\` (BCP-47).`);
+    }
+    const label = typeof field.admin['label'] === 'string'
+        ? field.admin['label']
+        : undefined;
+    return {
+        ...valueSchema(field),
+        nullable: true,
+        ...(label ? { title: label } : {}),
+        ...(notes.length ? { description: notes.join(' ') } : {})
+    };
+}

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

@@ -0,0 +1,23 @@
+import { OutboxWriter, UnitOfWork } from '@orthacms/database';
+import type { AnyContentType } from '../../../types/content-type';
+import { EntryValidationService } from '../../../validation/services/entry-validation.service';
+import { EntryWriterService } from '../../infrastructure/persistence/entry-writer.service';
+import { type BulkPublishResult } from '../../types/bulk-publish';
+/**
+ * Commit a bulk publish. Preserves the original single **locked** transaction:
+ * the candidate rows are selected `FOR UPDATE` and re-validated inside one
+ * unit of work, so a concurrent edit can't invalidate a row between the dry run
+ * and the write (the TOCTOU window the original defended). Publishes only the
+ * `publishable` ids, reporting which were skipped and why (partial success),
+ * and appends one `entry.published` event per newly-published id to the outbox —
+ * atomically with the batch.
+ */
+export declare class BulkPublishEntriesUseCase {
+    private readonly uow;
+    private readonly outbox;
+    private readonly writer;
+    private readonly validation;
+    constructor(uow: UnitOfWork, outbox: OutboxWriter, writer: EntryWriterService, validation: EntryValidationService);
+    execute(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkPublishResult>;
+}
+//# sourceMappingURL=bulk-publish-entries.use-case.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-publish-entries.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/application/use-cases/bulk-publish-entries.use-case.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE9D,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,EAAgB,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGhF;;;;;;;;GAQG;AACH,qBACa,yBAAyB;IAE9B,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,GAAG,EAAE,MAAM,EAAE,EACb,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,iBAAiB,CAAC;CA6DhC"}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkPublishEntriesUseCase = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const database_1 = require("@orthacms/database");
+const content_domain_1 = require("@orthacms/content-domain");
+const entry_validation_service_1 = require("../../../validation/services/entry-validation.service");
+const entry_writer_service_1 = require("../../infrastructure/persistence/entry-writer.service");
+const bulk_publish_verdicts_1 = require("../../infrastructure/persistence/bulk-publish-verdicts");
+const bulk_publish_1 = require("../../types/bulk-publish");
+const entry_1 = require("../../domain/entry");
+/**
+ * Commit a bulk publish. Preserves the original single **locked** transaction:
+ * the candidate rows are selected `FOR UPDATE` and re-validated inside one
+ * unit of work, so a concurrent edit can't invalidate a row between the dry run
+ * and the write (the TOCTOU window the original defended). Publishes only the
+ * `publishable` ids, reporting which were skipped and why (partial success),
+ * and appends one `entry.published` event per newly-published id to the outbox —
+ * atomically with the batch.
+ */
+let BulkPublishEntriesUseCase = class BulkPublishEntriesUseCase {
+    uow;
+    outbox;
+    writer;
+    validation;
+    constructor(uow, outbox, writer, validation) {
+        this.uow = uow;
+        this.outbox = outbox;
+        this.writer = writer;
+        this.validation = validation;
+    }
+    async execute(type, ids, workspaceId) {
+        if (!type.publishable) {
+            throw new common_1.BadRequestException(`Content type "${type.name}" is not publishable.`);
+        }
+        if (!ids.length)
+            return { published: [], skipped: [] };
+        return this.uow.run(async () => {
+            const exec = this.uow.current();
+            const byId = await this.writer.loadLiveByIdsForUpdate(exec, type, ids, workspaceId);
+            const items = (0, bulk_publish_verdicts_1.computeBulkPublishVerdicts)(type, ids, byId, (t, values) => this.validation.validate(t, values));
+            const published = items
+                .filter((item) => item.verdict === bulk_publish_1.BULK_VERDICT.Publishable)
+                .map((item) => item.id);
+            if (published.length) {
+                await this.writer.markPublishedBulk(exec, type, published, workspaceId);
+                // Promote each published entry's latest revision to live, so the
+                // history timeline matches however the entry was published.
+                for (const id of published) {
+                    await this.writer.markRevisionPublished(exec, id, workspaceId);
+                }
+                await this.outbox.append(published.flatMap((id) => {
+                    const entry = entry_1.Entry.rehydrate({
+                        id,
+                        contentType: type.name,
+                        status: content_domain_1.ENTRY_STATUS.Draft
+                    });
+                    entry.publish({ valid: true, issues: [] });
+                    return entry.pullEvents();
+                }));
+            }
+            const skipped = items
+                .filter((item) => item.verdict !== bulk_publish_1.BULK_VERDICT.Publishable)
+                .map((item) => ({ id: item.id, reason: item.verdict }));
+            return { published, skipped };
+        });
+    }
+};
+exports.BulkPublishEntriesUseCase = BulkPublishEntriesUseCase;
+exports.BulkPublishEntriesUseCase = BulkPublishEntriesUseCase = 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])
+], BulkPublishEntriesUseCase);

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

@@ -0,0 +1,23 @@
+import { OutboxWriter, UnitOfWork } from '@orthacms/database';
+import type { AnyContentType } from '../../../types/content-type';
+import { EntryWriterService } from '../../infrastructure/persistence/entry-writer.service';
+import type { BulkActionResult } from '../../types/bulk-publish';
+/**
+ * Revert a set of live entries to draft. Runs inside one {@link UnitOfWork}, and
+ * **one set of ids runs through all three effects**: the `{ count }` reported,
+ * the revisions reverted, and the `entry.unpublished` events appended are the
+ * rows that were `published` before the write and no others.
+ *
+ * The count used to be broader — every live row the id list matched, draft ones
+ * included — while the events were already per real transition. Two numbers for
+ * one operation, and the wider of them was the one the caller was shown. 400 on
+ * a non-publishable type.
+ */
+export declare class BulkUnpublishEntriesUseCase {
+    private readonly uow;
+    private readonly outbox;
+    private readonly writer;
+    constructor(uow: UnitOfWork, outbox: OutboxWriter, writer: EntryWriterService);
+    execute(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkActionResult>;
+}
+//# sourceMappingURL=bulk-unpublish-entries.use-case.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-unpublish-entries.use-case.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/application/use-cases/bulk-unpublish-entries.use-case.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAC3F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGjE;;;;;;;;;;GAUG;AACH,qBACa,2BAA2B;IAEhC,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,GAAG,EAAE,MAAM,EAAE,EACb,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,gBAAgB,CAAC;CA+C/B"}

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkUnpublishEntriesUseCase = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const database_1 = require("@orthacms/database");
+const content_domain_1 = require("@orthacms/content-domain");
+const entry_writer_service_1 = require("../../infrastructure/persistence/entry-writer.service");
+const entry_1 = require("../../domain/entry");
+/**
+ * Revert a set of live entries to draft. Runs inside one {@link UnitOfWork}, and
+ * **one set of ids runs through all three effects**: the `{ count }` reported,
+ * the revisions reverted, and the `entry.unpublished` events appended are the
+ * rows that were `published` before the write and no others.
+ *
+ * The count used to be broader — every live row the id list matched, draft ones
+ * included — while the events were already per real transition. Two numbers for
+ * one operation, and the wider of them was the one the caller was shown. 400 on
+ * a non-publishable type.
+ */
+let BulkUnpublishEntriesUseCase = class BulkUnpublishEntriesUseCase {
+    uow;
+    outbox;
+    writer;
+    constructor(uow, outbox, writer) {
+        this.uow = uow;
+        this.outbox = outbox;
+        this.writer = writer;
+    }
+    async execute(type, ids, workspaceId) {
+        if (!type.publishable) {
+            throw new common_1.BadRequestException(`Content type "${type.name}" is not publishable.`);
+        }
+        if (!ids.length)
+            return { count: 0 };
+        return this.uow.run(async () => {
+            const exec = this.uow.current();
+            // The set that actually transitions (published → draft), captured
+            // before the write so we emit one event per real change.
+            const publishedIds = await this.writer.publishedIdsAmong(exec, type, ids, workspaceId);
+            const count = await this.writer.markDraftBulk(exec, type, ids, workspaceId);
+            // Revert each really-transitioned entry's published revision back to
+            // draft — the same set the outbox emits an event for.
+            for (const id of publishedIds) {
+                await this.writer.markRevisionUnpublished(exec, id, workspaceId);
+            }
+            await this.outbox.append(publishedIds.flatMap((id) => {
+                const entry = entry_1.Entry.rehydrate({
+                    id,
+                    contentType: type.name,
+                    status: content_domain_1.ENTRY_STATUS.Published
+                });
+                entry.unpublish();
+                return entry.pullEvents();
+            }));
+            return { count };
+        });
+    }
+};
+exports.BulkUnpublishEntriesUseCase = BulkUnpublishEntriesUseCase;
+exports.BulkUnpublishEntriesUseCase = BulkUnpublishEntriesUseCase = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [database_1.UnitOfWork,
+        database_1.OutboxWriter,
+        entry_writer_service_1.EntryWriterService])
+], BulkUnpublishEntriesUseCase);

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

@@ -0,0 +1,43 @@
+import { OutboxWriter, UnitOfWork } from '@orthacms/database';
+import type { AnyContentType } from '../../../types/content-type';
+import { EntryValidationService } from '../../../validation/services/entry-validation.service';
+import { EntryWriterService } from '../../infrastructure/persistence/entry-writer.service';
+import type { EntryRecord } from '../../types/entry-list-view';
+/**
+ * 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.
+ */
+export declare class PublishEntryUseCase {
+    private readonly uow;
+    private readonly outbox;
+    private readonly writer;
+    private readonly validation;
+    constructor(uow: UnitOfWork, outbox: OutboxWriter, writer: EntryWriterService, validation: EntryValidationService);
+    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;
+    }, 
+    /**
+     * 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?: number): Promise<EntryRecord>;
+    private notFound;
+}
+//# sourceMappingURL=publish-entry.use-case.d.ts.map