@forestadmin/agent 1.95.1 → 1.96.0

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

@@ -0,0 +1,293 @@
+"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 luxon_1 = require("luxon");
+const audit_trail_1 = require("../../audit-trail");
+const scope_1 = __importStar(require("../../audit-trail/scope"));
+const types_1 = require("../../types");
+const id_1 = __importDefault(require("../../utils/id"));
+const query_string_1 = __importDefault(require("../../utils/query-string"));
+const collection_route_1 = __importDefault(require("../collection-route"));
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+const DATE_TIME = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}):(\d{2})(?::(\d{2}))?$/;
+// ISO 8601 instant: carries its own timezone designator (`Z` or `±HH:mm` / `±HHMM`).
+const ISO_INSTANT = /[Zz]$|[+-]\d{2}:?\d{2}$/;
+const DEFAULT_PAGE_SIZE = 20;
+const MAX_PAGE_SIZE = 100;
+class AuditTrailRoute extends collection_route_1.default {
+    setupRoutes(router) {
+        router.get(`/_audit-trail/${this.collectionUrlSlug}/:id`, this.handleHistory.bind(this));
+        router.get(`/_audit-trail/${this.collectionUrlSlug}/:id/state`, this.handleStateAt.bind(this));
+    }
+    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);
+        if (!visible) {
+            context.throw(types_1.HttpCode.NotFound, 'Record does not exists');
+            return;
+        }
+        const { store } = this.options.auditTrail;
+        const { skip, limit } = AuditTrailRoute.parsePagination(context);
+        const order = AuditTrailRoute.parseSort(context);
+        const { userIds, startTimestamp, endTimestamp, fields, search } = AuditTrailRoute.parseFilters(context);
+        const filters = {
+            collection: this.collection.name,
+            recordId: context.params.id,
+            ...(userIds && { userIds }),
+            ...(startTimestamp && { startTimestamp }),
+            ...(endTimestamp && { endTimestamp }),
+            ...(fields && { fields }),
+            ...(search && { search }),
+        };
+        // Distinct authors are scoped to the active filters but independent of the page — returned
+        // only on the first fetch (no explicit page[number]) so the front keeps the list it already
+        // saw rather than it silently drifting across pages, mirroring Forest's activity-logs route.
+        const isFirstFetch = context.request.query['page[number]'] === undefined;
+        // `count` reflects the active filters and is independent of the page.
+        const [rawData, count, availableUsers] = await Promise.all([
+            store.listByRecord({ ...filters, skip, limit, order }),
+            store.countByRecord(filters),
+            isFirstFetch ? store.listDistinctUsers(filters) : undefined,
+        ]);
+        // A genuinely deleted record bypasses the 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,
+        // 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;
+        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;
+        });
+    }
+    // Only audited columns are returned; read-only/computed fields are not captured in the log.
+    async handleStateAt(context) {
+        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);
+            if (stillExists) {
+                context.throw(types_1.HttpCode.NotFound, 'Record did not exist at this timestamp');
+                return;
+            }
+        }
+        const { store } = this.options.auditTrail;
+        const fetched = await store.listByRecord({
+            collection: this.collection.name,
+            recordId: context.params.id,
+            startTimestamp: at,
+            order: 'desc',
+        });
+        // `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).
+        //
+        // Action rows are excluded outright: their previousValues/newValues hold a submitted form and a
+        // summary of the action's answer, not column values, so replaying them as a diff would corrupt
+        // the reconstructed record. An action's effect on the data still shows up through the
+        // create/update/delete rows it produced under the same correlation key.
+        //
+        // A `pending` row is also excluded: its write may or may not have landed (that's the whole
+        // point of the status), and if it hasn't, its previousValues/newValues aren't the write's
+        // actual result — a concurrent request could otherwise revert a mutation that never happened,
+        // or a row left permanently `pending` (e.g. the process crashed between write and confirm)
+        // would permanently corrupt every state-at-a-past-timestamp reconstruction for this record.
+        const entries = fetched.filter(entry => entry.timestamp !== at &&
+            entry.operation !== 'action' &&
+            entry.operation !== 'action_failed' &&
+            entry.status !== 'pending');
+        const state = (0, audit_trail_1.revertRecord)(current, entries);
+        if (!state)
+            context.throw(types_1.HttpCode.NotFound, 'Record did not exist at this timestamp');
+        context.response.body = { data: state };
+    }
+    async fetchCurrentRecord(context, auditedColumns, scope) {
+        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),
+        });
+        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;
+    }
+    // Must mirror the audit log's column selection (writable + primary keys, including read-only
+    // PKs) so the reconstructed record carries the same columns the log captured.
+    static auditedColumns(schema) {
+        const writable = Object.keys(schema.fields).filter(name => {
+            const field = schema.fields[name];
+            return field.type === 'Column' && !field.isReadOnly;
+        });
+        return [...new Set([...datasource_toolkit_1.SchemaUtils.getPrimaryKeys(schema), ...writable])];
+    }
+    static parseAt(context) {
+        const query = context.request.query;
+        const raw = query.at?.toString();
+        if (!raw)
+            throw new datasource_toolkit_1.ValidationError('Missing "at" query parameter');
+        const timezone = query.timezone?.toString() || 'UTC';
+        return AuditTrailRoute.parseDateBoundary(raw, timezone, 'start');
+    }
+    // JSON:API `sort=timestamp` → oldest first, anything else (or absent) → newest first.
+    static parseSort(context) {
+        const sort = context.request.query.sort?.toString();
+        return sort === 'timestamp' ? 'asc' : 'desc';
+    }
+    // 1-based `page[number]` (default 1) and `page[size]` (default 20, capped at 100). Invalid values
+    // fall back to the defaults rather than erroring.
+    static parsePagination(context) {
+        const query = context.request.query;
+        const size = AuditTrailRoute.parsePageSize(query['page[size]']?.toString());
+        const number = AuditTrailRoute.parsePageNumber(query['page[number]']?.toString());
+        return { skip: (number - 1) * size, limit: size };
+    }
+    static parsePageSize(raw) {
+        const size = Number.parseInt(raw ?? '', 10);
+        if (Number.isNaN(size) || size < 1)
+            return DEFAULT_PAGE_SIZE;
+        return Math.min(size, MAX_PAGE_SIZE);
+    }
+    static parsePageNumber(raw) {
+        const number = Number.parseInt(raw ?? '', 10);
+        return Number.isNaN(number) || number < 1 ? 1 : number;
+    }
+    static parseFilters(context) {
+        const query = context.request.query;
+        const timezone = query.timezone?.toString() || 'UTC';
+        return {
+            userIds: AuditTrailRoute.parseUserIds(query.userIds?.toString()),
+            startTimestamp: AuditTrailRoute.parseDateBoundary(query.startDate?.toString(), timezone, 'start'),
+            endTimestamp: AuditTrailRoute.parseDateBoundary(query.endDate?.toString(), timezone, 'end'),
+            fields: AuditTrailRoute.parseFields(query.fields?.toString()),
+            search: AuditTrailRoute.parseSearch(query.search?.toString()),
+        };
+    }
+    // Comma-separated integer ids; non-numeric tokens are dropped. Empty after parsing → no filter.
+    static parseUserIds(raw) {
+        if (!raw)
+            return undefined;
+        const ids = raw
+            .split(',')
+            .map(token => token.trim())
+            .filter(token => /^\d+$/.test(token))
+            .map(token => Number.parseInt(token, 10));
+        return ids.length > 0 ? ids : undefined;
+    }
+    static parseFields(raw) {
+        if (!raw)
+            return undefined;
+        const fields = raw
+            .split(',')
+            .map(token => token.trim())
+            .filter(token => token.length > 0);
+        return fields.length > 0 ? fields : undefined;
+    }
+    // Trimmed; empty after trimming is treated the same as absent.
+    static parseSearch(raw) {
+        const trimmed = raw?.trim();
+        return trimmed || undefined;
+    }
+    // Bare day (`YYYY-MM-DD`) or wall-clock datetime (`YYYY-MM-DD[T| ]HH:mm[:ss]`), interpreted as
+    // local time in the request timezone and returned as a UTC instant so the store can compare it
+    // to stored timestamps.
+    static parseDateBoundary(raw, timezone, boundary) {
+        if (!raw)
+            return undefined;
+        const instant = AuditTrailRoute.toLocalInstant(raw, timezone, boundary);
+        if (!instant.isValid) {
+            throw new datasource_toolkit_1.ValidationError(instant.invalidReason === 'unsupported zone'
+                ? `Invalid timezone: "${timezone}"`
+                : `Invalid date: "${raw}" (expected YYYY-MM-DD, YYYY-MM-DDTHH:mm, or an ISO 8601 instant)`);
+        }
+        return instant.toUTC().toISO() ?? undefined;
+    }
+    static toLocalInstant(raw, timezone, boundary) {
+        // An embedded offset already pins the instant — the request timezone and start/end boundary
+        // don't apply.
+        if (ISO_INSTANT.test(raw))
+            return luxon_1.DateTime.fromISO(raw, { setZone: true });
+        if (DATE_ONLY.test(raw)) {
+            const day = luxon_1.DateTime.fromISO(raw, { zone: timezone });
+            return boundary === 'end' ? day.endOf('day') : day.startOf('day');
+        }
+        const match = DATE_TIME.exec(raw);
+        if (!match)
+            return luxon_1.DateTime.invalid('unparsable');
+        const [, date, hours, minutes, seconds] = match;
+        const base = luxon_1.DateTime.fromISO(`${date}T${hours}:${minutes}`, { zone: timezone });
+        if (seconds !== undefined)
+            return base.set({ second: Number(seconds), millisecond: 0 });
+        // Minutes-only: end snaps to :59.999 to stay inclusive; start stays at :00.000.
+        return boundary === 'end' ? base.set({ second: 59, millisecond: 999 }) : base;
+    }
+}
+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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"}

