@orthacms/content-server 0.0.0-reserve.0

package/dist/lib/entries/http/dto/save-entry.dto.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveEntryDto = void 0;
+const tslib_1 = require("tslib");
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+const relation_delta_map_validator_1 = require("./relation-delta-map.validator");
+/** Longest accepted locale slug (BCP-47's practical bound). */
+const LOCALE_MAX_LENGTH = 35;
+/** OpenAPI schema of one uuid-array leg of a relation delta. */
+const UUID_ARRAY_SCHEMA = {
+    type: 'array',
+    maxItems: relation_delta_map_validator_1.MAX_DELTA_IDS,
+    items: { type: 'string', format: 'uuid' }
+};
+/**
+ * Body for `POST /api/content/:typeName` (create) and
+ * `PATCH /api/content/:typeName/:id` (update). The field `values` bag crosses the
+ * wire, plus optional per-field relation **deltas** (`relations`) — the editor
+ * stages its many-to-many / inverse link changes locally and sends them here
+ * with the rest of the document, so a save persists everything in **one
+ * transaction** without ever transmitting a huge relation whole.
+ *
+ * Reserved envelope columns (`status`/`published_at`/`deleted_at`) are owned by
+ * the service and can't be set from here: `coerceValues`/`toColumns` project
+ * only keys declared on the type, so a reserved (or otherwise unknown) key in
+ * the bag is **silently dropped** — including before validation, which runs on
+ * the coerced bag, so an unknown key is never a 422 on either kind of type.
+ * (That is what keeps an old revision snapshot restorable after its field was
+ * removed from the type.) The bag's
+ * *contents* are validated against the type's field specs by that same service
+ * (a dynamic, per-type contract class-validator can't express); the relation
+ * deltas' ids are validated as existing workspace entries by
+ * `RelationLinkService`. `values` is structurally only "an object" (its contents
+ * are the per-type contract); the `relations` bag's *shape* — each value a
+ * `{ link?, unlink?, order? }` of uuid arrays — is enforced here so a malformed
+ * delta is a clean 400, not a 500 from a bad id hitting the query.
+ */
+class SaveEntryDto {
+    /** Field values keyed by field name. */
+    values;
+    /**
+     * Per-field relation deltas (`{ <field>: { link?, unlink?, order? } }`) —
+     * many/inverse relations only; a single relation is set through `values`.
+     */
+    relations;
+    /**
+     * Locale slug the entry is created in — an **extension-owned** param this
+     * package declares but never interprets (forwarded to the bound
+     * `CONTENT_ENTRY_EXTENSION`, which validates it and stamps the envelope
+     * column). Read on create only; an update never re-homes a row's locale.
+     */
+    locale;
+    /**
+     * The existing translation group a created row joins (making it a sibling)
+     * — an **extension-owned**, opaque param, like {@link locale}. Absent → the
+     * row starts its own fresh group. The bound extension validates it against
+     * the workspace. Read on create only.
+     */
+    localeGroupId;
+}
+exports.SaveEntryDto = SaveEntryDto;
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: 'object',
+        additionalProperties: true,
+        example: { title: 'Hello world', author: null },
+        description: "Field values keyed by field name — the per-type contract, so this is structurally just an object. Contents are validated against the content type's field specs (a failure is a 422 carrying per-field issues). Reserved envelope keys (`status`, `publishedAt`, `deletedAt`, `locale`, `localeGroupId`) are not settable here."
+    }),
+    (0, class_validator_1.IsObject)(),
+    tslib_1.__metadata("design:type", Object)
+], SaveEntryDto.prototype, "values", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: 'object',
+        maxProperties: relation_delta_map_validator_1.MAX_DELTA_FIELDS,
+        additionalProperties: {
+            type: 'object',
+            properties: {
+                link: UUID_ARRAY_SCHEMA,
+                unlink: UUID_ARRAY_SCHEMA,
+                order: UUID_ARRAY_SCHEMA
+            },
+            additionalProperties: false
+        },
+        example: {
+            tags: {
+                link: ['9c4b1e77-2f0a-4d3b-8e6c-1a5f7b2d9e04'],
+                unlink: []
+            }
+        },
+        description: `Per-field relation deltas, keyed by relation field. Many-to-many and inverse relations only — a single relation is set through \`values\`, and naming one here is a 400. At most ${relation_delta_map_validator_1.MAX_DELTA_FIELDS} fields per save and ${relation_delta_map_validator_1.MAX_DELTA_IDS} ids per array; \`order\` is accepted on the owning side only.`
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsObject)(),
+    (0, relation_delta_map_validator_1.IsRelationDeltaMap)(),
+    tslib_1.__metadata("design:type", Object)
+], SaveEntryDto.prototype, "relations", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: String,
+        maxLength: LOCALE_MAX_LENGTH,
+        example: 'de',
+        description: 'Locale slug the entry is created in. Extension-owned: forwarded to the bound `CONTENT_ENTRY_EXTENSION`, which validates it and stamps the envelope column. Read on create only — an update never re-homes a row’s locale.'
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MaxLength)(LOCALE_MAX_LENGTH),
+    tslib_1.__metadata("design:type", String)
+], SaveEntryDto.prototype, "locale", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: String,
+        format: 'uuid',
+        description: 'The existing translation group a created row joins, making it a sibling. Absent → the row starts its own fresh group. Validated against the workspace by the bound extension (unknown group → 404; duplicate locale in the group → 409). Read on create only.'
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsUUID)(),
+    tslib_1.__metadata("design:type", String)
+], SaveEntryDto.prototype, "localeGroupId", void 0);

