@explita/prisma-audit-log 0.1.0

package/README.md

@@ -0,0 +1,139 @@
+# Prisma Audit Log
+
+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
+- ✅ Tracks changed fields for updates
+- ✅ Context-aware logging with user and request information
+- ✅ Customizable field masking and data sanitization
+- ✅ TypeScript support
+
+## Installation
+
+```bash
+npm install @explita/prisma-audit-log
+# or
+yarn add @explita/prisma-audit-log
+```
+
+#
+
+### Basic Setup
+
+```typescript
+import { PrismaClient } from "@prisma/client";
+import { auditLogExtension } from "@explita/prisma-audit-log";
+import { getContext } from "..."; // or your auth context
+
+const prisma = new PrismaClient().$extends(
+  auditLogExtension({
+    // Optional: Only include specific models
+    // includeModels: ['User', 'Post'],
+
+    // Optional: Exclude specific models
+    // excludeModels: ['SensitiveData'],
+
+    // Get context for audit logs.
+    // The values returned here will be merged with operation context.
+    // Make sure whatever returned matches your audit log schema.
+    getContext: () => {
+      const { auth, req } = getContext();
+      return {
+        userId: auth.id,
+        companyId: auth.companyId,
+        ipAddress: req.ip,
+        metadata: {
+          ip: req.ip,
+          browser: req.headers["user-agent"],
+        },
+      };
+    },
+
+    // Optional: Mask sensitive fields
+    maskFields: ["password", "token"],
+    maskValue: "[REDACTED]", // default value
+
+    // Optional: Truncate long values
+    maxStringLength: 1000,
+    maxArrayLength: 50,
+
+    // Optional: Custom logger
+    logger: (log) => {
+      // Send logs to your logging service
+      console.log("AUDIT:", log);
+    },
+  })
+);
+```
+
+#
+
+### Database Schema
+
+Add this to your Prisma schema:
+
+```prisma
+model AuditLog {
+  id            String   @id @default(cuid())
+  userId        String?  @map("user_id")
+  recordId      String   @map("record_id")
+  action        String
+  model         String
+  oldData       Json?    @map("old_data")
+  newData       Json?    @map("new_data")
+  changedFields String[] @map("changed_fields")
+  ipAddress     String?  @map("ip_address")
+  userAgent     String?  @map("user_agent")
+  metadata      Json?
+  createdAt     DateTime @default(now()) @map("created_at")
+
+  @@map("audit_logs")
+}
+```
+
+#
+
+### Example Usage
+
+```typescript
+// Example Fastify route
+route.put("/test/:id", async (request, reply) => {
+  // These operations will be automatically logged
+  await db.branch.update({
+    where: { id: "123" },
+    data: { address: "123 Main St" },
+  });
+
+  await db.branch.updateMany({
+    where: { phone: "0123456789" },
+    data: { phone: "1023456789" },
+  });
+
+  reply.send("Operations completed");
+});
+```
+
+## 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`)                    |
+
+## License
+
+MIT
+
+---
+
+Built with ❤️ by [Explita](https://explita.ng)

package/dist/core/create-many.d.ts

@@ -0,0 +1,7 @@
+import type { HandlerArgs } from "../types.js";
+/**
+ * Handle createMany and createManyAndReturn operations
+ * - createManyAndReturn: logs each created record using the returned rows
+ * - createMany: logs best-effort using the input data (uses provided id if present)
+ */
+export declare function handleCreateMany(opts: HandlerArgs): Promise<any>;

package/dist/core/create-many.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCreateMany = handleCreateMany;
+const process_js_1 = require("./process.js");
+/**
+ * Handle createMany and createManyAndReturn operations
+ * - createManyAndReturn: logs each created record using the returned rows
+ * - createMany: logs best-effort using the input data (uses provided id if present)
+ */
+async function handleCreateMany(opts) {
+    const { args, prisma, query, options, modelName, operation } = opts;
+    if (operation === "createManyAndReturn") {
+        const created = await query(args);
+        const rows = Array.isArray(created) ? created : [created];
+        // Build logs
+        const logs = rows.map((row) => {
+            var _a;
+            return ({
+                action: "CREATE",
+                model: modelName,
+                recordId: String((_a = row.id) !== null && _a !== void 0 ? _a : "unknown"),
+                newData: row,
+            });
+        });
+        await (0, process_js_1.saveAuditLogs)(prisma, logs, options);
+        return created;
+    }
+    // Fallback for createMany (does not return created records)
+    const rawData = args === null || args === void 0 ? void 0 : args.data;
+    const dataArray = Array.isArray(rawData)
+        ? rawData
+        : rawData
+            ? [rawData]
+            : [];
+    // Guard: skip logging when data is empty or missing
+    if (!dataArray.length) {
+        return query(args);
+    }
+    const result = await query(args);
+    const logs = dataArray.map((item) => {
+        var _a;
+        return ({
+            action: "CREATE",
+            model: modelName,
+            recordId: String((_a = item === null || item === void 0 ? void 0 : item.id) !== null && _a !== void 0 ? _a : "unknown"),
+            newData: item,
+        });
+    });
+    await (0, process_js_1.saveAuditLogs)(prisma, logs, options);
+    return result;
+}

package/dist/core/create.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerArgs } from "../types.js";
+export declare function handleCreate(opts: HandlerArgs): Promise<any>;