package/dist/routes/capabilities.js

@@ -24,6 +24,10 @@ class Capabilities extends base_route_1.default {
                 canUseProjectionViaHeader: true,
                 canUseProjectionViaHeaderOnList: true,
                 canUseMultipleFieldsProjectionOnRelation: true,
+                // The audit-trail routes are only mounted when `auditTrail` is configured, but
+                // `x-forest-correlation-id` is emitted on every response regardless — the frontend must
+                // gate the History tab on this flag rather than inferring the feature from that header.
+                canUseAuditTrail: this.options.auditTrail !== null,
             },
             collections: collections?.map(collection => {
                 const { aggregationCapabilities } = collection.schema;
@@ -74,4 +78,4 @@ class Capabilities extends base_route_1.default {
     }
 }
 exports.default = Capabilities;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/routes/index.js

@@ -7,6 +7,8 @@ exports.NATIVE_QUERY_ROUTES_CTOR = exports.CAPABILITIES_ROUTES_CTOR = exports.RE
 exports.default = makeRoutes;
 const api_chart_collection_1 = __importDefault(require("./access/api-chart-collection"));
 const api_chart_datasource_1 = __importDefault(require("./access/api-chart-datasource"));
+const audit_trail_1 = __importDefault(require("./access/audit-trail"));
+const audit_trail_correlation_1 = __importDefault(require("./access/audit-trail-correlation"));
 const chart_1 = __importDefault(require("./access/chart"));
 const count_1 = __importDefault(require("./access/count"));
 const count_related_1 = __importDefault(require("./access/count-related"));
@@ -118,6 +120,16 @@ function getWorkflowExecutorRoutes(options, services) {
         return [];
     return [new workflow_executor_proxy_1.default(services, options)];
 }
+function getAuditTrailRoutes(dataSource, options, services) {
+    if (!options.auditTrail)
+        return [];
+    return [
+        // Registered before the per-collection routes: if a collection is named "correlation", its
+        // `/_audit-trail/correlation/:id` route would otherwise shadow this one.
+        new audit_trail_correlation_1.default(services, options, dataSource),
+        ...dataSource.collections.map(collection => new audit_trail_1.default(services, options, dataSource, collection.name)),
+    ];
+}
 function makeRoutes(dataSource, options, services) {
     const routes = [
         ...getRootRoutes(options, services),
@@ -128,8 +140,9 @@ function makeRoutes(dataSource, options, services) {
         ...getRelatedRoutes(dataSource, options, services),
         ...getActionRoutes(dataSource, options, services),
         ...getWorkflowExecutorRoutes(options, services),
+        ...getAuditTrailRoutes(dataSource, options, services),
     ];
     // Ensure routes and middlewares are loaded in the right order.
     return routes.sort((a, b) => a.type - b.type);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/routes/modification/action/action.d.ts

@@ -9,6 +9,9 @@ export default class ActionRoute extends CollectionRoute {
     constructor(services: ForestAdminHttpDriverServices, options: AgentOptionsWithDefaults, dataSource: DataSource, collectionName: string, actionName: string);
     setupRoutes(router: Router): void;
     private handleExecute;
+    private executeAndAudit;
+    private resolveAuditedRecordIds;
+    private auditedRecordIds;
     private handleHook;
     private middlewareCustomActionApprovalRequestData;
     private getRecordSelection;

package/dist/routes/modification/action/action.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
 const action_authorization_1 = __importDefault(require("./action-authorization"));
+const audit_trail_1 = require("../../../audit-trail");
 const types_1 = require("../../../types");
 const body_parser_1 = __importDefault(require("../../../utils/body-parser"));
 const context_filter_factory_1 = __importDefault(require("../../../utils/context-filter-factory"));
@@ -65,7 +66,7 @@ class ActionRoute extends collection_route_1.default {
         const { fields } = generator_actions_1.default.extractFieldsAndLayout(form);
         // Now that we have the field list, we can parse the data again.
         const data = action_values_1.default.makeFormData(dataSource, rawData, fields);
-        const result = await this.collection.execute(caller, this.actionName, data, filterForCaller);
+        const result = await this.executeAndAudit(context, caller, data, filterForCaller);
         if (result.responseHeaders) {
             context.response.set(result.responseHeaders);
         }
@@ -97,6 +98,109 @@ class ActionRoute extends collection_route_1.default {
             throw new Error('Unexpected Action result.');
         }
     }
+    // A failed run is worth recording too: "who tried to run this" is usually the interesting part.
+    // A resolved `{ type: 'Error' }` result counts as failed as well — the customer-declared action
+    // rejected the request (HTTP 400 below), it just didn't throw to say so.
+    //
+    // Record ids are resolved *before* `execute()` runs, not after: the action itself may delete the
+    // targeted records or change a field their own selection filter matched on, so resolving them
+    // afterward could find nothing and silently lose the association between the audit entry and the
+    // records it actually affected. The pending audit entry is inserted before `execute()` too, for the
+    // same reason `instrument.ts` inserts pending rows before a create/update/delete runs: a broken
+    // store fails the request *before* the action has any effect, instead of 500ing after it already
+    // ran (`critical: true`), or is swallowed and the action proceeds unaudited (`critical: false`,
+    // default) — see `captureActionPending`.
+    async executeAndAudit(context, caller, data, filter) {
+        const { auditTrail } = this.options;
+        const recordIds = await this.resolveAuditedRecordIds(context, caller, filter);
+        const audit = auditTrail
+            ? {
+                recorder: (0, audit_trail_1.buildRecorder)(auditTrail.store, undefined, auditTrail.critical ?? false, this.options.logger),
+                redactedFields: auditTrail.redact?.[this.collection.name] ?? [],
+            }
+            : null;
+        const pending = audit
+            ? await (0, audit_trail_1.captureActionPending)(audit.recorder, audit.redactedFields, {
+                caller,
+                collection: this.collection.name,
+                actionName: this.actionName,
+                formValues: data,
+                recordIds,
+            })
+            : null;
+        try {
+            const result = await this.collection.execute(caller, this.actionName, data, filter);
+            if (audit && pending) {
+                await (0, audit_trail_1.captureActionConfirm)(audit.recorder, pending, result, result.type === 'Error');
+            }
+            return result;
+        }
+        catch (error) {
+            if (audit && pending)
+                await (0, audit_trail_1.captureActionConfirm)(audit.recorder, pending, undefined, true);
+            throw error;
+        }
+    }
+    // Best-effort under `critical: false`: resolving the audited ids is itself an extra query (see
+    // auditedRecordIds), and a transient failure there must not prevent the action from running at
+    // all — same principle the pending-capture step below applies. Under `critical: true`, falling
+    // back to `[]` would let a record-scoped action run with only a no-record audit entry instead of
+    // per-record coverage, which is exactly what `critical` exists to refuse — so this rethrows
+    // there instead, refusing the action before execute() runs.
+    async resolveAuditedRecordIds(context, caller, filter) {
+        if (!this.options.auditTrail)
+            return [];
+        try {
+            return await this.auditedRecordIds(context, caller, filter);
+        }
+        catch (error) {
+            if (this.options.auditTrail.critical)
+                throw error;
+            this.options.logger('Error', `[ForestAdmin] Unable to resolve audited record ids, continuing: ${error}`);
+            return [];
+        }
+    }
+    // Packed ids, the form the audit store keys on. A global action targets nothing, and a select-all
+    // selection only tells us which ids were *excluded*: naming the targets would mean querying the
+    // whole selection, so those runs are recorded once, attached to no record. An explicit selection
+    // is narrowed down to the caller's own authorized subset — via `filterForCaller`, the same filter
+    // `execute()` itself was given — so an id excluded by scope doesn't get an entry for an action that
+    // never touched it.
+    //
+    // The selection is capped at MAX_SNAPSHOT_RECORDS, same as a bulk update/delete's before-write
+    // snapshot (instrument.ts) and the same value the Ruby agent uses for this exact check — one shared
+    // constant so the two can't drift apart. Fetching cap+1 is what makes "matched more than the cap"
+    // distinguishable from "matched exactly the cap". Over the cap, recording one row per id would be a
+    // partial audit of the run, which is what `critical` exists to refuse; non-critical falls back to
+    // the existing no-record-attached recording instead of naming a subset of the targets.
+    //
+    // `filterForCaller` can carry a live-query segment with unresolved `$contextVariable` placeholders
+    // — the same filter reaches `getForm`/`execute` unresolved too, but those hand it to the collection
+    // as-is; this method calls `collection.list` directly, so it must run the filter through
+    // `segmentQueryHandler.handleLiveQuerySegmentFilter` itself first, the same step `list`/`count`
+    // apply before their own `collection.list` call.
+    async auditedRecordIds(context, caller, filterForCaller) {
+        if (this.collection.schema.actions[this.actionName].scope === 'Global')
+            return [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const attributes = context.request.body?.data?.attributes;
+        if (attributes?.all_records)
+            return [];
+        if (!attributes?.ids?.length)
+            return [];
+        const paginatedFilter = await this.services.segmentQueryHandler.handleLiveQuerySegmentFilter(context, new datasource_toolkit_1.PaginatedFilter({ ...filterForCaller, page: new datasource_toolkit_1.Page(0, audit_trail_1.MAX_SNAPSHOT_RECORDS + 1) }));
+        const authorized = await this.collection.list(caller, paginatedFilter, new datasource_toolkit_1.Projection(...datasource_toolkit_1.SchemaUtils.getPrimaryKeys(this.collection.schema)));
+        if (authorized.length <= audit_trail_1.MAX_SNAPSHOT_RECORDS) {
+            return id_1.default.packIds(this.collection.schema, authorized);
+        }
+        const message = `[ForestAdmin] Audit trail: "${this.collection.name}" action "${this.actionName}" targets ` +
+            `more than ${audit_trail_1.MAX_SNAPSHOT_RECORDS} records — recorded as one entry attached to no record.`;
+        if (this.options.auditTrail.critical) {
+            throw new Error(`${message} Refusing the action because "critical" is enabled.`);
+        }
+        this.options.logger('Warn', message);
+        return [];
+    }
     async handleHook(context) {
         const body = context.request.body;
         const { id: userId } = context.state.user;
@@ -170,4 +274,4 @@ class ActionRoute extends collection_route_1.default {
     }
 }
 exports.default = ActionRoute;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action.js","sourceRoot":"","sources":["../../../../src/routes/modification/action/action.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action.js","sourceRoot":"","sources":["../../../../src/routes/modification/action/action.ts"],"names":[],"mappings":"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"}