package/dist/lib/entries/http/guards/content-grant.guard.d.ts

@@ -0,0 +1,37 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { WorkspaceGrantsQuery } from '../../../content-types/queries/workspace-grants.query';
+/**
+ * Refuses a content route whose `:typeName` the **open workspace** was never
+ * granted (`workspace_content`), with the same `404` an unknown type gets.
+ *
+ * The grant set is the workspace's declared content surface: the nav renders
+ * from it, the workspace wizard writes it, and revoking a grant is refused
+ * while entries of that type still exist. Every other surface over this same
+ * content already honours it — the public REST API
+ * (`resolveGrantedType`), the GraphQL adapter, the MCP tools and the copilot's
+ * read/propose tools all resolve a type through the grants. The session-side
+ * admin API was the one exception, so a member of a workspace granted only
+ * `article` could still list, read, create, edit, publish and delete `tag`
+ * entries in it by naming the type in the URL — rows the admin then never
+ * shows (its nav is grant-driven) yet which count toward the workspace-delete
+ * guard, and which re-break the "a revoked grant never orphans records"
+ * invariant from the other side.
+ *
+ * **Unknown and ungranted are deliberately indistinguishable** — same status,
+ * same message, and the grant read happens before any registry decision — so
+ * the route carries no signal about which types exist outside the caller's
+ * workspace. That is also why this is a guard rather than a check inside each
+ * handler: it runs before the controller can leak a type-shaped error.
+ *
+ * Must be listed **after** `WorkspaceGuard`, which validates the header and
+ * attaches `request.workspaceId`. Applies only to routes carrying a
+ * `:typeName` param; a route without one is left alone (there is nothing to
+ * scope), which is why the global `/api/content-schema` catalogue keeps its own
+ * rules.
+ */
+export declare class ContentGrantGuard implements CanActivate {
+    private readonly grants;
+    constructor(grants: WorkspaceGrantsQuery);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}
+//# sourceMappingURL=content-grant.guard.d.ts.map

package/dist/lib/entries/http/guards/content-grant.guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-grant.guard.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/http/guards/content-grant.guard.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,WAAW,EACX,gBAAgB,EAGnB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,oBAAoB,EAAE,MAAM,uDAAuD,CAAC;AAK7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBACa,iBAAkB,YAAW,WAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,oBAAoB;IAEnD,WAAW,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;CAkBjE"}

