@forestadmin/agent 1.95.1 → 1.96.0

package/dist/audit-trail/sql-store.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TABLE = exports.DEFAULT_SCHEMA = void 0;
+exports.defineAuditLogModel = defineAuditLogModel;
+exports.ensureAuditStorage = ensureAuditStorage;
+exports.toRow = toRow;
+exports.fieldsChangedCondition = fieldsChangedCondition;
+exports.searchCondition = searchCondition;
+exports.fromRow = fromRow;
+exports.createSqlAuditStore = createSqlAuditStore;
+const sequelize_1 = require("sequelize");
+const migrations_1 = require("./migrations");
+exports.DEFAULT_SCHEMA = 'forest';
+exports.DEFAULT_TABLE = 'audit_logs';
+const DIALECTS_WITH_SCHEMAS = new Set(['postgres', 'mssql']);
+const MODEL_NAME = 'ForestAuditLog';
+function defineAuditLogModel(sequelize, options) {
+    return sequelize.define(MODEL_NAME, {
+        id: { type: sequelize_1.DataTypes.BIGINT, primaryKey: true, autoIncrement: true },
+        // Millisecond precision: a bare DATE truncates to whole seconds on MySQL, which would
+        // silently drop the fractional part the `/state` boundary and the `id` tiebreaker both rely
+        // on for correct ordering.
+        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 },
+        // TEXT, not STRING (VARCHAR(255)): a packed composite-id can exceed 255 characters, and the
+        // migration creates the column as such — this must match. Nullable: a pending create's row
+        // has no id yet, since the record doesn't exist until the write resolves.
+        recordId: { type: sequelize_1.DataTypes.TEXT, allowNull: true },
+        userId: { type: sequelize_1.DataTypes.INTEGER, allowNull: true },
+        // Denormalised from the caller at write time — who acted then, not who holds that id today.
+        userFirstName: { type: sequelize_1.DataTypes.TEXT, allowNull: true },
+        userLastName: { type: sequelize_1.DataTypes.TEXT, allowNull: true },
+        userEmail: { type: sequelize_1.DataTypes.TEXT, allowNull: true },
+        // `action` / `action_failed` rows only.
+        actionName: { type: sequelize_1.DataTypes.TEXT, allowNull: true },
+        correlationKey: { type: sequelize_1.DataTypes.STRING, allowNull: true },
+        previousValues: { type: sequelize_1.DataTypes.JSON, allowNull: false, defaultValue: {} },
+        newValues: { type: sequelize_1.DataTypes.JSON, allowNull: false, defaultValue: {} },
+        status: { type: sequelize_1.DataTypes.STRING, allowNull: false, defaultValue: 'done' },
+    }, {
+        schema: options.schema,
+        tableName: options.tableName,
+        timestamps: false,
+        underscored: true,
+        freezeTableName: true,
+    });
+}
+async function ensureAuditStorage(sequelize, options) {
+    const schema = DIALECTS_WITH_SCHEMAS.has(sequelize.getDialect()) ? options.schema : undefined;
+    await (0, migrations_1.runAuditMigrations)(sequelize, { schema, tableName: options.tableName });
+    return defineAuditLogModel(sequelize, { schema, tableName: options.tableName });
+}
+function toRow(record) {
+    return {
+        timestamp: record.timestamp,
+        operation: record.operation,
+        collection: record.collection,
+        recordId: record.recordId,
+        userId: record.userId,
+        userFirstName: record.userFirstName,
+        userLastName: record.userLastName,
+        userEmail: record.userEmail,
+        actionName: record.actionName,
+        correlationKey: record.correlationKey,
+        previousValues: record.previousValues,
+        newValues: record.newValues,
+        status: record.status,
+    };
+}
+// A bare `$.${field}` path treats a dot in `field` as a nested-member separator instead of a
+// literal character (so `profile.name` would look up `profile` → `name` instead of the top-level
+// key `"profile.name"` the audit row actually stores under). Quoting the segment makes it literal.
+function jsonPath(field) {
+    return `$."${field.replace(/"/g, '\\"')}"`;
+}
+function fieldsChangedCondition(sequelize, fields) {
+    const dialect = sequelize.getDialect();
+    if (dialect === 'postgres') {
+        const keys = fields.map(field => sequelize.escape(field)).join(',');
+        return sequelize_1.Sequelize.literal(`(jsonb_exists_any("previous_values"::jsonb, ARRAY[${keys}]) ` +
+            `OR jsonb_exists_any("new_values"::jsonb, ARRAY[${keys}]))`);
+    }
+    if (dialect === 'sqlite') {
+        const tests = fields.flatMap(field => {
+            const path = sequelize.escape(jsonPath(field));
+            return [
+                `json_type(previous_values, ${path}) IS NOT NULL`,
+                `json_type(new_values, ${path}) IS NOT NULL`,
+            ];
+        });
+        return sequelize_1.Sequelize.literal(`(${tests.join(' OR ')})`);
+    }
+    if (dialect === 'mysql' || dialect === 'mariadb') {
+        const paths = fields.map(field => sequelize.escape(jsonPath(field))).join(',');
+        return sequelize_1.Sequelize.literal(`(JSON_CONTAINS_PATH(previous_values, 'one', ${paths}) ` +
+            `OR JSON_CONTAINS_PATH(new_values, 'one', ${paths}))`);
+    }
+    if (dialect === 'mssql') {
+        const tests = fields.flatMap(field => {
+            const path = sequelize.escape(jsonPath(field));
+            return [
+                `JSON_PATH_EXISTS(previous_values, ${path}) = 1`,
+                `JSON_PATH_EXISTS(new_values, ${path}) = 1`,
+            ];
+        });
+        // JSON_PATH_EXISTS requires SQL Server 2022+.
+        return sequelize_1.Sequelize.literal(`(${tests.join(' OR ')})`);
+    }
+    throw new Error(`Audit-trail "fields" filter is not supported on dialect "${dialect}"`);
+}
+// JSON columns are already stored as plain text on dialects with no native JSON type (sqlite,
+// mssql); only postgres/mysql/mariadb need an explicit cast before a text match can run on them.
+function jsonColumnAsText(sequelize, column) {
+    const dialect = sequelize.getDialect();
+    if (dialect === 'postgres')
+        return `${column}::text`;
+    if (dialect === 'mysql' || dialect === 'mariadb')
+        return `CAST(${column} AS CHAR)`;
+    return column;
+}
+// A free-text search against the *serialized* JSON text naturally covers "keys and scalar values
+// at any depth" without walking the structure by hand: both a key and a value appear as a quoted
+// literal substring of that text. This runs as a SQL WHERE clause (not an in-memory scan of
+// fetched rows), so it composes with pagination and COUNT the same way every other filter does. A
+// redacted value can't match a search for the real value — the real value already isn't in this
+// text, `redactValues` replaced it before the row was ever written.
+function searchCondition(sequelize, term) {
+    // `~` rather than the standard `\`: MySQL/MariaDB treat backslash as a string-literal escape
+    // character under the default sql_mode (no NO_BACKSLASH_ESCAPES), so a bare `ESCAPE '\'` is
+    // itself malformed there — the backslash escapes the closing quote instead of terminating the
+    // literal. `~` has no special meaning to any of the four supported dialects' string literals, so
+    // it sidesteps that interaction entirely. Escapes the two LIKE wildcards plus itself, so a term
+    // containing `%`/`_`/`~` is matched literally instead of behaving like a pattern.
+    const escaped = term.replace(/[~%_]/g, char => `~${char}`);
+    const pattern = sequelize.escape(`%${escaped}%`);
+    const columns = [
+        'action_name',
+        'user_first_name',
+        'user_last_name',
+        'user_email',
+        jsonColumnAsText(sequelize, 'previous_values'),
+        jsonColumnAsText(sequelize, 'new_values'),
+    ];
+    return sequelize_1.Sequelize.literal(`(${columns.map(column => `LOWER(${column}) LIKE LOWER(${pattern}) ESCAPE '~'`).join(' OR ')})`);
+}
+function buildHistoryWhereClause({ collection, recordId, userIds, startTimestamp, endTimestamp, fields, search, }, sequelize) {
+    const where = { collection, recordId };
+    if (userIds)
+        where.userId = { [sequelize_1.Op.in]: userIds };
+    const timestampRange = {};
+    if (startTimestamp)
+        timestampRange[sequelize_1.Op.gte] = new Date(startTimestamp);
+    if (endTimestamp)
+        timestampRange[sequelize_1.Op.lte] = new Date(endTimestamp);
+    if (Object.getOwnPropertySymbols(timestampRange).length)
+        where.timestamp = timestampRange;
+    const andConditions = [];
+    if (fields?.length)
+        andConditions.push(fieldsChangedCondition(sequelize, fields));
+    if (search)
+        andConditions.push(searchCondition(sequelize, search));
+    if (andConditions.length)
+        where[sequelize_1.Op.and] = andConditions;
+    return where;
+}
+function fromRow(row) {
+    const plain = row.get({ plain: true });
+    const { timestamp } = plain;
+    return {
+        id: Number(plain.id),
+        timestamp: timestamp instanceof Date ? timestamp.toISOString() : String(timestamp),
+        operation: plain.operation,
+        collection: plain.collection,
+        recordId: plain.recordId ?? null,
+        userId: plain.userId,
+        userFirstName: plain.userFirstName ?? null,
+        userLastName: plain.userLastName ?? null,
+        userEmail: plain.userEmail ?? null,
+        actionName: plain.actionName ?? null,
+        correlationKey: plain.correlationKey,
+        previousValues: plain.previousValues ?? {},
+        newValues: plain.newValues ?? {},
+        status: plain.status,
+    };
+}
+/**
+ * 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.
+ */
+function createSqlAuditStore(options) {
+    const { connectionString, schema = exports.DEFAULT_SCHEMA, tableName = exports.DEFAULT_TABLE } = options;
+    let sequelize = null;
+    let bootstrap = null;
+    const init = () => {
+        if (bootstrap)
+            return bootstrap;
+        const connection = new sequelize_1.Sequelize(connectionString, { logging: false });
+        sequelize = connection;
+        bootstrap = (async () => {
+            try {
+                await connection.authenticate();
+                const model = await ensureAuditStorage(connection, { schema, tableName });
+                return { model, connection };
+            }
+            catch (error) {
+                // Reset so a later call can retry once the database is reachable.
+                await connection.close().catch(() => undefined);
+                sequelize = null;
+                bootstrap = null;
+                throw error;
+            }
+        })();
+        return bootstrap;
+    };
+    // Insertion-order tiebreaker on `id` keeps paging deterministic when timestamps collide.
+    const chronologicalOrder = [
+        ['timestamp', 'ASC'],
+        ['id', 'ASC'],
+    ];
+    return {
+        store: {
+            async init() {
+                await init();
+            },
+            async insertPending(record) {
+                const { model } = await init();
+                const row = await model.create(toRow({ ...record, status: 'pending' }));
+                return Number(row.get('id'));
+            },
+            // Per-row generated ids from one statement are trustworthy on every supported dialect:
+            // Postgres/MSSQL return them natively (RETURNING/OUTPUT), Sequelize infers them sequentially
+            // from the single last-insert-id on MySQL/MariaDB (safe because a multi-row INSERT holds the
+            // table's auto-increment lock for the whole statement under the default lock mode — no other
+            // connection's insert can land an id in the middle of this batch), and sqlite returns them
+            // directly too (verified empirically).
+            async insertPendingBatch(records) {
+                const { model } = await init();
+                const rows = await model.bulkCreate(records.map(record => toRow({ ...record, status: 'pending' })));
+                return rows.map(row => Number(row.get('id')));
+            },
+            async confirm(id, patch) {
+                const { model } = await init();
+                await model.update({ ...patch, status: 'done' }, { where: { id } });
+            },
+            async listByRecord(query) {
+                const { model, connection } = await init();
+                const { skip = 0, limit, order = 'asc' } = query;
+                const direction = order === 'desc' ? 'DESC' : 'ASC';
+                const rows = await model.findAll({
+                    where: buildHistoryWhereClause(query, connection),
+                    order: [
+                        ['timestamp', direction],
+                        ['id', direction],
+                    ],
+                    offset: skip,
+                    limit,
+                });
+                return rows.map(fromRow);
+            },
+            async countByRecord(query) {
+                const { model, connection } = await init();
+                return model.count({ where: buildHistoryWhereClause(query, connection) });
+            },
+            async listDistinctUsers(query) {
+                const { model, connection } = await init();
+                // MAX() rather than a bare column: grouping by `user_id` alone is invalid in strict SQL
+                // unless every selected column is either grouped or aggregated.
+                const rows = (await model.findAll({
+                    where: buildHistoryWhereClause(query, connection),
+                    attributes: [
+                        'userId',
+                        [sequelize_1.Sequelize.fn('MAX', sequelize_1.Sequelize.col('user_first_name')), 'userFirstName'],
+                        [sequelize_1.Sequelize.fn('MAX', sequelize_1.Sequelize.col('user_last_name')), 'userLastName'],
+                        [sequelize_1.Sequelize.fn('MAX', sequelize_1.Sequelize.col('user_email')), 'userEmail'],
+                    ],
+                    group: ['userId'],
+                    raw: true,
+                }));
+                return rows.map(row => ({
+                    id: row.userId,
+                    firstName: row.userFirstName ?? null,
+                    lastName: row.userLastName ?? null,
+                    email: row.userEmail ?? null,
+                }));
+            },
+            async listByCorrelation({ collection, recordId, correlationKey }) {
+                const { model } = await init();
+                const rows = await model.findAll({
+                    where: { collection, recordId, correlationKey },
+                    order: chronologicalOrder,
+                });
+                return rows.map(fromRow);
+            },
+            async listByCorrelations({ collection, recordId, correlationKeys }) {
+                if (!correlationKeys.length)
+                    return [];
+                const { model } = await init();
+                const rows = await model.findAll({
+                    where: { collection, recordId, correlationKey: { [sequelize_1.Op.in]: correlationKeys } },
+                    order: chronologicalOrder,
+                });
+                return rows.map(fromRow);
+            },
+        },
+        close: async () => {
+            if (sequelize)
+                await sequelize.close();
+            sequelize = null;
+            bootstrap = null;
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sql-store.js","sourceRoot":"","sources":["../../src/audit-trail/sql-store.ts"],"names":[],"mappings":";;;AAqBA,kDAsCC;AAED,gDASC;AAED,sBAkBC;AASD,wDAiDC;AAmBD,0CAsBC;AA+BD,0BAoBC;AAQD,kDAmJC;AAjYD,yCAAqD;AAErD,6CAAkD;AAErC,QAAA,cAAc,GAAG,QAAQ,CAAC;AAC1B,QAAA,aAAa,GAAG,YAAY,CAAC;AAE1C,MAAM,qBAAqB,GAAG,IAAI,GAAG,CAAC,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;AAE7D,MAAM,UAAU,GAAG,gBAAgB,CAAC;AAEpC,SAAgB,mBAAmB,CACjC,SAAoB,EACpB,OAA+C;IAE/C,OAAO,SAAS,CAAC,MAAM,CACrB,UAAU,EACV;QACE,EAAE,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE;QACrE,sFAAsF;QACtF,4FAA4F;QAC5F,2BAA2B;QAC3B,SAAS,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE;QACxD,SAAS,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE;QACvD,UAAU,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE;QACxD,4FAA4F;QAC5F,2FAA2F;QAC3F,0EAA0E;QAC1E,QAAQ,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE;QACnD,MAAM,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE;QACpD,4FAA4F;QAC5F,aAAa,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE;QACxD,YAAY,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE;QACvD,SAAS,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE;QACpD,wCAAwC;QACxC,UAAU,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE;QACrD,cAAc,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE;QAC3D,cAAc,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE;QAC5E,SAAS,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE;QACvE,MAAM,EAAE,EAAE,IAAI,EAAE,qBAAS,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE;KAC3E,EACD;QACE,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,UAAU,EAAE,KAAK;QACjB,WAAW,EAAE,IAAI;QACjB,eAAe,EAAE,IAAI;KACtB,CACF,CAAC;AACJ,CAAC;AAEM,KAAK,UAAU,kBAAkB,CACtC,SAAoB,EACpB,OAA+C;IAE/C,MAAM,MAAM,GAAG,qBAAqB,CAAC,GAAG,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;IAE9F,MAAM,IAAA,+BAAkB,EAAC,SAAS,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAE9E,OAAO,mBAAmB,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;AAClF,CAAC;AAED,SAAgB,KAAK,CACnB,MAAoD;IAEpD,OAAO;QACL,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,QAAQ,EAAE,MAAM,CAAC,QAAQ;QACzB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,aAAa,EAAE,MAAM,CAAC,aAAa;QACnC,YAAY,EAAE,MAAM,CAAC,YAAY;QACjC,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,cAAc,EAAE,MAAM,CAAC,cAAc;QACrC,cAAc,EAAE,MAAM,CAAC,cAAc;QACrC,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,MAAM,EAAE,MAAM,CAAC,MAAM;KACtB,CAAC;AACJ,CAAC;AAED,6FAA6F;AAC7F,iGAAiG;AACjG,mGAAmG;AACnG,SAAS,QAAQ,CAAC,KAAa;IAC7B,OAAO,MAAM,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC;AAC7C,CAAC;AAED,SAAgB,sBAAsB,CAAC,SAAoB,EAAE,MAAgB;IAC3E,MAAM,OAAO,GAAG,SAAS,CAAC,UAAU,EAAE,CAAC;IAEvC,IAAI,OAAO,KAAK,UAAU,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEpE,OAAO,qBAAS,CAAC,OAAO,CACtB,qDAAqD,IAAI,KAAK;YAC5D,kDAAkD,IAAI,KAAK,CAC9D,CAAC;IACJ,CAAC;IAED,IAAI,OAAO,KAAK,QAAQ,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACnC,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;YAE/C,OAAO;gBACL,8BAA8B,IAAI,eAAe;gBACjD,yBAAyB,IAAI,eAAe;aAC7C,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,OAAO,qBAAS,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACtD,CAAC;IAED,IAAI,OAAO,KAAK,OAAO,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QACjD,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAE/E,OAAO,qBAAS,CAAC,OAAO,CACtB,+CAA+C,KAAK,IAAI;YACtD,4CAA4C,KAAK,IAAI,CACxD,CAAC;IACJ,CAAC;IAED,IAAI,OAAO,KAAK,OAAO,EAAE,CAAC;QACxB,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACnC,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;YAE/C,OAAO;gBACL,qCAAqC,IAAI,OAAO;gBAChD,gCAAgC,IAAI,OAAO;aAC5C,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,8CAA8C;QAC9C,OAAO,qBAAS,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACtD,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,4DAA4D,OAAO,GAAG,CAAC,CAAC;AAC1F,CAAC;AAED,8FAA8F;AAC9F,iGAAiG;AACjG,SAAS,gBAAgB,CAAC,SAAoB,EAAE,MAAc;IAC5D,MAAM,OAAO,GAAG,SAAS,CAAC,UAAU,EAAE,CAAC;IAEvC,IAAI,OAAO,KAAK,UAAU;QAAE,OAAO,GAAG,MAAM,QAAQ,CAAC;IACrD,IAAI,OAAO,KAAK,OAAO,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,QAAQ,MAAM,WAAW,CAAC;IAEnF,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,iGAAiG;AACjG,iGAAiG;AACjG,4FAA4F;AAC5F,kGAAkG;AAClG,gGAAgG;AAChG,oEAAoE;AACpE,SAAgB,eAAe,CAAC,SAAoB,EAAE,IAAY;IAChE,6FAA6F;IAC7F,4FAA4F;IAC5F,8FAA8F;IAC9F,iGAAiG;IACjG,gGAAgG;IAChG,kFAAkF;IAClF,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;IAC3D,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,CAAC,IAAI,OAAO,GAAG,CAAC,CAAC;IAEjD,MAAM,OAAO,GAAG;QACd,aAAa;QACb,iBAAiB;QACjB,gBAAgB;QAChB,YAAY;QACZ,gBAAgB,CAAC,SAAS,EAAE,iBAAiB,CAAC;QAC9C,gBAAgB,CAAC,SAAS,EAAE,YAAY,CAAC;KAC1C,CAAC;IAEF,OAAO,qBAAS,CAAC,OAAO,CACtB,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,MAAM,gBAAgB,OAAO,cAAc,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAChG,CAAC;AACJ,CAAC;AAED,SAAS,uBAAuB,CAC9B,EACE,UAAU,EACV,QAAQ,EACR,OAAO,EACP,cAAc,EACd,YAAY,EACZ,MAAM,EACN,MAAM,GACY,EACpB,SAAoB;IAEpB,MAAM,KAAK,GAAqC,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC;IAEzE,IAAI,OAAO;QAAE,KAAK,CAAC,MAAM,GAAG,EAAE,CAAC,cAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC;IAEjD,MAAM,cAAc,GAAyB,EAAE,CAAC;IAChD,IAAI,cAAc;QAAE,cAAc,CAAC,cAAE,CAAC,GAAG,CAAC,GAAG,IAAI,IAAI,CAAC,cAAc,CAAC,CAAC;IACtE,IAAI,YAAY;QAAE,cAAc,CAAC,cAAE,CAAC,GAAG,CAAC,GAAG,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC;IAClE,IAAI,MAAM,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC,MAAM;QAAE,KAAK,CAAC,SAAS,GAAG,cAAc,CAAC;IAE1F,MAAM,aAAa,GAAG,EAAE,CAAC;IACzB,IAAI,MAAM,EAAE,MAAM;QAAE,aAAa,CAAC,IAAI,CAAC,sBAAsB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;IAClF,IAAI,MAAM;QAAE,aAAa,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;IACnE,IAAI,aAAa,CAAC,MAAM;QAAE,KAAK,CAAC,cAAE,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC;IAExD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAgB,OAAO,CAAC,GAAU;IAChC,MAAM,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAA4B,CAAC;IAClE,MAAM,EAAE,SAAS,EAAE,GAAG,KAAK,CAAC;IAE5B,OAAO;QACL,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACpB,SAAS,EAAE,SAAS,YAAY,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC;QAClF,SAAS,EAAE,KAAK,CAAC,SAAqC;QACtD,UAAU,EAAE,KAAK,CAAC,UAAoB;QACtC,QAAQ,EAAG,KAAK,CAAC,QAAmB,IAAI,IAAI;QAC5C,MAAM,EAAE,KAAK,CAAC,MAAgB;QAC9B,aAAa,EAAG,KAAK,CAAC,aAAwB,IAAI,IAAI;QACtD,YAAY,EAAG,KAAK,CAAC,YAAuB,IAAI,IAAI;QACpD,SAAS,EAAG,KAAK,CAAC,SAAoB,IAAI,IAAI;QAC9C,UAAU,EAAG,KAAK,CAAC,UAAqB,IAAI,IAAI;QAChD,cAAc,EAAE,KAAK,CAAC,cAAwB;QAC9C,cAAc,EAAG,KAAK,CAAC,cAA0C,IAAI,EAAE;QACvE,SAAS,EAAG,KAAK,CAAC,SAAqC,IAAI,EAAE;QAC7D,MAAM,EAAE,KAAK,CAAC,MAAqB;KACpC,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,OAA4B;IAI9D,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,sBAAc,EAAE,SAAS,GAAG,qBAAa,EAAE,GAAG,OAAO,CAAC;IAEzF,IAAI,SAAS,GAAqB,IAAI,CAAC;IACvC,IAAI,SAAS,GAAyE,IAAI,CAAC;IAE3F,MAAM,IAAI,GAAG,GAAkE,EAAE;QAC/E,IAAI,SAAS;YAAE,OAAO,SAAS,CAAC;QAEhC,MAAM,UAAU,GAAG,IAAI,qBAAS,CAAC,gBAAgB,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;QACvE,SAAS,GAAG,UAAU,CAAC;QACvB,SAAS,GAAG,CAAC,KAAK,IAAI,EAAE;YACtB,IAAI,CAAC;gBACH,MAAM,UAAU,CAAC,YAAY,EAAE,CAAC;gBAChC,MAAM,KAAK,GAAG,MAAM,kBAAkB,CAAC,UAAU,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;gBAE1E,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC;YAC/B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,kEAAkE;gBAClE,MAAM,UAAU,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;gBAChD,SAAS,GAAG,IAAI,CAAC;gBACjB,SAAS,GAAG,IAAI,CAAC;gBACjB,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC,CAAC,EAAE,CAAC;QAEL,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;IAEF,yFAAyF;IACzF,MAAM,kBAAkB,GAAG;QACzB,CAAC,WAAW,EAAE,KAAK,CAAC;QACpB,CAAC,IAAI,EAAE,KAAK,CAAC;KACL,CAAC;IAEX,OAAO;QACL,KAAK,EAAE;YACL,KAAK,CAAC,IAAI;gBACR,MAAM,IAAI,EAAE,CAAC;YACf,CAAC;YACD,KAAK,CAAC,aAAa,CAAC,MAAM;gBACxB,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;gBAC/B,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;gBAExE,OAAO,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;YAC/B,CAAC;YACD,uFAAuF;YACvF,6FAA6F;YAC7F,6FAA6F;YAC7F,6FAA6F;YAC7F,2FAA2F;YAC3F,uCAAuC;YACvC,KAAK,CAAC,kBAAkB,CAAC,OAAO;gBAC9B,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;gBAC/B,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,UAAU,CACjC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,CAC/D,CAAC;gBAEF,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAChD,CAAC;YACD,KAAK,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK;gBACrB,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;gBAC/B,MAAM,KAAK,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;YACtE,CAAC;YACD,KAAK,CAAC,YAAY,CAAC,KAAK;gBACtB,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;gBAC3C,MAAM,EAAE,IAAI,GAAG,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,KAAK,EAAE,GAAG,KAAK,CAAC;gBACjD,MAAM,SAAS,GAAG,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;gBAEpD,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC;oBAC/B,KAAK,EAAE,uBAAuB,CAAC,KAAK,EAAE,UAAU,CAAC;oBACjD,KAAK,EAAE;wBACL,CAAC,WAAW,EAAE,SAAS,CAAC;wBACxB,CAAC,IAAI,EAAE,SAAS,CAAC;qBAClB;oBACD,MAAM,EAAE,IAAI;oBACZ,KAAK;iBACN,CAAC,CAAC;gBAEH,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAC3B,CAAC;YACD,KAAK,CAAC,aAAa,CAAC,KAAK;gBACvB,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;gBAE3C,OAAO,KAAK,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,uBAAuB,CAAC,KAAK,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC;YAC5E,CAAC;YACD,KAAK,CAAC,iBAAiB,CAAC,KAAK;gBAC3B,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;gBAE3C,wFAAwF;gBACxF,gEAAgE;gBAChE,MAAM,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,OAAO,CAAC;oBAChC,KAAK,EAAE,uBAAuB,CAAC,KAA0B,EAAE,UAAU,CAAC;oBACtE,UAAU,EAAE;wBACV,QAAQ;wBACR,CAAC,qBAAS,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAS,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC,EAAE,eAAe,CAAC;wBACxE,CAAC,qBAAS,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAS,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC,EAAE,cAAc,CAAC;wBACtE,CAAC,qBAAS,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAS,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,EAAE,WAAW,CAAC;qBAChE;oBACD,KAAK,EAAE,CAAC,QAAQ,CAAC;oBACjB,GAAG,EAAE,IAAI;iBACV,CAAC,CAKA,CAAC;gBAEH,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBACtB,EAAE,EAAE,GAAG,CAAC,MAAM;oBACd,SAAS,EAAE,GAAG,CAAC,aAAa,IAAI,IAAI;oBACpC,QAAQ,EAAE,GAAG,CAAC,YAAY,IAAI,IAAI;oBAClC,KAAK,EAAE,GAAG,CAAC,SAAS,IAAI,IAAI;iBAC7B,CAAC,CAAC,CAAC;YACN,CAAC;YACD,KAAK,CAAC,iBAAiB,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAE;gBAC9D,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;gBAE/B,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC;oBAC/B,KAAK,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAE;oBAC/C,KAAK,EAAE,kBAA2B;iBACnC,CAAC,CAAC;gBAEH,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAC3B,CAAC;YACD,KAAK,CAAC,kBAAkB,CAAC,EAAE,UAAU,EAAE,QAAQ,EAAE,eAAe,EAAE;gBAChE,IAAI,CAAC,eAAe,CAAC,MAAM;oBAAE,OAAO,EAAE,CAAC;gBAEvC,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,EAAE,CAAC;gBAE/B,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC;oBAC/B,KAAK,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAE,EAAE,CAAC,cAAE,CAAC,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE;oBAC7E,KAAK,EAAE,kBAA2B;iBACnC,CAAC,CAAC;gBAEH,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAC3B,CAAC;SACF;QACD,KAAK,EAAE,KAAK,IAAI,EAAE;YAChB,IAAI,SAAS;gBAAE,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;YACvC,SAAS,GAAG,IAAI,CAAC;YACjB,SAAS,GAAG,IAAI,CAAC;QACnB,CAAC;KACF,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,129 @@
+import type { Logger } from '@forestadmin/datasource-toolkit';
+export type AuditOperation = 'create' | 'update' | 'delete' | 'action' | 'action_failed';
+export type AuditStatus = 'pending' | 'done';
+export type AuditRecord = {
+    id: number;
+    timestamp: string;
+    operation: AuditOperation;
+    collection: string;
+    /** Null for a pending create — the record's primary key isn't assigned yet. */
+    recordId: string | null;
+    userId: number;
+    /** Denormalised from the caller at write time: who acted then, not who holds that id today. */
+    userFirstName: string | null;
+    userLastName: string | null;
+    userEmail: string | null;
+    /** `action` / `action_failed` rows only. */
+    actionName: string | null;
+    correlationKey: string;
+    previousValues: Record<string, unknown>;
+    newValues: Record<string, unknown>;
+    /**
+     * `pending` from the moment the row is inserted (before the write runs) until it's confirmed
+     * `done` afterward. A row left `pending` means the write may or may not have landed — that
+     * residue is evidence a write was attempted and never confirmed, which is the point.
+     */
+    status: AuditStatus;
+};
+/** The subset known before the write runs, when the pending row is first inserted. */
+export type PendingAuditRecord = Omit<AuditRecord, 'id' | 'status'>;
+/** What `confirm` updates once the write (or action) has resolved. */
+export type AuditRecordConfirmation = Pick<AuditRecord, 'operation' | 'recordId' | 'previousValues' | 'newValues'>;
+export type AuditHistoryQuery = {
+    collection: string;
+    recordId: string;
+    skip?: number;
+    limit?: number;
+    userIds?: number[];
+    /** Inclusive lower bound on `timestamp` as a UTC ISO instant. */
+    startTimestamp?: string;
+    /** Inclusive upper bound on `timestamp` as a UTC ISO instant. */
+    endTimestamp?: string;
+    /** Keep only entries whose change touched at least one of these fields. */
+    fields?: string[];
+    /**
+     * Free-text, case-insensitive substring match against `actionName`, `userFirstName`,
+     * `userLastName`, `userEmail`, and the keys and scalar values of `previousValues`/`newValues` at
+     * any depth. Never matches `operation`, `correlationKey`, `recordId`, `collection`, `status` or
+     * `timestamp` — those are machine identifiers a user would never search, and matching them
+     * produces confusing hits. A redacted value can't match a search for the real value: the real
+     * value was never stored in the first place.
+     *
+     * The match runs against the *serialized JSON text* of `previousValues`/`newValues`, not a
+     * structural walk of the parsed value — cheap, and correct for "keys and scalar values", but two
+     * things fall out of that: a punctuation-only term (`,`, `:`, `{`) matches almost any row whose
+     * diff has more than one key, since those characters are JSON structure rather than content; and
+     * a value containing a double quote or a backslash can't be found by searching for it literally
+     * (`5"` is stored as `5\"`, so searching `5"` never matches the row that holds it). Neither is
+     * severe, and both are inherent to matching the serialized form rather than the parsed value.
+     */
+    search?: string;
+    /** Sort direction on `timestamp` (ties broken by insertion order). Defaults to `'asc'`. */
+    order?: 'asc' | 'desc';
+};
+export type AuditCorrelationQuery = {
+    collection: string;
+    recordId: string;
+    correlationKey: string;
+};
+export type AuditCorrelationsQuery = {
+    collection: string;
+    recordId: string;
+    correlationKeys: string[];
+};
+export type AuditUserSummary = {
+    id: number;
+    firstName: string | null;
+    lastName: string | null;
+    email: string | null;
+};
+export interface AuditStore {
+    /** Inserts one `status: 'pending'` row before the write runs; returns its id. */
+    insertPending(record: PendingAuditRecord): Promise<number>;
+    /** Batched form of `insertPending`, for a bulk operation touching several records at once. */
+    insertPendingBatch(records: PendingAuditRecord[]): Promise<number[]>;
+    /** Updates a pending row to `status: 'done'` with the values known once the write resolved. */
+    confirm(id: number, patch: AuditRecordConfirmation): Promise<void>;
+    listByRecord(query: AuditHistoryQuery): AuditRecord[] | Promise<AuditRecord[]>;
+    /** Total entries matching the query filters, ignoring `skip` / `limit`. */
+    countByRecord(query: AuditHistoryQuery): number | Promise<number>;
+    /** Entries recorded under one `correlationKey` for a record, oldest first. */
+    listByCorrelation(query: AuditCorrelationQuery): AuditRecord[] | Promise<AuditRecord[]>;
+    /** Flat list of entries recorded under any of `correlationKeys` for a record, oldest first. */
+    listByCorrelations(query: AuditCorrelationsQuery): AuditRecord[] | Promise<AuditRecord[]>;
+    /** Distinct authors matching the query filters, independent of pagination. */
+    listDistinctUsers(query: Omit<AuditHistoryQuery, 'skip' | 'limit' | 'order'>): AuditUserSummary[] | Promise<AuditUserSummary[]>;
+    /** One-shot bootstrap awaited by `agent.start()`. Must be idempotent. */
+    init?(): Promise<void>;
+}
+export type AuditSink = (record: PendingAuditRecord) => void | Promise<void>;
+export type AuditTrailInstrumentOptions = {
+    sink?: AuditSink;
+    store?: AuditStore;
+    /**
+     * Fields to mask, keyed by collection name. Redacted fields still produce an audit entry when
+     * they change, but their value is replaced with a sentinel instead of being stored.
+     */
+    redact?: Record<string, string[]>;
+    /**
+     * When true, a failure inserting a write's pending audit row refuses the write itself — no
+     * unaudited write ever happens, though a row left `pending` doesn't guarantee its values are
+     * exact. When false (default), the same failure is logged and the write proceeds unaudited,
+     * matching today's behavior.
+     */
+    critical?: boolean;
+    logger?: Logger;
+};
+export type AuditStorageOptions = {
+    /**
+     * Postgres / SQL connection string for the audit database. May point at an empty database, the
+     * database already used by the agent, or one that already contains the `forest` schema — the
+     * schema and table are created on the fly when missing.
+     */
+    connectionString: string;
+    /** Defaults to `forest`. */
+    schema?: string;
+    /** Defaults to `audit_logs`. */
+    tableName?: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/audit-trail/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXVkaXQtdHJhaWwvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

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

@@ -0,0 +1,18 @@
+import type { ForestAdminHttpDriverServices } from '../../services';
+import type { AgentOptionsWithDefaults } from '../../types';
+import type { DataSource } from '@forestadmin/datasource-toolkit';
+import type Router from '@koa/router';
+import type { Context } from 'koa';
+import { RouteType } from '../../types';
+import BaseRoute from '../base-route';
+export default class AuditTrailCorrelationRoute extends BaseRoute {
+    readonly type = RouteType.PrivateRoute;
+    private readonly dataSource;
+    constructor(services: ForestAdminHttpDriverServices, options: AgentOptionsWithDefaults, dataSource: DataSource);
+    setupRoutes(router: Router): void;
+    handleHistory(context: Context): Promise<void>;
+    handleBatch(context: Context): Promise<void>;
+    private assertRecordReadable;
+    private static parseCorrelationKeys;
+}
+//# sourceMappingURL=audit-trail-correlation.d.ts.map

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

@@ -0,0 +1,84 @@
+"use strict";
+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 types_1 = require("../../types");
+const base_route_1 = __importDefault(require("../base-route"));
+class AuditTrailCorrelationRoute extends base_route_1.default {
+    constructor(services, options, dataSource) {
+        super(services, options);
+        this.type = types_1.RouteType.PrivateRoute;
+        this.dataSource = dataSource;
+    }
+    setupRoutes(router) {
+        router.get('/_audit-trail/correlation/:correlationKey', this.handleHistory.bind(this));
+        // POST accepts the keys in a JSON body to dodge any URL length limit.
+        router.get('/_audit-trail/correlations', this.handleBatch.bind(this));
+        router.post('/_audit-trail/correlations', this.handleBatch.bind(this));
+    }
+    async handleHistory(context) {
+        const target = await this.assertRecordReadable(context);
+        if (!target)
+            return;
+        const { collection, recordId } = target;
+        const { store } = this.options.auditTrail;
+        const history = await store.listByCorrelation({
+            collection,
+            recordId,
+            correlationKey: context.params.correlationKey,
+        });
+        context.response.body = { data: history };
+    }
+    async handleBatch(context) {
+        const target = await this.assertRecordReadable(context);
+        if (!target)
+            return;
+        const { collection, recordId } = target;
+        const correlationKeys = AuditTrailCorrelationRoute.parseCorrelationKeys(context);
+        const { store } = this.options.auditTrail;
+        const history = correlationKeys.length
+            ? await store.listByCorrelations({ collection, recordId, correlationKeys })
+            : [];
+        context.response.body = { data: history };
+    }
+    // Returns null (after issuing the 404) when a configured record-level 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) {
+        const query = context.request.query;
+        const body = (context.request.body ?? {});
+        const collectionName = (query.collection ?? body.collection)?.toString();
+        const recordId = (query.recordId ?? body.recordId)?.toString();
+        if (!collectionName)
+            throw new datasource_toolkit_1.ValidationError('Missing collection');
+        if (!recordId)
+            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);
+        if (!visible) {
+            context.throw(types_1.HttpCode.NotFound, 'Record does not exists');
+            return null;
+        }
+        return { collection: collectionName, recordId };
+    }
+    // Body array (POST) takes precedence over the comma-separated query param (GET).
+    static parseCorrelationKeys(context) {
+        const body = (context.request.body ?? {});
+        if (Array.isArray(body.correlationKeys)) {
+            return body.correlationKeys.map(key => String(key).trim()).filter(Boolean);
+        }
+        const raw = context.request.query.correlationKeys?.toString();
+        return raw
+            ? raw
+                .split(',')
+                .map(key => key.trim())
+                .filter(Boolean)
+            : [];
+    }
+}
+exports.default = AuditTrailCorrelationRoute;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,23 @@
+import type Router from '@koa/router';
+import type { Context } from 'koa';
+import CollectionRoute from '../collection-route';
+export default class AuditTrailRoute extends CollectionRoute {
+    setupRoutes(router: Router): void;
+    handleHistory(context: Context): Promise<void>;
+    private withholdOutOfScopeValues;
+    handleStateAt(context: Context): Promise<void>;
+    private fetchCurrentRecord;
+    private static auditedColumns;
+    private static parseAt;
+    private static parseSort;
+    private static parsePagination;
+    private static parsePageSize;
+    private static parsePageNumber;
+    private static parseFilters;
+    private static parseUserIds;
+    private static parseFields;
+    private static parseSearch;
+    private static parseDateBoundary;
+    private static toLocalInstant;
+}
+//# sourceMappingURL=audit-trail.d.ts.map