@orthacms/content-server 0.0.0-reserve.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"update-entry.controller.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/http/controllers/update-entry.controller.ts"],"names":[],"mappings":"AAQA,OAAO,EAKH,KAAK,UAAU,EAElB,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uDAAuD,CAAC;AAC3F,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAI/D;;;;;;GAMG;AACH,qBAGa,qBAAqB;IAG1B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB;IAI/C,MAAM,CACiB,QAAQ,EAAE,MAAM,EACP,EAAE,EAAE,MAAM,EAC9B,IAAI,EAAE,YAAY,EACN,WAAW,EAAE,MAAM,EACxB,IAAI,CAAC,EAAE,UAAU,GACjC,OAAO,CAAC,WAAW,CAAC;CAW1B"}

package/dist/lib/entries/http/controllers/update-entry.controller.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateEntryController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const identity_server_1 = require("@orthacms/identity-server");
+const workspaces_server_1 = require("@orthacms/workspaces-server");
+const content_grant_guard_1 = require("../guards/content-grant.guard");
+const content_tokens_1 = require("../../../content.tokens");
+const entry_writer_service_1 = require("../../infrastructure/persistence/entry-writer.service");
+const save_entry_dto_1 = require("../dto/save-entry.dto");
+const resolve_type_1 = require("./resolve-type");
+const to_actor_1 = require("./to-actor");
+/**
+ * `PATCH /api/content/:typeName/:id` — replace a live entry's values with a
+ * validated bag (the editor always submits the full document). 404 if there's no
+ * live row; 422 with the issue list on validation failure. `OriginGuard` defends
+ * this state-changing write; `WorkspaceGuard` scopes it to a workspace the caller
+ * belongs to; `content:update` gates it.
+ */
+let UpdateEntryController = class UpdateEntryController {
+    registry;
+    writer;
+    constructor(registry, writer) {
+        this.registry = registry;
+        this.writer = writer;
+    }
+    update(typeName, id, body, workspaceId, user) {
+        const type = (0, resolve_type_1.resolveType)(this.registry, typeName);
+        return this.writer.update(type, id, body.values, workspaceId, body.relations, (0, to_actor_1.toActor)(user));
+    }
+};
+exports.UpdateEntryController = UpdateEntryController;
+tslib_1.__decorate([
+    (0, common_1.Patch)(':typeName/:id'),
+    tslib_1.__param(0, (0, common_1.Param)('typeName')),
+    tslib_1.__param(1, (0, common_1.Param)('id', common_1.ParseUUIDPipe)),
+    tslib_1.__param(2, (0, common_1.Body)()),
+    tslib_1.__param(3, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__param(4, (0, identity_server_1.CurrentUser)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, String, save_entry_dto_1.SaveEntryDto, String, Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], UpdateEntryController.prototype, "update", null);
+exports.UpdateEntryController = UpdateEntryController = tslib_1.__decorate([
+    (0, common_1.UseGuards)(identity_server_1.OriginGuard, identity_server_1.PermissionsGuard, workspaces_server_1.WorkspaceGuard, content_grant_guard_1.ContentGrantGuard),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.CONTENT_UPDATE),
+    (0, common_1.Controller)('content'),
+    tslib_1.__param(0, (0, content_tokens_1.InjectContentRegistry)()),
+    tslib_1.__metadata("design:paramtypes", [Function, entry_writer_service_1.EntryWriterService])
+], UpdateEntryController);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-ids.dto.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/http/dto/bulk-ids.dto.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,qBAAa,UAAU;IACnB,2BAA2B;IAa3B,GAAG,EAAG,MAAM,EAAE,CAAC;CAClB"}

package/dist/lib/entries/http/dto/bulk-ids.dto.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkIdsDto = void 0;
+const tslib_1 = require("tslib");
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+const entries_constants_1 = require("../../entries.constants");
+/**
+ * Body for the bulk endpoints (`/bulk/publish`, `/bulk/unpublish`,
+ * `/bulk/delete`, `/bulk/restore`, and the publish dry run): the set of entry
+ * ids to act on. Non-empty, uuid-typed, and capped at {@link BULK_MAX_IDS} so a
+ * single request can't fan out unbounded work.
+ */
+class BulkIdsDto {
+    /** Entry ids to act on. */
+    ids;
+}
+exports.BulkIdsDto = BulkIdsDto;
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: [String],
+        format: 'uuid',
+        minItems: 1,
+        maxItems: entries_constants_1.BULK_MAX_IDS,
+        example: ['3f1a7c1e-9d2b-4a6f-8c11-5b8e2f0d7a91'],
+        description: `Entry ids to act on — v4 uuids, non-empty and capped at ${entries_constants_1.BULK_MAX_IDS} so one request can't fan out unbounded work.`
+    }),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.ArrayNotEmpty)(),
+    (0, class_validator_1.ArrayMaxSize)(entries_constants_1.BULK_MAX_IDS),
+    (0, class_validator_1.IsUUID)('4', { each: true }),
+    tslib_1.__metadata("design:type", Array)
+], BulkIdsDto.prototype, "ids", void 0);

package/dist/lib/entries/http/dto/list-entries-query.dto.d.ts

@@ -0,0 +1,66 @@
+/** `?deleted=only` flips the list to the trash view (soft-deleted rows). */
+export declare const DELETED_ONLY = "only";
+/**
+ * `?relations=preview` opts the list into a capped relation preview per row.
+ * Opt-in because the relation **picker** reuses this endpoint to list candidates
+ * — it would otherwise pay for relation expansion on every keystroke.
+ */
+export declare const RELATIONS_PREVIEW = "preview";
+/**
+ * Query parameters for `GET /api/content/:typeName`. Pagination is 1-based; the
+ * service applies the defaults (page 1, {@link DEFAULT_PAGE_SIZE}) so the
+ * contract has one source of truth. `@Type` coerces the raw query strings — the
+ * host's global `ValidationPipe` transforms but does not implicitly convert.
+ */
+export declare class ListEntriesQueryDto {
+    /** Free-text search across the type's text-like columns (text/richtext/select). */
+    search?: string;
+    /**
+     * Structured filter tree as a JSON string (`?filter=<json>`), produced by
+     * the admin query builder and validated against the type's derived filter
+     * schema by `parseFilterTree`. Length-capped here as a first line of
+     * defence; the engine's node/depth caps bound the parsed shape.
+     */
+    filter?: string;
+    /** Sort spec: a column id (ascending) or `-`-prefixed (descending). */
+    sort?: string;
+    /** 1-based page number. */
+    page?: number;
+    /** Rows per page, capped at {@link MAX_PAGE_SIZE}. */
+    pageSize?: number;
+    /**
+     * `only` lists soft-deleted rows (the trash view) instead of live ones.
+     * Meaningful only for paranoid types; ignored otherwise. Absent (the
+     * default) lists live rows.
+     */
+    deleted?: typeof DELETED_ONLY;
+    /**
+     * `preview` includes a capped {@link RELATIONS_PREVIEW} of each requested
+     * relation field's links on every row. Absent (the default) returns no
+     * relation data, exactly as before.
+     */
+    relations?: typeof RELATIONS_PREVIEW;
+    /**
+     * Comma-separated relation field names to preview — the table's **visible**
+     * relation columns, so a hidden column costs nothing. Ignored without
+     * `?relations=preview`. Names are matched against the type's own relation
+     * fields and anything unknown is dropped, so the raw string never reaches a
+     * query.
+     */
+    relationFields?: string;
+    /**
+     * Locale slug the list targets — an **extension-owned** param this package
+     * declares (the strict ValidationPipe rejects undeclared keys) but never
+     * interprets: it's forwarded to the bound `CONTENT_ENTRY_EXTENSION`, which
+     * validates and applies it. Ignored when no extension is bound or the type
+     * isn't localized.
+     */
+    locale?: string;
+    /**
+     * `default` widens the locale scope to fall back to the default locale
+     * where the requested one is missing (the relation picker's mode).
+     * Extension-owned, like {@link locale}.
+     */
+    localeFallback?: string;
+}
+//# sourceMappingURL=list-entries-query.dto.d.ts.map

package/dist/lib/entries/http/dto/list-entries-query.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-entries-query.dto.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/http/dto/list-entries-query.dto.ts"],"names":[],"mappings":"AAiBA,4EAA4E;AAC5E,eAAO,MAAM,YAAY,SAAS,CAAC;AAEnC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,YAAY,CAAC;AAQ3C;;;;;GAKG;AACH,qBAAa,mBAAmB;IAC5B,mFAAmF;IAUnF,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;OAKG;IAYH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,uEAAuE;IAWvE,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,2BAA2B;IAW3B,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,sDAAsD;IAatD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IAQH,OAAO,CAAC,EAAE,OAAO,YAAY,CAAC;IAE9B;;;;OAIG;IAQH,SAAS,CAAC,EAAE,OAAO,iBAAiB,CAAC;IAErC;;;;;;OAMG;IAWH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;;;OAMG;IAWH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;IAQH,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B"}

package/dist/lib/entries/http/dto/list-entries-query.dto.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListEntriesQueryDto = exports.RELATIONS_PREVIEW = exports.DELETED_ONLY = void 0;
+const tslib_1 = require("tslib");
+const swagger_1 = require("@nestjs/swagger");
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const entries_constants_1 = require("../../entries.constants");
+/** `?deleted=only` flips the list to the trash view (soft-deleted rows). */
+exports.DELETED_ONLY = 'only';
+/**
+ * `?relations=preview` opts the list into a capped relation preview per row.
+ * Opt-in because the relation **picker** reuses this endpoint to list candidates
+ * — it would otherwise pay for relation expansion on every keystroke.
+ */
+exports.RELATIONS_PREVIEW = 'preview';
+/** Upper bound on the `?relationFields=` list (a comma-separated field list). */
+const RELATION_FIELDS_MAX_LENGTH = 1024;
+/** Longest accepted locale slug (BCP-47's practical bound). */
+const LOCALE_MAX_LENGTH = 35;
+/**
+ * Query parameters for `GET /api/content/:typeName`. Pagination is 1-based; the
+ * service applies the defaults (page 1, {@link DEFAULT_PAGE_SIZE}) so the
+ * contract has one source of truth. `@Type` coerces the raw query strings — the
+ * host's global `ValidationPipe` transforms but does not implicitly convert.
+ */
+class ListEntriesQueryDto {
+    /** Free-text search across the type's text-like columns (text/richtext/select). */
+    search;
+    /**
+     * Structured filter tree as a JSON string (`?filter=<json>`), produced by
+     * the admin query builder and validated against the type's derived filter
+     * schema by `parseFilterTree`. Length-capped here as a first line of
+     * defence; the engine's node/depth caps bound the parsed shape.
+     */
+    filter;
+    /** Sort spec: a column id (ascending) or `-`-prefixed (descending). */
+    sort;
+    /** 1-based page number. */
+    page;
+    /** Rows per page, capped at {@link MAX_PAGE_SIZE}. */
+    pageSize;
+    /**
+     * `only` lists soft-deleted rows (the trash view) instead of live ones.
+     * Meaningful only for paranoid types; ignored otherwise. Absent (the
+     * default) lists live rows.
+     */
+    deleted;
+    /**
+     * `preview` includes a capped {@link RELATIONS_PREVIEW} of each requested
+     * relation field's links on every row. Absent (the default) returns no
+     * relation data, exactly as before.
+     */
+    relations;
+    /**
+     * Comma-separated relation field names to preview — the table's **visible**
+     * relation columns, so a hidden column costs nothing. Ignored without
+     * `?relations=preview`. Names are matched against the type's own relation
+     * fields and anything unknown is dropped, so the raw string never reaches a
+     * query.
+     */
+    relationFields;
+    /**
+     * Locale slug the list targets — an **extension-owned** param this package
+     * declares (the strict ValidationPipe rejects undeclared keys) but never
+     * interprets: it's forwarded to the bound `CONTENT_ENTRY_EXTENSION`, which
+     * validates and applies it. Ignored when no extension is bound or the type
+     * isn't localized.
+     */
+    locale;
+    /**
+     * `default` widens the locale scope to fall back to the default locale
+     * where the requested one is missing (the relation picker's mode).
+     * Extension-owned, like {@link locale}.
+     */
+    localeFallback;
+}
+exports.ListEntriesQueryDto = ListEntriesQueryDto;
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: String,
+        maxLength: 255,
+        description: "Free-text ILIKE search across the type's text-like columns (text/richtext/select)."
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MaxLength)(255),
+    tslib_1.__metadata("design:type", String)
+], ListEntriesQueryDto.prototype, "search", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: String,
+        maxLength: entries_constants_1.FILTER_MAX_LENGTH,
+        example: '{"op":"and","rules":[{"field":"author.name","op":"eq","value":"Ada"}]}',
+        description: "Structured filter tree as a JSON string, validated against the type's derived filter schema (relation paths included). Malformed → 400."
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MaxLength)(entries_constants_1.FILTER_MAX_LENGTH),
+    tslib_1.__metadata("design:type", String)
+], ListEntriesQueryDto.prototype, "filter", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: String,
+        maxLength: 255,
+        example: '-updatedAt',
+        description: 'Sort spec: a whitelisted column id (ascending) or `-`-prefixed (descending). `id` is always the tiebreaker.'
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MaxLength)(255),
+    tslib_1.__metadata("design:type", String)
+], ListEntriesQueryDto.prototype, "sort", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: 'integer',
+        minimum: 1,
+        default: 1,
+        description: '1-based page number.'
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_transformer_1.Type)(() => Number),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(1),
+    tslib_1.__metadata("design:type", Number)
+], ListEntriesQueryDto.prototype, "page", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: 'integer',
+        minimum: 1,
+        maximum: entries_constants_1.MAX_PAGE_SIZE,
+        default: entries_constants_1.DEFAULT_PAGE_SIZE,
+        description: `Rows per page, capped at ${entries_constants_1.MAX_PAGE_SIZE}.`
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_transformer_1.Type)(() => Number),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.Max)(entries_constants_1.MAX_PAGE_SIZE),
+    tslib_1.__metadata("design:type", Number)
+], ListEntriesQueryDto.prototype, "pageSize", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        enum: [exports.DELETED_ONLY],
+        description: '`only` lists soft-deleted rows (the trash view) instead of live ones. Meaningful only for paranoid types; absent lists live rows.'
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsIn)([exports.DELETED_ONLY]),
+    tslib_1.__metadata("design:type", Object)
+], ListEntriesQueryDto.prototype, "deleted", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        enum: [exports.RELATIONS_PREVIEW],
+        description: "`preview` adds a capped page of each requested relation field's links to every row. Opt-in: absent returns no relation data."
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsIn)([exports.RELATIONS_PREVIEW]),
+    tslib_1.__metadata("design:type", Object)
+], ListEntriesQueryDto.prototype, "relations", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: String,
+        maxLength: RELATION_FIELDS_MAX_LENGTH,
+        example: 'author,tags',
+        description: 'Comma-separated relation field names to preview. Ignored without `?relations=preview`; unknown names are dropped.'
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MaxLength)(RELATION_FIELDS_MAX_LENGTH),
+    tslib_1.__metadata("design:type", String)
+], ListEntriesQueryDto.prototype, "relationFields", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        type: String,
+        maxLength: LOCALE_MAX_LENGTH,
+        example: 'en',
+        description: "Locale slug the list targets. Extension-owned: forwarded verbatim to the bound `CONTENT_ENTRY_EXTENSION`, which validates it (unknown → 400). Ignored when no extension is bound or the type isn't localized."
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MaxLength)(LOCALE_MAX_LENGTH),
+    tslib_1.__metadata("design:type", String)
+], ListEntriesQueryDto.prototype, "locale", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        enum: ['default'],
+        description: '`default` widens the locale scope to fall back to the default locale where the requested one is missing (the relation picker’s mode).'
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsIn)(['default']),
+    tslib_1.__metadata("design:type", String)
+], ListEntriesQueryDto.prototype, "localeFallback", void 0);

