@explita/prisma-audit-log 0.1.0 → 0.2.0

package/README.md

@@ -5,10 +5,16 @@ A Prisma extension for automatic audit logging of database operations.
 ## Features
 
 - ✅ Automatic logging of create, update, and delete operations
-- ✅ Support for single and batch operations
+- ✅ Efficient batch processing of logs with automatic fallback to single inserts
+- ✅ Support for both single and batch operations
 - ✅ Tracks changed fields for updates
 - ✅ Context-aware logging with user and request information
 - ✅ Customizable field masking and data sanitization
+- ✅ Field-level filtering to include/exclude specific fields from logs
+- ✅ Ignores updates where only `updatedAt`/`updated_at` changed (noise-free logs)
+- ✅ Skip logging for specific operations using a callback function
+- ✅ Proper handling of Decimal and other special types
+- ✅ Ignores logging of AuditLog model
 - ✅ TypeScript support
 
 ## Installation
@@ -17,6 +23,8 @@ A Prisma extension for automatic audit logging of database operations.
 npm install @explita/prisma-audit-log
 # or
 yarn add @explita/prisma-audit-log
+# or
+pnpm add @explita/prisma-audit-log
 ```
 
 #
@@ -56,6 +64,18 @@ const prisma = new PrismaClient().$extends(
     maskFields: ["password", "token"],
     maskValue: "[REDACTED]", // default value
 
+    // Optional: Configure field inclusion/exclusion per model
+    fieldFilters: {
+      // Exclude sensitive fields from User model
+      User: {
+        exclude: ["password", "tokens", "refreshToken"],
+      },
+      // Only include specific fields for Payment model
+      Payment: {
+        include: ["id", "amount", "status", "createdAt"],
+      },
+    },
+
     // Optional: Truncate long values
     maxStringLength: 1000,
     maxArrayLength: 50,
@@ -64,7 +84,24 @@ const prisma = new PrismaClient().$extends(
     logger: (log) => {
       // Send logs to your logging service
       console.log("AUDIT:", log);
+      // log can be an array of AuditLog objects
     },
+
+    // Skip logging for specific operations
+    skip: ({ model, operation, args }) => {
+      // Skip logging for specific models or operations
+      if (model === "Session" && operation === "create") return true;
+
+      // Skip logging for specific conditions
+      if (model === "User" && args?.data?.isSystemUpdate) return true;
+
+      // Skip logging for specific operations on specific models
+      if (model === "AuditLog" || model === "audit_logs") return true;
+
+      return false;
+    },
+
+    // Timestamp-only updates are skipped automatically, so no extra config needed
   })
 );
 ```
@@ -118,17 +155,19 @@ route.put("/test/:id", async (request, reply) => {
 
 ## Configuration Options
 
-| Option            | Type                 | Description                                            |
-| ----------------- | -------------------- | ------------------------------------------------------ |
-| `includeModels`   | `string[]`           | Only log operations on these models                    |
-| `excludeModels`   | `string[]`           | Exclude these models from logging                      |
-| `getContext`      | `() => AuditContext` | Function to get current context (user, IP, etc.)       |
-| `maskFields`      | `string[]`           | Fields to mask in logs                                 |
-| `maskValue`       | `any`                | Value to use for masked fields (default: `[REDACTED]`) |
-| `maxStringLength` | `number`             | Truncate long strings                                  |
-| `maxArrayLength`  | `number`             | Truncate large arrays                                  |
-| `maxPayloadBytes` | `number`             | Maximum JSON payload size                              |
-| `batchInsert`     | `boolean`            | Use batch inserts (default: `true`)                    |
+| Option            | Type                                                                                       | Description                                                                                                      |
+| ----------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------- |
+| `includeModels`   | `string[]`                                                                                 | Only log operations on these models                                                                              |
+| `excludeModels`   | `string[]`                                                                                 | Exclude these models from logging                                                                                |
+| `getContext`      | `() => AuditContext`                                                                       | Function to get current context (user, IP, etc.)                                                                 |
+| `maskFields`      | `string[]`                                                                                 | Fields to mask in logs                                                                                           |
+| `maskValue`       | `any`                                                                                      | Value to use for masked fields (default: `[REDACTED]`)                                                           |
+| `maxStringLength` | `number`                                                                                   | Truncate long strings                                                                                            |
+| `maxArrayLength`  | `number`                                                                                   | Truncate large arrays                                                                                            |
+| `maxPayloadBytes` | `number`                                                                                   | Maximum JSON payload size (before truncation)                                                                    |
+| `fieldFilters`    | `{ [model: string]: { include?: string[]; exclude?: string[] } }`                          | Configure field inclusion/exclusion per model. Use `include` to whitelist fields or `exclude` to blacklist them. |
+| `skip`            | `(params: { model: string; operation: string; args: any }) => boolean \| Promise<boolean>` | Skip logging for specific operations                                                                             |
+| `logger`          | `(log: AuditLog \| AuditLog[]) => void`                                                    | Custom logger function for audit logs                                                                            |
 
 ## License
 

package/dist/core/create.js

@@ -11,6 +11,6 @@ async function handleCreate(opts) {
         recordId: result.id,
         newData: result,
     };
-    await (0, process_js_1.processAuditLog)(prisma, auditLog, options);
+    await (0, process_js_1.saveAuditLogs)(prisma, [auditLog], options);
     return result;
 }

package/dist/core/delete.js

@@ -16,7 +16,7 @@ async function handleDelete(opts) {
             recordId: current.id,
             oldData: current,
         };
-        await (0, process_js_1.processAuditLog)(prisma, auditLog, options);
+        await (0, process_js_1.saveAuditLogs)(prisma, [auditLog], options);
     }
     return result;
 }

