@orthacms/content-server 0.4.2 → 0.5.0

package/dist/lib/docs/public-api-schemas.js

@@ -0,0 +1,377 @@
+"use strict";
+/**
+ * The OpenAPI schemas of the **public** content API (`/api/v1/...`), kept apart
+ * from the admin's for the same reason `types/public-entry.ts` is kept apart
+ * from `EntryRecord`: this is a published contract an external site builds
+ * against, and it must be free to stay still while the admin's shape moves.
+ *
+ * Splitting them is not tidiness. Until this module existed the document
+ * described `/api/v1/content/{typeName}/{id}` with the **admin** entry schema,
+ * because the route pattern in `describe-content-api.ts` matched both spellings
+ * — so a consumer reading the reference was told a relation preview carries
+ * `RelationRef`s (id + title) when the public API returns whole entries, and
+ * that a media read is `Record<string, MediaRef[]>` when it is
+ * `Record<string, { items, total }>`. A wrong schema is worse than an absent
+ * one: the absent one sends you to curl, the wrong one does not.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicSchemaNamesOf = publicSchemaNamesOf;
+exports.publicUnionOf = publicUnionOf;
+exports.buildPublicApiSchemas = buildPublicApiSchemas;
+const fields_1 = require("../types/fields");
+const content_type_1 = require("../types/content-type");
+const field_schema_1 = require("./field-schema");
+const content_schemas_1 = require("./content-schemas");
+const UUID = { type: 'string', format: 'uuid' };
+const DATE_TIME = { type: 'string', format: 'date-time' };
+/** The three schema names a content type contributes to the public document. */
+function publicSchemaNamesOf(type) {
+    const base = `Public${(0, content_schemas_1.pascalCase)(type.name)}`;
+    return {
+        values: `${base}Values`,
+        entry: `${base}Entry`,
+        listPage: `${base}ListPage`
+    };
+}
+/**
+ * Whether a field's value appears in a public entry's `values` bag.
+ *
+ * Mirrors `public-api/infrastructure/public-entry-row.ts`'s
+ * `isPureValueField` — **every** reference kind is dropped, `relation` in all
+ * four cardinalities and `media` alike, because the public read resolves
+ * neither in `values` and a bare uuid is an identifier with nothing to follow.
+ * Deliberately stricter than the admin's `isValueField`, which keeps an owning
+ * single relation's FK.
+ */
+function isPublicValueField(field) {
+    return (field.type !== fields_1.CONTENT_FIELD_TYPE.Relation &&
+        field.type !== fields_1.CONTENT_FIELD_TYPE.Media);
+}
+/** The `values` bag of one content type, as the public API serves it. */
+function publicValuesSchema(type) {
+    const fields = type.fields.filter(isPublicValueField);
+    const omitted = type.fields
+        .filter((field) => !isPublicValueField(field))
+        .map((field) => field.name);
+    const properties = {};
+    for (const field of fields) {
+        properties[field.name] = (0, field_schema_1.fieldSchema)(field);
+    }
+    const notes = [
+        `Field values keyed by field name, for one \`${type.name}\` entry.`,
+        'An unset field reads back as `null`, never as a missing key — except under a `?fields=` sparse fieldset, where only the requested keys are present at all.',
+        omitted.length
+            ? `Reference fields (${omitted
+                .map((name) => `\`${name}\``)
+                .join(', ')}) are **not** in this bag: read relations through \`?relations=preview\` or the \`/relations/{field}\` route, and media through \`?media=preview\` or \`/media\`. The schema endpoint still describes them, because they are part of the real model.`
+            : ''
+    ].filter(Boolean);
+    return {
+        type: 'object',
+        title: `${type.label} values (public)`,
+        description: notes.join(' '),
+        properties,
+        // No `required`: a sparse fieldset may narrow the bag to one key, and a
+        // publishable type's "required" fields are required to publish rather
+        // than to exist.
+        additionalProperties: false
+    };
+}
+/** One entry of a content type, as the public API serves it. */
+function publicEntrySchema(type, names) {
+    const properties = {
+        id: { ...UUID, description: 'Entry id.' },
+        ...(type.publishable
+            ? {
+                status: {
+                    type: 'string',
+                    enum: Object.values(content_type_1.ENTRY_STATUS),
+                    description: 'Publish state. A read-only token only ever sees `published`; a write-scoped one can create a draft and read it back with `?status=`.'
+                },
+                publishedAt: {
+                    ...DATE_TIME,
+                    nullable: true,
+                    description: 'When this entry last went live. `draft` together with a non-null `publishedAt` is live content carrying unpublished edits — neither field alone tells those apart.'
+                }
+            }
+            : {}),
+        createdAt: DATE_TIME,
+        updatedAt: DATE_TIME,
+        ...(type.i18n
+            ? {
+                locale: {
+                    type: 'string',
+                    description: 'Locale slug of this row.'
+                },
+                localeGroupId: {
+                    ...UUID,
+                    description: 'Translation group — this row’s siblings in other locales share it, and it is the id the `/group/{localeGroupId}` routes take.'
+                }
+            }
+            : {}),
+        values: (0, content_schemas_1.ref)(names.values),
+        relations: {
+            type: 'object',
+            additionalProperties: (0, content_schemas_1.ref)('PublicRelationFieldPage'),
+            description: 'Relation links keyed by field name — present only with `?relations=preview`. Each linked record is a whole entry, not a ref.'
+        },
+        media: {
+            type: 'object',
+            additionalProperties: (0, content_schemas_1.ref)('PublicMediaFieldPage'),
+            description: 'Media assets keyed by field name — present only with `?media=preview`.'
+        },
+        ...(type.i18n
+            ? {
+                translations: {
+                    type: 'array',
+                    items: (0, content_schemas_1.ref)(names.entry),
+                    description: 'The entry’s **other** published locale rows — present only with `?translations=preview`. The entry itself is not repeated, and the siblings are not themselves expanded.'
+                }
+            }
+            : {})
+    };
+    return {
+        type: 'object',
+        title: `${type.label} (public)`,
+        description: `One \`${type.name}\` entry on the public API.`,
+        properties,
+        required: [
+            'id',
+            'createdAt',
+            'updatedAt',
+            'values',
+            ...(type.publishable ? ['status', 'publishedAt'] : []),
+            ...(type.i18n ? ['locale', 'localeGroupId'] : [])
+        ]
+    };
+}
+/** One page of public entries of a content type. */
+function publicListPageSchema(type, names) {
+    return {
+        type: 'object',
+        title: `${type.label} page (public)`,
+        description: `One page of \`${type.name}\` entries. \`total\` counts every match, ignoring pagination.`,
+        properties: {
+            items: { type: 'array', items: (0, content_schemas_1.ref)(names.entry) },
+            total: { type: 'integer' },
+            page: {
+                type: 'integer',
+                description: '1-based page number this page represents.'
+            },
+            pageSize: {
+                type: 'integer',
+                description: 'Rows per page actually applied.'
+            }
+        },
+        required: ['items', 'total', 'page', 'pageSize']
+    };
+}
+/**
+ * The public per-type entry schemas as alternatives — the response shape
+ * depends on `typeName`, which OpenAPI cannot express as a dependency. One
+ * registered type needs no union; none at all leaves an open object, since
+ * every one of these routes 404s anyway.
+ *
+ * `anyOf` rather than `oneOf`, for the reason `unionOf` in
+ * `describe-content-api.ts` spells out: the alternatives overlap, and *exactly
+ * one* is a promise the API does not keep.
+ */
+function publicUnionOf(names) {
+    if (!names.length)
+        return { type: 'object', additionalProperties: true };
+    return names.length === 1
+        ? (0, content_schemas_1.ref)(names[0])
+        : { anyOf: names.map((name) => (0, content_schemas_1.ref)(name)) };
+}
+/**
+ * The public API's fixed shapes — the ones that do not vary by content type,
+ * except where an entry appears inside them.
+ *
+ * `entryUnion` is threaded in rather than referenced by name because a relation
+ * page and a translation list carry whole entries, and which entries those are
+ * is the registry's answer, not this module's.
+ */
+function publicSharedSchemas(entryUnion) {
+    return {
+        PublicMediaTrack: {
+            type: 'object',
+            description: 'One timed-text track on a published video or audio asset — everything a `<track>` element needs.',
+            properties: {
+                kind: {
+                    type: 'string',
+                    description: '`captions` / `subtitles` / `descriptions` / `chapters`.'
+                },
+                srclang: {
+                    type: 'string',
+                    description: 'BCP-47 tag of the track’s language.'
+                },
+                label: {
+                    type: 'string',
+                    description: 'What a player shows in its track menu.'
+                },
+                src: {
+                    type: 'string',
+                    description: 'Route the WebVTT bytes stream from — same bearer token as the read.'
+                },
+                default: {
+                    type: 'boolean',
+                    description: 'Whether a player should enable this track by default.'
+                }
+            },
+            required: ['kind', 'srclang', 'label', 'src']
+        },
+        PublicMediaRef: {
+            type: 'object',
+            description: 'One attached asset. The URLs take the **same bearer token** as the read that produced them, so a server-side consumer can fetch the bytes with the credential it already holds — but a browser `<img src>` sends no `Authorization` header and will not load one. Proxy them from whatever holds the token.',
+            properties: {
+                id: UUID,
+                name: {
+                    type: 'string',
+                    description: 'Display name — the original file name.'
+                },
+                url: {
+                    type: 'string',
+                    description: 'Route the original bytes stream from.'
+                },
+                thumbUrl: {
+                    type: 'string',
+                    description: '~320px derivative, when one was generated (absent for non-images, SVGs, and images too small to derive).'
+                },
+                previewUrl: {
+                    type: 'string',
+                    description: '~1280px derivative, same caveats.'
+                },
+                kind: {
+                    type: 'string',
+                    description: 'Coarse kind — image / video / audio / document / archive.'
+                },
+                mimeType: { type: 'string' },
+                alt: {
+                    type: 'string',
+                    nullable: true,
+                    description: 'The text alternative for **this usage**. `""` and `null` mean different things: `""` is “render `alt=""`, this image says nothing”, `null` is “nobody supplied one” — a gap to report, not an instruction to hide the image from assistive tech.'
+                },
+                decorative: {
+                    type: 'boolean',
+                    enum: [true],
+                    description: 'Present, and always `true`, when the author marked this usage purely presentational.'
+                },
+                tracks: {
+                    type: 'array',
+                    items: (0, content_schemas_1.ref)('PublicMediaTrack'),
+                    description: 'Empty for an image, and for a video nobody has captioned.'
+                }
+            },
+            required: ['id', 'name', 'url', 'kind', 'mimeType', 'alt', 'tracks']
+        },
+        PublicMediaFieldPage: {
+            type: 'object',
+            description: 'One media field’s assets, in their stored order.',
+            properties: {
+                items: { type: 'array', items: (0, content_schemas_1.ref)('PublicMediaRef') },
+                total: {
+                    type: 'integer',
+                    description: 'Assets attached to this field.'
+                }
+            },
+            required: ['items', 'total']
+        },
+        PublicEntryMedia: {
+            type: 'object',
+            description: 'Every media field of the entry, keyed by field name.',
+            properties: {
+                media: {
+                    type: 'object',
+                    additionalProperties: (0, content_schemas_1.ref)('PublicMediaFieldPage')
+                }
+            },
+            required: ['media']
+        },
+        PublicRelationFieldPage: {
+            type: 'object',
+            description: 'One relation field’s links: a capped page plus the true total. Each item is a **whole entry**, envelope and `values` alike — not a ref — so a consumer renders a linked record with the code it already has. Linked entries are not themselves expanded. A target the caller may not see is omitted **and not counted**, so `total` is the number of links actually reachable.',
+            properties: {
+                items: { type: 'array', items: entryUnion },
+                total: {
+                    type: 'integer',
+                    description: 'Visible links for this field, ignoring the page cap.'
+                }
+            },
+            required: ['items', 'total']
+        },
+        PublicEntryTranslations: {
+            type: 'object',
+            description: 'The entry’s other published locale rows, ordered by locale slug. The entry itself is not repeated, and a locale that exists only as a draft is absent.',
+            properties: {
+                translations: { type: 'array', items: entryUnion }
+            },
+            required: ['translations']
+        },
+        PublicContentTypeList: {
+            type: 'object',
+            description: 'Every content type granted to the requested workspace — exactly the set of `typeName`s that will not 404.',
+            properties: {
+                items: { type: 'array', items: (0, content_schemas_1.ref)('ContentTypeSummary') }
+            },
+            required: ['items']
+        },
+        PublicBulkError: {
+            type: 'object',
+            description: 'Why one item of a batch did not go through, carrying **the status the same write would have failed with on its own** (404, 422, 400) rather than a bulk-specific vocabulary.',
+            properties: {
+                status: { type: 'integer' },
+                message: { type: 'string' },
+                issues: {
+                    type: 'array',
+                    items: (0, content_schemas_1.ref)('ValidationIssue'),
+                    description: 'The per-field issues of a 422.'
+                }
+            },
+            required: ['status', 'message']
+        },
+        PublicBulkSaveItemResult: {
+            type: 'object',
+            description: 'What became of one submitted item, positionally matched to the request.',
+            properties: {
+                index: {
+                    type: 'integer',
+                    description: '0-based position in the submitted `items`.'
+                },
+                op: { type: 'string', enum: ['create', 'update'] },
+                ok: { type: 'boolean' },
+                entry: entryUnion,
+                error: (0, content_schemas_1.ref)('PublicBulkError')
+            },
+            required: ['index', 'op', 'ok']
+        },
+        PublicBulkSaveResult: {
+            type: 'object',
+            description: '**Partial success is the contract**, not a degraded mode: items are written one transaction at a time, so the call is a 200 with per-item verdicts whether or not every item saved, and a caller retries the failures it can fix.',
+            properties: {
+                items: {
+                    type: 'array',
+                    items: (0, content_schemas_1.ref)('PublicBulkSaveItemResult')
+                },
+                created: { type: 'integer' },
+                updated: { type: 'integer' },
+                failed: { type: 'integer' }
+            },
+            required: ['items', 'created', 'updated', 'failed']
+        }
+    };
+}
+/**
+ * Every schema the public API contributes: its fixed shapes plus, per
+ * registered content type, the `Values` / `Entry` / `ListPage` trio.
+ */
+function buildPublicApiSchemas(types) {
+    const entryUnion = publicUnionOf(types.map((type) => publicSchemaNamesOf(type).entry));
+    const schemas = publicSharedSchemas(entryUnion);
+    for (const type of types) {
+        const names = publicSchemaNamesOf(type);
+        schemas[names.values] = publicValuesSchema(type);
+        schemas[names.entry] = publicEntrySchema(type, names);
+        schemas[names.listPage] = publicListPageSchema(type, names);
+    }
+    return schemas;
+}