package/dist/lib/entries/http/guards/content-grant.guard.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentGrantGuard = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const workspace_grants_query_1 = require("../../../content-types/queries/workspace-grants.query");
+/** The route param every registry-driven content route names its type with. */
+const TYPE_PARAM = 'typeName';
+/**
+ * Refuses a content route whose `:typeName` the **open workspace** was never
+ * granted (`workspace_content`), with the same `404` an unknown type gets.
+ *
+ * The grant set is the workspace's declared content surface: the nav renders
+ * from it, the workspace wizard writes it, and revoking a grant is refused
+ * while entries of that type still exist. Every other surface over this same
+ * content already honours it — the public REST API
+ * (`resolveGrantedType`), the GraphQL adapter, the MCP tools and the copilot's
+ * read/propose tools all resolve a type through the grants. The session-side
+ * admin API was the one exception, so a member of a workspace granted only
+ * `article` could still list, read, create, edit, publish and delete `tag`
+ * entries in it by naming the type in the URL — rows the admin then never
+ * shows (its nav is grant-driven) yet which count toward the workspace-delete
+ * guard, and which re-break the "a revoked grant never orphans records"
+ * invariant from the other side.
+ *
+ * **Unknown and ungranted are deliberately indistinguishable** — same status,
+ * same message, and the grant read happens before any registry decision — so
+ * the route carries no signal about which types exist outside the caller's
+ * workspace. That is also why this is a guard rather than a check inside each
+ * handler: it runs before the controller can leak a type-shaped error.
+ *
+ * Must be listed **after** `WorkspaceGuard`, which validates the header and
+ * attaches `request.workspaceId`. Applies only to routes carrying a
+ * `:typeName` param; a route without one is left alone (there is nothing to
+ * scope), which is why the global `/api/content-schema` catalogue keeps its own
+ * rules.
+ */
+let ContentGrantGuard = class ContentGrantGuard {
+    grants;
+    constructor(grants) {
+        this.grants = grants;
+    }
+    async canActivate(context) {
+        const request = context
+            .switchToHttp()
+            .getRequest();
+        const typeName = request.params?.[TYPE_PARAM];
+        if (!typeName)
+            return true;
+        const workspaceId = request.workspaceId;
+        if (!workspaceId) {
+            // Only reachable if the guard is wired without `WorkspaceGuard`
+            // ahead of it — refuse rather than fall open.
+            throw new common_1.NotFoundException(`Unknown content type "${typeName}".`);
+        }
+        const granted = await this.grants.grantedSlugs(workspaceId);
+        if (!granted.has(typeName)) {
+            throw new common_1.NotFoundException(`Unknown content type "${typeName}".`);
+        }
+        return true;
+    }
+};
+exports.ContentGrantGuard = ContentGrantGuard;
+exports.ContentGrantGuard = ContentGrantGuard = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [workspace_grants_query_1.WorkspaceGrantsQuery])
+], ContentGrantGuard);

package/dist/lib/entries/infrastructure/persistence/bulk-publish-verdicts.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The pure per-entry publish-verdict logic — shared by the bulk-publish **dry
+ * run** (the preview query) and the committed bulk-publish use-case so they can
+ * never disagree on what is publishable. Extracted verbatim from the original
+ * writer's `verdictsFor`/`buildChecks`; takes the validation as a function so it
+ * stays free of DI.
+ */
+import type { AnyContentType } from '../../../types/content-type';
+import type { ValidationResult } from '../../../validation/services/entry-validation.service';
+import { type BulkPublishVerdict } from '../../types/bulk-publish';
+/** A generated content row seen as a bag of values by property name. */
+type Row = Record<string, unknown>;
+/** How the caller runs value validation (the injectable service's `validate`). */
+export type ValidateEntry = (type: AnyContentType, values: Record<string, unknown>) => ValidationResult;
+/**
+ * Compute the per-entry publish verdict (will-publish / already-published /
+ * blocked / not-found) for `ids` in request order, given the live rows keyed by
+ * id and a value-validation function.
+ */
+export declare function computeBulkPublishVerdicts(type: AnyContentType, ids: string[], byId: Map<string, Row>, validate: ValidateEntry): BulkPublishVerdict[];
+export {};
+//# sourceMappingURL=bulk-publish-verdicts.d.ts.map

package/dist/lib/entries/infrastructure/persistence/bulk-publish-verdicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-publish-verdicts.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/persistence/bulk-publish-verdicts.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,6BAA6B,CAAC;AAE/E,OAAO,KAAK,EAER,gBAAgB,EACnB,MAAM,uDAAuD,CAAC;AAC/D,OAAO,EAGH,KAAK,kBAAkB,EAC1B,MAAM,0BAA0B,CAAC;AAGlC,wEAAwE;AACxE,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnC,kFAAkF;AAClF,MAAM,MAAM,aAAa,GAAG,CACxB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B,gBAAgB,CAAC;AAEtB;;;;GAIG;AACH,wBAAgB,0BAA0B,CACtC,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,MAAM,EAAE,EACb,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,EACtB,QAAQ,EAAE,aAAa,GACxB,kBAAkB,EAAE,CA0CtB"}

