@forestadmin/agent-bff 1.4.1 → 1.6.0

package/dist/adapters/console-metrics.d.ts

@@ -0,0 +1,4 @@
+import type { Logger } from '../ports/logger-port';
+import type { Metrics } from '../ports/metrics-port';
+export default function createConsoleMetrics(logger?: Logger): Metrics;
+//# sourceMappingURL=console-metrics.d.ts.map

package/dist/adapters/console-metrics.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createConsoleMetrics;
+const console_logger_1 = __importDefault(require("./console-logger"));
+function createConsoleMetrics(logger = (0, console_logger_1.default)()) {
+    return {
+        increment(name, tags) {
+            logger('Info', 'metric.increment', { metric: name, ...(tags ?? {}) });
+        },
+        gauge(name, value, tags) {
+            logger('Info', 'metric.gauge', { metric: name, value, ...(tags ?? {}) });
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc29sZS1tZXRyaWNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FkYXB0ZXJzL2NvbnNvbGUtbWV0cmljcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUtBLHVDQVNDO0FBWEQsc0VBQW1EO0FBRW5ELFNBQXdCLG9CQUFvQixDQUFDLFNBQWlCLElBQUEsd0JBQW1CLEdBQUU7SUFDakYsT0FBTztRQUNMLFNBQVMsQ0FBQyxJQUFZLEVBQUUsSUFBaUI7WUFDdkMsTUFBTSxDQUFDLE1BQU0sRUFBRSxrQkFBa0IsRUFBRSxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsR0FBRyxDQUFDLElBQUksSUFBSSxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDeEUsQ0FBQztRQUNELEtBQUssQ0FBQyxJQUFZLEVBQUUsS0FBYSxFQUFFLElBQWlCO1lBQ2xELE1BQU0sQ0FBQyxNQUFNLEVBQUUsY0FBYyxFQUFFLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsR0FBRyxDQUFDLElBQUksSUFBSSxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDM0UsQ0FBQztLQUNGLENBQUM7QUFDSixDQUFDIn0=

package/dist/adapters/safe-metrics.d.ts

@@ -0,0 +1,8 @@
+import type { Metrics } from '../ports/metrics-port';
+/**
+ * Wraps a Metrics port so emitting a metric can never throw into business logic. Metrics is a
+ * user-supplied implementation; a backend that throws must not break a request (e.g. a throwing
+ * gauge on the schema cache-hit path would otherwise degrade every read).
+ */
+export default function safeMetrics(metrics: Metrics): Metrics;
+//# sourceMappingURL=safe-metrics.d.ts.map

package/dist/adapters/safe-metrics.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = safeMetrics;
+/**
+ * Wraps a Metrics port so emitting a metric can never throw into business logic. Metrics is a
+ * user-supplied implementation; a backend that throws must not break a request (e.g. a throwing
+ * gauge on the schema cache-hit path would otherwise degrade every read).
+ */
+function safeMetrics(metrics) {
+    return {
+        increment(name, tags) {
+            try {
+                metrics.increment(name, tags);
+            }
+            catch {
+                // Swallow: a metrics-backend failure must never break business logic.
+            }
+        },
+        gauge(name, value, tags) {
+            try {
+                metrics.gauge(name, value, tags);
+            }
+            catch {
+                // Swallow: a metrics-backend failure must never break business logic.
+            }
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FmZS1tZXRyaWNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FkYXB0ZXJzL3NhZmUtbWV0cmljcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU9BLDhCQWlCQztBQXRCRDs7OztHQUlHO0FBQ0gsU0FBd0IsV0FBVyxDQUFDLE9BQWdCO0lBQ2xELE9BQU87UUFDTCxTQUFTLENBQUMsSUFBWSxFQUFFLElBQWlCO1lBQ3ZDLElBQUksQ0FBQztnQkFDSCxPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztZQUNoQyxDQUFDO1lBQUMsTUFBTSxDQUFDO2dCQUNQLHNFQUFzRTtZQUN4RSxDQUFDO1FBQ0gsQ0FBQztRQUNELEtBQUssQ0FBQyxJQUFZLEVBQUUsS0FBYSxFQUFFLElBQWlCO1lBQ2xELElBQUksQ0FBQztnQkFDSCxPQUFPLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUM7WUFDbkMsQ0FBQztZQUFDLE1BQU0sQ0FBQztnQkFDUCxzRUFBc0U7WUFDeEUsQ0FBQztRQUNILENBQUM7S0FDRixDQUFDO0FBQ0osQ0FBQyJ9

package/dist/http/bff-http-error.d.ts

@@ -31,4 +31,5 @@ export declare function sessionExpired(message?: string): BffHttpError;
 export declare function originNotAllowed(message?: string): BffHttpError;
 export declare function missingTimezone(message?: string): BffHttpError;
 export declare function invalidTimezone(value: string): BffHttpError;
+export declare function relationFieldNotSupported(fields: string[]): BffHttpError;
 //# sourceMappingURL=bff-http-error.d.ts.map

package/dist/http/bff-http-error.js

@@ -9,6 +9,7 @@ exports.sessionExpired = sessionExpired;
 exports.originNotAllowed = originNotAllowed;
 exports.missingTimezone = missingTimezone;
 exports.invalidTimezone = invalidTimezone;
+exports.relationFieldNotSupported = relationFieldNotSupported;
 class BffHttpError extends Error {
     constructor(status, type, message, details) {
         super(message);
@@ -52,4 +53,7 @@ function missingTimezone(message = 'A timezone is required but none was provided
 function invalidTimezone(value) {
     return new BffHttpError(400, 'invalid_timezone', `Invalid timezone: "${value}"`);
 }
-//# sourceMappingURL=data:application/json;base64,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
+function relationFieldNotSupported(fields) {
+    return new BffHttpError(422, 'relation_field_not_supported', 'Nested relation field paths are not supported on top-level list and count', { fields });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ports/metrics-port.d.ts

@@ -0,0 +1,6 @@
+export type MetricTags = Record<string, string | number>;
+export interface Metrics {
+    increment(name: string, tags?: MetricTags): void;
+    gauge(name: string, value: number, tags?: MetricTags): void;
+}
+//# sourceMappingURL=metrics-port.d.ts.map

package/dist/ports/metrics-port.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0cmljcy1wb3J0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3BvcnRzL21ldHJpY3MtcG9ydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/read-model/action-endpoint-resolver.d.ts

@@ -0,0 +1,23 @@
+import type ReadModel from './read-model';
+import type { Metrics } from '../ports/metrics-port';
+import type { ActionEndpointsByCollection } from '@forestadmin/agent-client';
+export declare const ACTION_ENDPOINT_MISS = "action_endpoint_miss";
+export declare const ACTION_ENDPOINT_ERROR = "action_endpoint_error";
+export type ActionEndpointInfo = ActionEndpointsByCollection[string][string];
+export type ReadModelProvider = () => Promise<ReadModel>;
+export interface ResolveActionContext {
+    rendering: string | number;
+}
+/**
+ * Resolves an action to its endpoint against the current read-model. Never throws: an absent
+ * mapping emits the miss counter, a failure to obtain the read-model emits the error counter.
+ * Both counters carry `rendering`, `collection`, and `action` tags. In normal flow the action
+ * allow-list already excludes endpoint-less actions, so the miss path is a defensive guard.
+ */
+export default class ActionEndpointResolver {
+    private readonly getReadModel;
+    private readonly metrics;
+    constructor(getReadModel: ReadModelProvider, metrics: Metrics);
+    resolve(collection: string, action: string, { rendering }: ResolveActionContext): Promise<ActionEndpointInfo | undefined>;
+}
+//# sourceMappingURL=action-endpoint-resolver.d.ts.map

package/dist/read-model/action-endpoint-resolver.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTION_ENDPOINT_ERROR = exports.ACTION_ENDPOINT_MISS = void 0;
+exports.ACTION_ENDPOINT_MISS = 'action_endpoint_miss';
+exports.ACTION_ENDPOINT_ERROR = 'action_endpoint_error';
+/**
+ * Resolves an action to its endpoint against the current read-model. Never throws: an absent
+ * mapping emits the miss counter, a failure to obtain the read-model emits the error counter.
+ * Both counters carry `rendering`, `collection`, and `action` tags. In normal flow the action
+ * allow-list already excludes endpoint-less actions, so the miss path is a defensive guard.
+ */
+class ActionEndpointResolver {
+    constructor(getReadModel, metrics) {
+        this.getReadModel = getReadModel;
+        this.metrics = metrics;
+    }
+    async resolve(collection, action, { rendering }) {
+        const tags = { rendering, collection, action };
+        let readModel;
+        try {
+            readModel = await this.getReadModel();
+        }
+        catch {
+            this.metrics.increment(exports.ACTION_ENDPOINT_ERROR, tags);
+            return undefined;
+        }
+        const info = readModel.getActionEndpoints()[collection]?.[action];
+        if (!info) {
+            this.metrics.increment(exports.ACTION_ENDPOINT_MISS, tags);
+            return undefined;
+        }
+        return info;
+    }
+}
+exports.default = ActionEndpointResolver;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9uLWVuZHBvaW50LXJlc29sdmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JlYWQtbW9kZWwvYWN0aW9uLWVuZHBvaW50LXJlc29sdmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUlhLFFBQUEsb0JBQW9CLEdBQUcsc0JBQXNCLENBQUM7QUFDOUMsUUFBQSxxQkFBcUIsR0FBRyx1QkFBdUIsQ0FBQztBQVU3RDs7Ozs7R0FLRztBQUNILE1BQXFCLHNCQUFzQjtJQUN6QyxZQUNtQixZQUErQixFQUMvQixPQUFnQjtRQURoQixpQkFBWSxHQUFaLFlBQVksQ0FBbUI7UUFDL0IsWUFBTyxHQUFQLE9BQU8sQ0FBUztJQUNoQyxDQUFDO0lBRUosS0FBSyxDQUFDLE9BQU8sQ0FDWCxVQUFrQixFQUNsQixNQUFjLEVBQ2QsRUFBRSxTQUFTLEVBQXdCO1FBRW5DLE1BQU0sSUFBSSxHQUFHLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsQ0FBQztRQUUvQyxJQUFJLFNBQW9CLENBQUM7UUFFekIsSUFBSSxDQUFDO1lBQ0gsU0FBUyxHQUFHLE1BQU0sSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQ3hDLENBQUM7UUFBQyxNQUFNLENBQUM7WUFDUCxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyw2QkFBcUIsRUFBRSxJQUFJLENBQUMsQ0FBQztZQUVwRCxPQUFPLFNBQVMsQ0FBQztRQUNuQixDQUFDO1FBRUQsTUFBTSxJQUFJLEdBQUcsU0FBUyxDQUFDLGtCQUFrQixFQUFFLENBQUMsVUFBVSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUVsRSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDVixJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyw0QkFBb0IsRUFBRSxJQUFJLENBQUMsQ0FBQztZQUVuRCxPQUFPLFNBQVMsQ0FBQztRQUNuQixDQUFDO1FBRUQsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0NBQ0Y7QUFqQ0QseUNBaUNDIn0=

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

@@ -0,0 +1,11 @@
+import type { CapabilitiesFetcher } from './capabilities-cache';
+export interface AgentCapabilitiesFetcherOptions {
+    agentUrl: string;
+    token: string;
+}
+/**
+ * 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.
+ */
+export default function createAgentCapabilitiesFetcher({ agentUrl, token, }: AgentCapabilitiesFetcherOptions): CapabilitiesFetcher;
+//# sourceMappingURL=agent-capabilities-fetcher.d.ts.map

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createAgentCapabilitiesFetcher;
+const agent_client_1 = require("@forestadmin/agent-client");
+/**
+ * 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.
+ */
+function createAgentCapabilitiesFetcher({ agentUrl, token, }) {
+    const client = (0, agent_client_1.createRemoteAgentClient)({ url: agentUrl, token });
+    return collection => client.collection(collection).capabilities();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdlbnQtY2FwYWJpbGl0aWVzLWZldGNoZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVhZC1tb2RlbC9hZ2VudC1jYXBhYmlsaXRpZXMtZmV0Y2hlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQWFBLGlEQU9DO0FBbEJELDREQUFvRTtBQU9wRTs7O0dBR0c7QUFDSCxTQUF3Qiw4QkFBOEIsQ0FBQyxFQUNyRCxRQUFRLEVBQ1IsS0FBSyxHQUMyQjtJQUNoQyxNQUFNLE1BQU0sR0FBRyxJQUFBLHNDQUF1QixFQUFDLEVBQUUsR0FBRyxFQUFFLFFBQVEsRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBRWpFLE9BQU8sVUFBVSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBQyxDQUFDLFlBQVksRUFBRSxDQUFDO0FBQ3BFLENBQUMifQ==

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

@@ -0,0 +1,27 @@
+export interface CapabilitiesResult {
+    fields: {
+        name: string;
+        type: string;
+        operators: string[];
+    }[];
+}
+export type CapabilitiesFetcher = (collection: string) => Promise<CapabilitiesResult>;
+export interface CapabilitiesCacheOptions {
+    now?: () => number;
+    ttlMs?: number;
+}
+/**
+ * Per-collection capabilities cache (24h). The fetcher is passed per call so it can be bound to
+ * the caller's request token. Invalidated together with the schema via `clear()`.
+ */
+export default class CapabilitiesCache {
+    private readonly now;
+    private readonly ttlMs;
+    private readonly entries;
+    private readonly inFlight;
+    private generation;
+    constructor({ now, ttlMs }?: CapabilitiesCacheOptions);
+    get(collection: string, fetcher: CapabilitiesFetcher): Promise<CapabilitiesResult>;
+    clear(): void;
+}
+//# sourceMappingURL=capabilities-cache.d.ts.map

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_cache_1 = require("./schema-cache");
+/**
+ * Per-collection capabilities cache (24h). The fetcher is passed per call so it can be bound to
+ * the caller's request token. Invalidated together with the schema via `clear()`.
+ */
+class CapabilitiesCache {
+    constructor({ now = Date.now, ttlMs = schema_cache_1.ONE_DAY_MS } = {}) {
+        this.entries = new Map();
+        this.inFlight = new Map();
+        this.generation = 0;
+        this.now = now;
+        this.ttlMs = ttlMs;
+    }
+    async get(collection, fetcher) {
+        const entry = this.entries.get(collection);
+        if (entry && this.now() - entry.fetchedAt < this.ttlMs)
+            return entry.result;
+        const pending = this.inFlight.get(collection);
+        if (pending)
+            return pending;
+        const { generation } = this;
+        const fetch = fetcher(collection)
+            .then(result => {
+            // Skip the write if a clear() (schema refresh) happened while this fetch was in flight —
+            // its result belongs to the old schema generation and must not repopulate the cache.
+            if (this.generation === generation) {
+                this.entries.set(collection, { result, fetchedAt: this.now() });
+            }
+            return result;
+        })
+            .finally(() => {
+            if (this.inFlight.get(collection) === fetch)
+                this.inFlight.delete(collection);
+        });
+        this.inFlight.set(collection, fetch);
+        return fetch;
+    }
+    clear() {
+        this.generation += 1;
+        this.entries.clear();
+        this.inFlight.clear();
+    }
+}
+exports.default = CapabilitiesCache;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/read-model/create-read-model.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from '../ports/logger-port';
+import type { Metrics } from '../ports/metrics-port';
+import ActionEndpointResolver from './action-endpoint-resolver';
+import ReadModelStore from './read-model-store';
+export interface CreateReadModelOptions {
+    forestServerUrl: string;
+    envSecret: string;
+    metrics?: Metrics;
+    logger?: Logger;
+    now?: () => number;
+}
+export interface ReadModelBundle {
+    store: ReadModelStore;
+    actionEndpointResolver: ActionEndpointResolver;
+}
+export default function createReadModel({ forestServerUrl, envSecret, metrics, logger, now, }: CreateReadModelOptions): ReadModelBundle;
+//# sourceMappingURL=create-read-model.d.ts.map

package/dist/read-model/create-read-model.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createReadModel;
+const action_endpoint_resolver_1 = __importDefault(require("./action-endpoint-resolver"));
+const capabilities_cache_1 = __importDefault(require("./capabilities-cache"));
+const forest_schema_client_1 = __importDefault(require("./forest-schema-client"));
+const read_model_store_1 = __importDefault(require("./read-model-store"));
+const schema_cache_1 = __importDefault(require("./schema-cache"));
+const console_metrics_1 = __importDefault(require("../adapters/console-metrics"));
+const safe_metrics_1 = __importDefault(require("../adapters/safe-metrics"));
+function createReadModel({ forestServerUrl, envSecret, metrics, logger, now, }) {
+    // Wrap once so a throwing metrics backend can never break business logic anywhere in the bundle.
+    const resolvedMetrics = (0, safe_metrics_1.default)(metrics ?? (0, console_metrics_1.default)(logger));
+    const fetcher = new forest_schema_client_1.default({ forestServerUrl, envSecret });
+    const schemaCache = new schema_cache_1.default({ fetcher, metrics: resolvedMetrics, now });
+    const capabilitiesCache = new capabilities_cache_1.default({ now });
+    const store = new read_model_store_1.default(schemaCache, capabilitiesCache);
+    const actionEndpointResolver = new action_endpoint_resolver_1.default(() => store.getReadModel(), resolvedMetrics);
+    return { store, actionEndpointResolver };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLXJlYWQtbW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVhZC1tb2RlbC9jcmVhdGUtcmVhZC1tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQXdCQSxrQ0FtQkM7QUF4Q0QsMEZBQWdFO0FBQ2hFLDhFQUFxRDtBQUNyRCxrRkFBd0Q7QUFDeEQsMEVBQWdEO0FBQ2hELGtFQUF5QztBQUN6QyxrRkFBK0Q7QUFDL0QsNEVBQW1EO0FBZW5ELFNBQXdCLGVBQWUsQ0FBQyxFQUN0QyxlQUFlLEVBQ2YsU0FBUyxFQUNULE9BQU8sRUFDUCxNQUFNLEVBQ04sR0FBRyxHQUNvQjtJQUN2QixpR0FBaUc7SUFDakcsTUFBTSxlQUFlLEdBQUcsSUFBQSxzQkFBVyxFQUFDLE9BQU8sSUFBSSxJQUFBLHlCQUFvQixFQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7SUFDN0UsTUFBTSxPQUFPLEdBQUcsSUFBSSw4QkFBa0IsQ0FBQyxFQUFFLGVBQWUsRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZFLE1BQU0sV0FBVyxHQUFHLElBQUksc0JBQVcsQ0FBQyxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsZUFBZSxFQUFFLEdBQUcsRUFBRSxDQUFDLENBQUM7SUFDaEYsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLDRCQUFpQixDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQztJQUN6RCxNQUFNLEtBQUssR0FBRyxJQUFJLDBCQUFjLENBQUMsV0FBVyxFQUFFLGlCQUFpQixDQUFDLENBQUM7SUFDakUsTUFBTSxzQkFBc0IsR0FBRyxJQUFJLGtDQUFzQixDQUN2RCxHQUFHLEVBQUUsQ0FBQyxLQUFLLENBQUMsWUFBWSxFQUFFLEVBQzFCLGVBQWUsQ0FDaEIsQ0FBQztJQUVGLE9BQU8sRUFBRSxLQUFLLEVBQUUsc0JBQXNCLEVBQUUsQ0FBQztBQUMzQyxDQUFDIn0=

package/dist/read-model/errors.d.ts

@@ -0,0 +1,5 @@
+export default class SchemaUnavailableError extends Error {
+    readonly cause?: unknown;
+    constructor(cause?: unknown);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/read-model/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SchemaUnavailableError extends Error {
+    constructor(cause) {
+        super('The agent schema is unavailable');
+        this.name = 'SchemaUnavailableError';
+        this.cause = cause;
+    }
+}
+exports.default = SchemaUnavailableError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JlYWQtbW9kZWwvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsTUFBcUIsc0JBQXVCLFNBQVEsS0FBSztJQUd2RCxZQUFZLEtBQWU7UUFDekIsS0FBSyxDQUFDLGlDQUFpQyxDQUFDLENBQUM7UUFDekMsSUFBSSxDQUFDLElBQUksR0FBRyx3QkFBd0IsQ0FBQztRQUNyQyxJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztJQUNyQixDQUFDO0NBQ0Y7QUFSRCx5Q0FRQyJ9

package/dist/read-model/forest-schema-client.d.ts

@@ -0,0 +1,14 @@
+import type { ForestSchemaCollection } from '@forestadmin/forestadmin-client';
+export interface ForestSchemaClientOptions {
+    forestServerUrl: string;
+    envSecret: string;
+}
+export interface SchemaFetcher {
+    fetchSchema(): Promise<ForestSchemaCollection[]>;
+}
+export default class ForestSchemaClient implements SchemaFetcher {
+    private readonly schemaService;
+    constructor({ forestServerUrl, envSecret }: ForestSchemaClientOptions);
+    fetchSchema(): Promise<ForestSchemaCollection[]>;
+}
+//# sourceMappingURL=forest-schema-client.d.ts.map

package/dist/read-model/forest-schema-client.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const forestadmin_client_1 = require("@forestadmin/forestadmin-client");
+class ForestSchemaClient {
+    constructor({ forestServerUrl, envSecret }) {
+        this.schemaService = new forestadmin_client_1.SchemaService(new forestadmin_client_1.ForestHttpApi(), { forestServerUrl, envSecret });
+    }
+    async fetchSchema() {
+        return this.schemaService.getSchema();
+    }
+}
+exports.default = ForestSchemaClient;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9yZXN0LXNjaGVtYS1jbGllbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVhZC1tb2RlbC9mb3Jlc3Qtc2NoZW1hLWNsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUVBLHdFQUErRTtBQVcvRSxNQUFxQixrQkFBa0I7SUFHckMsWUFBWSxFQUFFLGVBQWUsRUFBRSxTQUFTLEVBQTZCO1FBQ25FLElBQUksQ0FBQyxhQUFhLEdBQUcsSUFBSSxrQ0FBYSxDQUFDLElBQUksa0NBQWEsRUFBRSxFQUFFLEVBQUUsZUFBZSxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDOUYsQ0FBQztJQUVELEtBQUssQ0FBQyxXQUFXO1FBQ2YsT0FBTyxJQUFJLENBQUMsYUFBYSxDQUFDLFNBQVMsRUFBRSxDQUFDO0lBQ3hDLENBQUM7Q0FDRjtBQVZELHFDQVVDIn0=

package/dist/read-model/read-model-store.d.ts

@@ -0,0 +1,20 @@
+import type CapabilitiesCache from './capabilities-cache';
+import type { CapabilitiesFetcher, CapabilitiesResult } from './capabilities-cache';
+import type SchemaCache from './schema-cache';
+import ReadModel from './read-model';
+/**
+ * Single owner of the coupled schema + capabilities lifecycle. A successful schema refresh (a bump
+ * of the cache `revision`) rebuilds the read-model and clears capabilities atomically, so the
+ * allow-list and capabilities never split-brain across schema generations.
+ */
+export default class ReadModelStore {
+    private readonly schemaCache;
+    private readonly capabilitiesCache;
+    private builtRevision;
+    private readModel;
+    constructor(schemaCache: SchemaCache, capabilitiesCache: CapabilitiesCache);
+    getReadModel(): Promise<ReadModel>;
+    getCapabilities(collection: string, fetcher: CapabilitiesFetcher): Promise<CapabilitiesResult>;
+    ageSeconds(): number | undefined;
+}
+//# sourceMappingURL=read-model-store.d.ts.map

package/dist/read-model/read-model-store.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const read_model_1 = __importDefault(require("./read-model"));
+/**
+ * Single owner of the coupled schema + capabilities lifecycle. A successful schema refresh (a bump
+ * of the cache `revision`) rebuilds the read-model and clears capabilities atomically, so the
+ * allow-list and capabilities never split-brain across schema generations.
+ */
+class ReadModelStore {
+    constructor(schemaCache, capabilitiesCache) {
+        this.builtRevision = -1;
+        this.readModel = null;
+        this.schemaCache = schemaCache;
+        this.capabilitiesCache = capabilitiesCache;
+    }
+    async getReadModel() {
+        const collections = await this.schemaCache.get();
+        if (this.schemaCache.revision !== this.builtRevision || !this.readModel) {
+            this.readModel = new read_model_1.default(collections);
+            this.builtRevision = this.schemaCache.revision;
+            this.capabilitiesCache.clear();
+        }
+        return this.readModel;
+    }
+    async getCapabilities(collection, fetcher) {
+        // Ensure any pending schema refresh (and its capabilities invalidation) runs first.
+        await this.getReadModel();
+        // TODO(wiring): possible TOCTOU once this is called from request handling. A concurrent schema
+        // refresh can clear capabilities while this fetch is in flight, so the caller could receive
+        // capabilities from the previous schema generation alongside the new allow-list. When wiring
+        // the data endpoints, re-check `schemaCache.revision` after the fetch resolves and retry on a
+        // mismatch so capabilities and schema stay atomically coupled.
+        return this.capabilitiesCache.get(collection, fetcher);
+    }
+    ageSeconds() {
+        return this.schemaCache.ageSeconds();
+    }
+}
+exports.default = ReadModelStore;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhZC1tb2RlbC1zdG9yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9yZWFkLW1vZGVsL3JlYWQtbW9kZWwtc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFJQSw4REFBcUM7QUFFckM7Ozs7R0FJRztBQUNILE1BQXFCLGNBQWM7SUFPakMsWUFBWSxXQUF3QixFQUFFLGlCQUFvQztRQUhsRSxrQkFBYSxHQUFHLENBQUMsQ0FBQyxDQUFDO1FBQ25CLGNBQVMsR0FBcUIsSUFBSSxDQUFDO1FBR3pDLElBQUksQ0FBQyxXQUFXLEdBQUcsV0FBVyxDQUFDO1FBQy9CLElBQUksQ0FBQyxpQkFBaUIsR0FBRyxpQkFBaUIsQ0FBQztJQUM3QyxDQUFDO0lBRUQsS0FBSyxDQUFDLFlBQVk7UUFDaEIsTUFBTSxXQUFXLEdBQUcsTUFBTSxJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBRWpELElBQUksSUFBSSxDQUFDLFdBQVcsQ0FBQyxRQUFRLEtBQUssSUFBSSxDQUFDLGFBQWEsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQztZQUN4RSxJQUFJLENBQUMsU0FBUyxHQUFHLElBQUksb0JBQVMsQ0FBQyxXQUFXLENBQUMsQ0FBQztZQUM1QyxJQUFJLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDO1lBQy9DLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNqQyxDQUFDO1FBRUQsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQ3hCLENBQUM7SUFFRCxLQUFLLENBQUMsZUFBZSxDQUNuQixVQUFrQixFQUNsQixPQUE0QjtRQUU1QixvRkFBb0Y7UUFDcEYsTUFBTSxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7UUFFMUIsK0ZBQStGO1FBQy9GLDRGQUE0RjtRQUM1Riw2RkFBNkY7UUFDN0YsOEZBQThGO1FBQzlGLCtEQUErRDtRQUMvRCxPQUFPLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxHQUFHLENBQUMsVUFBVSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3pELENBQUM7SUFFRCxVQUFVO1FBQ1IsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLFVBQVUsRUFBRSxDQUFDO0lBQ3ZDLENBQUM7Q0FDRjtBQTFDRCxpQ0EwQ0MifQ==

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

@@ -0,0 +1,32 @@
+import type { ActionEndpointsByCollection } from '@forestadmin/agent-client';
+import type { ForestSchemaCollection } from '@forestadmin/forestadmin-client';
+export type RelationshipType = 'BelongsTo' | 'HasOne' | 'HasMany' | 'BelongsToMany';
+export type RelationTarget = {
+    type: RelationshipType;
+    polymorphic: false;
+    target: string;
+} | {
+    type: RelationshipType;
+    polymorphic: true;
+    targets: string[];
+};
+/**
+ * The agent read-model derived from a schema. Names are collection-scoped: relations and actions
+ * are keyed by `(collection, name)` so the same relation/action name on two collections stays
+ * distinct. The action allow-list is exactly the endpoint-map keys — endpoint-less actions are
+ * not exposed.
+ */
+export default class ReadModel {
+    private readonly collections;
+    private readonly relations;
+    private readonly actionEndpoints;
+    constructor(collections: ForestSchemaCollection[]);
+    private buildRelations;
+    private buildActionEndpoints;
+    isCollectionAllowed(collection: string): boolean;
+    isRelationAllowed(collection: string, relation: string): boolean;
+    getRelationTarget(collection: string, relation: string): RelationTarget | undefined;
+    isActionAllowed(collection: string, action: string): boolean;
+    getActionEndpoints(): ActionEndpointsByCollection;
+}
+//# sourceMappingURL=read-model.d.ts.map

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function toRelationTarget(field) {
+    if (!field.relationship)
+        return null;
+    const type = field.relationship;
+    if (field.polymorphicReferencedModels && field.polymorphicReferencedModels.length > 0) {
+        return { type, polymorphic: true, targets: [...field.polymorphicReferencedModels] };
+    }
+    if (field.reference) {
+        // reference is `${foreignCollection}.${key}`; the collection name may itself contain dots
+        // (e.g. mongoose nested collections like `User.address`), so drop only the trailing key.
+        return { type, polymorphic: false, target: field.reference.split('.').slice(0, -1).join('.') };
+    }
+    return null;
+}
+function deepFreeze(value) {
+    if (value && typeof value === 'object') {
+        Object.values(value).forEach(deepFreeze);
+        Object.freeze(value);
+    }
+    return value;
+}
+/**
+ * The agent read-model derived from a schema. Names are collection-scoped: relations and actions
+ * are keyed by `(collection, name)` so the same relation/action name on two collections stays
+ * distinct. The action allow-list is exactly the endpoint-map keys — endpoint-less actions are
+ * not exposed.
+ */
+class ReadModel {
+    constructor(collections) {
+        this.collections = new Set();
+        this.relations = new Map();
+        // Null-prototype so an action/collection named like an Object.prototype member
+        // (`toString`, `constructor`, `__proto__`, …) can't falsely pass the allow-list.
+        this.actionEndpoints = Object.create(null);
+        for (const collection of collections) {
+            this.collections.add(collection.name);
+            this.buildRelations(collection);
+            this.buildActionEndpoints(collection);
+        }
+        // Freeze the exposed structures so a consumer cannot mutate the shared cached read-model.
+        deepFreeze(this.actionEndpoints);
+        this.relations.forEach(byRelation => byRelation.forEach(deepFreeze));
+    }
+    buildRelations(collection) {
+        const relations = new Map();
+        for (const field of collection.fields ?? []) {
+            const target = toRelationTarget(field);
+            if (target)
+                relations.set(field.field, target);
+        }
+        this.relations.set(collection.name, relations);
+    }
+    buildActionEndpoints(collection) {
+        const actions = collection.actions ?? [];
+        const withEndpoint = actions.filter(action => Boolean(action.endpoint));
+        if (withEndpoint.length === 0)
+            return;
+        this.actionEndpoints[collection.name] = Object.create(null);
+        for (const action of withEndpoint) {
+            // Copy fields/hooks so a mutating consumer can't corrupt the shared cached schema, and
+            // default them defensively: the schema is cast from `Record<string, unknown>`, so a
+            // malformed action could omit them at runtime despite the declared type.
+            this.actionEndpoints[collection.name][action.name] = {
+                id: action.id,
+                name: action.name,
+                endpoint: action.endpoint,
+                hooks: { load: action.hooks?.load ?? false, change: [...(action.hooks?.change ?? [])] },
+                fields: (action.fields ?? []).map(field => ({ ...field })),
+            };
+        }
+    }
+    isCollectionAllowed(collection) {
+        return this.collections.has(collection);
+    }
+    isRelationAllowed(collection, relation) {
+        return this.relations.get(collection)?.has(relation) ?? false;
+    }
+    getRelationTarget(collection, relation) {
+        return this.relations.get(collection)?.get(relation);
+    }
+    isActionAllowed(collection, action) {
+        return this.actionEndpoints[collection]?.[action] !== undefined;
+    }
+    getActionEndpoints() {
+        return this.actionEndpoints;
+    }
+}
+exports.default = ReadModel;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,35 @@
+import type { SchemaFetcher } from './forest-schema-client';
+import type { Metrics } from '../ports/metrics-port';
+import type { ForestSchemaCollection } from '@forestadmin/forestadmin-client';
+export declare const ONE_DAY_MS: number;
+export declare const SCHEMA_CACHE_REFRESH_ERROR = "schema_cache_refresh_error";
+export declare const SCHEMA_CACHE_AGE_SECONDS = "schema_cache_age_seconds";
+export interface SchemaCacheOptions {
+    fetcher: SchemaFetcher;
+    metrics: Metrics;
+    now?: () => number;
+    ttlMs?: number;
+}
+/**
+ * Caches the agent schema for 24h. The TTL only *triggers* a refresh attempt: the last good
+ * schema keeps being served until a refresh succeeds. A cold cache (no last good) surfaces a
+ * typed `SchemaUnavailableError`. A monotonic `revision` increments on each successful refresh so
+ * a consumer can detect a new schema generation explicitly.
+ */
+export default class SchemaCache {
+    private readonly fetcher;
+    private readonly metrics;
+    private readonly now;
+    private readonly ttlMs;
+    private entry;
+    private inFlight;
+    private revisionValue;
+    constructor({ fetcher, metrics, now, ttlMs }: SchemaCacheOptions);
+    get(): Promise<ForestSchemaCollection[]>;
+    ageSeconds(): number | undefined;
+    get revision(): number;
+    private refresh;
+    private doRefresh;
+    private emitAge;
+}
+//# sourceMappingURL=schema-cache.d.ts.map

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

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA_CACHE_AGE_SECONDS = exports.SCHEMA_CACHE_REFRESH_ERROR = exports.ONE_DAY_MS = void 0;
+const errors_1 = __importDefault(require("./errors"));
+exports.ONE_DAY_MS = 24 * 60 * 60 * 1000;
+exports.SCHEMA_CACHE_REFRESH_ERROR = 'schema_cache_refresh_error';
+exports.SCHEMA_CACHE_AGE_SECONDS = 'schema_cache_age_seconds';
+/**
+ * Caches the agent schema for 24h. The TTL only *triggers* a refresh attempt: the last good
+ * schema keeps being served until a refresh succeeds. A cold cache (no last good) surfaces a
+ * typed `SchemaUnavailableError`. A monotonic `revision` increments on each successful refresh so
+ * a consumer can detect a new schema generation explicitly.
+ */
+class SchemaCache {
+    constructor({ fetcher, metrics, now = Date.now, ttlMs = exports.ONE_DAY_MS }) {
+        this.entry = null;
+        this.inFlight = null;
+        this.revisionValue = 0;
+        this.fetcher = fetcher;
+        this.metrics = metrics;
+        this.now = now;
+        this.ttlMs = ttlMs;
+    }
+    async get() {
+        if (this.entry && this.now() - this.entry.fetchedAt < this.ttlMs) {
+            this.emitAge();
+            return this.entry.collections;
+        }
+        return this.refresh();
+    }
+    ageSeconds() {
+        if (!this.entry)
+            return undefined;
+        return Math.floor((this.now() - this.entry.fetchedAt) / 1000);
+    }
+    get revision() {
+        return this.revisionValue;
+    }
+    async refresh() {
+        if (!this.inFlight) {
+            this.inFlight = this.doRefresh().finally(() => {
+                this.inFlight = null;
+            });
+        }
+        return this.inFlight;
+    }
+    async doRefresh() {
+        try {
+            const collections = await this.fetcher.fetchSchema();
+            // An agent always exposes collections, so an empty result is far likelier a broken response
+            // than a valid state. Caching it would silently deny everything for 24h — treat it as a
+            // failed fetch and fall through to the failure path below.
+            if (collections.length === 0)
+                throw new Error('Forest returned an empty schema');
+            this.entry = { collections, fetchedAt: this.now() };
+            this.revisionValue += 1;
+            this.emitAge();
+            return collections;
+        }
+        catch (error) {
+            this.metrics.increment(exports.SCHEMA_CACHE_REFRESH_ERROR);
+            // Warm cache: keep serving the last good schema (stale), do not poison — the next read
+            // re-attempts because `fetchedAt` is unchanged and the entry stays expired.
+            if (this.entry) {
+                this.emitAge();
+                return this.entry.collections;
+            }
+            // Cold cache: nothing to serve.
+            throw new errors_1.default(error);
+        }
+    }
+    emitAge() {
+        const age = this.ageSeconds();
+        if (age !== undefined)
+            this.metrics.gauge(exports.SCHEMA_CACHE_AGE_SECONDS, age);
+    }
+}
+exports.default = SchemaCache;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/validation/relation-field-guard.d.ts

@@ -0,0 +1,2 @@
+export default function assertNoRelationFieldPaths(paths: string[]): void;
+//# sourceMappingURL=relation-field-guard.d.ts.map

package/dist/validation/relation-field-guard.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = assertNoRelationFieldPaths;
+const bff_http_error_1 = require("../http/bff-http-error");
+const RELATION_SEPARATOR = ':';
+function assertNoRelationFieldPaths(paths) {
+    const offending = [];
+    for (const path of paths) {
+        if (path.includes(RELATION_SEPARATOR) && !offending.includes(path)) {
+            offending.push(path);
+        }
+    }
+    if (offending.length > 0)
+        throw (0, bff_http_error_1.relationFieldNotSupported)(offending);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVsYXRpb24tZmllbGQtZ3VhcmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmFsaWRhdGlvbi9yZWxhdGlvbi1maWVsZC1ndWFyZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUlBLDZDQVVDO0FBZEQsMkRBQW1FO0FBRW5FLE1BQU0sa0JBQWtCLEdBQUcsR0FBRyxDQUFDO0FBRS9CLFNBQXdCLDBCQUEwQixDQUFDLEtBQWU7SUFDaEUsTUFBTSxTQUFTLEdBQWEsRUFBRSxDQUFDO0lBRS9CLEtBQUssTUFBTSxJQUFJLElBQUksS0FBSyxFQUFFLENBQUM7UUFDekIsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDbkUsU0FBUyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN2QixDQUFDO0lBQ0gsQ0FBQztJQUVELElBQUksU0FBUyxDQUFDLE1BQU0sR0FBRyxDQUFDO1FBQUUsTUFBTSxJQUFBLDBDQUF5QixFQUFDLFNBQVMsQ0FBQyxDQUFDO0FBQ3ZFLENBQUMifQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forestadmin/agent-bff",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "main": "dist/index.js",
   "bin": {
     "forest-bff": "dist/cli.js"
@@ -31,6 +31,7 @@
     "test": "jest"
   },
   "dependencies": {
+    "@forestadmin/agent-client": "1.10.1",
     "@forestadmin/forestadmin-client": "1.40.4",
     "@koa/bodyparser": "^6.1.0",
     "jsonwebtoken": "^9.0.3",