package/dist/core/create.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCreate = handleCreate;
+const process_js_1 = require("./process.js");
+async function handleCreate(opts) {
+    const { args, prisma, query, options, modelName } = opts;
+    const result = await query(args);
+    const auditLog = {
+        action: "CREATE",
+        model: modelName,
+        recordId: result.id,
+        newData: result,
+    };
+    await (0, process_js_1.processAuditLog)(prisma, auditLog, options);
+    return result;
+}

package/dist/core/delete-many.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerArgs } from "../types.js";
+export declare function handleDeleteMany(opts: HandlerArgs): Promise<any>;

package/dist/core/delete-many.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDeleteMany = handleDeleteMany;
+const process_js_1 = require("./process.js");
+async function handleDeleteMany(opts) {
+    const { args, prisma, query, options, modelName } = opts;
+    // Get the current state of records that will be deleted
+    const currentRecords = await prisma[modelName].findMany({
+        where: args["where"],
+    });
+    // Guard: if no records match, skip logging
+    if (!currentRecords.length) {
+        return query(args);
+    }
+    const result = await query(args);
+    // Create audit logs for each deleted record
+    const logs = currentRecords.map((record) => ({
+        action: "DELETE",
+        model: modelName,
+        recordId: record.id,
+        oldData: record,
+    }));
+    await (0, process_js_1.saveAuditLogs)(prisma, logs, options);
+    return result;
+}

package/dist/core/delete.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerArgs } from "../types.js";
+export declare function handleDelete(opts: HandlerArgs): Promise<any>;

package/dist/core/delete.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDelete = handleDelete;
+const process_js_1 = require("./process.js");
+async function handleDelete(opts) {
+    const { args, prisma, query, options, modelName } = opts;
+    // Get the current state before delete
+    const current = await prisma[modelName].findUnique({
+        where: args["where"],
+    });
+    const result = await query(args);
+    if (current) {
+        const auditLog = {
+            action: "DELETE",
+            model: modelName,
+            recordId: current.id,
+            oldData: current,
+        };
+        await (0, process_js_1.processAuditLog)(prisma, auditLog, options);
+    }
+    return result;
+}

package/dist/core/process.d.ts

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

@@ -0,0 +1,46 @@
+"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;
+    if (!logs.length)
+        return;
+    if (options.batchInsert && ((_a = prisma.auditLog) === null || _a === void 0 ? void 0 : _a.createMany)) {
+        const finals = await Promise.all(logs.map((log) => (0, process_log_helpers_js_1.buildFinalLog)(log, options)));
+        if (finals.length) {
+            await prisma.auditLog.createMany({ data: finals });
+            if (options.logger) {
+                for (const entry of finals) {
+                    await options.logger(entry);
+                }
+            }
+        }
+        return;
+    }
+    for (const log of logs) {
+        await processAuditLog(prisma, log, options);
+    }
+}

package/dist/core/update-many.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerArgs } from "../types.js";
+export declare function handleUpdateMany(opts: HandlerArgs): Promise<any>;

