@forestadmin/agent-bff 1.5.0 → 1.7.0

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

@@ -0,0 +1,39 @@
+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[];
+};
+export type PrimaryKeyField = {
+    name: string;
+    type: 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;
+    private readonly primaryKeys;
+    constructor(collections: ForestSchemaCollection[]);
+    private buildRelations;
+    private buildActionEndpoints;
+    private buildPrimaryKeys;
+    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;
+    getPrimaryKeys(collection: string): PrimaryKeyField[];
+}
+//# sourceMappingURL=read-model.d.ts.map

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

@@ -0,0 +1,105 @@
+"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);
+        this.primaryKeys = new Map();
+        for (const collection of collections) {
+            this.collections.add(collection.name);
+            this.buildRelations(collection);
+            this.buildActionEndpoints(collection);
+            this.buildPrimaryKeys(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));
+        this.primaryKeys.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 })),
+            };
+        }
+    }
+    buildPrimaryKeys(collection) {
+        const keys = [];
+        for (const field of collection.fields ?? []) {
+            if (field.isPrimaryKey)
+                keys.push({ name: field.field, type: field.type });
+        }
+        this.primaryKeys.set(collection.name, keys);
+    }
+    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;
+    }
+    getPrimaryKeys(collection) {
+        return this.primaryKeys.get(collection) ?? [];
+    }
+}
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forestadmin/agent-bff",
-  "version": "1.5.0",
+  "version": "1.7.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",