@forestadmin/agent 1.103.3 → 1.103.5

package/dist/audit-trail/instrument.js

@@ -156,9 +156,12 @@ const redactValues = (values, redactedFields) => {
     if (!redactedFields.length)
         return values;
     const result = { ...values };
-    for (const field of redactedFields)
-        if (field in result)
+    // Own properties only: `'toString' in result` is true of every object, so a `redact` config
+    // naming an `Object.prototype` member would write a placeholder for a column the row never had.
+    for (const field of redactedFields) {
+        if (Object.prototype.hasOwnProperty.call(result, field))
             result[field] = exports.REDACTED;
+    }
     return result;
 };
 const consoleSink = record => {
@@ -390,4 +393,4 @@ function installAuditTrailHooks(dataSourceCustomizer, _collectionCustomizer, opt
     // Returned so a broken bootstrap fails agent.start() instead of the first write.
     return store?.init?.();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instrument.js","sourceRoot":"","sources":["../../src/audit-trail/instrument.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instrument.js","sourceRoot":"","sources":["../../src/audit-trail/instrument.ts"],"names":[],"mappings":"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"}

package/dist/audit-trail/record-visibility.d.ts

@@ -0,0 +1,28 @@
+import type { Collection, ConditionTree } from '@forestadmin/datasource-toolkit';
+import type { Context } from 'koa';
+export declare function recordExists(collection: Collection, packedId: string, context: Context, permissionScope: ConditionTree | null): Promise<boolean>;
+export type RecordVisibility = {
+    /** False → the id still exists and fails the permission scope; the caller must be denied entirely (404). */
+    visible: boolean;
+    /**
+     * True once the id no longer exists at all, under any scope. `visible` is then true for a
+     * different reason than "the record matches the scope": there is nothing left to check
+     * existence against. It doesn't mean every value the audit trail holds for that record is safe
+     * to hand back to this caller — a scoped-down field value captured while the record still
+     * existed can still fall outside the caller's permission scope, and callers should check that separately
+     * (e.g. by re-evaluating the permission scope's `ConditionTree` against a delete row's `previousValues`)
+     * before deciding how much of the record's captured data to surface.
+     */
+    goneEntirely: boolean;
+};
+export default function checkRecordVisibility(collection: Collection, packedId: string, context: Context, permissionScope: ConditionTree | null): Promise<RecordVisibility>;
+/**
+ * The record can be deleted — or moved out of the caller's permission scope — between the check
+ * that authorized the request and the audit read that answers it: the audit trail lives in its own
+ * database, often its own engine, so no single snapshot spans both. Re-reads once the rows are in
+ * hand, and returns null when there is nothing to re-read: a caller with no scope has nothing to
+ * withhold, and a record already gone at the first check has already had the withholding applied —
+ * an id recreated in the meantime would only widen what is served, never what is hidden.
+ */
+export declare function recheckRecordVisibility(collection: Collection, packedId: string, context: Context, permissionScope: ConditionTree | null, wasGoneEntirely: boolean): Promise<RecordVisibility | null>;
+//# sourceMappingURL=record-visibility.d.ts.map

package/dist/audit-trail/record-visibility.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordExists = recordExists;
+exports.default = checkRecordVisibility;
+exports.recheckRecordVisibility = recheckRecordVisibility;
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const id_1 = __importDefault(require("../utils/id"));
+const query_string_1 = __importDefault(require("../utils/query-string"));
+async function recordExists(collection, packedId, context, permissionScope) {
+    const id = id_1.default.unpackId(collection.schema, packedId);
+    const filter = new datasource_toolkit_1.PaginatedFilter({
+        conditionTree: datasource_toolkit_1.ConditionTreeFactory.intersect(datasource_toolkit_1.ConditionTreeFactory.matchIds(collection.schema, [id]), permissionScope),
+    });
+    const records = await collection.list(query_string_1.default.parseCaller(context, { defaultTimezone: 'UTC' }), filter, new datasource_toolkit_1.Projection(...datasource_toolkit_1.SchemaUtils.getPrimaryKeys(collection.schema)));
+    return records.length > 0;
+}
+// A record-level permission scope can't be evaluated against a record that no longer exists, so a caller whose
+// access is scoped down is only denied when the id currently exists and fails that permission scope — once it's
+// genuinely gone there is nothing left to scope against, and showing that it existed (including that
+// it was deleted, by whom and when) is much of the point of an audit trail.
+// The caller passes the permission scope it will also withhold with, rather than this reading its
+// own: two lookups can disagree if the scope cache turns over between them, and the answer here
+// decides what that scope is then applied to.
+async function checkRecordVisibility(collection, packedId, context, permissionScope) {
+    if (!permissionScope)
+        return { visible: true, goneEntirely: false };
+    if (await recordExists(collection, packedId, context, permissionScope)) {
+        return { visible: true, goneEntirely: false };
+    }
+    const existsOutsidePermissionScope = await recordExists(collection, packedId, context, null);
+    return { visible: !existsOutsidePermissionScope, goneEntirely: !existsOutsidePermissionScope };
+}
+/**
+ * The record can be deleted — or moved out of the caller's permission scope — between the check
+ * that authorized the request and the audit read that answers it: the audit trail lives in its own
+ * database, often its own engine, so no single snapshot spans both. Re-reads once the rows are in
+ * hand, and returns null when there is nothing to re-read: a caller with no scope has nothing to
+ * withhold, and a record already gone at the first check has already had the withholding applied —
+ * an id recreated in the meantime would only widen what is served, never what is hidden.
+ */
+async function recheckRecordVisibility(collection, packedId, context, permissionScope, wasGoneEntirely) {
+    if (!permissionScope || wasGoneEntirely)
+        return null;
+    return checkRecordVisibility(collection, packedId, context, permissionScope);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/audit-trail/withhold.d.ts

@@ -0,0 +1,41 @@
+import type { AuditRecord } from './types';
+import type { Collection, ConditionTree, Logger } from '@forestadmin/datasource-toolkit';
+export type Withholding = {
+    collection: Collection;
+    permissionScope: ConditionTree;
+    timezone: string;
+    logger?: Logger;
+};
+/**
+ * Whether the row's own packed id answers for the side being tested.
+ *
+ * `false` for the previous side of an `update`: the capture files a row under the identity the
+ * record ended up with, so on an update that moved the primary key the row's id describes the new
+ * state only. It is also `false` for `/state`, whose reconstruction can sit on the far side of a
+ * move the route cannot see.
+ */
+type IdAnswersForSide = boolean;
+export declare function permissionScopeAccepts(snapshot: Record<string, unknown>, { collection, permissionScope, timezone }: Withholding): boolean;
+/**
+ * The row's packed id as a `{ key: value }` map, or null when there is none to read — no id at all
+ * (a pending create), or one the current schema can no longer unpack.
+ *
+ * Absence is `null`, not falsiness: `''` is a legal value for a string primary key, and it packs
+ * and unpacks like any other. Reading it as "no id" would leave the key unanswered and blank the
+ * values of a record whose id genuinely is the empty string.
+ */
+export declare function decodePrimaryKeys(packedId: string | null, collection: Collection, logger?: Logger): Record<string, unknown> | null;
+/** The snapshot a permission scope should be evaluated against, for one side of one row. */
+export declare function snapshotFor(values: Record<string, unknown>, packedId: string | null, { collection, logger }: Pick<Withholding, 'collection' | 'logger'>, idAnswersForSide?: IdAnswersForSide): Record<string, unknown>;
+/**
+ * Blanks the captured values a caller's record-level permission scope does not cover, keeping the row itself:
+ * that it happened, by whom and when stays visible either way.
+ *
+ * Each side is tested against its own snapshot. An `update` carries a partial diff, so a permission scope on a
+ * column it never touched is simply unanswerable there and withheld by the same rule as everything
+ * else — which is why this needs no special case beyond `action` rows, whose two columns hold a
+ * submitted form and a result summary rather than column values.
+ */
+export default function withholdOutsidePermissionScope(entries: AuditRecord[], withholding: Withholding): AuditRecord[];
+export {};
+//# sourceMappingURL=withhold.d.ts.map

package/dist/audit-trail/withhold.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.permissionScopeAccepts = permissionScopeAccepts;
+exports.decodePrimaryKeys = decodePrimaryKeys;
+exports.snapshotFor = snapshotFor;
+exports.default = withholdOutsidePermissionScope;
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const instrument_1 = require("./instrument");
+const id_1 = __importDefault(require("../utils/id"));
+// Only a snapshot that answers every field the permission scope asks about is worth matching. The
+// capture keeps the writable columns, so a permission scope reaching for anything else — a
+// read-only column, a relation — reads `undefined` there and would answer for a value the row never
+// held: `status != 'private'` matches on the missing key and releases it.
+//
+// The snapshot reaching this point has already had its unanswerable fields removed, so a missing key
+// is the whole test — see `answerableSnapshot`.
+//
+// Own properties only: `'toString' in snapshot` is true of every object, so a permission scope on a
+// column named after one of `Object.prototype`'s members would otherwise resolve against the
+// prototype.
+function permissionScopeAccepts(snapshot, { collection, permissionScope, timezone }) {
+    const values = snapshot ?? {};
+    const answered = permissionScope.projection.every(field => Object.prototype.hasOwnProperty.call(values, field));
+    return answered && permissionScope.match(values, collection, timezone);
+}
+/**
+ * What this side of a row can honestly answer about.
+ *
+ * A redacted value answers nothing, so it is dropped rather than matched against the placeholder:
+ * the field then reads as unanswered, which withholds.
+ *
+ * The packed id then fills in the primary keys the snapshot cannot supply, but only where the row's
+ * id is authoritative for this side:
+ *
+ * - **absent** means the key is read-only — the capture keeps every writable column — and a
+ *   read-only key cannot move, so the row's id answers for it on either side. Always filled.
+ * - **redacted** means the key is writable, so it can have moved. The row's id then answers only for
+ *   the side it was filed under. Filling the other side would judge the previous state by an id it
+ *   never had, and a permission scope on the new id would release values captured under the old one.
+ *
+ * Declining to fill over-withholds an update's previous side whenever its primary key is redacted —
+ * the same "absent is not the same as passing" direction as everything else here. Carrying the
+ * id it moved from is what would remove that cost; see PRD-1321.
+ */
+function answerableSnapshot(values, decoded, idAnswersForSide) {
+    const entries = Object.entries(values ?? {});
+    const answered = Object.fromEntries(entries.filter(([, value]) => value !== instrument_1.REDACTED));
+    if (!decoded)
+        return answered;
+    const redacted = new Set(entries.filter(([, value]) => value === instrument_1.REDACTED).map(([field]) => field));
+    const fill = Object.fromEntries(Object.entries(decoded).filter(([field]) => idAnswersForSide || !redacted.has(field)));
+    return { ...fill, ...answered };
+}
+/**
+ * The row's packed id as a `{ key: value }` map, or null when there is none to read — no id at all
+ * (a pending create), or one the current schema can no longer unpack.
+ *
+ * Absence is `null`, not falsiness: `''` is a legal value for a string primary key, and it packs
+ * and unpacks like any other. Reading it as "no id" would leave the key unanswered and blank the
+ * values of a record whose id genuinely is the empty string.
+ */
+function decodePrimaryKeys(packedId, collection, logger) {
+    if (packedId === null || packedId === undefined)
+        return null;
+    try {
+        const names = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(collection.schema);
+        const ids = id_1.default.unpackId(collection.schema, packedId);
+        return Object.fromEntries(names.map((name, index) => [name, ids[index]]));
+    }
+    catch (error) {
+        // The id the row was filed under no longer fits the collection's key: a renamed or retyped
+        // primary key, or a corrupted row. Withholding is the safe answer and the caller gets it
+        // either way, but a live audit read failing to decode its own ids is worth saying out loud.
+        logger?.('Warn', `Audit trail: cannot unpack record id "${packedId}" (${error.message})`);
+        return null;
+    }
+}
+/** The snapshot a permission scope should be evaluated against, for one side of one row. */
+function snapshotFor(values, packedId, { collection, logger }, idAnswersForSide = true) {
+    return answerableSnapshot(values, decodePrimaryKeys(packedId, collection, logger), idAnswersForSide);
+}
+/**
+ * Blanks the captured values a caller's record-level permission scope does not cover, keeping the row itself:
+ * that it happened, by whom and when stays visible either way.
+ *
+ * Each side is tested against its own snapshot. An `update` carries a partial diff, so a permission scope on a
+ * column it never touched is simply unanswerable there and withheld by the same rule as everything
+ * else — which is why this needs no special case beyond `action` rows, whose two columns hold a
+ * submitted form and a result summary rather than column values.
+ */
+function withholdOutsidePermissionScope(entries, withholding) {
+    return entries.map(entry => {
+        if (entry.operation === 'action' || entry.operation === 'action_failed')
+            return entry;
+        // Decoded once per row rather than once per side: the two sides read the same id, and a row
+        // whose id no longer decodes should say so once.
+        const decoded = decodePrimaryKeys(entry.recordId, withholding.collection, withholding.logger);
+        const side = (values, idAnswersForSide) => permissionScopeAccepts(answerableSnapshot(values, decoded, idAnswersForSide), withholding)
+            ? values ?? {}
+            : {};
+        return {
+            ...entry,
+            // The row is filed under the identity the record ended up with, so its id answers for the
+            // new side of an update and for a create or a delete — never for what an update moved away
+            // from.
+            previousValues: side(entry.previousValues, entry.operation !== 'update'),
+            newValues: side(entry.newValues, true),
+        };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/routes/access/audit-trail-correlation.d.ts

@@ -12,6 +12,7 @@ export default class AuditTrailCorrelationRoute extends BaseRoute {
     setupRoutes(router: Router): void;
     handleHistory(context: Context): Promise<void>;
     handleBatch(context: Context): Promise<void>;
+    private withhold;
     private assertRecordReadable;
     private static parseCorrelationKeys;
 }

package/dist/routes/access/audit-trail-correlation.js

@@ -1,11 +1,46 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
-const scope_1 = __importDefault(require("../../audit-trail/scope"));
+const record_visibility_1 = __importStar(require("../../audit-trail/record-visibility"));
+const withhold_1 = __importDefault(require("../../audit-trail/withhold"));
 const types_1 = require("../../types");
+const query_string_1 = __importDefault(require("../../utils/query-string"));
 const base_route_1 = __importDefault(require("../base-route"));
 class AuditTrailCorrelationRoute extends base_route_1.default {
     constructor(services, options, dataSource) {
@@ -30,7 +65,10 @@ class AuditTrailCorrelationRoute extends base_route_1.default {
             recordId,
             correlationKey: context.params.correlationKey,
         });
-        context.response.body = { data: history };
+        const data = await this.withhold(history, target, context);
+        if (!data)
+            return;
+        context.response.body = { data };
     }
     async handleBatch(context) {
         const target = await this.assertRecordReadable(context);
@@ -42,9 +80,37 @@ class AuditTrailCorrelationRoute extends base_route_1.default {
         const history = correlationKeys.length
             ? await store.listByCorrelations({ collection, recordId, correlationKeys })
             : [];
-        context.response.body = { data: history };
+        const data = await this.withhold(history, target, context);
+        if (!data)
+            return;
+        context.response.body = { data };
     }
-    // Returns null (after issuing the 404) when a configured record-level scope excludes the id —
+    // Same rule as the per-record history route: these routes return the same rows, so a gone
+    // record's captured values are tested against the caller's permission scope here too. Without it the
+    // values the history route withholds come back through a correlation lookup.
+    // The record can go away — or move out of the caller's permission scope — while the audit read is
+    // in flight, so the decision is taken again on the way out rather than reused from the check that
+    // authorized the request. Returns null once it has issued the 404.
+    async withhold(entries, target, context) {
+        // An empty answer has nothing to withhold, so it does not earn a second read of the record.
+        if (!entries.length)
+            return entries;
+        const after = await (0, record_visibility_1.recheckRecordVisibility)(target.collectionObject, target.recordId, context, target.permissionScope, target.goneEntirely);
+        if (after && !after.visible) {
+            context.throw(types_1.HttpCode.NotFound, 'Record does not exists');
+            return null;
+        }
+        const gone = after ? after.goneEntirely : target.goneEntirely;
+        if (!target.permissionScope || !gone)
+            return entries;
+        return (0, withhold_1.default)(entries, {
+            collection: target.collectionObject,
+            permissionScope: target.permissionScope,
+            timezone: query_string_1.default.parseCaller(context, { defaultTimezone: 'UTC' }).timezone,
+            logger: this.options.logger,
+        });
+    }
+    // Returns null (after issuing the 404) when a configured record-level permission scope excludes the id —
     // same rule as the per-collection route: a scope can't be evaluated retroactively for a
     // now-deleted record, so a scoped caller cannot look up correlations for an out-of-scope id.
     async assertRecordReadable(context) {
@@ -58,12 +124,19 @@ class AuditTrailCorrelationRoute extends base_route_1.default {
             throw new datasource_toolkit_1.ValidationError('Missing recordId');
         const collection = this.dataSource.getCollection(collectionName);
         await this.services.authorization.assertCanRead(context, collectionName);
-        const { visible } = await (0, scope_1.default)(this.services, collection, recordId, context);
+        const permissionScope = await this.services.authorization.getScope(collection, context);
+        const { visible, goneEntirely } = await (0, record_visibility_1.default)(collection, recordId, context, permissionScope);
         if (!visible) {
             context.throw(types_1.HttpCode.NotFound, 'Record does not exists');
             return null;
         }
-        return { collection: collectionName, recordId };
+        return {
+            collection: collectionName,
+            recordId,
+            collectionObject: collection,
+            permissionScope,
+            goneEntirely,
+        };
     }
     // Body array (POST) takes precedence over the comma-separated query param (GET).
     static parseCorrelationKeys(context) {
@@ -81,4 +154,4 @@ class AuditTrailCorrelationRoute extends base_route_1.default {
     }
 }
 exports.default = AuditTrailCorrelationRoute;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/routes/access/audit-trail.d.ts

@@ -4,7 +4,7 @@ import CollectionRoute from '../collection-route';
 export default class AuditTrailRoute extends CollectionRoute {
     setupRoutes(router: Router): void;
     handleHistory(context: Context): Promise<void>;
-    private withholdOutOfScopeValues;
+    private withhold;
     handleStateAt(context: Context): Promise<void>;
     private fetchCurrentRecord;
     private static auditedColumns;

package/dist/routes/access/audit-trail.js

@@ -39,7 +39,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
 const luxon_1 = require("luxon");
 const audit_trail_1 = require("../../audit-trail");
-const scope_1 = __importStar(require("../../audit-trail/scope"));
+const record_visibility_1 = __importStar(require("../../audit-trail/record-visibility"));
+const withhold_1 = __importStar(require("../../audit-trail/withhold"));
 const types_1 = require("../../types");
 const id_1 = __importDefault(require("../../utils/id"));
 const query_string_1 = __importDefault(require("../../utils/query-string"));
@@ -57,8 +58,8 @@ class AuditTrailRoute extends collection_route_1.default {
     }
     async handleHistory(context) {
         await this.services.authorization.assertCanRead(context, this.collection.name);
-        const scope = await this.services.authorization.getScope(this.collection, context);
-        const { visible, goneEntirely } = await (0, scope_1.default)(this.services, this.collection, context.params.id, context);
+        const permissionScope = await this.services.authorization.getScope(this.collection, context);
+        const { visible, goneEntirely } = await (0, record_visibility_1.default)(this.collection, context.params.id, context, permissionScope);
         if (!visible) {
             context.throw(types_1.HttpCode.NotFound, 'Record does not exists');
             return;
@@ -86,41 +87,34 @@ class AuditTrailRoute extends collection_route_1.default {
             store.countByRecord(filters),
             isFirstFetch ? store.listDistinctUsers(filters) : undefined,
         ]);
-        // A genuinely deleted record bypasses the scope check above — there's nothing left to check
+        // The record can be deleted — or moved out of the caller's permission scope — between the check above and
+        // the audit read: the audit trail lives in its own database, often its own engine, so no single
+        // snapshot spans both. Ask again once the rows are in hand and let that answer decide, so a
+        // record that went away mid-request is treated as the request starting a moment later would
+        // have treated it. Only for a scoped caller: with no permission scope there is nothing to withhold.
+        const after = await (0, record_visibility_1.recheckRecordVisibility)(this.collection, context.params.id, context, permissionScope, goneEntirely);
+        if (after && !after.visible) {
+            context.throw(types_1.HttpCode.NotFound, 'Record does not exists');
+            return;
+        }
+        const gone = after ? after.goneEntirely : goneEntirely;
+        // A genuinely deleted record bypasses the permission-scope check above — there's nothing left to check
         // existence against — but create/update/delete rows still carry captured column values from
-        // when the record existed. If those values themselves would have failed the caller's scope,
+        // when the record existed. If those values themselves would have failed the caller's permission scope,
         // withhold them while still surfacing that the row happened, by whom and when: that part
         // stays visible regardless.
-        const data = scope && goneEntirely ? this.withholdOutOfScopeValues(rawData, scope, context) : rawData;
+        const data = permissionScope && gone ? this.withhold(rawData, permissionScope, context) : rawData;
         context.response.body = {
             data,
             meta: { count, ...(availableUsers && { availableUsers }) },
         };
     }
-    withholdOutOfScopeValues(entries, scope, context) {
-        const { timezone } = query_string_1.default.parseCaller(context, { defaultTimezone: 'UTC' });
-        return entries.map(entry => {
-            // `delete`'s previousValues and `create`'s newValues both capture every writable column
-            // (see instrument.ts's pickColumns), so the scope can be evaluated against them directly.
-            if (entry.operation === 'delete') {
-                if (scope.match(entry.previousValues, this.collection, timezone))
-                    return entry;
-                return { ...entry, previousValues: {} };
-            }
-            if (entry.operation === 'create') {
-                if (scope.match(entry.newValues, this.collection, timezone))
-                    return entry;
-                return { ...entry, newValues: {} };
-            }
-            // `update`'s previousValues/newValues are a partial diff (only the columns that changed) —
-            // a scope condition referencing a column this particular update didn't touch can't be
-            // evaluated reliably against it, so withhold unconditionally rather than risk a false
-            // negative. `action`/`action_failed` rows hold a submitted form and a result summary, not
-            // column values, so the scope doesn't apply to them at all.
-            if (entry.operation === 'update') {
-                return { ...entry, previousValues: {}, newValues: {} };
-            }
-            return entry;
+    withhold(entries, permissionScope, context) {
+        return (0, withhold_1.default)(entries, {
+            collection: this.collection,
+            permissionScope,
+            timezone: query_string_1.default.parseCaller(context, { defaultTimezone: 'UTC' }).timezone,
+            logger: this.options.logger,
         });
     }
     // Only audited columns are returned; read-only/computed fields are not captured in the log.
@@ -128,18 +122,20 @@ class AuditTrailRoute extends collection_route_1.default {
         await this.services.authorization.assertCanRead(context, this.collection.name);
         const at = AuditTrailRoute.parseAt(context);
         const auditedColumns = AuditTrailRoute.auditedColumns(this.collection.schema);
-        const scope = await this.services.authorization.getScope(this.collection, context);
-        const current = await this.fetchCurrentRecord(context, auditedColumns, scope);
-        // A missing current record is ambiguous (deleted vs. out-of-scope) once a scope applies; only
-        // deny when the id still exists outside that scope. If it's genuinely gone there's nothing
-        // left to evaluate the scope against, so the revert walk below proceeds — including, possibly,
-        // surfacing a delete entry's snapshot, which is the point once nothing exists to protect.
-        if (!current && scope) {
-            const stillExists = await (0, scope_1.recordExists)(this.collection, context.params.id, context, null);
+        const permissionScope = await this.services.authorization.getScope(this.collection, context);
+        const current = await this.fetchCurrentRecord(context, auditedColumns, permissionScope);
+        // A missing current record is ambiguous (deleted vs. out-of-scope) once a permission scope applies; only
+        // deny when the id still exists outside that scope. If it's genuinely gone the revert walk
+        // below proceeds — the reconstruction is then tested against the scope in its own right, since
+        // this route hands back nothing but those values.
+        let goneEntirely = false;
+        if (!current && permissionScope) {
+            const stillExists = await (0, record_visibility_1.recordExists)(this.collection, context.params.id, context, null);
             if (stillExists) {
                 context.throw(types_1.HttpCode.NotFound, 'Record did not exist at this timestamp');
                 return;
             }
+            goneEntirely = true;
         }
         const { store } = this.options.auditTrail;
         const fetched = await store.listByRecord({
@@ -148,6 +144,15 @@ class AuditTrailRoute extends collection_route_1.default {
             startTimestamp: at,
             order: 'desc',
         });
+        // Same re-read as the history route: the record can be deleted — or moved out of the caller's
+        // permission scope — while the audit read is in flight, and without asking again the gate below
+        // never runs for a record that was still there at the first check.
+        const after = await (0, record_visibility_1.recheckRecordVisibility)(this.collection, context.params.id, context, permissionScope, goneEntirely);
+        if (after && !after.visible) {
+            context.throw(types_1.HttpCode.NotFound, 'Record did not exist at this timestamp');
+            return;
+        }
+        const goneNow = after ? after.goneEntirely : goneEntirely;
         // `startTimestamp` is an inclusive lower bound, so an entry timestamped exactly `at` comes
         // back too — but the record already reflects that entry's change at instant `at`, so it must
         // be kept rather than reverted (which would wrongly return the state just *before* it).
@@ -167,14 +172,35 @@ class AuditTrailRoute extends collection_route_1.default {
             entry.operation !== 'action_failed' &&
             entry.status !== 'pending');
         const state = (0, audit_trail_1.revertRecord)(current, entries);
-        if (!state)
+        if (!state) {
             context.throw(types_1.HttpCode.NotFound, 'Record did not exist at this timestamp');
+            return;
+        }
+        // The history route withholds a gone record's captured values from a caller whose permission scope they
+        // fail; this route is nothing but those values, reassembled, so the same test applies to the
+        // reconstruction. Without it the withheld values are one request away for the same caller.
+        // A reconstruction the permission scope cannot answer — a scope on a column the capture never
+        // kept — withholds too: absent is not the same as passing, here as everywhere else. The packed
+        // id is merged in first for the same reason it is on a row: a read-only primary key never lands
+        // in the capture, so a scope on the id would blank the very record it names.
+        if (goneNow &&
+            !(0, withhold_1.permissionScopeAccepts)(
+            // `false`: the reconstruction may sit on the far side of a primary-key move this route
+            // cannot see, so the requested id does not answer for a key the trail redacted.
+            (0, withhold_1.snapshotFor)(state, context.params.id, { collection: this.collection, logger: this.options.logger }, false), {
+                collection: this.collection,
+                permissionScope,
+                timezone: query_string_1.default.parseCaller(context, { defaultTimezone: 'UTC' }).timezone,
+            })) {
+            context.response.body = { data: null };
+            return;
+        }
         context.response.body = { data: state };
     }
-    async fetchCurrentRecord(context, auditedColumns, scope) {
+    async fetchCurrentRecord(context, auditedColumns, permissionScope) {
         const id = id_1.default.unpackId(this.collection.schema, context.params.id);
         const filter = new datasource_toolkit_1.PaginatedFilter({
-            conditionTree: datasource_toolkit_1.ConditionTreeFactory.intersect(datasource_toolkit_1.ConditionTreeFactory.matchIds(this.collection.schema, [id]), scope),
+            conditionTree: datasource_toolkit_1.ConditionTreeFactory.intersect(datasource_toolkit_1.ConditionTreeFactory.matchIds(this.collection.schema, [id]), permissionScope),
         });
         const records = await this.collection.list(query_string_1.default.parseCaller(context, { defaultTimezone: 'UTC' }), filter, new datasource_toolkit_1.Projection(...auditedColumns));
         return records[0] ?? null;
@@ -290,4 +316,4 @@ class AuditTrailRoute extends collection_route_1.default {
     }
 }
 exports.default = AuditTrailRoute;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audit-trail.js","sourceRoot":"","sources":["../../../src/routes/access/audit-trail.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audit-trail.js","sourceRoot":"","sources":["../../../src/routes/access/audit-trail.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forestadmin/agent",
-  "version": "1.103.3",
+  "version": "1.103.5",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "publishConfig": {
@@ -17,7 +17,7 @@
     "@forestadmin/datasource-customizer": "1.71.3",
     "@forestadmin/datasource-toolkit": "1.55.1",
     "@forestadmin/forestadmin-client": "1.43.4",
-    "@forestadmin/mcp-server": "1.24.5",
+    "@forestadmin/mcp-server": "1.24.6",
     "@koa/bodyparser": "^6.0.0",
     "@koa/cors": "^5.0.0",
     "@koa/router": "^13.1.0",

package/dist/audit-trail/scope.d.ts

@@ -1,20 +0,0 @@
-import type { ForestAdminHttpDriverServices } from '../services';
-import type { Collection, ConditionTree } from '@forestadmin/datasource-toolkit';
-import type { Context } from 'koa';
-export declare function recordExists(collection: Collection, packedId: string, context: Context, scope: ConditionTree | null): Promise<boolean>;
-export type RecordVisibility = {
-    /** False → the id still exists and fails the scope; the caller must be denied entirely (404). */
-    visible: boolean;
-    /**
-     * True once the id no longer exists at all, under any scope. `visible` is then true for a
-     * different reason than "the record matches the scope": there is nothing left to check
-     * existence against. It doesn't mean every value the audit trail holds for that record is safe
-     * to hand back to this caller — a scoped-down field value captured while the record still
-     * existed can still fall outside the caller's scope, and callers should check that separately
-     * (e.g. by re-evaluating the scope's `ConditionTree` against a delete row's `previousValues`)
-     * before deciding how much of the record's captured data to surface.
-     */
-    goneEntirely: boolean;
-};
-export default function checkRecordVisibility(services: ForestAdminHttpDriverServices, collection: Collection, packedId: string, context: Context): Promise<RecordVisibility>;
-//# sourceMappingURL=scope.d.ts.map

package/dist/audit-trail/scope.js

@@ -1,33 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.recordExists = recordExists;
-exports.default = checkRecordVisibility;
-const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
-const id_1 = __importDefault(require("../utils/id"));
-const query_string_1 = __importDefault(require("../utils/query-string"));
-async function recordExists(collection, packedId, context, scope) {
-    const id = id_1.default.unpackId(collection.schema, packedId);
-    const filter = new datasource_toolkit_1.PaginatedFilter({
-        conditionTree: datasource_toolkit_1.ConditionTreeFactory.intersect(datasource_toolkit_1.ConditionTreeFactory.matchIds(collection.schema, [id]), scope),
-    });
-    const records = await collection.list(query_string_1.default.parseCaller(context, { defaultTimezone: 'UTC' }), filter, new datasource_toolkit_1.Projection(...datasource_toolkit_1.SchemaUtils.getPrimaryKeys(collection.schema)));
-    return records.length > 0;
-}
-// A record-level scope can't be evaluated against a record that no longer exists, so a caller whose
-// access is scoped down is only denied when the id currently exists and fails that scope — once it's
-// genuinely gone there is nothing left to scope against, and showing that it existed (including that
-// it was deleted, by whom and when) is much of the point of an audit trail.
-async function checkRecordVisibility(services, collection, packedId, context) {
-    const scope = await services.authorization.getScope(collection, context);
-    if (!scope)
-        return { visible: true, goneEntirely: false };
-    if (await recordExists(collection, packedId, context, scope)) {
-        return { visible: true, goneEntirely: false };
-    }
-    const existsOutsideScope = await recordExists(collection, packedId, context, null);
-    return { visible: !existsOutsideScope, goneEntirely: !existsOutsideScope };
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NvcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXVkaXQtdHJhaWwvc2NvcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFjQSxvQ0FxQkM7QUFxQkQsd0NBaUJDO0FBckVELHdFQUt5QztBQUV6QyxxREFBa0M7QUFDbEMseUVBQXNEO0FBRS9DLEtBQUssVUFBVSxZQUFZLENBQ2hDLFVBQXNCLEVBQ3RCLFFBQWdCLEVBQ2hCLE9BQWdCLEVBQ2hCLEtBQTJCO0lBRTNCLE1BQU0sRUFBRSxHQUFHLFlBQU8sQ0FBQyxRQUFRLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsQ0FBQztJQUN6RCxNQUFNLE1BQU0sR0FBRyxJQUFJLG9DQUFlLENBQUM7UUFDakMsYUFBYSxFQUFFLHlDQUFvQixDQUFDLFNBQVMsQ0FDM0MseUNBQW9CLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUN0RCxLQUFLLENBQ047S0FDRixDQUFDLENBQUM7SUFFSCxNQUFNLE9BQU8sR0FBRyxNQUFNLFVBQVUsQ0FBQyxJQUFJLENBQ25DLHNCQUFpQixDQUFDLFdBQVcsQ0FBQyxPQUFPLEVBQUUsRUFBRSxlQUFlLEVBQUUsS0FBSyxFQUFFLENBQUMsRUFDbEUsTUFBTSxFQUNOLElBQUksK0JBQVUsQ0FBQyxHQUFHLGdDQUFXLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUNqRSxDQUFDO0lBRUYsT0FBTyxPQUFPLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQztBQUM1QixDQUFDO0FBaUJELG9HQUFvRztBQUNwRyxxR0FBcUc7QUFDckcscUdBQXFHO0FBQ3JHLDRFQUE0RTtBQUM3RCxLQUFLLFVBQVUscUJBQXFCLENBQ2pELFFBQXVDLEVBQ3ZDLFVBQXNCLEVBQ3RCLFFBQWdCLEVBQ2hCLE9BQWdCO0lBRWhCLE1BQU0sS0FBSyxHQUFHLE1BQU0sUUFBUSxDQUFDLGFBQWEsQ0FBQyxRQUFRLENBQUMsVUFBVSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBRXpFLElBQUksQ0FBQyxLQUFLO1FBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxDQUFDO0lBRTFELElBQUksTUFBTSxZQUFZLENBQUMsVUFBVSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUM3RCxPQUFPLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLENBQUM7SUFDaEQsQ0FBQztJQUVELE1BQU0sa0JBQWtCLEdBQUcsTUFBTSxZQUFZLENBQUMsVUFBVSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFFbkYsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDLGtCQUFrQixFQUFFLFlBQVksRUFBRSxDQUFDLGtCQUFrQixFQUFFLENBQUM7QUFDN0UsQ0FBQyJ9