package/dist/core/update-many.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleUpdateMany = handleUpdateMany;
+const utils_js_1 = require("../lib/utils.js");
+const process_js_1 = require("./process.js");
+async function handleUpdateMany(opts) {
+    const { args, prisma, query, options, modelName, operation } = opts;
+    // Get the current state of records that will be updated
+    const currentRecords = await prisma[modelName].findMany({
+        where: args["where"],
+    });
+    // Guard: if no records will be updated, skip logging
+    if (!currentRecords.length) {
+        return query(args);
+    }
+    const ids = currentRecords.map((row) => row.id);
+    const result = await query(args);
+    //updated records
+    const updatedRecords = operation == "createManyAndReturn"
+        ? result
+        : await prisma[modelName].findMany({
+            where: { id: { in: ids } },
+        });
+    const logs = [];
+    // Create audit logs for each updated record
+    for (const current of currentRecords) {
+        const updated = updatedRecords.find((r) => r.id === current.id);
+        if (!updated)
+            continue;
+        const changedFields = (0, utils_js_1.getChangedFields)(current, updated);
+        const { oldData, newData } = (0, utils_js_1.buildSnapshot)(changedFields, current, updated);
+        logs.push({
+            action: "UPDATE",
+            model: modelName,
+            recordId: current.id,
+            oldData,
+            newData,
+            changedFields,
+        });
+    }
+    await (0, process_js_1.saveAuditLogs)(prisma, logs, options);
+    return result;
+}

package/dist/core/update.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerArgs } from "../types.js";
+export declare function handleUpdate(opts: HandlerArgs): Promise<any>;

