@lucaapp/service-utils 5.34.0 → 5.35.0

package/dist/lib/api/endpoint.js

@@ -110,6 +110,12 @@ const sendErrorResponse = (response, error, knownErrors, debug) => {
         sendKnownErrorResponse(response, statusCode, error, debug);
         return;
     }
+    if (isTypedError(error)) {
+        // The service knew what went wrong and named it; the route just never said
+        // what to answer. Without this line that is a silent 500, and the only way
+        // anyone finds one is a 5xx alert days later.
+        response.log?.warn({ errorType: error.type, url: response.req?.originalUrl }, 'Typed error is not declared on this route, answering 500');
+    }
     sendUnknownErrorResponse(response, error, debug);
     return;
 };

package/dist/lib/atomicAuditLog/index.d.ts

@@ -1,11 +1,25 @@
 import type { Model, ModelStatic, Sequelize } from 'sequelize';
 import { DataTypes } from 'sequelize';
+type AuditOperation = 'create' | 'update' | 'destroy';
 export interface PartitionTable {
     tableName: string;
     timestamp: Date;
 }
+interface DiffEntry {
+    key: string;
+    values: {
+        old?: unknown;
+        new?: unknown;
+    };
+}
 interface AddHistoryOptions {
     exclude?: string[];
+    /**
+     * Attributes whose change is recorded, but whose values are not. The diff
+     * keeps the key with a placeholder, so the log shows THAT the attribute
+     * changed without storing large or sensitive payloads.
+     */
+    redact?: string[];
 }
 interface AtomicAuditLogOptions {
     attributeRevisionModelTableName?: string;
@@ -18,6 +32,8 @@ export interface PartitionResult {
     archiveTableName: string;
     timestamp: Date;
 }
+export declare const REDACTED_VALUE = "[redacted]";
+export declare const computeDiff: <T extends Model>(instance: T, operation: AuditOperation, exclude: string[], redact: string[]) => DiffEntry[];
 export declare class AtomicAuditLog {
     private sequelize;
     private tableName;

package/dist/lib/atomicAuditLog/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AtomicAuditLog = void 0;
+exports.AtomicAuditLog = exports.computeDiff = exports.REDACTED_VALUE = void 0;
 const sequelize_1 = require("sequelize");
 const DEFAULT_EXCLUDE = [
     'id',
@@ -11,25 +11,32 @@ const DEFAULT_EXCLUDE = [
     'revision',
 ];
 const isValidValue = (value) => value !== undefined && value !== null;
-const computeCreateDiff = (currentValues, excludeSet) => {
+exports.REDACTED_VALUE = '[redacted]';
+const computeCreateDiff = (currentValues, excludeSet, redactSet) => {
     const diff = [];
     for (const [key, value] of Object.entries(currentValues)) {
         if (!excludeSet.has(key) && isValidValue(value)) {
-            diff.push({ key, values: { new: value } });
+            diff.push({
+                key,
+                values: { new: redactSet.has(key) ? exports.REDACTED_VALUE : value },
+            });
         }
     }
     return diff;
 };
-const computeDestroyDiff = (previousValues, excludeSet) => {
+const computeDestroyDiff = (previousValues, excludeSet, redactSet) => {
     const diff = [];
     for (const [key, value] of Object.entries(previousValues)) {
         if (!excludeSet.has(key) && isValidValue(value)) {
-            diff.push({ key, values: { old: value } });
+            diff.push({
+                key,
+                values: { old: redactSet.has(key) ? exports.REDACTED_VALUE : value },
+            });
         }
     }
     return diff;
 };
-const computeUpdateDiff = (instance, previousValues, currentValues, excludeSet) => {
+const computeUpdateDiff = (instance, previousValues, currentValues, excludeSet, redactSet) => {
     const diff = [];
     const changedKeys = instance.changed();
     if (!changedKeys || !Array.isArray(changedKeys)) {
@@ -39,24 +46,29 @@ const computeUpdateDiff = (instance, previousValues, currentValues, excludeSet)
         if (!excludeSet.has(key)) {
             diff.push({
                 key,
-                values: { old: previousValues[key], new: currentValues[key] },
+                values: redactSet.has(key)
+                    ? { old: exports.REDACTED_VALUE, new: exports.REDACTED_VALUE }
+                    : { old: previousValues[key], new: currentValues[key] },
             });
         }
     }
     return diff;
 };
-const computeDiff = (instance, operation, exclude) => {
+// exported for tests
+const computeDiff = (instance, operation, exclude, redact) => {
     const previousValues = instance.previous();
     const currentValues = instance.dataValues;
     const excludeSet = new Set([...DEFAULT_EXCLUDE, ...exclude]);
+    const redactSet = new Set(redact);
     if (operation === 'create') {
-        return computeCreateDiff(currentValues, excludeSet);
+        return computeCreateDiff(currentValues, excludeSet, redactSet);
     }
     if (operation === 'destroy') {
-        return computeDestroyDiff(previousValues, excludeSet);
+        return computeDestroyDiff(previousValues, excludeSet, redactSet);
     }
-    return computeUpdateDiff(instance, previousValues, currentValues, excludeSet);
+    return computeUpdateDiff(instance, previousValues, currentValues, excludeSet, redactSet);
 };
+exports.computeDiff = computeDiff;
 class AtomicAuditLog {
     constructor(sequelize, options = {}) {
         this.sequelize = sequelize;
@@ -86,12 +98,12 @@ class AtomicAuditLog {
         return `${this.tableName}_View`;
     }
     addHistory(model, options = {}) {
-        const { exclude = [] } = options;
+        const { exclude = [], redact = [] } = options;
         const modelName = model.name;
         const primaryKeyAttribute = model.primaryKeyAttribute || 'uuid';
-        const createHook = this.createAuditHook(modelName, primaryKeyAttribute, exclude, 'create');
-        const updateHook = this.createAuditHook(modelName, primaryKeyAttribute, exclude, 'update');
-        const destroyHook = this.createAuditHook(modelName, primaryKeyAttribute, exclude, 'destroy');
+        const createHook = this.createAuditHook(modelName, primaryKeyAttribute, exclude, redact, 'create');
+        const updateHook = this.createAuditHook(modelName, primaryKeyAttribute, exclude, redact, 'update');
+        const destroyHook = this.createAuditHook(modelName, primaryKeyAttribute, exclude, redact, 'destroy');
         model.addHook('afterCreate', createHook);
         model.addHook('afterUpdate', updateHook);
         model.addHook('afterDestroy', destroyHook);
@@ -144,10 +156,10 @@ class AtomicAuditLog {
             transaction,
         });
     }
-    createAuditHook(modelName, primaryKeyAttribute, exclude, operation) {
+    createAuditHook(modelName, primaryKeyAttribute, exclude, redact, operation) {
         return async (instance, options) => {
             try {
-                const diff = computeDiff(instance, operation, exclude);
+                const diff = (0, exports.computeDiff)(instance, operation, exclude, redact);
                 if (diff.length === 0) {
                     return;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "5.34.0",
+  "version": "5.35.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [