@forestadmin/agent-bff 1.15.1 → 1.17.0

package/dist/openapi/schemas.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPERATORS = exports.ConditionTreeSchema = exports.MessagelessErrorResponseSchema = exports.ErrorResponseSchema = exports.CountResponseSchema = exports.ListResponseSchema = exports.ActionRequestSchema = exports.RelationCountRequestSchema = exports.RelationListRequestSchema = exports.CountRequestSchema = exports.ListRequestSchema = void 0;
+exports.OPERATORS = exports.ParentIdSchema = exports.ConditionTreeSchema = exports.MessagelessErrorResponseSchema = exports.ErrorResponseSchema = exports.CountResponseSchema = exports.ListResponseSchema = exports.ActionRequestSchema = exports.RelationCountRequestSchema = exports.RelationListRequestSchema = exports.CountRequestSchema = exports.ListRequestSchema = exports.TimezoneSchema = exports.PageSchema = exports.SortClauseSchema = void 0;
 const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
 const zod_openapi_1 = require("./zod-openapi");
 const capabilities_validator_1 = require("../validation/capabilities-validator");
@@ -32,13 +32,13 @@ const ConditionTreeSchema = zod_openapi_1.z
         'collection capabilities; relation list and count forward the filter without either check.',
 });
 exports.ConditionTreeSchema = ConditionTreeSchema;
-const SortClauseSchema = zod_openapi_1.z
+exports.SortClauseSchema = zod_openapi_1.z
     .object({
     field: zod_openapi_1.z.string(),
     direction: zod_openapi_1.z.enum(['asc', 'desc']).optional(),
 })
     .openapi('SortClause', { description: 'Omitting `direction` sorts ascending.' });
-const PageSchema = zod_openapi_1.z
+exports.PageSchema = zod_openapi_1.z
     .object({
     limit: zod_openapi_1.z.number().int().positive(),
     offset: zod_openapi_1.z.number().int().nonnegative(),
@@ -47,7 +47,7 @@ const PageSchema = zod_openapi_1.z
     description: 'The agent paginates by page number, so `offset` must be a whole multiple of `limit`. ' +
         'Any other offset is rejected with 400 invalid_request.',
 });
