@forestadmin/agent-bff 1.16.0 → 1.18.0

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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"}

package/dist/openapi/unfolding.d.ts

@@ -0,0 +1,66 @@
+import type { FieldType } from '../read-model/capabilities-cache';
+import type { PrimaryKeyField } from '../read-model/read-model';
+import type { Operator } from '@forestadmin/datasource-toolkit';
+/**
+ * The snapshot the OpenAPI generator unfolds. It is plain data on purpose: collecting it hits the
+ * network (schema + capabilities per collection), generating from it does not, so the route and the
+ * CLI can be proven to emit the same document by feeding them one snapshot.
+ */
+export interface Unfolding {
+    collections: UnfoldedCollection[];
+}
+export interface UnfoldedCollection {
+    name: string;
+    fields: CollectionFields;
+    primaryKeys: PrimaryKeyField[];
+    /** To-many relations whose foreign collection is exposed too — the only ones with a route. */
+    relations: UnfoldedRelation[];
+    actions: UnfoldedAction[];
+}
+export interface UnfoldedRelation {
+    name: string;
+    foreignCollection: string;
+}
+/**
+ * `projectable` is every capability field; `filterable` is the subset carrying operators. They
+ * differ: a `ManyToOne` is reported by the agent without operators, so projecting or sorting on it
+ * works while filtering on it answers 422 field_not_filterable.
+ *
+ * `degraded` is set when the field set could not be established. The collection keeps its paths, but
+ * their field schemas stay free-form strings — an empty enum would forbid every valid call.
+ */
+export interface CollectionFields {
+    projectable: string[];
+    filterable: FilterableField[];
+    degraded: DegradedReason | null;
+}
+/**
+ * A field the agent reports at least one operator for, with that operator set — the very set the
+ * runtime validates a filter leaf against. Normalized to canonical PascalCase and to the
+ * `allOperators` order at collect time, so the same capabilities answer always yields the same
+ * document whatever order the agent serialized the operators in.
+ */
+export interface FilterableField {
+    name: string;
+    operators: Operator[];
+}
+export type DegradedReason = 'capabilities_unavailable' | 'no_fields';
+/** True when at least one collection went out without its field set. */
+export declare function hasDegradedCollection(unfolding: Unfolding): boolean;
+/**
+ * True when NO collection got its field set — the signature of an unreachable agent rather than of
+ * one odd collection. An empty schema is not degraded: there was nothing to enumerate.
+ */
+export declare function isFullyDegraded(unfolding: Unfolding): boolean;
+export interface UnfoldedAction {
+    name: string;
+    fields: UnfoldedActionField[];
+}
+export interface UnfoldedActionField {
+    name: string;
+    type: FieldType;
+    isRequired: boolean;
+    enums: string[] | null;
+}
+export type { FieldType };
+//# sourceMappingURL=unfolding.d.ts.map