package/dist/core/process.d.ts

@@ -1,3 +1,2 @@
 import type { AuditLog, AuditLogOptions } from "../types.js";
-export declare function processAuditLog(prisma: any, auditLog: Omit<AuditLog, "id">, options: AuditLogOptions): Promise<void>;
 export declare function saveAuditLogs(prisma: any, logs: Omit<AuditLog, "id">[], options: AuditLogOptions): Promise<void>;

package/dist/core/process.js

@@ -1,46 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processAuditLog = processAuditLog;
 exports.saveAuditLogs = saveAuditLogs;
 const process_log_helpers_js_1 = require("../lib/process-log-helpers.js");
-async function processAuditLog(prisma, auditLog, options) {
-    const finalLog = await (0, process_log_helpers_js_1.buildFinalLog)(auditLog, options);
-    // Use custom logger if provided, otherwise log to console
-    if (options.logger) {
-        await options.logger(finalLog);
-    }
-    //  else {
-    //   console.log("[AUDIT LOG]", finalLog);
-    // }
-    // Try to save to database if AuditLog model exists
-    try {
-        if (prisma.auditLog) {
-            await prisma.auditLog.create({
-                data: finalLog,
-            });
-        }
-    }
-    catch (error) {
-        console.error("Failed to save audit log to database:", error);
-    }
-}
 async function saveAuditLogs(prisma, logs, options) {
-    var _a;
+    var _a, _b;
     if (!logs.length)
         return;
-    if (options.batchInsert && ((_a = prisma.auditLog) === null || _a === void 0 ? void 0 : _a.createMany)) {
+    try {
         const finals = await Promise.all(logs.map((log) => (0, process_log_helpers_js_1.buildFinalLog)(log, options)));
-        if (finals.length) {
+        if (!finals.length)
+            return;
+        if ((_a = prisma.auditLog) === null || _a === void 0 ? void 0 : _a.createMany) {
             await prisma.auditLog.createMany({ data: finals });
-            if (options.logger) {
-                for (const entry of finals) {
-                    await options.logger(entry);
-                }
+        }
+        else if ((_b = prisma.auditLog) === null || _b === void 0 ? void 0 : _b.create) {
+            // Fall back to individual inserts if createMany is not available
+            for (const finalLog of finals) {
+                await prisma.auditLog.create({
+                    data: finalLog,
+                });
             }
         }
-        return;
+        if (options.logger && finals.length) {
+            await options.logger(finals);
+        }
     }
-    for (const log of logs) {
-        await processAuditLog(prisma, log, options);
+    catch (error) {
+        console.error("Failed to save audit log to database:", error);
     }
 }

package/dist/core/update-many.js

@@ -28,6 +28,10 @@ async function handleUpdateMany(opts) {
         if (!updated)
             continue;
         const changedFields = (0, utils_js_1.getChangedFields)(current, updated);
+        if (changedFields.length === 1 &&
+            (changedFields[0] === "updatedAt" || changedFields[0] === "updated_at")) {
+            continue;
+        }
         const { oldData, newData } = (0, utils_js_1.buildSnapshot)(changedFields, current, updated);
         logs.push({
             action: "UPDATE",

package/dist/core/update.js

@@ -12,6 +12,10 @@ async function handleUpdate(opts) {
     const result = await query(args);
     if (current) {
         const changedFields = (0, utils_js_1.getChangedFields)(current, result);
+        if (changedFields.length === 1 &&
+            (changedFields[0] === "updatedAt" || changedFields[0] === "updated_at")) {
+            return result;
+        }
         const { oldData, newData } = (0, utils_js_1.buildSnapshot)(changedFields, current, result);
         const auditLog = {
             action: "UPDATE",
@@ -21,7 +25,7 @@ async function handleUpdate(opts) {
             newData,
             changedFields,
         };
-        await (0, process_js_1.processAuditLog)(prisma, auditLog, options);
+        await (0, process_js_1.saveAuditLogs)(prisma, [auditLog], options);
     }
     return result;
 }

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export type { AuditLog, AuditLogOptions } from "./types.js";
+export type { AuditContext, AuditLog, AuditLogOptions, ModelFieldFilters, } from "./types.js";
 export { auditLogExtension } from "./lib/prisma-extension.js";

package/dist/lib/prisma-extension.js

@@ -15,17 +15,29 @@ const update_js_1 = require("../core/update.js");
 function auditLogExtension(options = {}) {
     return extension_1.Prisma.defineExtension((prisma) => {
         return prisma.$extends({
+            name: "auditLogExtension",
             query: {
                 $allModels: {
                     async $allOperations({ model, operation, args, query }) {
                         const modelName = model === null || model === void 0 ? void 0 : model.toString();
+                        // Never audit the audit log model itself
+                        if (["auditLog", "AuditLog"].includes(modelName !== null && modelName !== void 0 ? modelName : "")) {
+                            return query(args);
+                        }
                         // Skip if model is excluded or not included
                         if ((0, utils_js_1.shouldSkipModel)(modelName, options)) {
                             return query(args);
                         }
-                        // Never audit the audit log model itself
-                        if (["auditLog", "AuditLog"].includes(modelName !== null && modelName !== void 0 ? modelName : "")) {
-                            return query(args);
+                        // Check if the operation should be skipped via the skip callback
+                        if (options.skip) {
+                            const shouldSkip = await options.skip({
+                                model: modelName,
+                                operation,
+                                args,
+                            });
+                            if (shouldSkip) {
+                                return query(args);
+                            }
                         }
                         const queryArgs = {
                             args,

package/dist/lib/process-log-helpers.d.ts

@@ -1,2 +1,7 @@
-import type { AuditLog, AuditLogOptions } from "../types.js";
+import type { AuditLog, AuditLogOptions, FilterFieldsResult, ModelFieldFilters } from "../types.js";
 export declare function buildFinalLog(auditLog: Omit<AuditLog, "id">, options: AuditLogOptions): Promise<Omit<AuditLog, "id">>;
+/**
+ * Filter object fields based on include/exclude rules
+ * @returns An object containing the filtered data and changedFields
+ */
+export declare function filterFields<T extends Record<string, any>>(data: T | undefined, model: string, fieldFilters?: ModelFieldFilters, changedFields?: string[]): FilterFieldsResult<T>;

package/dist/lib/process-log-helpers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildFinalLog = buildFinalLog;
+exports.filterFields = filterFields;
 function matchesMaskPath(maskPaths, keyPath) {
     if (!maskPaths || keyPath.length === 0)
         return false;
@@ -38,6 +39,13 @@ function maskAndTruncate(value, opts, keyPath = []) {
         const limited = maxArrayLength ? value.slice(0, maxArrayLength) : value;
         return limited.map((v, i) => maskAndTruncate(v, opts, [...keyPath, String(i)]));
     }
+    // Handle Decimal type from Prisma
+    if (value &&
+        typeof value === "object" &&
+        "constructor" in value &&
+        ["Decimal", "Decimal2"].includes(value.constructor.name)) {
+        return value.toString();
+    }
     if (typeof value === "object") {
         const out = {};
         for (const [k, v] of Object.entries(value)) {
@@ -72,6 +80,20 @@ async function buildFinalLog(auditLog, options) {
     const finalLog = {
         ...auditLog,
     };
+    // Apply field filtering if configured
+    if (options.fieldFilters) {
+        if (finalLog.oldData) {
+            const { filteredData } = filterFields(finalLog.oldData, auditLog.model, options.fieldFilters);
+            finalLog.oldData = filteredData;
+        }
+        if (finalLog.newData) {
+            const { filteredData, filteredChangedFields } = filterFields(finalLog.newData, auditLog.model, options.fieldFilters, finalLog.changedFields);
+            finalLog.newData = filteredData;
+            if (filteredChangedFields) {
+                finalLog.changedFields = filteredChangedFields;
+            }
+        }
+    }
     // Merge extra context
     if (options.getContext) {
         const context = await options.getContext();
@@ -91,3 +113,50 @@ async function buildFinalLog(auditLog, options) {
     }
     return finalLog;
 }
+/**
+ * Filter object fields based on include/exclude rules
+ * @returns An object containing the filtered data and changedFields
+ */
+function filterFields(data, model, fieldFilters, changedFields) {
+    if (!data)
+        return { filteredData: data, filteredChangedFields: changedFields };
+    const modelFilters = fieldFilters === null || fieldFilters === void 0 ? void 0 : fieldFilters[model];
+    if (!modelFilters)
+        return { filteredData: data, filteredChangedFields: changedFields };
+    // Handle both include and exclude being optional
+    const include = "include" in modelFilters ? modelFilters.include : undefined;
+    const exclude = "exclude" in modelFilters ? modelFilters.exclude : undefined;
+    let filteredChangedFields = changedFields;
+    // If include is specified, only include those fields
+    if (include === null || include === void 0 ? void 0 : include.length) {
+        const includeSet = new Set(include);
+        const result = include.reduce((result, field) => {
+            if (field in data) {
+                result[field] = data[field];
+            }
+            return result;
+        }, {});
+        if (changedFields) {
+            filteredChangedFields = changedFields.filter((field) => includeSet.has(field));
+        }
+        return { filteredData: result, filteredChangedFields };
+    }
+    // If exclude is specified, exclude those fields
+    if (exclude === null || exclude === void 0 ? void 0 : exclude.length) {
+        const excludeSet = new Set(exclude);
+        const result = Object.entries(data).reduce((result, [key, value]) => {
+            if (!excludeSet.has(key)) {
+                result[key] = value;
+            }
+            return result;
+        }, {});
+        if (changedFields) {
+            filteredChangedFields = changedFields.filter((field) => !excludeSet.has(field));
+        }
+        return { filteredData: result, filteredChangedFields };
+    }
+    return {
+        filteredData: data,
+        filteredChangedFields: changedFields,
+    };
+}

package/dist/types.d.ts

@@ -1,5 +1,14 @@
 import type { JsArgs } from "@prisma/client/runtime/client";
 export interface AuditLogOptions {
+    /**
+     * Function to determine if audit logging should be skipped for the current operation
+     * @returns true to skip logging, false or undefined to continue with logging
+     */
+    skip?: (params: {
+        model: string;
+        operation: string;
+        args: any;
+    }) => boolean | Promise<boolean>;
     /**
      * Tables to include in audit logging
      * If not provided, all tables will be included
@@ -10,6 +19,15 @@ export interface AuditLogOptions {
      * Takes precedence over includeModels
      */
     excludeModels?: string[];
+    /**
+     * Configure field inclusion/exclusion per model
+     * @example
+     * {
+     *   User: { exclude: ['password', 'tokens'] },
+     *   Payment: { include: ['id', 'amount', 'status'] }
+     * }
+     */
+    fieldFilters?: ModelFieldFilters;
     /**
      * Function to get extra context for the audit trail (e.g., userId, companyId, branchId, metadata, ...)
      * Return any additional fields your AuditLog model supports. They will be merged into the final log.
@@ -19,7 +37,7 @@ export interface AuditLogOptions {
      * Custom logger function
      * If not provided, logs will be written to console
      */
-    logger?: (log: AuditLog) => void | Promise<void>;
+    logger?: (log: AuditLog | AuditLog[]) => void | Promise<void>;
     /**
      * Keys to mask in oldData/newData/metadata. Exact match on property name.
      */
@@ -36,8 +54,6 @@ export interface AuditLogOptions {
     maxArrayLength?: number;
     /** Maximum JSON payload size per field (old/new/metadata). Entries exceeding this will be replaced with a truncated preview */
     maxPayloadBytes?: number;
-    /** Whether to use createMany for bulk inserts when available (default: true) */
-    batchInsert?: boolean;
 }
 export interface AuditLog {
     id: string;
@@ -69,3 +85,14 @@ export type HandlerArgs = {
     options: AuditLogOptions;
     operation?: string;
 };
+export type FieldFilterConfig = {
+    include?: string[];
+    exclude?: string[];
+};
+export type ModelFieldFilters = {
+    [model: string]: FieldFilterConfig;
+};
+export interface FilterFieldsResult<T> {
+    filteredData: T | undefined;
+    filteredChangedFields?: string[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@explita/prisma-audit-log",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A Prisma extension for automatic audit logging",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",