package/dist/lib/entries/http/dto/relation-delta-map.validator.d.ts

@@ -0,0 +1,30 @@
+import { type ValidationOptions, type ValidatorConstraintInterface } from 'class-validator';
+/**
+ * Max ids in any one `link`/`unlink`/`order` array. The read side is already
+ * clamped (`pageSize ≤ MAX_PAGE_SIZE`); this bounds the write side so a single
+ * save can't carry an unbounded id array — which would fan out into a huge
+ * `inArray(...)` probe or a one-`WHEN`-per-id `CASE` reorder. Generous enough
+ * for a realistic drag-reorder of a scrolled-open relation, finite enough to
+ * reject a pathological payload.
+ */
+export declare const MAX_DELTA_IDS = 1000;
+/** Max relation fields one save may touch (a bound on the map's key count). */
+export declare const MAX_DELTA_FIELDS = 100;
+/**
+ * Validates the `relations` bag of {@link SaveEntryDto}: a map from field name to
+ * `{ link?, unlink?, order? }`, each an array of uuid strings. class-validator
+ * can't decorate a `Record`'s dynamic keys, so this constraint checks the shape
+ * of every value — turning a malformed delta (a non-array `unlink`, a non-uuid
+ * id, an unknown inner key, or an over-large array) into a clean **400** instead
+ * of letting it reach `inArray(...)` against a `uuid` column and surface as a
+ * 500. Unknown inner keys are rejected so the nested `Record` can't slip past
+ * the app's `forbidNonWhitelisted` posture, and the id arrays and the map itself
+ * are size-bounded so a single request can't carry an unbounded payload.
+ */
+export declare class RelationDeltaMapConstraint implements ValidatorConstraintInterface {
+    validate(value: unknown): boolean;
+    defaultMessage(): string;
+}
+/** Property decorator applying {@link RelationDeltaMapConstraint}. */
+export declare function IsRelationDeltaMap(options?: ValidationOptions): (object: object, propertyName: string) => void;
+//# sourceMappingURL=relation-delta-map.validator.d.ts.map