package/dist/openapi/unfolding.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDegradedCollection = hasDegradedCollection;
+exports.isFullyDegraded = isFullyDegraded;
+/** True when at least one collection went out without its field set. */
+function hasDegradedCollection(unfolding) {
+    return unfolding.collections.some(collection => collection.fields.degraded !== null);
+}
+/**
+ * True when NO collection got its field set — the signature of an unreachable agent rather than of
+ * one odd collection. An empty schema is not degraded: there was nothing to enumerate.
+ */
+function isFullyDegraded(unfolding) {
+    return (unfolding.collections.length > 0 &&
+        unfolding.collections.every(collection => collection.fields.degraded !== null));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5mb2xkaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL29wZW5hcGkvdW5mb2xkaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBdURBLHNEQUVDO0FBTUQsMENBS0M7QUFkRCx3RUFBd0U7QUFDeEUsU0FBZ0IscUJBQXFCLENBQUMsU0FBb0I7SUFDeEQsT0FBTyxTQUFTLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsUUFBUSxLQUFLLElBQUksQ0FBQyxDQUFDO0FBQ3ZGLENBQUM7QUFFRDs7O0dBR0c7QUFDSCxTQUFnQixlQUFlLENBQUMsU0FBb0I7SUFDbEQsT0FBTyxDQUNMLFNBQVMsQ0FBQyxXQUFXLENBQUMsTUFBTSxHQUFHLENBQUM7UUFDaEMsU0FBUyxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLFFBQVEsS0FBSyxJQUFJLENBQUMsQ0FDL0UsQ0FBQztBQUNKLENBQUMifQ==

package/dist/read-model/agent-capabilities-fetcher.d.ts

@@ -1,12 +1,17 @@
 import type { CapabilitiesFetcher } from './capabilities-cache';
 export interface AgentCapabilitiesFetcherOptions {
     agentUrl: string;
-    token: string;
+    /** A borrowed request token, or a factory when the caller can mint one per fetch. */
+    token: string | (() => string);
     timeoutMs?: number;
 }
 /**
- * Builds a capabilities fetcher bound to a request's agent token. The cache calls it only on a
- * miss, so the token of whichever request first populates a collection is the one used.
+ * Builds a capabilities fetcher bound to an agent token. The cache calls it only on a miss, so the
+ * token of whichever request first populates a collection is the one used.
+ *
+ * A factory exists for the token because an agent token lives 5 minutes: a caller fanning out over
+ * hundreds of collections can outlive a single one, and the tail of that fan-out would fail on an
+ * expired token. A request can only borrow its caller's, so it passes the string.
  */
 export default function createAgentCapabilitiesFetcher({ agentUrl, token, timeoutMs, }: AgentCapabilitiesFetcherOptions): CapabilitiesFetcher;
 //# sourceMappingURL=agent-capabilities-fetcher.d.ts.map

package/dist/read-model/agent-capabilities-fetcher.js

@@ -7,15 +7,23 @@ exports.default = createAgentCapabilitiesFetcher;
 const agent_client_1 = require("@forestadmin/agent-client");
 const create_agent_http_requester_1 = __importDefault(require("../agent/create-agent-http-requester"));
 /**
- * Builds a capabilities fetcher bound to a request's agent token. The cache calls it only on a
- * miss, so the token of whichever request first populates a collection is the one used.
+ * Builds a capabilities fetcher bound to an agent token. The cache calls it only on a miss, so the
+ * token of whichever request first populates a collection is the one used.
+ *
+ * A factory exists for the token because an agent token lives 5 minutes: a caller fanning out over
+ * hundreds of collections can outlive a single one, and the tail of that fan-out would fail on an
+ * expired token. A request can only borrow its caller's, so it passes the string.
  */
 function createAgentCapabilitiesFetcher({ agentUrl, token, timeoutMs, }) {
-    const client = (0, agent_client_1.createRemoteAgentClient)({
+    const clientFor = (bearer) => (0, agent_client_1.createRemoteAgentClient)({
         url: agentUrl,
-        token,
-        httpRequester: (0, create_agent_http_requester_1.default)(token, agentUrl, timeoutMs),
+        token: bearer,
+        httpRequester: (0, create_agent_http_requester_1.default)(bearer, agentUrl, timeoutMs),
     });
-    return collection => client.collection(collection).capabilities();
+    if (typeof token === 'string') {
+        const client = clientFor(token);
+        return collection => client.collection(collection).capabilities();
+    }
+    return collection => clientFor(token()).collection(collection).capabilities();
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdlbnQtY2FwYWJpbGl0aWVzLWZldGNoZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVhZC1tb2RlbC9hZ2VudC1jYXBhYmlsaXRpZXMtZmV0Y2hlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQWdCQSxpREFZQztBQTFCRCw0REFBb0U7QUFFcEUsdUdBQTRFO0FBUTVFOzs7R0FHRztBQUNILFNBQXdCLDhCQUE4QixDQUFDLEVBQ3JELFFBQVEsRUFDUixLQUFLLEVBQ0wsU0FBUyxHQUN1QjtJQUNoQyxNQUFNLE1BQU0sR0FBRyxJQUFBLHNDQUF1QixFQUFDO1FBQ3JDLEdBQUcsRUFBRSxRQUFRO1FBQ2IsS0FBSztRQUNMLGFBQWEsRUFBRSxJQUFBLHFDQUF3QixFQUFDLEtBQUssRUFBRSxRQUFRLEVBQUUsU0FBUyxDQUFDO0tBQ3BFLENBQUMsQ0FBQztJQUVILE9BQU8sVUFBVSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQyxDQUFDLFlBQVksRUFBRSxDQUFDO0FBQ3BFLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdlbnQtY2FwYWJpbGl0aWVzLWZldGNoZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVhZC1tb2RlbC9hZ2VudC1jYXBhYmlsaXRpZXMtZmV0Y2hlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQXFCQSxpREFtQkM7QUF0Q0QsNERBQW9FO0FBRXBFLHVHQUE0RTtBQVM1RTs7Ozs7OztHQU9HO0FBQ0gsU0FBd0IsOEJBQThCLENBQUMsRUFDckQsUUFBUSxFQUNSLEtBQUssRUFDTCxTQUFTLEdBQ3VCO0lBQ2hDLE1BQU0sU0FBUyxHQUFHLENBQUMsTUFBYyxFQUFFLEVBQUUsQ0FDbkMsSUFBQSxzQ0FBdUIsRUFBQztRQUN0QixHQUFHLEVBQUUsUUFBUTtRQUNiLEtBQUssRUFBRSxNQUFNO1FBQ2IsYUFBYSxFQUFFLElBQUEscUNBQXdCLEVBQUMsTUFBTSxFQUFFLFFBQVEsRUFBRSxTQUFTLENBQUM7S0FDckUsQ0FBQyxDQUFDO0lBRUwsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUM5QixNQUFNLE1BQU0sR0FBRyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUM7UUFFaEMsT0FBTyxVQUFVLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDcEUsQ0FBQztJQUVELE9BQU8sVUFBVSxDQUFDLEVBQUUsQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLENBQUMsWUFBWSxFQUFFLENBQUM7QUFDaEYsQ0FBQyJ9

package/dist/read-model/capabilities-cache.d.ts

@@ -1,7 +1,17 @@
+/**
+ * A Forest column type: a primitive name, a one-element array wrapping another type, a composite
+ * `{ fields }`, or a relation marker like `ManyToOne`.
+ */
+export type FieldType = string | FieldType[] | {
+    fields: {
+        field: string;
+        type: FieldType;
+    }[];
+};
 export interface CapabilitiesResult {
     fields: {
         name: string;
-        type: string;
+        type: FieldType;
         operators?: string[];
     }[];
 }

package/dist/read-model/capabilities-cache.js

@@ -44,4 +44,4 @@ class CapabilitiesCache {
     }
 }
 exports.default = CapabilitiesCache;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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