package/dist/lib/docs/views-schemas.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The OpenAPI schemas the **saved views** plugin contributes.
+ *
+ * `SavedView` is a plain TypeScript `interface` in `views/domain/`, which the
+ * swagger scanner cannot see and ADR-0003 forbids decorating — so the shape is
+ * written out here instead, the same way the content types are.
+ *
+ * One thing about it is runtime data rather than a fixed contract: `scope` is
+ * `content:<typeName>`, and which type names exist is what the host registered.
+ * {@link buildViewsSchemas} therefore takes the serialized registry and turns
+ * the scope into an enum of the real lists, so a reader of the reference sees
+ * `content:article`, not "some string".
+ */
+import type { SerializedContentType } from '../registry/content-type-registry';
+import type { OpenApiSchema } from './field-schema';
+/** Schema name of one saved view. */
+export declare const SAVED_VIEW_SCHEMA = "SavedView";
+/** Schema name of the slice a view restores. */
+export declare const SAVED_VIEW_PAYLOAD_SCHEMA = "SavedViewPayload";
+/** The saved-view schemas, keyed by schema name. */
+export declare function buildViewsSchemas(types: readonly SerializedContentType[]): Record<string, OpenApiSchema>;
+//# sourceMappingURL=views-schemas.d.ts.map

