@forestadmin/agent 1.95.2 → 1.96.0

package/dist/audit-trail/migrations.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUmzug = buildUmzug;
+exports.isSchemaAlreadyExistsError = isSchemaAlreadyExistsError;
+exports.ensureSchema = ensureSchema;
+exports.runAuditMigrations = runAuditMigrations;
+const sequelize_1 = require("sequelize");
+const umzug_1 = require("umzug");
+// Arbitrary but stable pair, only needs to be unique across the advisory locks the application
+// takes — the audit-trail migration is the only critical section we hold this lock for.
+const ADVISORY_LOCK = [0x464f, 0x5254];
+// Scoped by `tableName` (not a single fixed name) so two stores configured with different table
+// names in the same schema don't share migration state — otherwise Umzug would see the second
+// store's migrations as already applied and never create its table.
+function migrationsTableName(tableName) {
+    return `${tableName}_migration`;
+}
+// Qualifies the migration name with the schema/table it targets, so a name is self-descriptive
+// when read directly out of the migrations table — e.g. `forest.audit_logs:001-create-audit-logs`.
+function qualifiedMigrationName(schema, tableName) {
+    return schema
+        ? `${schema}.${tableName}:001-create-audit-logs`
+        : `${tableName}:001-create-audit-logs`;
+}
+// Every table name claimed by an audit-trail store configured in this process, keyed by
+// `schema\0name` — both its own data table and the migration table Umzug derives from it.
+// A second store's data table can otherwise land on the exact name a first store's migration
+// table derives to (e.g. `tableName: 'audit'` derives `audit_migration`, which collides with a
+// second store's `tableName: 'audit_migration'`), silently adopting that tracking table as its
+// own audit table and aborting startup via assertOwnsTable — confusing, since neither store's
+// configuration is wrong in isolation. Catching it here, at store-creation time, names the actual
+// collision instead of leaving it to that unrelated-looking failure deep inside migration 001.
+const claimedTableNames = new Map();
+function claimTableName(schema, name, claimedBy) {
+    const key = `${schema ?? ''}\0${name}`;
+    const existingOwner = claimedTableNames.get(key);
+    if (existingOwner !== undefined && existingOwner !== claimedBy) {
+        const target = schema ? `${schema}.${name}` : name;
+        throw new Error(`[ForestAdmin] Audit trail: "${target}" is claimed by both "tableName: ${claimedBy}" and ` +
+            `"tableName: ${existingOwner}" (as either store's own table, or the migration-tracking ` +
+            'table Umzug derives from it) — use distinct "tableName" values for each store.');
+    }
+    claimedTableNames.set(key, claimedBy);
+}
+async function indexNames(queryInterface, table, transaction) {
+    const indexes = (await queryInterface.showIndex(table, { transaction }));
+    return new Set(indexes.map(index => index.name));
+}
+async function columnNames(queryInterface, table) {
+    const columns = await queryInterface.describeTable(table);
+    return new Set(Object.keys(columns));
+}
+// The migration's own idempotency check (`tableExists`) only asks "is there a table with this
+// name", not "is it ours" — so an unrelated customer table happening to share the name would be
+// silently adopted. Verifying every column this migration creates catches that.
+const AUDIT_LOG_COLUMNS = [
+    'id',
+    'timestamp',
+    'operation',
+    'collection',
+    'record_id',
+    'user_id',
+    'user_first_name',
+    'user_last_name',
+    'user_email',
+    'action_name',
+    'correlation_key',
+    'previous_values',
+    'new_values',
+    'status',
+];
+async function assertOwnsTable(queryInterface, table) {
+    const existing = await columnNames(queryInterface, table);
+    const missing = AUDIT_LOG_COLUMNS.filter(column => !existing.has(column));
+    if (missing.length > 0) {
+        const target = table.schema ? `${table.schema}.${table.tableName}` : table.tableName;
+        throw new Error(`[ForestAdmin] Audit trail: "${target}" already exists but is missing column(s) ` +
+            `${missing.join(', ')} — it does not look like a Forest audit-trail table. Point ` +
+            `auditTrail at a different table via the "tableName" option instead of reusing this one.`);
+    }
+}
+async function ensureIndexes(queryInterface, table, transaction) {
+    const existing = await indexNames(queryInterface, table, transaction);
+    const ensureIndex = async (fields, name) => {
+        if (existing.has(name))
+            return;
+        await queryInterface.addIndex(table, { fields, name, transaction });
+    };
+    // Length-prefixed so it stays valid on MySQL/MariaDB, which cannot index an unbounded TEXT
+    // column directly — `record_id` is TEXT (not VARCHAR) since a packed composite id can be long.
+    await ensureIndex([{ name: 'record_id', length: 191 }], `${table.tableName}_record_id`);
+    await ensureIndex(['correlation_key'], `${table.tableName}_correlation_key`);
+    await ensureIndex(['user_id'], `${table.tableName}_user_id`);
+}
+function buildMigrations(schema, tableName) {
+    return [
+        {
+            name: qualifiedMigrationName(schema, tableName),
+            up: async ({ context }) => {
+                const table = { tableName: context.tableName, schema: context.schema };
+                // Idempotent: lets a process that loses a concurrent-boot race retry cleanly instead of
+                // failing on a "relation already exists" error from the winner's DDL. Guards against
+                // reusing an unrelated table sharing the name, too — see assertOwnsTable.
+                if (await context.queryInterface.tableExists(table, { transaction: context.transaction })) {
+                    await assertOwnsTable(context.queryInterface, table);
+                    return;
+                }
+                await context.queryInterface.createTable(table, {
+                    id: { type: sequelize_1.DataTypes.BIGINT, primaryKey: true, autoIncrement: true },
+                    // Millisecond precision: a bare DATE truncates to whole seconds on MySQL, silently
+                    // dropping the fractional part the `/state` inclusive boundary and the `id` ordering
+                    // tiebreaker both rely on.
+                    timestamp: { type: sequelize_1.DataTypes.DATE(3), allowNull: false },
+                    operation: { type: sequelize_1.DataTypes.STRING, allowNull: false },
+                    collection: { type: sequelize_1.DataTypes.STRING, allowNull: false },
+                    // Nullable: a pending create's row has no id yet, since the record doesn't exist
+                    // until the write resolves.
+                    record_id: { type: sequelize_1.DataTypes.TEXT, allowNull: true },
+                    user_id: { type: sequelize_1.DataTypes.INTEGER, allowNull: true },
+                    // Denormalised from the caller at write time — who acted then, not who holds that id
+                    // today.
+                    user_first_name: { type: sequelize_1.DataTypes.TEXT, allowNull: true },
+                    user_last_name: { type: sequelize_1.DataTypes.TEXT, allowNull: true },
+                    user_email: { type: sequelize_1.DataTypes.TEXT, allowNull: true },
+                    // `action` / `action_failed` rows only.
+                    action_name: { type: sequelize_1.DataTypes.TEXT, allowNull: true },
+                    correlation_key: { type: sequelize_1.DataTypes.STRING, allowNull: true },
+                    previous_values: { type: sequelize_1.DataTypes.JSON, allowNull: false, defaultValue: {} },
+                    new_values: { type: sequelize_1.DataTypes.JSON, allowNull: false, defaultValue: {} },
+                    // A row is inserted `pending` before the write runs and confirmed `done` after.
+                    status: { type: sequelize_1.DataTypes.STRING, allowNull: false, defaultValue: 'done' },
+                }, { transaction: context.transaction });
+                await ensureIndexes(context.queryInterface, table, context.transaction);
+            },
+            down: async ({ context }) => {
+                await context.queryInterface.dropTable({ tableName: context.tableName, schema: context.schema }, { transaction: context.transaction });
+            },
+        },
+    ];
+}
+function buildUmzug(sequelize, options) {
+    claimTableName(options.schema, options.tableName, options.tableName);
+    claimTableName(options.schema, migrationsTableName(options.tableName), options.tableName);
+    return new umzug_1.Umzug({
+        migrations: buildMigrations(options.schema, options.tableName),
+        context: {
+            queryInterface: sequelize.getQueryInterface(),
+            schema: options.schema,
+            tableName: options.tableName,
+            transaction: options.transaction,
+        },
+        storage: new umzug_1.SequelizeStorage({
+            sequelize,
+            schema: options.schema,
+            tableName: migrationsTableName(options.tableName),
+            // Sequelize caches model definitions by name on the `Sequelize` instance: without a distinct
+            // name here, a second store sharing that instance (a different `tableName`, same connection)
+            // would reuse the first store's model and read/write the wrong migration-state table.
+            modelName: migrationsTableName(options.tableName),
+        }),
+        logger: undefined,
+    });
+}
+// 42P06 = duplicate_schema (Postgres ≥ 9.2), 23505 = unique_violation on pg_namespace.
+const SCHEMA_ALREADY_EXISTS_CODES = new Set(['42P06', '23505']);
+function isSchemaAlreadyExistsError(error) {
+    const code = error?.original?.code;
+    return code !== undefined && SCHEMA_ALREADY_EXISTS_CODES.has(code);
+}
+/**
+ * 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.
+ */
+async function ensureSchema(sequelize, schema) {
+    if (!schema)
+        return;
+    const queryInterface = sequelize.getQueryInterface();
+    const schemas = (await queryInterface.showAllSchemas());
+    if (schemas.includes(schema))
+        return;
+    try {
+        await queryInterface.createSchema(schema);
+    }
+    catch (error) {
+        if (!isSchemaAlreadyExistsError(error))
+            throw error;
+    }
+}
+/**
+ * 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.
+ */
+async function runAuditMigrations(sequelize, options) {
+    await ensureSchema(sequelize, options.schema);
+    if (sequelize.getDialect() !== 'postgres') {
+        await buildUmzug(sequelize, options).up();
+        return;
+    }
+    await sequelize.transaction(async (transaction) => {
+        await sequelize.query('SELECT pg_advisory_xact_lock(:a, :b)', {
+            transaction,
+            replacements: { a: ADVISORY_LOCK[0], b: ADVISORY_LOCK[1] },
+        });
+        await buildUmzug(sequelize, { ...options, transaction }).up();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrations.js","sourceRoot":"","sources":["../../src/audit-trail/migrations.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,8 @@
+type AuditEntry = {
+    operation: 'create' | 'update' | 'delete';
+    previousValues: Record<string, unknown>;
+    newValues: Record<string, unknown>;
+};
+export default function revertRecord(current: Record<string, unknown> | null, entries: AuditEntry[]): Record<string, unknown> | null;
+export {};
+//# sourceMappingURL=revert.d.ts.map

package/dist/audit-trail/revert.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = revertRecord;
+const isPlainObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date);
+// Plain object on both sides ⇒ nested diff, walking the union of both sides' keys so an added key
+// (present only in `next`) is caught too, not just a removed one. Anything else — including a key
+// present in `next` but not `previous` at this exact level — is a leaf: `previous` is the value to
+// write back as-is (this also covers "the whole field was replaced with something else", where
+// `previous`/`next` at this level aren't a matching object pair at all).
+const revertValue = (current, previous, next) => {
+    if (!isPlainObject(previous) || !isPlainObject(next))
+        return previous;
+    const keys = new Set([...Object.keys(previous), ...Object.keys(next)]);
+    if (Array.isArray(current)) {
+        const result = [...current];
+        const removedIndices = [];
+        for (const key of keys) {
+            if (!(key in previous)) {
+                // Present only in `next`: this index was appended by the change, remove it on revert.
+                removedIndices.push(Number(key));
+            }
+            else {
+                result[Number(key)] = revertValue(result[Number(key)], previous[key], next[key]);
+            }
+        }
+        // Highest index first so removing one doesn't shift the position of the next one to remove.
+        removedIndices
+            .sort((a, b) => b - a)
+            .forEach(index => {
+            result.splice(index, 1);
+        });
+        return result;
+    }
+    const base = isPlainObject(current) ? current : {};
+    const result = { ...base };
+    for (const key of keys) {
+        if (!(key in previous)) {
+            // Present only in `next`: this key was added by the change, remove it on revert.
+            delete result[key];
+        }
+        else {
+            result[key] = revertValue(result[key], previous[key], next[key]);
+        }
+    }
+    return result;
+};
+const revertOne = (current, entry) => {
+    const result = { ...current };
+    const columns = new Set([...Object.keys(entry.previousValues), ...Object.keys(entry.newValues)]);
+    for (const column of columns) {
+        if (!(column in entry.previousValues)) {
+            // The change added this column (e.g. a smart action wrote a new field for the first time);
+            // reverting removes it rather than writing back a bogus `null`.
+            delete result[column];
+        }
+        else {
+            result[column] = revertValue(result[column], entry.previousValues[column], entry.newValues[column]);
+        }
+    }
+    return result;
+};
+// `entries` must arrive newest-first. `create`/`delete` restore their terminal snapshot (`null` /
+// `previousValues`) and walking continues into older entries, so a target timestamp that predates
+// a delete-then-recreate (or update-then-delete) cycle still resolves to the earlier incarnation
+// instead of stopping dead on the first terminal event encountered.
+function revertRecord(current, entries) {
+    let state = current;
+    for (const entry of entries) {
+        if (entry.operation === 'create') {
+            state = null;
+        }
+        else if (entry.operation === 'delete') {
+            state = { ...entry.previousValues };
+        }
+        else if (state) {
+            state = revertOne(state, entry);
+        }
+    }
+    return state;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,33 @@
+"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

package/dist/audit-trail/sql-store.d.ts

@@ -0,0 +1,30 @@
+import type { AuditRecord, AuditStatus, AuditStorageOptions, AuditStore, PendingAuditRecord } from './types';
+import type { Model, ModelStatic } from 'sequelize';
+import { Sequelize } from 'sequelize';
+export declare const DEFAULT_SCHEMA = "forest";
+export declare const DEFAULT_TABLE = "audit_logs";
+export declare function defineAuditLogModel(sequelize: Sequelize, options: {
+    schema?: string;
+    tableName: string;
+}): ModelStatic<Model>;
+export declare function ensureAuditStorage(sequelize: Sequelize, options: {
+    schema?: string;
+    tableName: string;
+}): Promise<ModelStatic<Model>>;
+export declare function toRow(record: PendingAuditRecord & {
+    status: AuditStatus;
+}): Record<string, unknown>;
+export declare function fieldsChangedCondition(sequelize: Sequelize, fields: string[]): import("sequelize/types/utils").Literal;
+export declare function searchCondition(sequelize: Sequelize, term: string): import("sequelize/types/utils").Literal;
+export declare function fromRow(row: Model): AuditRecord;
+/**
+ * Returns a SQL-backed audit store. Construction is synchronous so the store can be passed to
+ * `createAgent` at module top level; the connection (and pending migrations) only run when
+ * `store.init()` is awaited during `agent.start()`. The store also self-initializes on the first
+ * append or read so tests and manual scripts work without an explicit init.
+ */
+export declare function createSqlAuditStore(options: AuditStorageOptions): {
+    store: AuditStore;
+    close: () => Promise<void>;
+};
+//# sourceMappingURL=sql-store.d.ts.map