package/dist/core/update.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleUpdate = handleUpdate;
+const utils_js_1 = require("../lib/utils.js");
+const process_js_1 = require("./process.js");
+async function handleUpdate(opts) {
+    const { args, prisma, query, options, modelName } = opts;
+    // Get the current state before update
+    const current = await prisma[modelName].findUnique({
+        where: args["where"],
+    });
+    const result = await query(args);
+    if (current) {
+        const changedFields = (0, utils_js_1.getChangedFields)(current, result);
+        const { oldData, newData } = (0, utils_js_1.buildSnapshot)(changedFields, current, result);
+        const auditLog = {
+            action: "UPDATE",
+            model: modelName,
+            recordId: result.id,
+            oldData,
+            newData,
+            changedFields,
+        };
+        await (0, process_js_1.processAuditLog)(prisma, auditLog, options);
+    }
+    return result;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditLogExtension = void 0;
+var prisma_extension_js_1 = require("./lib/prisma-extension.js");
+Object.defineProperty(exports, "auditLogExtension", { enumerable: true, get: function () { return prisma_extension_js_1.auditLogExtension; } });

package/dist/lib/prisma-extension.d.ts

@@ -0,0 +1,5 @@
+import type { AuditLogOptions } from "../types.js";
+/**
+ * Creates a Prisma extension that adds audit logging
+ */
+export declare function auditLogExtension(options?: AuditLogOptions): (client: any) => import("@prisma/client/extension").PrismaClientExtends<import("@prisma/client/runtime/client").InternalArgs<{}, {}, {}, {}> & import("@prisma/client/runtime/client").DefaultArgs>;

package/dist/lib/prisma-extension.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditLogExtension = auditLogExtension;
+const extension_1 = require("@prisma/client/extension");
+const utils_js_1 = require("./utils.js");
+const create_js_1 = require("../core/create.js");
+const create_many_js_1 = require("../core/create-many.js");
+const update_many_js_1 = require("../core/update-many.js");
+const delete_js_1 = require("../core/delete.js");
+const delete_many_js_1 = require("../core/delete-many.js");
+const update_js_1 = require("../core/update.js");
+/**
+ * Creates a Prisma extension that adds audit logging
+ */
+function auditLogExtension(options = {}) {
+    return extension_1.Prisma.defineExtension((prisma) => {
+        return prisma.$extends({
+            query: {
+                $allModels: {
+                    async $allOperations({ model, operation, args, query }) {
+                        const modelName = model === null || model === void 0 ? void 0 : model.toString();
+                        // 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);
+                        }
+                        const queryArgs = {
+                            args,
+                            prisma,
+                            query,
+                            options,
+                            modelName,
+                            operation,
+                        };
+                        // Handle different operations
+                        switch (operation) {
+                            case "create":
+                                return (0, create_js_1.handleCreate)(queryArgs);
+                            case "createMany":
+                            case "createManyAndReturn":
+                                return (0, create_many_js_1.handleCreateMany)(queryArgs);
+                            case "delete":
+                                return (0, delete_js_1.handleDelete)(queryArgs);
+                            case "deleteMany":
+                                return (0, delete_many_js_1.handleDeleteMany)(queryArgs);
+                            case "update":
+                                return (0, update_js_1.handleUpdate)(queryArgs);
+                            case "updateMany":
+                            case "updateManyAndReturn":
+                                return (0, update_many_js_1.handleUpdateMany)(queryArgs);
+                            default:
+                                return query(args);
+                        }
+                    },
+                },
+            },
+        });
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { AuditLog, AuditLogOptions } from "../types.js";
+export declare function buildFinalLog(auditLog: Omit<AuditLog, "id">, options: AuditLogOptions): Promise<Omit<AuditLog, "id">>;

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFinalLog = buildFinalLog;
+function matchesMaskPath(maskPaths, keyPath) {
+    if (!maskPaths || keyPath.length === 0)
+        return false;
+    return maskPaths.some((path) => {
+        const segments = path.split(".");
+        if (segments.length !== keyPath.length)
+            return false;
+        return segments.every((segment, index) => segment === "*" || segment === keyPath[index]);
+    });
+}
+function maskAndTruncate(value, opts, keyPath = []) {
+    const { maskFields, maskPaths, maskValue = "[REDACTED]", maxStringLength, maxArrayLength, } = opts;
+    const currentKey = keyPath[keyPath.length - 1];
+    const shouldMaskField = currentKey && (maskFields === null || maskFields === void 0 ? void 0 : maskFields.includes(currentKey));
+    const shouldMaskPath = matchesMaskPath(maskPaths, keyPath);
+    if (shouldMaskField || shouldMaskPath) {
+        return maskValue;
+    }
+    if (value == null)
+        return value;
+    if (value instanceof Date) {
+        const iso = value.toISOString();
+        if (maxStringLength && iso.length > maxStringLength) {
+            return iso.slice(0, maxStringLength) + "…";
+        }
+        return iso;
+    }
+    if (typeof value === "string") {
+        if (maxStringLength && value.length > maxStringLength) {
+            return value.slice(0, maxStringLength) + "…";
+        }
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const limited = maxArrayLength ? value.slice(0, maxArrayLength) : value;
+        return limited.map((v, i) => maskAndTruncate(v, opts, [...keyPath, String(i)]));
+    }
+    if (typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = maskAndTruncate(v, opts, [...keyPath, k]);
+        }
+        return out;
+    }
+    return value;
+}
+function enforcePayloadLimit(value, opts) {
+    const { maxPayloadBytes } = opts;
+    if (!maxPayloadBytes || value == null)
+        return value;
+    try {
+        const json = JSON.stringify(value);
+        if (json.length <= maxPayloadBytes)
+            return value;
+        return {
+            truncated: true,
+            originalSize: json.length,
+            preview: json.slice(0, maxPayloadBytes),
+        };
+    }
+    catch {
+        return {
+            truncated: true,
+            reason: "serialization_failed",
+        };
+    }
+}
+async function buildFinalLog(auditLog, options) {
+    const finalLog = {
+        ...auditLog,
+    };
+    // Merge extra context
+    if (options.getContext) {
+        const context = await options.getContext();
+        if (context && typeof context === "object") {
+            Object.assign(finalLog, context);
+        }
+    }
+    // Apply masking/truncation to payload sections
+    if (finalLog.oldData) {
+        finalLog.oldData = enforcePayloadLimit(maskAndTruncate(finalLog.oldData, options), options);
+    }
+    if (finalLog.newData) {
+        finalLog.newData = enforcePayloadLimit(maskAndTruncate(finalLog.newData, options), options);
+    }
+    if (finalLog.metadata) {
+        finalLog.metadata = enforcePayloadLimit(maskAndTruncate(finalLog.metadata, options), options);
+    }
+    return finalLog;
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,7 @@
+import type { AuditLogOptions } from "../types.js";
+export declare function shouldSkipModel(modelName: string | undefined, options: AuditLogOptions): boolean;
+export declare function getChangedFields(oldObj: any, newObj: any): string[];
+export declare function buildSnapshot(changedFields: string[], current: any, updated: any): {
+    newData: any;
+    oldData: any;
+};

package/dist/lib/utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldSkipModel = shouldSkipModel;
+exports.getChangedFields = getChangedFields;
+exports.buildSnapshot = buildSnapshot;
+function shouldSkipModel(modelName, options) {
+    var _a;
+    if (!modelName)
+        return true;
+    // Skip if model is in exclude list
+    if ((_a = options.excludeModels) === null || _a === void 0 ? void 0 : _a.includes(modelName)) {
+        return true;
+    }
+    // Skip if includeModels is specified and model is not in the list
+    if (options.includeModels && !options.includeModels.includes(modelName)) {
+        return true;
+    }
+    return false;
+}
+function getChangedFields(oldObj, newObj) {
+    const changedFields = [];
+    for (const key in newObj) {
+        if (JSON.stringify(oldObj[key]) !== JSON.stringify(newObj[key])) {
+            changedFields.push(key);
+        }
+    }
+    return changedFields;
+}
+function buildSnapshot(changedFields, current, updated) {
+    // Build partial snapshots containing only changed fields
+    const oldData = changedFields.reduce((acc, key) => {
+        acc[key] = current[key];
+        return acc;
+    }, {});
+    const newData = changedFields.reduce((acc, key) => {
+        acc[key] = updated[key];
+        return acc;
+    }, {});
+    return { newData, oldData };
+}

package/dist/types.d.ts

@@ -0,0 +1,71 @@
+import type { JsArgs } from "@prisma/client/runtime/client";
+export interface AuditLogOptions {
+    /**
+     * Tables to include in audit logging
+     * If not provided, all tables will be included
+     */
+    includeModels?: string[];
+    /**
+     * Tables to exclude from audit logging
+     * Takes precedence over includeModels
+     */
+    excludeModels?: string[];
+    /**
+     * 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.
+     */
+    getContext?: () => AuditContext | Promise<AuditContext | undefined>;
+    /**
+     * Custom logger function
+     * If not provided, logs will be written to console
+     */
+    logger?: (log: AuditLog) => void | Promise<void>;
+    /**
+     * Keys to mask in oldData/newData/metadata. Exact match on property name.
+     */
+    maskFields?: string[];
+    /**
+     * Dot-delimited paths to mask (e.g., "payment.card.number"). Supports '*' wildcard per segment.
+     */
+    maskPaths?: string[];
+    /** Value used to replace masked fields (default: "[REDACTED]") */
+    maskValue?: any;
+    /** Truncate long string values to this length (default: no limit) */
+    maxStringLength?: number;
+    /** Truncate arrays to this length (default: no limit) */
+    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;
+    action: "CREATE" | "UPDATE" | "DELETE";
+    model: string;
+    recordId: string;
+    oldData?: Record<string, any>;
+    newData?: Record<string, any>;
+    changedFields?: string[];
+    userId?: string;
+    ipAddress?: string;
+    userAgent?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Arbitrary context that can be merged into the audit log.
+ * Include any additional fields your schema supports (e.g., companyId, branchId, tenantId, etc.)
+ */
+export interface AuditContext {
+    userId?: string;
+    metadata?: Record<string, any>;
+    [key: string]: any;
+}
+export type HandlerArgs = {
+    prisma: any;
+    modelName: string;
+    args: JsArgs;
+    query: (args: JsArgs) => Promise<any>;
+    options: AuditLogOptions;
+    operation?: string;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@explita/prisma-audit-log",
+  "version": "0.1.0",
+  "description": "A Prisma extension for automatic audit logging",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "prisma",
+    "audit",
+    "logging",
+    "extension"
+  ],
+  "license": "MIT",
+  "author": "Explita",
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "npm run clean && tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@prisma/client": "^7"
+  },
+  "devDependencies": {
+    "@types/node": "^24",
+    "rimraf": "^6.0.1",
+    "typescript": "^5"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}