-const TimezoneSchema = zod_openapi_1.z.string().openapi({
+exports.TimezoneSchema = zod_openapi_1.z.string().openapi('Timezone', {
     description: 'Used when the X-Forest-Timezone header is absent. The header wins when both are sent. A ' +
         'deployment with no configured default rejects a request carrying neither with 400 ' +
         'missing_timezone.',
@@ -56,21 +56,22 @@ exports.ListRequestSchema = zod_openapi_1.z
     .object({
     filter: ConditionTreeSchema.optional(),
     projection: zod_openapi_1.z.array(zod_openapi_1.z.string()).optional(),
-    sort: zod_openapi_1.z.array(SortClauseSchema).optional(),
-    page: PageSchema.optional(),
-    timezone: TimezoneSchema.optional(),
+    sort: zod_openapi_1.z.array(exports.SortClauseSchema).optional(),
+    page: exports.PageSchema.optional(),
+    timezone: exports.TimezoneSchema.optional(),
 })
     .openapi('ListRequest');
 exports.CountRequestSchema = zod_openapi_1.z
     .object({
     filter: ConditionTreeSchema.optional(),
-    timezone: TimezoneSchema.optional(),
+    timezone: exports.TimezoneSchema.optional(),
 })
     .openapi('CountRequest');
 const ParentIdSchema = zod_openapi_1.z.union([zod_openapi_1.z.string().regex(/\S/), zod_openapi_1.z.number()]).openapi('ParentId', {
     description: 'The parent record id, opaque: a composite or packed id must be passed unchanged. A ' +
         'blank string is rejected.',
 });
+exports.ParentIdSchema = ParentIdSchema;
 exports.RelationListRequestSchema = exports.ListRequestSchema.extend({
     parentId: ParentIdSchema,
 }).openapi('RelationListRequest', {
@@ -84,7 +85,7 @@ exports.ActionRequestSchema = zod_openapi_1.z
     .object({
     recordIds: zod_openapi_1.z.array(zod_openapi_1.z.union([zod_openapi_1.z.string(), zod_openapi_1.z.number()])),
     values: zod_openapi_1.z.record(zod_openapi_1.z.string(), zod_openapi_1.z.unknown()).optional(),
-    timezone: TimezoneSchema.optional(),
+    timezone: exports.TimezoneSchema.optional(),
 })
     .openapi('ActionRequest', {
     description: '`recordIds` is required, even on a global action: send an empty array when the action ' +
@@ -138,4 +139,4 @@ exports.MessagelessErrorResponseSchema = zod_openapi_1.z
     .openapi('MessagelessErrorResponse', {
     description: 'The unsupported-action-result body, which carries no message field unlike every other error.',
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/openapi/unfolded-document.d.ts

@@ -0,0 +1,28 @@
+import type { Unfolding } from './unfolding';
+import type { Logger } from '../ports/logger-port';
+import type ReadModel from '../read-model/read-model';
+import type ReadModelStore from '../read-model/read-model-store';
+/** Everything needed to unfold. Absent when the deployment cannot reach its schema or its agent. */
+export interface UnfoldSource {
+    store: ReadModelStore;
+    agentUrl: string;
+    timeoutMs?: number;
+    logger: Logger;
+}
+export interface UnfoldedDocument {
+    document: string;
+    /** Handed back so a caller can react to a collection that went out without its field set. */
+    unfolding: Unfolding;
+}
+export default function buildUnfoldedDocument(source: UnfoldSource, readModel: ReadModel, token: string | (() => string), version: string): Promise<UnfoldedDocument>;
+/**
+ * The CLI has no caller to borrow an agent token from, so it signs its own with the deployment's
+ * auth secret — the only thing the agent verifies, and the capabilities route it calls runs no
+ * permission check. The identity is inert on purpose: it is never used to read or write records.
+ *
+ * Minted per capabilities call rather than once: an agent token lives 5 minutes
+ * (`AGENT_TOKEN_EXPIRES_IN`) and a fan-out over hundreds of collections against a slow agent can
+ * outlive that, which would degrade the tail of the document for no reason.
+ */
+export declare function issueOpenApiAgentToken(authSecret: string): string;
+//# sourceMappingURL=unfolded-document.d.ts.map

package/dist/openapi/unfolded-document.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = buildUnfoldedDocument;
+exports.issueOpenApiAgentToken = issueOpenApiAgentToken;
+const collect_unfolding_1 = __importDefault(require("./collect-unfolding"));
+const openapi_document_1 = require("./openapi-document");
+const agent_token_1 = require("../api-key/agent-token");
+const agent_capabilities_fetcher_1 = __importDefault(require("../read-model/agent-capabilities-fetcher"));
+async function buildUnfoldedDocument(source, readModel, token, version) {
+    const unfolding = await (0, collect_unfolding_1.default)({
+        readModel,
+        store: source.store,
+        capabilitiesFetcher: (0, agent_capabilities_fetcher_1.default)({
+            agentUrl: source.agentUrl,
+            token,
+            timeoutMs: source.timeoutMs,
+        }),
+        logger: source.logger,
+    });
+    return { document: (0, openapi_document_1.serializeOpenApi)((0, openapi_document_1.generateOpenApiDocument)(version, unfolding)), unfolding };
+}
+/**
+ * The CLI has no caller to borrow an agent token from, so it signs its own with the deployment's
+ * auth secret — the only thing the agent verifies, and the capabilities route it calls runs no
+ * permission check. The identity is inert on purpose: it is never used to read or write records.
+ *
+ * Minted per capabilities call rather than once: an agent token lives 5 minutes
+ * (`AGENT_TOKEN_EXPIRES_IN`) and a fan-out over hundreds of collections against a slow agent can
+ * outlive that, which would degrade the tail of the document for no reason.
+ */
+function issueOpenApiAgentToken(authSecret) {
+    return (0, agent_token_1.issueAgentToken)({
+        authSecret,
+        identity: {
+            renderingId: 0,
+            allowedOrigins: [],
+            user: {
+                id: 0,
+                email: 'openapi@agent-bff.forestadmin.com',
+                firstName: 'Forest',
+                lastName: 'BFF',
+                team: 'Operations',
+                tags: [],
+                permissionLevel: 'admin',
+            },
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5mb2xkZWQtZG9jdW1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvb3BlbmFwaS91bmZvbGRlZC1kb2N1bWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQXdCQSx3Q0FrQkM7QUFXRCx3REFpQkM7QUFqRUQsNEVBQW1EO0FBQ25ELHlEQUErRTtBQUMvRSx3REFBeUQ7QUFDekQsMEdBQXNGO0FBZ0J2RSxLQUFLLFVBQVUscUJBQXFCLENBQ2pELE1BQW9CLEVBQ3BCLFNBQW9CLEVBQ3BCLEtBQThCLEVBQzlCLE9BQWU7SUFFZixNQUFNLFNBQVMsR0FBRyxNQUFNLElBQUEsMkJBQWdCLEVBQUM7UUFDdkMsU0FBUztRQUNULEtBQUssRUFBRSxNQUFNLENBQUMsS0FBSztRQUNuQixtQkFBbUIsRUFBRSxJQUFBLG9DQUE4QixFQUFDO1lBQ2xELFFBQVEsRUFBRSxNQUFNLENBQUMsUUFBUTtZQUN6QixLQUFLO1lBQ0wsU0FBUyxFQUFFLE1BQU0sQ0FBQyxTQUFTO1NBQzVCLENBQUM7UUFDRixNQUFNLEVBQUUsTUFBTSxDQUFDLE1BQU07S0FDdEIsQ0FBQyxDQUFDO0lBRUgsT0FBTyxFQUFFLFFBQVEsRUFBRSxJQUFBLG1DQUFnQixFQUFDLElBQUEsMENBQXVCLEVBQUMsT0FBTyxFQUFFLFNBQVMsQ0FBQyxDQUFDLEVBQUUsU0FBUyxFQUFFLENBQUM7QUFDaEcsQ0FBQztBQUVEOzs7Ozs7OztHQVFHO0FBQ0gsU0FBZ0Isc0JBQXNCLENBQUMsVUFBa0I7SUFDdkQsT0FBTyxJQUFBLDZCQUFlLEVBQUM7UUFDckIsVUFBVTtRQUNWLFFBQVEsRUFBRTtZQUNSLFdBQVcsRUFBRSxDQUFDO1lBQ2QsY0FBYyxFQUFFLEVBQUU7WUFDbEIsSUFBSSxFQUFFO2dCQUNKLEVBQUUsRUFBRSxDQUFDO2dCQUNMLEtBQUssRUFBRSxtQ0FBbUM7Z0JBQzFDLFNBQVMsRUFBRSxRQUFRO2dCQUNuQixRQUFRLEVBQUUsS0FBSztnQkFDZixJQUFJLEVBQUUsWUFBWTtnQkFDbEIsSUFBSSxFQUFFLEVBQUU7Z0JBQ1IsZUFBZSxFQUFFLE9BQU87YUFDekI7U0FDRjtLQUNGLENBQUMsQ0FBQztBQUNMLENBQUMifQ==

package/dist/openapi/unfolded-paths.d.ts

@@ -0,0 +1,20 @@
+import type ComponentPool from './component-pool';
+import type { Unfolding } from './unfolding';
+import type { z } from './zod-openapi';
+import type { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import type { ReferenceObject } from 'openapi3-ts/oas31';
+interface Deps {
+    registry: OpenAPIRegistry;
+    pool: ComponentPool;
+    prefix: string;
+    security: Record<string, string[]>[];
+    timezoneHeader: z.ZodType[];
+    errorResponses: (executeResults: boolean) => Record<string, ReferenceObject>;
+}
+/**
+ * Emits one path per exposed collection, to-many relation and action. The runtime routes stay the
+ * generic regexes — only the document unfolds.
+ */
+export default function registerUnfoldedPaths(deps: Deps, unfolding: Unfolding): void;
+export {};
+//# sourceMappingURL=unfolded-paths.d.ts.map

package/dist/openapi/unfolded-paths.js

@@ -0,0 +1,408 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = registerUnfoldedPaths;
+const field_schemas_1 = __importDefault(require("./field-schemas"));
+const names_1 = __importDefault(require("./names"));
+const schemas_1 = require("./schemas");
+const pack_id_1 = require("../data/pack-id");
+const AGGREGATORS = ['And', 'Or'];
+const DEGRADED_NOTE = {
+    capabilities_unavailable: 'The field names are NOT enumerated here: the agent could not be asked for this ' +
+        "collection's capabilities when the document was built. Any field the collection really " +
+        'exposes is still accepted.',
+    no_fields: 'The field names are NOT enumerated here: the agent reports no filterable or projectable ' +
+        'field on this collection. Any field sent in `projection`, `sort` or `filter` is therefore ' +
+        'rejected with 422 unknown_field — call this path without them.',
+};
+function quoted(name) {
+    return JSON.stringify(name);
+}
+// A name reaches the runtime through decodeURIComponent, so the document must carry it encoded —
+// including the separators that would otherwise change the route, such as a slash inside an action
+// name (`a/b` is reachable only as `a%2Fb`).
+function segment(name) {
+    return encodeURIComponent(name);
+}
+function fieldsEnum(pool, name, fields, description) {
+    // An empty enum would forbid every value, so a collection with no known field set keeps a plain
+    // string — the runtime is the one that rejects an unknown field, and it says which.
+    if (fields.length === 0)
+        return { type: 'string' };
+    return pool.add(name, { type: 'string', enum: fields, description });
+}
+/**
+ * Groups the filterable fields by the operator set they share. One leaf per field would be as exact
+ * but would multiply the document by the field count; the number of distinct operator sets is bounded
+ * by the column types a collection really uses, and the cross product of a group is precisely the set
+ * of valid `(field, operator)` pairs. The grouping is derived from what capabilities reported — two
+ * fields of DIFFERENT types sharing an operator set land in one group, so nothing here is a type
+ * table.
+ */
+function groupByOperators(filterable) {
+    const groups = new Map();
+    filterable.forEach(field => {
+        // An empty set would emit `enum: []`, which forbids every value and makes the leaf unsatisfiable —
+        // the trap `fieldsEnum` guards above. `collectFilterableFields` cannot produce one, but `Unfolding`
+        // is hand-constructible plain data, so the generator holds the invariant rather than assume it.
+        if (field.operators.length === 0)
+            return;
+        // Safe as a key because the operators are normalized to one canonical order at collect time.
+        const signature = field.operators.join(',');
+        const group = groups.get(signature);
+        if (group)
+            group.fields.push(field.name);
+        else
+            groups.set(signature, { fields: [field.name], operators: [...field.operators] });
+    });
+    return [...groups.values()];
+}
+// A node readable as BOTH a leaf and a branch is rejected with 400 (`agent-query.ts`
+// `assertNoNodeReadableAsBothLeafAndBranch`), so each alternative excludes the other's discriminator.
+// The exclusion carries the TYPE the runtime looks for — `isBranch` needs an ARRAY `conditions` and
+// `isLeaf` a STRING `field` — because `{field, operator, conditions: "x"}` is a plain leaf the runtime
+// accepts. Expressed as `not: { required }` rather than `additionalProperties: false`, which would
+// also forbid an unknown extra key the runtime strips.
+function leafShape(field, operators, description) {
+    return {
+        type: 'object',
+        description,
+        properties: {
+            field,
+            operator: { type: 'string', enum: operators },
+            value: {},
+        },
+        required: ['field', 'operator'],
+        not: { properties: { conditions: { type: 'array' } }, required: ['conditions'] },
+    };
+}
+/**
+ * One leaf alternative per operator set. A field absent from `filterable` is in none of them, which is
+ * the only honest way to document it: a `ManyToOne` answers 422 field_not_filterable, and a field the
+ * collector dropped for an unmappable operator answers 500 mapping_error on every filter.
+ */
+function filterLeaves(pool, plan) {
+    const { name, fields } = plan.collection;
+    const groups = groupByOperators(fields.filterable);
+    // No known filterable field: the field stays free-form and every operator stays allowed, because a
+    // collection whose capabilities could not be read still accepts whatever it really exposes.
+    if (groups.length === 0) {
+        return [
+            pool.add(`FilterLeaf_${plan.key}`, leafShape({ type: 'string' }, schemas_1.OPERATORS, `A single condition on ${quoted(name)}.`)),
+        ];
+    }
+    // `-` rather than `_` before the index, and the difference is load-bearing: `sanitizeIdentifier` maps
+    // every character outside `[A-Za-z0-9_]` to `_`, so a collection key can end in `_<digit>` — either
+    // because the customer named a collection `Invoice 1`, or because `createNamer` suffixed a name that
+    // collapsed. With `_`, collection `Invoice 1` (no group, so the bare name below) and collection
+    // `Invoice` (first group) both claim `FilterLeaf_Invoice_1`, and `ComponentPool.add` settles it
+    // last-wins in silence — one collection would document the other's fields and operators. Sanitizing
+    // can never produce a `-`, so this separator makes the two namespaces disjoint by construction.
+    return groups.map((group, index) => pool.add(`FilterLeaf_${plan.key}-${index + 1}`, leafShape({ type: 'string', enum: group.fields }, group.operators, `A single condition on ${quoted(name)}. These fields share one operator set, as the ` +
+        "collection's capabilities report it.")));
+}
+function filterSchema({ pool }, plan) {
+    const { name, fields } = plan.collection;
+    const treeName = `Filter_${plan.key}`;
+    const treeRef = { $ref: `#/components/schemas/${treeName}` };
+    const leaves = filterLeaves(pool, plan);
+    const pairing = fields.filterable.length > 0
+        ? ' There is one leaf alternative per operator set: a field accepts only the operators of ' +
+            'the alternative listing it, and an operator it does not support answers 400 ' +
+            'invalid_filter_operator.'
+        : '';
+    return pool.add(treeName, {
+        description: `A filter on ${quoted(name)}: either a leaf condition or a branch nesting more ` +
+            'conditions. A branch must carry its aggregator. A node carrying both `field` and ' +
+            `\`conditions\` is rejected with 400, so the two shapes are mutually exclusive.${pairing}`,
+        anyOf: [
+            ...leaves,
+            {
+                type: 'object',
+                properties: {
+                    aggregator: { type: 'string', enum: AGGREGATORS },
+                    conditions: { type: 'array', items: treeRef },
+                },
+                required: ['aggregator', 'conditions'],
+                not: { properties: { field: { type: 'string' } }, required: ['field'] },
+            },
+        ],
+    });
+}
+function fieldRefs(deps, plan) {
+    const { pool } = deps;
+    const { name, fields } = plan.collection;
+    const projectable = fieldsEnum(pool, `Fields_${plan.key}`, fields.projectable, `A field of ${quoted(name)}.`);
+    // Filterable is a strict subset of projectable: the agent reports a ManyToOne without operators, so
+    // projecting or sorting on it works while filtering on it answers 422 field_not_filterable. Which is
+    // why the filterable fields are not enumerated here but inside the filter leaves, where each one
+    // sits next to the operators it actually supports.
+    return {
+        projectable,
+        filter: filterSchema(deps, plan),
+        sort: fields.projectable.length === 0
+            ? pool.reuse('SortClause', schemas_1.SortClauseSchema)
+            : pool.add(`SortClause_${plan.key}`, {
+                type: 'object',
+                description: 'Omitting `direction` sorts ascending.',
+                properties: {
+                    field: projectable,
+                    direction: { type: 'string', enum: ['asc', 'desc'] },
+                },
+                required: ['field'],
+            }),
+    };
+}
+function requestDescription(collection, subject) {
+    const note = collection.fields.degraded ? ` ${DEGRADED_NOTE[collection.fields.degraded]}` : '';
+    return `${subject}${note}`;
+}
+function registerRequests(deps, plan) {
+    const { pool } = deps;
+    const { collection, key } = plan;
+    const refs = fieldRefs(deps, plan);
+    const timezone = pool.reuse('Timezone', schemas_1.TimezoneSchema);
+    return {
+        list: pool.add(`ListRequest_${key}`, {
+            type: 'object',
+            description: requestDescription(collection, `Filter, sort and project records of ${quoted(collection.name)}.`),
+            properties: {
+                filter: refs.filter,
+                projection: { type: 'array', items: refs.projectable },
+                sort: { type: 'array', items: refs.sort },
+                page: pool.reuse('Page', schemas_1.PageSchema),
+                timezone,
+            },
+        }),
+        count: pool.add(`CountRequest_${key}`, {
+            type: 'object',
+            description: requestDescription(collection, `Count records of ${quoted(collection.name)} matching a filter.`),
+            properties: { filter: refs.filter, timezone },
+        }),
+    };
+}
+const PARENT_ID_SHAPE = {
+    anyOf: [{ type: 'string', pattern: '\\S' }, { type: 'number' }],
+};
+/**
+ * `parentId` is opaque on the wire: `parseParentId` takes a non-blank string or a finite number
+ * whatever the key's type is, and forwards it to the agent as a string. So the SHAPE stays that
+ * union — narrowing a numeric key to `number` would make a generated client reject `"123"`, which
+ * the endpoint accepts. What the read-model knows goes in the description: which column the id
+ * belongs to, and, for a composite key, the `|`-joined order `unpackPrimaryKey` expects.
+ */
+function parentIdSchema(pool, parent, primaryKeys) {
+    if (primaryKeys.length === 0)
+        return pool.reuse('ParentId', schemas_1.ParentIdSchema);
+    if (primaryKeys.length > 1) {
+        return {
+            // A composite id only works as its packed string: a number could never carry the separator.
+            type: 'string',
+            pattern: '\\S',
+            description: `The composite id of the parent ${quoted(parent)} record: the values of ` +
+                `${primaryKeys.map(key => key.name).join(', ')} joined by ` +
+                `${quoted(pack_id_1.PACKED_ID_SEPARATOR)}, in that order.`,
+        };
+    }
+    const [key] = primaryKeys;
+    return {
+        ...PARENT_ID_SHAPE,
+        description: `The parent ${quoted(parent)} record id (${key.name}, ${key.type}). A number or its ` +
+            'string form are both accepted; the BFF forwards it to the agent as a string.',
+    };
+}
+function registerRelationRequests(deps, plan, relation, relationKey, foreign) {
+    const { pool } = deps;
+    const parentId = parentIdSchema(pool, plan.collection.name, plan.collection.primaryKeys);
+    const parentProperties = {
+        type: 'object',
+        properties: { parentId },
+        required: ['parentId'],
+    };
+    const description = `Filter, sort and projection apply to ${quoted(foreign.collection.name)}, the foreign ` +
+        `collection of ${quoted(plan.collection.name)}.${quoted(relation.name)}; the parent only ` +
+        'resolves which records are related.';
+    return {
+        list: pool.add(`RelationListRequest_${relationKey}`, {
+            description,
+            allOf: [foreign.requests.list, parentProperties],
+        }),
+        count: pool.add(`RelationCountRequest_${relationKey}`, {
+            description,
+            allOf: [foreign.requests.count, parentProperties],
+        }),
+    };
+}
+function actionFieldSchema(field) {
+    const base = field.enums
+        ? { type: 'string', enum: field.enums }
+        : (0, field_schemas_1.default)(field.type);
+    return field.isRequired
+        ? { ...base, description: 'The agent declares this field required on the static form.' }
+        : base;
+}
+function actionValuesSchema(action) {
+    return {
+        type: 'object',
+        // No property is required and no additional one is forbidden on purpose: a load or change hook
+        // rebuilds the form at call time, so the schema's static fields are an indication, not the
+        // contract — and the read-model cannot tell a hookless action from a legacy schema that simply
+        // omitted its hooks, so "static" is never certain.
+        description: 'The submitted action fields. These are the fields the schema declares statically; a load ' +
+            'or change hook can add, drop or require others at call time.',
+        properties: Object.fromEntries(action.fields.map(field => [field.name, actionFieldSchema(field)])),
+    };
+}
+function registerActionRequest(deps, plan, action, actionKey) {
+    const { pool } = deps;
+    return pool.add(`ActionRequest_${actionKey}`, {
+        type: 'object',
+        description: `The body of action ${quoted(action.name)} on ${quoted(plan.collection.name)}. ` +
+            '`recordIds` is required even on a global action: send an empty array when the action ' +
+            'targets no record.',
+        properties: {
+            recordIds: { type: 'array', items: { anyOf: [{ type: 'string' }, { type: 'number' }] } },
+            values: actionValuesSchema(action),
+            timezone: pool.reuse('Timezone', schemas_1.TimezoneSchema),
+        },
+        required: ['recordIds'],
+    });
+}
+function registerOperation(deps, options) {
+    deps.registry.registerPath({
+        method: 'post',
+        path: `${deps.prefix}/${options.path}`,
+        operationId: options.operationId,
+        summary: options.summary,
+        description: options.description,
+        security: deps.security,
+        request: {
+            headers: deps.timezoneHeader,
+            body: {
+                required: options.bodyRequired,
+                content: { 'application/json': { schema: options.request } },
+            },
+        },
+        responses: {
+            200: {
+                description: options.responseDescription,
+                content: { 'application/json': { schema: options.response } },
+            },
+            ...deps.errorResponses(options.executeResults === true),
+        },
+    });
+}
+function registerCollectionOperations(deps, plan) {
+    const { pool } = deps;
+    const { name } = plan.collection;
+    const listResponse = pool.reuse('ListResponse', schemas_1.ListResponseSchema);
+    const countResponse = pool.reuse('CountResponse', schemas_1.CountResponseSchema);
+    registerOperation(deps, {
+        path: `${segment(name)}/list`,
+        operationId: `listRecords_${plan.key}`,
+        summary: `List records of ${name}`,
+        description: `Lists records of the ${quoted(name)} collection.`,
+        request: plan.requests.list,
+        response: listResponse,
+        responseDescription: `A page of ${quoted(name)} records`,
+        bodyRequired: false,
+    });
+    registerOperation(deps, {
+        path: `${segment(name)}/count`,
+        operationId: `countRecords_${plan.key}`,
+        summary: `Count records of ${name}`,
+        description: `Counts records of the ${quoted(name)} collection.`,
+        request: plan.requests.count,
+        response: countResponse,
+        responseDescription: `The matching ${quoted(name)} record count`,
+        bodyRequired: false,
+    });
+}
+function registerRelationOperations(deps, plan, plansByName, namer) {
+    const { pool } = deps;
+    plan.collection.relations.forEach(relation => {
+        const foreign = plansByName.get(relation.foreignCollection);
+        if (!foreign)
+            return;
+        const relationKey = namer(`${plan.key}_${relation.name}`);
+        const requests = registerRelationRequests(deps, plan, relation, relationKey, foreign);
+        const parent = `${quoted(plan.collection.name)}.${quoted(relation.name)}`;
+        registerOperation(deps, {
+            path: `${segment(plan.collection.name)}/relations/${segment(relation.name)}/list`,
+            operationId: `listRelatedRecords_${relationKey}`,
+            summary: `List ${relation.name} of ${plan.collection.name}`,
+            description: `Lists the ${quoted(foreign.collection.name)} records related to a ${quoted(plan.collection.name)} record through ${parent}.`,
+            request: requests.list,
+            response: pool.reuse('ListResponse', schemas_1.ListResponseSchema),
+            responseDescription: `A page of related ${quoted(foreign.collection.name)} records`,
+            bodyRequired: true,
+        });
+        registerOperation(deps, {
+            path: `${segment(plan.collection.name)}/relations/${segment(relation.name)}/count`,
+            operationId: `countRelatedRecords_${relationKey}`,
+            summary: `Count ${relation.name} of ${plan.collection.name}`,
+            description: `Counts the ${quoted(foreign.collection.name)} records related through ${parent}.`,
+            request: requests.count,
+            response: pool.reuse('CountResponse', schemas_1.CountResponseSchema),
+            responseDescription: `The matching related ${quoted(foreign.collection.name)} record count`,
+            bodyRequired: true,
+        });
+    });
+}
+function registerActionOperations(deps, plan, namer) {
+    plan.collection.actions.forEach(action => {
+        const actionKey = namer(`${plan.key}_${action.name}`);
+        const request = registerActionRequest(deps, plan, action, actionKey);
+        // The path segment is the exact schema action name, URL-encoded — that is what the middleware
+        // decodes and looks up. The operationId is sanitized, so the exact name lives in prose.
+        const identity = `The action name is exactly ${quoted(action.name)}.`;
+        const base = `${segment(plan.collection.name)}/actions/${segment(action.name)}`;
+        registerOperation(deps, {
+            path: `${base}/form`,
+            operationId: `getActionForm_${actionKey}`,
+            summary: `Load the form of ${action.name} on ${plan.collection.name}`,
+            description: `Loads the form of the custom action. ${identity} An unknown submitted field is skipped here, not rejected.`,
+            request,
+            response: {},
+            responseDescription: 'The action form fields',
+            bodyRequired: true,
+        });
+        registerOperation(deps, {
+            path: `${base}/execute`,
+            operationId: `executeAction_${actionKey}`,
+            summary: `Execute ${action.name} on ${plan.collection.name}`,
+            description: `Executes the custom action. ${identity} A submitted field the loaded form does not carry is rejected with 400.`,
+            request,
+            response: {},
+            responseDescription: 'The normalized action result',
+            bodyRequired: true,
+            executeResults: true,
+        });
+    });
+}
+/**
+ * Emits one path per exposed collection, to-many relation and action. The runtime routes stay the
+ * generic regexes — only the document unfolds.
+ */
+function registerUnfoldedPaths(deps, unfolding) {
+    // One namer per identifier family, fed the WHOLE composed name. Deduplicating each segment on its
+    // own would not be enough: sanitizing produces `_`, which is also the separator, so collection
+    // `A_B` with action `C` and collection `A` with action `B_C` both compose `A_B_C` — one action
+    // would then get the other's request schema.
+    const collections = (0, names_1.default)();
+    const relations = (0, names_1.default)();
+    const actions = (0, names_1.default)();
+    const plans = unfolding.collections.map(collection => {
+        const key = collections(collection.name);
+        return { collection, key, requests: registerRequests(deps, { collection, key }) };
+    });
+    const plansByName = new Map(plans.map(plan => [plan.collection.name, plan]));
+    plans.forEach(plan => {
+        registerCollectionOperations(deps, plan);
+        registerRelationOperations(deps, plan, plansByName, relations);
+        registerActionOperations(deps, plan, actions);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unfolded-paths.js","sourceRoot":"","sources":["../../src/openapi/unfolded-paths.ts"],"names":[],"mappings":"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"}