package/dist/lib/docs/views-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"views-schemas.d.ts","sourceRoot":"","sources":["../../../src/lib/docs/views-schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAepD,qCAAqC;AACrC,eAAO,MAAM,iBAAiB,cAAc,CAAC;AAC7C,gDAAgD;AAChD,eAAO,MAAM,yBAAyB,qBAAqB,CAAC;AA8I5D,oDAAoD;AACpD,wBAAgB,iBAAiB,CAC7B,KAAK,EAAE,SAAS,qBAAqB,EAAE,GACxC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAK/B"}

package/dist/lib/docs/views-schemas.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * The OpenAPI schemas the **saved views** plugin contributes.
+ *
+ * `SavedView` is a plain TypeScript `interface` in `views/domain/`, which the
+ * swagger scanner cannot see and ADR-0003 forbids decorating — so the shape is
+ * written out here instead, the same way the content types are.
+ *
+ * One thing about it is runtime data rather than a fixed contract: `scope` is
+ * `content:<typeName>`, and which type names exist is what the host registered.
+ * {@link buildViewsSchemas} therefore takes the serialized registry and turns
+ * the scope into an enum of the real lists, so a reader of the reference sees
+ * `content:article`, not "some string".
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAVED_VIEW_PAYLOAD_SCHEMA = exports.SAVED_VIEW_SCHEMA = void 0;
+exports.buildViewsSchemas = buildViewsSchemas;
+const content_schemas_1 = require("./content-schemas");
+const saved_view_1 = require("../views/domain/saved-view");
+const views_constants_1 = require("../views/views.constants");
+const entries_constants_1 = require("../entries/entries.constants");
+/** Schema name of one saved view. */
+exports.SAVED_VIEW_SCHEMA = 'SavedView';
+/** Schema name of the slice a view restores. */
+exports.SAVED_VIEW_PAYLOAD_SCHEMA = 'SavedViewPayload';
+/**
+ * The `scope` values the API will accept and return.
+ *
+ * An enum when the host registered types, a plain bounded string when it
+ * registered none — an empty `enum` would be a schema nothing can satisfy, and
+ * "no views are reachable" is better said by the absence of types than by a
+ * response schema that rejects every answer.
+ */
+function scopeSchema(types) {
+    const base = {
+        type: 'string',
+        maxLength: views_constants_1.VIEW_SCOPE_MAX_LENGTH,
+        description: `The list this view belongs to, as \`${views_constants_1.CONTENT_SCOPE_PREFIX}<typeName>\`. A scope naming a type this workspace was not granted is a 404 — the same answer an unknown type gives, so the endpoint cannot be used to discover which types exist elsewhere.`
+    };
+    if (types.length === 0) {
+        return base;
+    }
+    return {
+        ...base,
+        enum: types.map((type) => `${views_constants_1.CONTENT_SCOPE_PREFIX}${type.name}`)
+    };
+}
+/**
+ * The stored slice.
+ *
+ * `filter` and `sort` are the records page's own `?filter=` / `?sort=` strings
+ * carried verbatim, so this describes them as the strings they are rather than
+ * re-modelling a filter tree that would then have two spellings. `search` and
+ * `page` are absent by design — see {@link SavedViewPayload}.
+ */
+function payloadSchema() {
+    return {
+        type: 'object',
+        title: 'Saved view payload',
+        description: 'The filter/sort/columns/page-size slice a view restores. Mirrors the records page’s URL params, so a saved view and a hand-edited link replay through one code path. A one-off `search` and the reading position `page` are deliberately not part of a view.',
+        properties: {
+            filter: {
+                type: 'string',
+                maxLength: entries_constants_1.FILTER_MAX_LENGTH,
+                description: 'The filter tree as a JSON string, byte-identical to `?filter=`. Stored opaquely and re-validated against the type when replayed.'
+            },
+            sort: {
+                type: 'string',
+                maxLength: 255,
+                description: 'Sort spec: a column id (ascending) or `-`-prefixed (descending).'
+            },
+            pageSize: {
+                type: 'integer',
+                minimum: 1,
+                maximum: entries_constants_1.MAX_PAGE_SIZE,
+                description: 'Rows per page this view opens with.'
+            },
+            columns: {
+                type: 'array',
+                maxItems: views_constants_1.VIEW_MAX_COLUMNS,
+                items: { type: 'string', maxLength: views_constants_1.VIEW_COLUMN_MAX_LENGTH },
+                description: 'Visible column ids **in display order**. Ids the type no longer has are dropped when the view is applied.'
+            },
+            extra: {
+                type: 'object',
+                additionalProperties: { type: 'string' },
+                description: 'Slot-contributed list params (the i18n plugin’s `locale`, and whatever a later plugin adds), as a flat string map. Opaque on purpose — the keys come from plugin-registered toolbar items at runtime.'
+            }
+        },
+        // Every field is optional: a view over an unfiltered, unsorted,
+        // default-column list stores `{}`, and that is a legitimate view.
+        additionalProperties: false
+    };
+}
+/** One saved view, as every one of these routes answers it. */
+function savedViewSchema(types) {
+    const properties = {
+        id: { type: 'string', format: 'uuid', description: 'View id.' },
+        scope: scopeSchema(types),
+        name: {
+            type: 'string',
+            minLength: 1,
+            maxLength: views_constants_1.VIEW_NAME_MAX_LENGTH,
+            description: 'Display name. Unique per person within one workspace and scope.'
+        },
+        visibility: {
+            type: 'string',
+            enum: [...saved_view_1.VIEW_VISIBILITY_VALUES],
+            description: '`private` (only its owner) or `workspace` (every member). Sharing needs `views:share`.'
+        },
+        ownerId: {
+            type: 'string',
+            format: 'uuid',
+            description: 'The user who created it.'
+        },
+        isOwn: {
+            type: 'boolean',
+            description: 'Whether the **caller** owns it. Computed per request, so the same row answers differently to two people — the admin gates Save and Delete on it.'
+        },
+        isDefault: {
+            type: 'boolean',
+            description: 'Whether it is the caller’s default for this scope. Also per-caller: a default is a personal landing choice, not a property of the view.'
+        },
+        payload: (0, content_schemas_1.ref)(exports.SAVED_VIEW_PAYLOAD_SCHEMA),
+        updatedAt: {
+            type: 'string',
+            format: 'date-time',
+            description: 'Last modified, ISO-8601.'
+        }
+    };
+    return {
+        type: 'object',
+        title: 'Saved view',
+        description: 'A named slice of one content list. The stored payload is **not** a grant: it is replayed through the ordinary list query with the reader’s own permissions, workspace scope and content grants, so a shared view shows a narrower reader fewer rows — never more.',
+        properties,
+        required: [
+            'id',
+            'scope',
+            'name',
+            'visibility',
+            'ownerId',
+            'isOwn',
+            'isDefault',
+            'payload',
+            'updatedAt'
+        ],
+        additionalProperties: false
+    };
+}
+/** The saved-view schemas, keyed by schema name. */
+function buildViewsSchemas(types) {
+    return {
+        [exports.SAVED_VIEW_PAYLOAD_SCHEMA]: payloadSchema(),
+        [exports.SAVED_VIEW_SCHEMA]: savedViewSchema(types)
+    };
+}

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

