@willyim/drizzle-audit 0.1.3

package/README.md

@@ -0,0 +1,278 @@
+# drizzle-audit
+
+Automatic audit logging for [Drizzle ORM](https://orm.drizzle.team). Supports Postgres (triggers) and D1/SQLite (triggers or app-level wrapper).
+
+## Install
+
+```bash
+npm install @willyim/drizzle-audit
+```
+
+Peer dependencies: `drizzle-orm`. Optional: `drizzle-kit` (for CLI), `tsx` (for TS config files).
+
+## Quick Start
+
+### Postgres (triggers)
+
+```ts
+import {
+  pgAuditLogTable,
+  createAuditInstallSql,
+  createAttachAuditTriggersSql,
+  withAuditedTransaction,
+} from "@willyim/drizzle-audit/postgres"
+
+// 1. Add to your Drizzle schema
+export const auditLogs = pgAuditLogTable()
+
+// 2. Generate migration SQL
+const migrationSql = [
+  createAuditInstallSql(),
+  createAttachAuditTriggersSql([
+    { table: "users" },
+    { table: "invoices", rowIdColumn: "invoice_id" },
+  ]),
+].join("\n\n")
+
+// 3. Use in your app
+await withAuditedTransaction(db, currentUser.id, async (tx) => {
+  await tx.insert(users).values({ id: "u1", name: "Ada" })
+  await tx.update(users).set({ name: "Ada Lovelace" }).where(eq(users.id, "u1"))
+})
+```
+
+Postgres triggers capture full row snapshots (`old_data`/`new_data` as JSONB) automatically.
+
+### D1/SQLite — App-Level Wrapper (recommended)
+
+For D1 and SQLite, the `withAudit` wrapper is the simplest approach. No triggers, no context tables — it intercepts operations in your JS code where you already have the user session.
+
+```ts
+import { d1AuditLogTable } from "@willyim/drizzle-audit/d1"
+import { withAudit } from "@willyim/drizzle-audit/d1-runtime"
+
+// 1. Add to your schema
+export const auditLogs = d1AuditLogTable()
+
+// 2. Create the audit_logs table (in a migration or setup script)
+// CREATE TABLE audit_logs (
+//   id INTEGER PRIMARY KEY AUTOINCREMENT,
+//   table_name TEXT NOT NULL,
+//   operation TEXT NOT NULL,
+//   row_id TEXT,
+//   user_id TEXT,
+//   old_data TEXT,
+//   new_data TEXT,
+//   created_at TEXT NOT NULL DEFAULT (datetime('now'))
+// );
+
+// 3. Use in your app (e.g. React Router action)
+const audit = withAudit(db, auditLogs, { userId: session.userId })
+
+audit.insert(users, { id: "u1", name: "Ada" })
+audit.update(users, eq(users.id, "u1"), { name: "Ada Lovelace" })
+audit.delete(users, eq(users.id, "u1"))
+
+// Non-audited access is still available
+audit.db.select().from(users).all()
+```
+
+The wrapper auto-detects primary keys from your Drizzle table schema, captures old/new row data, and runs each operation + audit log insert in a transaction.
+
+### D1/SQLite — Triggers
+
+If you prefer trigger-based auditing on SQLite (works with D1, better-sqlite3, libsql):
+
+```ts
+import {
+  createD1AuditInstallSql,
+  createAttachD1AuditTriggersSql,
+  d1AuditLogTable,
+  d1AuditContextTable,
+  withD1AuditedTransaction,
+} from "@willyim/drizzle-audit/d1"
+
+// 1. Add to schema
+export const auditLogs = d1AuditLogTable()
+export const auditContext = d1AuditContextTable()
+
+// 2. Install (creates audit_logs + _audit_context tables + triggers)
+sqlite.exec(createD1AuditInstallSql())
+sqlite.exec(createAttachD1AuditTriggersSql([
+  { table: "users" },
+]))
+
+// 3. Use — context is passed via _audit_context table within a transaction
+withD1AuditedTransaction(db, "user_123", (tx) => {
+  tx.insert(users).values({ id: "u1", name: "Ada" }).run()
+})
+```
+
+Since SQLite has no session variables, context (user_id) is stored in a `_audit_context` table that triggers read from within the transaction.
+
+For full row snapshots, use the column-aware variant (SQLite can't enumerate columns dynamically):
+
+```ts
+sqlite.exec(createAttachD1AuditTriggersSqlWithColumns([
+  { table: "users", columns: ["id", "name", "email"] },
+]))
+```
+
+## Workspace / Tenant Scoping
+
+All three approaches support an optional workspace column for multi-tenant apps.
+
+### Postgres
+
+```ts
+// Install with workspace column
+createAuditInstallSql({ workspaceIdColumn: "workspace_id" })
+export const auditLogs = pgAuditLogTable({ workspaceIdColumn: "workspace_id" })
+
+// Pass workspace at runtime
+await withAuditedTransaction(
+  db, userId, async (tx) => { /* ... */ },
+  "app.user_id",
+  { workspaceId: "ws_1" },
+)
+```
+
+To add workspace to an existing install, use `createAuditAddWorkspaceColumnSql()`.
+
+### D1 Runtime
+
+```ts
+const audit = withAudit(db, auditLogs, {
+  userId: "user_1",
+  workspaceId: "ws_1",
+})
+```
+
+### D1 Triggers
+
+```ts
+createD1AuditInstallSql({ workspaceIdColumn: "workspace_id" })
+createAttachD1AuditTriggersSql(
+  [{ table: "users" }],
+  { workspaceIdColumn: "workspace_id" },
+)
+
+withD1AuditedTransaction(db, "user_1", (tx) => { /* ... */ }, {
+  workspaceId: "ws_1",
+})
+```
+
+## CLI
+
+Generate a Drizzle migration with audit SQL appended:
+
+```bash
+npx drizzle-audit generate \
+  --config app/db/audit.ts \
+  --drizzle-config drizzle.config.ts \
+  --migrations-dir drizzle
+```
+
+Your config file exports a `createAuditSql()` function:
+
+```ts
+// app/db/audit.ts
+import { createAuditInstallSql, createAttachAuditTriggersSql } from "@willyim/drizzle-audit/postgres"
+
+export function createAuditSql() {
+  return [
+    createAuditInstallSql(),
+    createAttachAuditTriggersSql([
+      { table: "users" },
+      { table: "workspaces" },
+    ]),
+  ].join("\n\n")
+}
+```
+
+## API Reference
+
+### `@willyim/drizzle-audit/postgres`
+
+| Export | Description |
+|---|---|
+| `pgAuditLogTable(options?)` | Drizzle table definition for `audit_logs` |
+| `createAuditInstallSql(options?)` | SQL to create the audit table, indexes, and trigger function |
+| `createAttachAuditTriggerSql(target, options?)` | SQL to attach audit trigger to one table |
+| `createAttachAuditTriggersSql(targets, options?)` | Same, for multiple tables |
+| `createAuditAddWorkspaceColumnSql(options)` | SQL to add workspace column to existing install |
+| `setAuditContext(db, actorId, contextKey?, options?)` | Set actor context in current transaction |
+| `withAuditedTransaction(db, actorId, callback, contextKey?, options?)` | Transaction wrapper with actor context |
+
+### `@willyim/drizzle-audit/d1`
+
+| Export | Description |
+|---|---|
+| `d1AuditLogTable(options?)` | Drizzle SQLite table definition for `audit_logs` |
+| `d1AuditContextTable(options?)` | Drizzle SQLite table definition for `_audit_context` |
+| `createD1AuditInstallSql(options?)` | SQL to create audit + context tables and indexes |
+| `createAttachD1AuditTriggerSql(target, options?)` | SQL for audit triggers (one table) |
+| `createAttachD1AuditTriggersSql(targets, options?)` | Same, for multiple tables |
+| `createAttachD1AuditTriggerSqlWithColumns(target, options?)` | Column-aware triggers with full row snapshots |
+| `createAttachD1AuditTriggersSqlWithColumns(targets, options?)` | Same, for multiple tables |
+| `setD1AuditContext(db, actorId, options?)` | Set actor in `_audit_context` table |
+| `clearD1AuditContext(db, options?)` | Clear actor from `_audit_context` table |
+| `withD1AuditedTransaction(db, actorId, callback, options?)` | Transaction wrapper with context management |
+
+### `@willyim/drizzle-audit/d1-runtime`
+
+| Export | Description |
+|---|---|
+| `withAudit(db, auditTable, context)` | App-level audit wrapper (no triggers needed) |
+
+`withAudit` returns an object with:
+- `.insert(table, data)` — Insert + audit log
+- `.update(table, where, data)` — Fetch old rows, update, audit log (per row)
+- `.delete(table, where)` — Fetch old rows, delete, audit log (per row)
+- `.db` — Raw Drizzle instance for non-audited operations
+
+## Audit Log Schema
+
+### Postgres
+
+```sql
+CREATE TABLE audit_logs (
+  id         BIGSERIAL PRIMARY KEY,
+  table_name TEXT NOT NULL,
+  operation  TEXT NOT NULL CHECK (operation IN ('INSERT', 'UPDATE', 'DELETE')),
+  row_id     TEXT,
+  user_id    TEXT,
+  old_data   JSONB,
+  new_data   JSONB,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+```
+
+### D1/SQLite
+
+```sql
+CREATE TABLE audit_logs (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  table_name TEXT NOT NULL,
+  operation  TEXT NOT NULL CHECK (operation IN ('INSERT', 'UPDATE', 'DELETE')),
+  row_id     TEXT,
+  user_id    TEXT,
+  old_data   TEXT,  -- JSON string
+  new_data   TEXT,  -- JSON string
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+```
+
+## Which Approach Should I Use?
+
+| | Postgres Triggers | D1 Runtime (`withAudit`) | D1 Triggers |
+|---|---|---|---|
+| **Setup** | Migration SQL | Create table only | Migration SQL + context table |
+| **Row snapshots** | Automatic (full JSONB) | Automatic (full JSON) | Requires listing columns |
+| **User context** | Native session vars | Available in JS | `_audit_context` table |
+| **Bypass risk** | Low (DB-level) | Medium (must use wrapper) | Low (DB-level) |
+| **Best for** | Postgres apps | D1/Cloudflare Workers | SQLite apps needing DB-level guarantees |
+
+## License
+
+MIT

package/dist/src/cli/generate-migration.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * CLI: run drizzle-kit generate, then append audit SQL from the consumer's
+ * config to the newly created migration file.
+ *
+ * Usage: drizzle-audit generate [options]
+ * Options:
+ *   --config <path>         Path to audit config (TS or JS) exporting createAuditSql/createWebAuditSql
+ *   --drizzle-config <path> Path to drizzle config for drizzle-kit (default: drizzle.config.ts)
+ *   --migrations-dir <path> Dir for migrations relative to cwd (default: drizzle)
+ *   --cwd <path>            Working directory (default: process.cwd())
+ */
+export {};
+//# sourceMappingURL=generate-migration.d.ts.map

package/dist/src/cli/generate-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-migration.d.ts","sourceRoot":"","sources":["../../../src/cli/generate-migration.ts"],"names":[],"mappings":";AACA;;;;;;;;;;GAUG"}

package/dist/src/cli/generate-migration.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * CLI: run drizzle-kit generate, then append audit SQL from the consumer's
+ * config to the newly created migration file.
+ *
+ * Usage: drizzle-audit generate [options]
+ * Options:
+ *   --config <path>         Path to audit config (TS or JS) exporting createAuditSql/createWebAuditSql
+ *   --drizzle-config <path> Path to drizzle config for drizzle-kit (default: drizzle.config.ts)
+ *   --migrations-dir <path> Dir for migrations relative to cwd (default: drizzle)
+ *   --cwd <path>            Working directory (default: process.cwd())
+ */
+import { execSync, spawnSync } from "node:child_process";
+import { readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+const DEFAULT_DRIZZLE_CONFIG = "drizzle.config.ts";
+const DEFAULT_MIGRATIONS_DIR = "drizzle";
+function parseArgs() {
+    const args = process.argv.slice(2);
+    if (args[0] !== "generate") {
+        console.error("Usage: drizzle-audit generate --config <path> [options]");
+        process.exit(1);
+    }
+    let config = "";
+    let drizzleConfig = DEFAULT_DRIZZLE_CONFIG;
+    let migrationsDir = DEFAULT_MIGRATIONS_DIR;
+    let cwd = process.cwd();
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] === "--config" && args[i + 1]) {
+            config = args[++i];
+        }
+        else if (args[i] === "--drizzle-config" && args[i + 1]) {
+            drizzleConfig = args[++i];
+        }
+        else if (args[i] === "--migrations-dir" && args[i + 1]) {
+            migrationsDir = args[++i];
+        }
+        else if (args[i] === "--cwd" && args[i + 1]) {
+            cwd = args[++i];
+        }
+    }
+    if (!config) {
+        console.error("Missing required --config <path>");
+        process.exit(1);
+    }
+    return { config, drizzleConfig, migrationsDir, cwd };
+}
+function findNewestMigrationDir(migrationsDir) {
+    const abs = resolve(migrationsDir);
+    const entries = readdirSync(abs, { withFileTypes: true });
+    const dirs = entries
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name)
+        .filter((n) => /^\d+_.+/.test(n))
+        .sort();
+    const newest = dirs[dirs.length - 1];
+    if (!newest) {
+        throw new Error(`No migration folders found in ${abs}`);
+    }
+    return resolve(abs, newest);
+}
+async function getAuditSql(configPath, cwd) {
+    const resolved = resolve(cwd, configPath);
+    const ext = resolved.endsWith(".ts")
+        ? ".ts"
+        : resolved.endsWith(".mts")
+            ? ".mts"
+            : "";
+    if (ext) {
+        try {
+            const __dirname = fileURLToPath(new URL(".", import.meta.url));
+            const runnerPath = resolve(__dirname, "runner.js");
+            const out = execSync(`node --experimental-strip-types "${runnerPath}" "${resolved}"`, { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+            return out.trim();
+        }
+        catch (e) {
+            const err = e;
+            console.error("Failed to load .ts config. Requires Node >= 22.6.0.");
+            console.error(err.stderr ?? err.message);
+            process.exit(1);
+        }
+    }
+    const url = pathToFileURL(resolved).href;
+    const mod = await import(url);
+    const fn = mod.createAuditSql ?? mod.createWebAuditSql;
+    if (typeof fn !== "function") {
+        console.error("Config module must export createAuditSql() or createWebAuditSql()");
+        process.exit(1);
+    }
+    return String(fn()).trim();
+}
+async function main() {
+    const { config, drizzleConfig, migrationsDir, cwd } = parseArgs();
+    const drizzleConfigPath = resolve(cwd, drizzleConfig);
+    const migrationsAbs = resolve(cwd, migrationsDir);
+    console.log("Running drizzle-kit generate...");
+    const kit = spawnSync("npx", ["drizzle-kit", "generate", "--config", drizzleConfigPath], {
+        cwd,
+        stdio: ["pipe", "inherit", "inherit"],
+        input: "\n\n",
+        encoding: "utf-8",
+    });
+    if (kit.status !== 0) {
+        process.exit(kit.status ?? 1);
+    }
+    const migrationDir = findNewestMigrationDir(migrationsAbs);
+    const migrationFile = resolve(migrationDir, "migration.sql");
+    const existing = readFileSync(migrationFile, "utf-8");
+    const auditSql = await getAuditSql(config, cwd);
+    const separator = "\n\n";
+    writeFileSync(migrationFile, existing + separator + "-- drizzle-audit\n\n" + auditSql, "utf-8");
+    console.log("Appended audit SQL to", migrationFile);
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/src/cli/runner.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=runner.d.ts.map

package/dist/src/cli/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/cli/runner.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,CAAA"}

package/dist/src/cli/runner.js

@@ -0,0 +1,23 @@
+/**
+ * Runner script used to load a consumer's audit config (TS or JS) and print the
+ * generated SQL to stdout. Invoked with: node --experimental-strip-types runner.js <config-path>
+ * Config module must export createAuditSql() or createWebAuditSql().
+ */
+const configPath = process.argv[2];
+if (!configPath) {
+    process.stderr.write("Usage: runner.js <config-path>\n");
+    process.exit(1);
+}
+const path = await import("node:path");
+const { pathToFileURL } = await import("node:url");
+const resolved = path.resolve(process.cwd(), configPath);
+const url = pathToFileURL(resolved).href;
+const mod = await import(url);
+const fn = mod.createAuditSql ?? mod.createWebAuditSql;
+if (typeof fn !== "function") {
+    process.stderr.write("Config module must export createAuditSql() or createWebAuditSql()\n");
+    process.exit(1);
+}
+const sql = String(fn());
+process.stdout.write(sql);
+export {};

package/dist/src/d1/audit-log-schema.d.ts

@@ -0,0 +1,181 @@
+export type D1AuditLogTableOptions = {
+    /** When set (e.g. "workspace_id"), the table definition includes this optional column. */
+    workspaceIdColumn?: string;
+};
+export declare function d1AuditLogTable(options?: D1AuditLogTableOptions): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "audit_logs";
+    schema: undefined;
+    columns: {
+        old_data: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "audit_logs";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        new_data: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "audit_logs";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        created_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "audit_logs";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "audit_logs";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        table_name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "audit_logs";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        operation: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "audit_logs";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        row_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "audit_logs";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        user_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "audit_logs";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "sqlite";
+}>;
+export declare function d1AuditContextTable(options?: {
+    contextTable?: string;
+}): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+        key: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        value: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: string;
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "sqlite";
+}>;
+//# sourceMappingURL=audit-log-schema.d.ts.map

package/dist/src/d1/audit-log-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-log-schema.d.ts","sourceRoot":"","sources":["../../../src/d1/audit-log-schema.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,sBAAsB,GAAG;IACnC,0FAA0F;IAC1F,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyB/D;AAED,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAMtE"}

package/dist/src/d1/audit-log-schema.js

@@ -0,0 +1,30 @@
+import { index, integer, sqliteTable, text, } from "drizzle-orm/sqlite-core";
+export function d1AuditLogTable(options) {
+    const workspaceIdColumn = options?.workspaceIdColumn?.trim();
+    const columns = {
+        id: integer("id").primaryKey({ autoIncrement: true }),
+        table_name: text("table_name").notNull(),
+        operation: text("operation").notNull(),
+        row_id: text("row_id"),
+        user_id: text("user_id"),
+        ...(workspaceIdColumn
+            ? { [workspaceIdColumn]: text(workspaceIdColumn) }
+            : {}),
+        old_data: text("old_data"),
+        new_data: text("new_data"),
+        created_at: text("created_at").notNull().default("(datetime('now'))"),
+    };
+    return sqliteTable("audit_logs", columns, (table) => [
+        index("audit_logs_table_name_idx").on(table.table_name),
+        index("audit_logs_row_id_idx").on(table.row_id),
+        index("audit_logs_user_id_idx").on(table.user_id),
+        index("audit_logs_created_at_idx").on(table.created_at),
+    ]);
+}
+export function d1AuditContextTable(options) {
+    const tableName = options?.contextTable ?? "_audit_context";
+    return sqliteTable(tableName, {
+        key: text("key").primaryKey(),
+        value: text("value"),
+    });
+}

package/dist/src/d1/index.d.ts

@@ -0,0 +1,7 @@
+export { d1AuditLogTable, d1AuditContextTable } from "./audit-log-schema.js";
+export type { D1AuditLogTableOptions } from "./audit-log-schema.js";
+export { createAttachD1AuditTriggerSql, createAttachD1AuditTriggersSql, createAttachD1AuditTriggerSqlWithColumns, createAttachD1AuditTriggersSqlWithColumns, createD1AuditInstallSql, } from "./sql.js";
+export type { D1AuditTriggerTargetWithColumns } from "./sql.js";
+export { clearD1AuditContext, setD1AuditContext, withD1AuditedTransaction, } from "./runtime.js";
+export type { D1AuditInstallOptions, D1AuditSqlExecutor, D1AuditTriggerTarget, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/d1/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/d1/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAC5E,YAAY,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,EACL,6BAA6B,EAC7B,8BAA8B,EAC9B,wCAAwC,EACxC,yCAAyC,EACzC,uBAAuB,GACxB,MAAM,UAAU,CAAA;AACjB,YAAY,EAAE,+BAA+B,EAAE,MAAM,UAAU,CAAA;AAC/D,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,cAAc,CAAA;AAErB,YAAY,EACV,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,YAAY,CAAA"}

package/dist/src/d1/index.js

@@ -0,0 +1,3 @@
+export { d1AuditLogTable, d1AuditContextTable } from "./audit-log-schema.js";
+export { createAttachD1AuditTriggerSql, createAttachD1AuditTriggersSql, createAttachD1AuditTriggerSqlWithColumns, createAttachD1AuditTriggersSqlWithColumns, createD1AuditInstallSql, } from "./sql.js";
+export { clearD1AuditContext, setD1AuditContext, withD1AuditedTransaction, } from "./runtime.js";