@forestadmin/agent 1.95.2 → 1.97.0

package/dist/audit-trail/instrument.js

@@ -0,0 +1,393 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REDACTED = exports.MAX_SNAPSHOT_RECORDS = void 0;
+exports.buildRecorder = buildRecorder;
+exports.default = installAuditTrailHooks;
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const stableKeyOrderReplacer = (key, value) => {
+    // JSON.stringify has no native BigInt support and throws on one, regardless of nesting depth or
+    // whether it's the root value; the replacer gets a chance to convert it first either way.
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return Object.keys(value)
+            .sort()
+            .reduce((sorted, name) => {
+            sorted[name] = value[name];
+            return sorted;
+        }, {});
+    }
+    return value;
+};
+// Date/BSON values round-trip through JSON.stringify via their toJSON; the replacer makes
+// plain-object key order irrelevant.
+const deepEquals = (a, b) => JSON.stringify(a, stableKeyOrderReplacer) === JSON.stringify(b, stableKeyOrderReplacer);
+// A value with its own `toJSON` (Date, a BSON wrapper) has a canonical representation that
+// `Object.entries` can't be trusted to reproduce: BSON's `toJSON` is typically on the prototype
+// while the actual data lives in unrelated (and sometimes non-enumerable) own fields, so walking
+// `Object.entries` would silently reconstruct the wrong — or an empty — object instead.
+const hasCanonicalJson = (value) => typeof value.toJSON === 'function';
+// A raw BigInt surviving into a stored `previousValues`/`newValues` would fail later — Sequelize
+// serializing the JSON column, or Koa serializing an HTTP history response — the same way
+// JSON.stringify does above. Recurses through arrays and plain objects (leaving anything with its
+// own `toJSON` untouched, see above) since a BigInt can be nested inside a JSON column's value
+// rather than being the column's value itself — `pickColumns` hands this a whole column value
+// unprocessed by `diff`'s own recursion, and a primitive array is a `diff` leaf kept whole rather
+// than walked.
+const toJsonSafe = (value) => {
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (Array.isArray(value))
+        return value.map(toJsonSafe);
+    if (value && typeof value === 'object' && !hasCanonicalJson(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+            key,
+            toJsonSafe(entry),
+        ]));
+    }
+    return value;
+};
+// Records touched by a bulk operation, bounded so one write can't hold an unbounded result set in
+// memory (or fan out an unbounded number of pending-row inserts). Truncation is logged explicitly
+// rather than silently auditing only part of the operation. Also the cap a smart action's audited
+// selection is checked against (action.ts) — one constant, so the two can't drift apart the way this
+// value and the Ruby agent's once did.
+exports.MAX_SNAPSHOT_RECORDS = 1000;
+// One caller-supplied `Filter` object can be reused across concurrent (or sequential, e.g. a
+// continue-on-error bulk loop) operations sharing the same template, so each key holds a queue of
+// snapshots rather than a single value — otherwise a second `Before` would overwrite the first
+// snapshot and its `After` would silently emit nothing.
+const snapshotsByFilter = new WeakMap();
+function pushSnapshot(key, entry) {
+    const queue = snapshotsByFilter.get(key) ?? [];
+    queue.push(entry);
+    snapshotsByFilter.set(key, queue);
+}
+// Correlates by `patch` content rather than queue position: if a write throws, its `Before`
+// snapshot is never consumed (there is no matching `After` call), so blindly taking the front of
+// the queue would hand a later, unrelated operation someone else's stale snapshot instead of its
+// own. Delete has no equivalent secondary key, so it falls back to FIFO order — a narrower version
+// of the same risk that remains for deletes sharing one `Filter` reference.
+function takeSnapshot(key, patch) {
+    const queue = snapshotsByFilter.get(key);
+    if (!queue || queue.length === 0)
+        return undefined;
+    const index = patch ? queue.findIndex(entry => deepEquals(entry.patch, patch)) : 0;
+    const [entry] = queue.splice(index === -1 ? 0 : index, 1);
+    if (queue.length === 0)
+        snapshotsByFilter.delete(key);
+    return entry;
+}
+// Create has no Filter to key by (there's nothing to select yet), but `context.data` is the exact
+// same array reference in both the Before and After hook for one `.create()` call — verified via
+// `HookBeforeCreateContext`/`HookAfterCreateContext`, which both wrap the literal `data` argument.
+const pendingIdsByData = new WeakMap();
+// Must match IdUtils.packId so recordIds align with the rest of Forest.
+const toPackedRecordId = (record, primaryKeys) => {
+    if (primaryKeys.length === 0) {
+        throw new Error('Cannot audit a collection with no primary key');
+    }
+    return primaryKeys.map(pk => String(record[pk])).join('|');
+};
+const pickColumns = (record, columns) => Object.fromEntries(columns.map(column => [column, toJsonSafe(record[column]) ?? null]));
+const isPlainObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date);
+const isObjectArray = (value) => Array.isArray(value) && value.length > 0 && value.every(isPlainObject);
+// Returns only the leaves that changed. Plain objects and object-arrays recurse; everything else
+// (scalars, primitive arrays, Date, BSON) is compared and kept whole. A leaf that did not exist
+// before/after (as opposed to one explicitly set to `null`) is marked `*Absent`, so the caller
+// simply omits that key/index from that side rather than writing a placeholder value: the stored
+// diff itself never carries a marker, it just doesn't have the key.
+const diff = (before, after) => {
+    if (deepEquals(before, after))
+        return null;
+    if (isPlainObject(before) && isPlainObject(after)) {
+        const previous = {};
+        const next = {};
+        for (const key of new Set([...Object.keys(before), ...Object.keys(after)])) {
+            const subDelta = diff(before[key], after[key]);
+            if (subDelta) {
+                if (!subDelta.previousAbsent)
+                    previous[key] = subDelta.previous;
+                if (!subDelta.nextAbsent)
+                    next[key] = subDelta.next;
+            }
+        }
+        return { previous, next, previousAbsent: false, nextAbsent: false };
+    }
+    if (isObjectArray(before) && isObjectArray(after)) {
+        const previous = {};
+        const next = {};
+        for (let index = 0; index < Math.max(before.length, after.length); index += 1) {
+            const subDelta = diff(before[index], after[index]);
+            if (subDelta) {
+                if (!subDelta.previousAbsent)
+                    previous[index] = subDelta.previous;
+                if (!subDelta.nextAbsent)
+                    next[index] = subDelta.next;
+            }
+        }
+        return { previous, next, previousAbsent: false, nextAbsent: false };
+    }
+    return {
+        previous: before === undefined ? undefined : toJsonSafe(before) ?? null,
+        next: after === undefined ? undefined : toJsonSafe(after) ?? null,
+        previousAbsent: before === undefined,
+        nextAbsent: after === undefined,
+    };
+};
+// Diffs against the record actually persisted by the write (`after`), not the requested patch, so
+// the log reflects normalization/coercion/side effects applied by the datasource or a decorator.
+const changedValues = (before, after, columns) => {
+    const previousValues = {};
+    const newValues = {};
+    for (const column of columns) {
+        const delta = diff(before[column], after[column]);
+        if (delta) {
+            if (!delta.previousAbsent)
+                previousValues[column] = delta.previous;
+            if (!delta.nextAbsent)
+                newValues[column] = delta.next;
+        }
+    }
+    return { previousValues, newValues };
+};
+exports.REDACTED = '[redacted]';
+const redactValues = (values, redactedFields) => {
+    if (!redactedFields.length)
+        return values;
+    const result = { ...values };
+    for (const field of redactedFields)
+        if (field in result)
+            result[field] = exports.REDACTED;
+    return result;
+};
+const consoleSink = record => {
+    // eslint-disable-next-line no-console
+    console.info('[audit-trail]', JSON.stringify(record));
+};
+function buildRecorder(store, sink, critical, logger) {
+    if (store) {
+        return {
+            async insertPendingBatch(records) {
+                if (records.length === 0)
+                    return [];
+                try {
+                    return await store.insertPendingBatch(records);
+                }
+                catch (error) {
+                    // Critical: no unaudited write — refuse the operation before it runs. Non-critical:
+                    // logged and swallowed, exactly like today's single-shot failures; the write proceeds
+                    // with nothing to confirm later.
+                    if (critical)
+                        throw error;
+                    logger?.('Error', `[ForestAdmin] Audit trail: unable to record pending entries, continuing: ${error}`);
+                    return records.map(() => null);
+                }
+            },
+            async confirm(id, patch) {
+                if (id === null)
+                    return;
+                try {
+                    await store.confirm(id, patch);
+                }
+                catch (error) {
+                    // The write has already happened by now; there is nothing left to refuse.
+                    logger?.('Error', `[ForestAdmin] Audit trail: unable to confirm entry, continuing: ${error}`);
+                }
+            },
+        };
+    }
+    const emit = sink ?? consoleSink;
+    const pendingById = new Map();
+    let nextId = 1;
+    return {
+        async insertPendingBatch(records) {
+            return records.map(record => {
+                const id = nextId;
+                nextId += 1;
+                pendingById.set(id, record);
+                return id;
+            });
+        },
+        async confirm(id, patch) {
+            if (id === null)
+                return;
+            const pending = pendingById.get(id);
+            pendingById.delete(id);
+            if (!pending)
+                return;
+            try {
+                await emit({ ...pending, ...patch });
+            }
+            catch (error) {
+                // The write has already happened by now; there is nothing left to refuse.
+                logger?.('Error', `[ForestAdmin] Audit trail: unable to confirm entry, continuing: ${error}`);
+            }
+        },
+    };
+}
+function instrumentCollection(collection, recorder, redactedFields, logger, critical) {
+    const { schema } = collection;
+    const writableColumns = Object.keys(schema.fields).filter(name => {
+        const field = schema.fields[name];
+        return field.type === 'Column' && !field.isReadOnly;
+    });
+    const primaryKeys = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(schema);
+    // PKs may be read-only, but they are required to build the packed recordId; the diff itself
+    // stays restricted to writableColumns.
+    const readProjection = [...new Set([...primaryKeys, ...writableColumns])];
+    const { name } = collection;
+    const buildRecord = (caller, entry) => ({
+        timestamp: new Date().toISOString(),
+        collection: name,
+        userId: caller.id,
+        userFirstName: caller.firstName,
+        userLastName: caller.lastName,
+        userEmail: caller.email,
+        actionName: null,
+        correlationKey: caller.requestId,
+        ...entry,
+        previousValues: redactValues(entry.previousValues, redactedFields),
+        newValues: redactValues(entry.newValues, redactedFields),
+    });
+    // Requests one more than the cap: fetching exactly `MAX_SNAPSHOT_RECORDS` can never distinguish
+    // "matched exactly the cap" (nothing lost) from "matched more than it" (truncated) — the extra
+    // row is what makes that distinguishable, and is dropped again below before anything is audited.
+    // Constructs a real `PaginatedFilter` (via `.override`-equivalent spread of `context.filter`'s
+    // own fields, which is a plain `Filter` for Update/Delete) rather than merging `page` onto a bare
+    // object: the latter would depend on `context.collection.list` happening to reconstruct a proper
+    // instance from whatever shape it's handed, which isn't part of its contract.
+    const withLimit = (filter) => new datasource_toolkit_1.PaginatedFilter({ ...filter, page: new datasource_toolkit_1.Page(0, exports.MAX_SNAPSHOT_RECORDS + 1) });
+    // Hitting the cap means the operation may have matched more records than were actually audited.
+    // Under `critical: false`, silently dropping the excess would look identical to "everything got
+    // audited" — logged instead. Under `critical: true`, that gap is exactly what the option exists
+    // to refuse: no unaudited write, so the whole operation is refused rather than let through
+    // partially covered.
+    const enforceSnapshotCap = (operation, truncated) => {
+        if (!truncated)
+            return;
+        const message = `[ForestAdmin] Audit trail: "${name}" ${operation} matched more than ` +
+            `${exports.MAX_SNAPSHOT_RECORDS} records — only the first ${exports.MAX_SNAPSHOT_RECORDS} can be audited.`;
+        if (critical) {
+            throw new Error(`${message} Refusing the operation because "critical" is enabled.`);
+        }
+        logger?.('Warn', `${message} The rest were skipped.`);
+    };
+    collection.addInternalHook('Before', 'Create', async (context) => {
+        const pendingRecords = context.data.map(() => buildRecord(context.caller, {
+            operation: 'create',
+            recordId: null,
+            previousValues: {},
+            newValues: {},
+        }));
+        const pendingIds = await recorder.insertPendingBatch(pendingRecords);
+        pendingIdsByData.set(context.data, pendingIds);
+    });
+    collection.addInternalHook('After', 'Create', async (context) => {
+        const pendingIds = pendingIdsByData.get(context.data) ?? [];
+        pendingIdsByData.delete(context.data);
+        await Promise.all(context.records.map((record, index) => recorder.confirm(pendingIds[index] ?? null, {
+            operation: 'create',
+            recordId: toPackedRecordId(record, primaryKeys),
+            previousValues: {},
+            newValues: redactValues(pickColumns(record, writableColumns), redactedFields),
+        })));
+    });
+    collection.addInternalHook('Before', 'Update', async (context) => {
+        const fetched = (await context.collection.list(
+        // `context.filter` is typed as the plain-object `TFilter` shape for customer ergonomics, but
+        // is a real (frozen) `Filter` instance at runtime — the same cast the hook decorator itself
+        // performs to produce it.
+        withLimit(context.filter), readProjection));
+        const truncated = fetched.length > exports.MAX_SNAPSHOT_RECORDS;
+        enforceSnapshotCap('update', truncated);
+        const before = truncated ? fetched.slice(0, exports.MAX_SNAPSHOT_RECORDS) : fetched;
+        const pendingRecords = before.map(record => buildRecord(context.caller, {
+            operation: 'update',
+            recordId: toPackedRecordId(record, primaryKeys),
+            previousValues: pickColumns(record, writableColumns),
+            newValues: {},
+        }));
+        const pendingIds = await recorder.insertPendingBatch(pendingRecords);
+        pushSnapshot(context.filter, { before, patch: context.patch, pendingIds });
+    });
+    collection.addInternalHook('After', 'Update', async (context) => {
+        const snapshot = takeSnapshot(context.filter, context.patch);
+        if (!snapshot || snapshot.before.length === 0)
+            return;
+        const { before, pendingIds } = snapshot;
+        // Re-read each touched record by its own (possibly patch-changed) identity rather than via
+        // `context.filter`: if the update changed a field the filter matched on — including a
+        // writable primary key — re-querying with that same filter would find nothing, silently
+        // dropping the entry instead of filing it under the record's new id.
+        const expectedRecords = before.map(record => ({ ...record, ...context.patch }));
+        const expectedIds = expectedRecords.map(record => primaryKeys.map(pk => record[pk]));
+        const after = (await context.collection.list({ conditionTree: datasource_toolkit_1.ConditionTreeFactory.matchIds(schema, expectedIds) }, readProjection));
+        const afterById = new Map(after.map(record => [toPackedRecordId(record, primaryKeys), record]));
+        await Promise.all(before.map((record, index) => {
+            const updated = afterById.get(toPackedRecordId(expectedRecords[index], primaryKeys));
+            const pendingId = pendingIds[index] ?? null;
+            if (!updated)
+                return undefined;
+            const { previousValues, newValues } = changedValues(record, updated, writableColumns);
+            // Confirmed even when empty: the write still ran and resolved, so leaving the pending row
+            // unconfirmed would misrepresent a completed no-op write as one that never landed.
+            // Packed from the post-update values: if the update changed a writable primary key, the
+            // entry is filed under the record's new id, matching what later history lookups use.
+            return recorder.confirm(pendingId, {
+                operation: 'update',
+                recordId: toPackedRecordId(updated, primaryKeys),
+                previousValues: redactValues(previousValues, redactedFields),
+                newValues: redactValues(newValues, redactedFields),
+            });
+        }));
+    });
+    collection.addInternalHook('Before', 'Delete', async (context) => {
+        const fetched = (await context.collection.list(
+        // `context.filter` is typed as the plain-object `TFilter` shape for customer ergonomics, but
+        // is a real (frozen) `Filter` instance at runtime — the same cast the hook decorator itself
+        // performs to produce it.
+        withLimit(context.filter), readProjection));
+        const truncated = fetched.length > exports.MAX_SNAPSHOT_RECORDS;
+        enforceSnapshotCap('delete', truncated);
+        const before = truncated ? fetched.slice(0, exports.MAX_SNAPSHOT_RECORDS) : fetched;
+        const pendingRecords = before.map(record => buildRecord(context.caller, {
+            operation: 'delete',
+            recordId: toPackedRecordId(record, primaryKeys),
+            previousValues: pickColumns(record, writableColumns),
+            newValues: {},
+        }));
+        const pendingIds = await recorder.insertPendingBatch(pendingRecords);
+        pushSnapshot(context.filter, { before, pendingIds });
+    });
+    collection.addInternalHook('After', 'Delete', async (context) => {
+        const snapshot = takeSnapshot(context.filter);
+        if (!snapshot)
+            return;
+        const { before, pendingIds } = snapshot;
+        await Promise.all(before.map((record, index) => recorder.confirm(pendingIds[index] ?? null, {
+            operation: 'delete',
+            recordId: toPackedRecordId(record, primaryKeys),
+            previousValues: redactValues(pickColumns(record, writableColumns), redactedFields),
+            newValues: {},
+        })));
+    });
+}
+function installAuditTrailHooks(dataSourceCustomizer, _collectionCustomizer, options) {
+    const { sink, store, redact, critical = false, logger } = options ?? {};
+    const recorder = buildRecorder(store, sink, critical, logger);
+    for (const collection of dataSourceCustomizer.collections) {
+        // toPackedRecordId throws for a collection with no primary key — there is nothing to key an
+        // audit entry on, so skip instrumenting it entirely rather than installing hooks that would
+        // throw on the collection's first write.
+        if (datasource_toolkit_1.SchemaUtils.getPrimaryKeys(collection.schema).length === 0) {
+            logger?.('Warn', `[ForestAdmin] Audit trail: skipping "${collection.name}" — it has no primary key.`);
+        }
+        else {
+            instrumentCollection(collection, recorder, redact?.[collection.name] ?? [], logger, critical);
+        }
+    }
+    // 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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"}

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

@@ -0,0 +1,34 @@
+import type { QueryInterface, Sequelize, Transaction } from 'sequelize';
+import { Umzug } from 'umzug';
+export type MigrationContext = {
+    queryInterface: QueryInterface;
+    schema?: string;
+    tableName: string;
+    transaction?: Transaction;
+};
+export declare function buildUmzug(sequelize: Sequelize, options: {
+    schema?: string;
+    tableName: string;
+    transaction?: Transaction;
+}): Umzug<MigrationContext>;
+export declare function isSchemaAlreadyExistsError(error: unknown): boolean;
+/**
+ * Idempotent CREATE SCHEMA. Must run (and commit) on its own before Umzug, because Umzug's storage
+ * opens its own connection to create the meta table and would not see a CREATE SCHEMA still
+ * pending in a transaction. Not covered by the advisory lock; the existence check + tolerated
+ * "already exists" error makes it safe under concurrent boots instead.
+ */
+export declare function ensureSchema(sequelize: Sequelize, schema: string | undefined): Promise<void>;
+/**
+ * Creates the schema then applies every pending audit-table migration. On Postgres the migrations
+ * run inside a transaction-scoped advisory lock, and every DDL statement runs on that same
+ * transaction, so concurrent agent boots serialize on the DDL and a failure partway through a
+ * migration rolls back cleanly instead of leaving partial DDL behind. Other dialects have no
+ * equivalent distributed lock; each migration instead checks what already exists before creating
+ * it, which closes most — but not all — of the race window on a truly simultaneous boot.
+ */
+export declare function runAuditMigrations(sequelize: Sequelize, options: {
+    schema?: string;
+    tableName: string;
+}): Promise<void>;
+//# sourceMappingURL=migrations.d.ts.map