@@ -1,4 +1,4 @@
-import { OutboxWriter, UnitOfWork } from '@orthacms/database';
+import { type EventActor, 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';
@@ -11,6 +11,12 @@ import { type BulkPublishResult } from '../../types/bulk-publish';
  * `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.
+ *
+ * `actor` is stamped onto every one of those events. It used to be missing here
+ * while the single-entry publish and the bulk *delete* beside it both carried
+ * one, so publishing fifty entries from the records toolbar wrote fifty audit
+ * rows attributed to "System" — the one operation in the content lifecycle that
+ * silently lost the person who performed it.
  */
 export declare class BulkPublishEntriesUseCase {
     private readonly uow;
@@ -18,6 +24,6 @@ export declare class BulkPublishEntriesUseCase {
     private readonly writer;
     private readonly validation;
     constructor(uow: UnitOfWork, outbox: OutboxWriter, writer: EntryWriterService, validation: EntryValidationService);
-    execute(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkPublishResult>;
+    execute(type: AnyContentType, ids: string[], workspaceId: string, actor?: EventActor): 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

@@ -1 +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"}
+{"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,EAEH,KAAK,UAAU,EACf,YAAY,EACZ,UAAU,EACb,MAAM,oBAAoB,CAAC;AAE5B,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;AAIhF;;;;;;;;;;;;;;GAcG;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,EACnB,KAAK,CAAC,EAAE,UAAU,GACnB,OAAO,CAAC,iBAAiB,CAAC;CAqEhC"}

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

@@ -10,6 +10,7 @@ const entry_writer_service_1 = require("../../infrastructure/persistence/entry-w
 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");
+const entry_row_1 = require("../../infrastructure/persistence/entry-row");
 /**
  * Commit a bulk publish. Preserves the original single **locked** transaction:
  * the candidate rows are selected `FOR UPDATE` and re-validated inside one
@@ -18,6 +19,12 @@ const entry_1 = require("../../domain/entry");
  * `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.
+ *
+ * `actor` is stamped onto every one of those events. It used to be missing here
+ * while the single-entry publish and the bulk *delete* beside it both carried
+ * one, so publishing fifty entries from the records toolbar wrote fifty audit
+ * rows attributed to "System" — the one operation in the content lifecycle that
+ * silently lost the person who performed it.
  */
 let BulkPublishEntriesUseCase = class BulkPublishEntriesUseCase {
     uow;
@@ -30,7 +37,7 @@ let BulkPublishEntriesUseCase = class BulkPublishEntriesUseCase {
         this.writer = writer;
         this.validation = validation;
     }
-    async execute(type, ids, workspaceId) {
+    async execute(type, ids, workspaceId, actor) {
         if (!type.publishable) {
             throw new common_1.BadRequestException(`Content type "${type.name}" is not publishable.`);
         }
@@ -50,15 +57,23 @@ let BulkPublishEntriesUseCase = class BulkPublishEntriesUseCase {
                 for (const id of published) {
                     await this.writer.markRevisionPublished(exec, id, workspaceId);
                 }
-                await this.outbox.append(published.flatMap((id) => {
+                const events = published.flatMap((id) => {
                     const entry = entry_1.Entry.rehydrate({
                         id,
                         contentType: type.name,
-                        status: content_domain_1.ENTRY_STATUS.Draft
+                        status: content_domain_1.ENTRY_STATUS.Draft,
+                        workspaceId,
+                        // The candidate rows were already locked and loaded for
+                        // re-validation, so each row's own label is to hand.
+                        title: (() => {
+                            const row = byId.get(id);
+                            return row ? (0, entry_row_1.entryTitle)(type, row) : null;
+                        })()
                     });
                     entry.publish({ valid: true, issues: [] });
                     return entry.pullEvents();
-                }));
+                });
+                await this.outbox.append(actor ? (0, database_1.attachActor)(events, actor) : events);
             }
             const skipped = items
                 .filter((item) => item.verdict !== bulk_publish_1.BULK_VERDICT.Publishable)

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

@@ -1,4 +1,4 @@
-import { OutboxWriter, UnitOfWork } from '@orthacms/database';
+import { type EventActor, 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';
@@ -18,6 +18,6 @@ export declare class BulkUnpublishEntriesUseCase {
     private readonly outbox;
     private readonly writer;
     constructor(uow: UnitOfWork, outbox: OutboxWriter, writer: EntryWriterService);
-    execute(type: AnyContentType, ids: string[], workspaceId: string): Promise<BulkActionResult>;
+    execute(type: AnyContentType, ids: string[], workspaceId: string, actor?: EventActor): Promise<BulkActionResult>;
 }
 //# sourceMappingURL=bulk-unpublish-entries.use-case.d.ts.map