package/dist/lib/entries/http/dto/relation-delta-map.validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relation-delta-map.validator.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/http/dto/relation-delta-map.validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,iBAAiB,EACtB,KAAK,4BAA4B,EACpC,MAAM,iBAAiB,CAAC;AAezB;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC,+EAA+E;AAC/E,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAepC;;;;;;;;;;GAUG;AACH,qBACa,0BACT,YAAW,4BAA4B;IAEvC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IA6CjC,cAAc,IAAI,MAAM;CAO3B;AAED,sEAAsE;AACtE,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,iBAAiB,IAClD,QAAQ,MAAM,EAAE,cAAc,MAAM,KAAG,IAAI,CAOtD"}

package/dist/lib/entries/http/dto/relation-delta-map.validator.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationDeltaMapConstraint = exports.MAX_DELTA_FIELDS = exports.MAX_DELTA_IDS = void 0;
+exports.IsRelationDeltaMap = IsRelationDeltaMap;
+const tslib_1 = require("tslib");
+const class_validator_1 = require("class-validator");
+/** RFC-4122 uuid (any version), matched case-insensitively. */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+/** The only keys a per-field delta may carry. */
+const DELTA_KEYS = ['link', 'unlink', 'order', 'set', 'by'];
+/** The array keys — a join-backed relation's change set. */
+const LINK_KEYS = ['link', 'unlink', 'order'];
+/** Accepted values of the delta's `by` key. @see RelationDelta.by */
+const ADDRESSING = ['id', 'localeGroup'];
+/**
+ * Max ids in any one `link`/`unlink`/`order` array. The read side is already
+ * clamped (`pageSize ≤ MAX_PAGE_SIZE`); this bounds the write side so a single
+ * save can't carry an unbounded id array — which would fan out into a huge
+ * `inArray(...)` probe or a one-`WHEN`-per-id `CASE` reorder. Generous enough
+ * for a realistic drag-reorder of a scrolled-open relation, finite enough to
+ * reject a pathological payload.
+ */
+exports.MAX_DELTA_IDS = 1000;
+/** Max relation fields one save may touch (a bound on the map's key count). */
+exports.MAX_DELTA_FIELDS = 100;
+/**
+ * A key is valid when absent or an array of at most {@link MAX_DELTA_IDS} uuid
+ * strings.
+ */
+function isUuidArray(value) {
+    return (value === undefined ||
+        (Array.isArray(value) &&
+            value.length <= exports.MAX_DELTA_IDS &&
+            value.every((id) => typeof id === 'string' && UUID_RE.test(id))));
+}
+/**
+ * Validates the `relations` bag of {@link SaveEntryDto}: a map from field name to
+ * `{ link?, unlink?, order? }`, each an array of uuid strings. class-validator
+ * can't decorate a `Record`'s dynamic keys, so this constraint checks the shape
+ * of every value — turning a malformed delta (a non-array `unlink`, a non-uuid
+ * id, an unknown inner key, or an over-large array) into a clean **400** instead
+ * of letting it reach `inArray(...)` against a `uuid` column and surface as a
+ * 500. Unknown inner keys are rejected so the nested `Record` can't slip past
+ * the app's `forbidNonWhitelisted` posture, and the id arrays and the map itself
+ * are size-bounded so a single request can't carry an unbounded payload.
+ */
+let RelationDeltaMapConstraint = class RelationDeltaMapConstraint {
+    validate(value) {
+        if (value === null || typeof value !== 'object')
+            return false;
+        const entries = Object.entries(value);
+        if (entries.length > exports.MAX_DELTA_FIELDS)
+            return false;
+        return entries.every(([, delta]) => {
+            if (delta === null || typeof delta !== 'object')
+                return false;
+            const record = delta;
+            // Reject any key beyond link/unlink/order — the nested Record isn't
+            // reached by the global whitelist pipe, so enforce it here.
+            if (Object.keys(record).some((key) => !DELTA_KEYS.includes(key)))
+                return false;
+            const by = record['by'];
+            if (by !== undefined &&
+                !ADDRESSING.includes(by))
+                return false;
+            // `set` targets an owning single relation; the arrays target a
+            // join-backed one. A field is one or the other, so mixing them is a
+            // contradiction rather than a merge — reject it here instead of
+            // silently honouring one.
+            const hasSet = record['set'] !== undefined;
+            const hasLinks = LINK_KEYS.some((key) => record[key] !== undefined);
+            if (hasSet && hasLinks)
+                return false;
+            if (hasSet &&
+                record['set'] !== null &&
+                !(typeof record['set'] === 'string' &&
+                    UUID_RE.test(record['set'])))
+                return false;
+            return (isUuidArray(record['link']) &&
+                isUuidArray(record['unlink']) &&
+                isUuidArray(record['order']));
+        });
+    }
+    defaultMessage() {
+        return ('relations must map each field to { link?, unlink?, order? } arrays of uuids ' +
+            '(join-backed relations) or { set } with a uuid or null (a single relation), ' +
+            `each with an optional by: ${ADDRESSING.join(' | ')}`);
+    }
+};
+exports.RelationDeltaMapConstraint = RelationDeltaMapConstraint;
+exports.RelationDeltaMapConstraint = RelationDeltaMapConstraint = tslib_1.__decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'relationDeltaMap' })
+], RelationDeltaMapConstraint);
+/** Property decorator applying {@link RelationDeltaMapConstraint}. */
+function IsRelationDeltaMap(options) {
+    return (object, propertyName) => (0, class_validator_1.registerDecorator)({
+        target: object.constructor,
+        propertyName,
+        options,
+        validator: RelationDeltaMapConstraint
+    });
+}