package/dist/lib/entries/infrastructure/persistence/bulk-publish-verdicts.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * The pure per-entry publish-verdict logic — shared by the bulk-publish **dry
+ * run** (the preview query) and the committed bulk-publish use-case so they can
+ * never disagree on what is publishable. Extracted verbatim from the original
+ * writer's `verdictsFor`/`buildChecks`; takes the validation as a function so it
+ * stays free of DI.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeBulkPublishVerdicts = computeBulkPublishVerdicts;
+const content_type_1 = require("../../../types/content-type");
+const bulk_publish_1 = require("../../types/bulk-publish");
+const entry_row_1 = require("./entry-row");
+/**
+ * Compute the per-entry publish verdict (will-publish / already-published /
+ * blocked / not-found) for `ids` in request order, given the live rows keyed by
+ * id and a value-validation function.
+ */
+function computeBulkPublishVerdicts(type, ids, byId, validate) {
+    return ids.map((id) => {
+        const row = byId.get(id);
+        if (!row) {
+            return {
+                id,
+                title: id,
+                status: null,
+                verdict: bulk_publish_1.BULK_VERDICT.NotFound,
+                issues: [],
+                checks: []
+            };
+        }
+        const title = (0, entry_row_1.entryTitle)(type, row);
+        const status = row['status'];
+        if (status === content_type_1.ENTRY_STATUS.Published) {
+            // Already published, so nothing will change — but still surface its
+            // per-field gate (an already-published row is valid, so the checks
+            // all pass) so the dialog can expand it like every other row instead
+            // of leaving it a dead, non-collapsible entry.
+            const result = validate(type, (0, entry_row_1.toRecord)(type, row).values);
+            return {
+                id,
+                title,
+                status,
+                verdict: bulk_publish_1.BULK_VERDICT.AlreadyPublished,
+                issues: [],
+                checks: buildChecks(type, result.issues)
+            };
+        }
+        const result = validate(type, (0, entry_row_1.toRecord)(type, row).values);
+        return {
+            id,
+            title,
+            status,
+            verdict: result.valid
+                ? bulk_publish_1.BULK_VERDICT.Publishable
+                : bulk_publish_1.BULK_VERDICT.Blocked,
+            issues: result.issues,
+            checks: buildChecks(type, result.issues)
+        };
+    });
+}
+/**
+ * The per-field publish-gate checklist for one record: every required field plus
+ * any field that has an issue, each marked pass/fail. Mirrors the editor's
+ * Publish Gate so a row can show its passed fields, not just the failures.
+ */
+function buildChecks(type, issues) {
+    const byField = new Map();
+    for (const issue of issues) {
+        if (!byField.has(issue.field))
+            byField.set(issue.field, issue.message);
+    }
+    return Object.entries(type.fields)
+        .filter(([name, spec]) => spec.required || byField.has(name))
+        .map(([name, spec]) => ({
+        field: name,
+        label: spec.admin.label ?? name,
+        ok: !byField.has(name),
+        message: byField.get(name)
+    }));
+}

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

@@ -0,0 +1,42 @@
+import { type Database } from '@orthacms/database';
+import type { ContentEntryCounter } from '@orthacms/workspaces-server';
+import type { ContentTypeRegistry } from '../../../registry/content-type-registry';
+/**
+ * Implements identity's {@link ContentEntryCounter} port over the generated
+ * `content_<name>` tables: counts how many entries of a content type a
+ * workspace holds. Bound to `CONTENT_ENTRY_COUNTER` in {@link ContentModule},
+ * so identity's "revoke a content-type grant only when empty" rule resolves
+ * against the real stored entries.
+ */
+export declare class EntryCounterService implements ContentEntryCounter {
+    private readonly db;
+    private readonly registry;
+    constructor(db: Database, registry: ContentTypeRegistry);
+    /**
+     * Every stored row of content type `slug` in `workspaceId`. Counts the
+     * whole workspace slice of the type's table — including soft-deleted rows
+     * for paranoid types (data that still exists must keep the grant). An
+     * unknown slug (no such content type) counts as `0`.
+     */
+    countEntries(workspaceId: string, slug: string): Promise<number>;
+    /**
+     * Every stored row the workspace holds across **all** content types —
+     * summed over each type's table. Backs the workspace-delete guard (delete is
+     * refused until this is zero). The per-type counts run concurrently.
+     *
+     * Deliberately **not** narrowed to the workspace's `workspace_content`
+     * grants, even though every read/write surface now is
+     * (`ContentGrantGuard`). This is a data-safety guard, not an access-control
+     * surface, and the two want opposite defaults: counting only granted types
+     * would let a workspace be deleted while rows of an ungranted type still
+     * sat in its slice — exactly the orphaned records the guard exists to
+     * prevent. Such rows are no longer *creatable* through the API, but a grant
+     * revoked between two deployments, or data written before the grant check
+     * landed, still has to hold the delete. Counting everything can only ever
+     * refuse a delete too often, which is the safe direction to be wrong in.
+     */
+    countWorkspaceEntries(workspaceId: string): Promise<number>;
+    /** Counts a single content type's rows in a workspace. */
+    private countTable;
+}
+//# sourceMappingURL=entry-counter.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entry-counter.service.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/persistence/entry-counter.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAMnF;;;;;;GAMG;AACH,qBACa,mBAAoB,YAAW,mBAAmB;IAErC,OAAO,CAAC,QAAQ,CAAC,EAAE;IACZ,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBADf,EAAE,EAAE,QAAQ,EACL,QAAQ,EAAE,mBAAmB;IAG3E;;;;;OAKG;IACG,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAMtE;;;;;;;;;;;;;;;OAeG;IACG,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IASjE,0DAA0D;YAC5C,UAAU;CAW3B"}

package/dist/lib/entries/infrastructure/persistence/entry-counter.service.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntryCounterService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const drizzle_orm_1 = require("drizzle-orm");
+const database_1 = require("@orthacms/database");
+const content_tokens_1 = require("../../../content.tokens");
+/**
+ * Implements identity's {@link ContentEntryCounter} port over the generated
+ * `content_<name>` tables: counts how many entries of a content type a
+ * workspace holds. Bound to `CONTENT_ENTRY_COUNTER` in {@link ContentModule},
+ * so identity's "revoke a content-type grant only when empty" rule resolves
+ * against the real stored entries.
+ */
+let EntryCounterService = class EntryCounterService {
+    db;
+    registry;
+    constructor(db, registry) {
+        this.db = db;
+        this.registry = registry;
+    }
+    /**
+     * Every stored row of content type `slug` in `workspaceId`. Counts the
+     * whole workspace slice of the type's table — including soft-deleted rows
+     * for paranoid types (data that still exists must keep the grant). An
+     * unknown slug (no such content type) counts as `0`.
+     */
+    async countEntries(workspaceId, slug) {
+        const type = this.registry.get(slug);
+        if (!type)
+            return 0;
+        return this.countTable(type, workspaceId);
+    }
+    /**
+     * Every stored row the workspace holds across **all** content types —
+     * summed over each type's table. Backs the workspace-delete guard (delete is
+     * refused until this is zero). The per-type counts run concurrently.
+     *
+     * Deliberately **not** narrowed to the workspace's `workspace_content`
+     * grants, even though every read/write surface now is
+     * (`ContentGrantGuard`). This is a data-safety guard, not an access-control
+     * surface, and the two want opposite defaults: counting only granted types
+     * would let a workspace be deleted while rows of an ungranted type still
+     * sat in its slice — exactly the orphaned records the guard exists to
+     * prevent. Such rows are no longer *creatable* through the API, but a grant
+     * revoked between two deployments, or data written before the grant check
+     * landed, still has to hold the delete. Counting everything can only ever
+     * refuse a delete too often, which is the safe direction to be wrong in.
+     */
+    async countWorkspaceEntries(workspaceId) {
+        const counts = await Promise.all(this.registry
+            .all()
+            .map((type) => this.countTable(type, workspaceId)));
+        return counts.reduce((sum, n) => sum + n, 0);
+    }
+    /** Counts a single content type's rows in a workspace. */
+    async countTable(type, workspaceId) {
+        const table = type.table;
+        const [{ total }] = await this.db
+            .select({ total: (0, drizzle_orm_1.count)() })
+            .from(type.table)
+            .where((0, drizzle_orm_1.eq)(table['workspaceId'], workspaceId));
+        return total;
+    }
+};
+exports.EntryCounterService = EntryCounterService;
+exports.EntryCounterService = EntryCounterService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, database_1.InjectDatabase)()),
+    tslib_1.__param(1, (0, content_tokens_1.InjectContentRegistry)()),
+    tslib_1.__metadata("design:paramtypes", [Object, Function])
+], EntryCounterService);