package/dist/lib/entries/http/dto/save-entry.dto.d.ts

@@ -0,0 +1,48 @@
+import type { RelationDelta } from '../../types/entry-list-view';
+/**
+ * Body for `POST /api/content/:typeName` (create) and
+ * `PATCH /api/content/:typeName/:id` (update). The field `values` bag crosses the
+ * wire, plus optional per-field relation **deltas** (`relations`) — the editor
+ * stages its many-to-many / inverse link changes locally and sends them here
+ * with the rest of the document, so a save persists everything in **one
+ * transaction** without ever transmitting a huge relation whole.
+ *
+ * Reserved envelope columns (`status`/`published_at`/`deleted_at`) are owned by
+ * the service and can't be set from here: `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.
+ */
+export declare class SaveEntryDto {
+    /** Field values keyed by field name. */
+    values: Record<string, unknown>;
+    /**
+     * Per-field relation deltas (`{ <field>: { link?, unlink?, order? } }`) —
+     * many/inverse relations only; a single relation is set through `values`.
+     */
+    relations?: Record<string, RelationDelta>;
+    /**
+     * Locale slug the entry is created in — an **extension-owned** param this
+     * package declares but never interprets (forwarded to the bound
+     * `CONTENT_ENTRY_EXTENSION`, which validates it and stamps the envelope
+     * column). Read on create only; an update never re-homes a row's locale.
+     */
+    locale?: string;
+    /**
+     * The existing translation group a created row joins (making it a sibling)
+     * — an **extension-owned**, opaque param, like {@link locale}. Absent → the
+     * row starts its own fresh group. The bound extension validates it against
+     * the workspace. Read on create only.
+     */
+    localeGroupId?: string;
+}
+//# sourceMappingURL=save-entry.dto.d.ts.map

package/dist/lib/entries/http/dto/save-entry.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"save-entry.dto.d.ts","sourceRoot":"","sources":["../../../../../src/lib/entries/http/dto/save-entry.dto.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAiBjE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,YAAY;IACrB,wCAAwC;IASxC,MAAM,EAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEjC;;;OAGG;IAwBH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAE1C;;;;;OAKG;IAWH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;OAKG;IASH,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B"}