package/dist/lib/entries/infrastructure/persistence/entry-row.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Pure row ↔ entry mappers shared by the read ({@link EntriesService}) and write
+ * ({@link EntryWriterService}) paths, so the wire shape and the column projection
+ * have one definition each. No DB access, no NestJS — just shape translation.
+ */
+import type { AnyContentType } from '../../../types/content-type';
+import type { EntryRecord } from '../../types/entry-list-view';
+/** A generated content table row seen as a bag of values by property name. */
+type Row = Record<string, unknown>;
+/**
+ * Map a raw DB row to the admin {@link EntryRecord}: envelope fields plus a
+ * `values` bag keyed by field name. `status`/`publishedAt` are emitted only for
+ * publishable types. Relations that own no column — many-relations (their links live in join
+ * tables) and inverse/back-references (they reuse the owning side's storage) —
+ * aren't selected here; an owning single relation passes through as its FK uuid.
+ */
+export declare function toRecord(type: AnyContentType, row: Row): EntryRecord;
+/**
+ * Normalize the admin's (string-shaped) `values` bag to the proper JS types the
+ * validator and storage expect — numbers parsed, JSON text parsed, empties
+ * collapsed to null — keeping every field (so a many-relation array still
+ * validates). The single coercion point: both {@link toColumns} (storage) and
+ * the writer's validation run against the result, so they can't disagree on a
+ * value's type. Datetime/date stay ISO strings (the validator accepts them;
+ * {@link toColumns} converts datetime to `Date` for `timestamptz`).
+ */
+export declare function coerceValues(type: AnyContentType, values: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Project a (coerced) `values` bag onto the columns of a generated table for an
+ * insert/update. Includes only keys declared on the type (reserved envelope
+ * columns — `status`/`published_at`/`deleted_at`/timestamps — are owned by the
+ * service, never the client), skips relations that own no column (many-relations,
+ * whose links live in join tables, and inverse/back-references, which reuse the
+ * owning side's storage), collapses empties to `null`, converts a `datetime` to a `Date` for
+ * the `timestamptz` column (guarding an invalid date to `null` rather than
+ * letting `pg` throw), and drops a `NaN` number to `null`. A field absent from
+ * `values` is written as `null` — the editor submits the full bag, so a write
+ * replaces the whole document.
+ */
+export declare function toColumns(type: AnyContentType, values: Record<string, unknown>): Record<string, unknown>;
+/**
+ * A human display label for an entry — the first non-empty title-eligible field's
+ * value (see {@link TITLE_FIELD_TYPES}), falling back to the id. Used to label
+ * rows in the bulk-publish preview.
+ */
+export declare function entryTitle(type: AnyContentType, row: Row): string;
+/**
+ * The slug handle for an entry — the value of its **slug field**: the first
+ * field flagged `admin.widget === 'slug'`, else a field literally named `slug`.
+ * Returns the trimmed value when present and non-empty, otherwise `undefined`
+ * (the type has no slug field, or the row's slug is blank). Used to give a
+ * linked relation record a stable `/handle` in the admin.
+ */
+export declare function entrySlug(type: AnyContentType, row: Row): string | undefined;
+export {};
+//# sourceMappingURL=entry-row.d.ts.map

package/dist/lib/entries/infrastructure/persistence/entry-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-row.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/infrastructure/persistence/entry-row.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAElE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE/D,8EAA8E;AAC9E,KAAK,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnC;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,GAAG,GAAG,WAAW,CA6BpE;AAiBD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CACxB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgCzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACrB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA2BzB;AAWD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,CAOjE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAS5E"}