@lenso/audit 0.0.0-stage → 0.2.1

package/dist/sqlite.d.ts

@@ -0,0 +1,398 @@
+import type { BunSQLiteDatabase } from "drizzle-orm/bun-sqlite";
+import type { DrizzleD1Database } from "drizzle-orm/d1";
+import type { AuditRepository } from "./contracts";
+export declare const auditEvents: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "lenso_audit_events";
+    schema: undefined;
+    columns: {
+        tenantKey: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "tenant_key";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        scopeId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "scope_id";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        recordedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "recorded_at";
+            tableName: "lenso_audit_events";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        action: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "action";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        targetType: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "target_type";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        targetId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "target_id";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        result: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "result";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        correlationId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "correlation_id";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        eventJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "event_json";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: 'sqlite';
+}>;
+export declare const auditSqliteSchema: {
+    auditEvents: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        name: "lenso_audit_events";
+        schema: undefined;
+        columns: {
+            tenantKey: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "tenant_key";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            scopeId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "scope_id";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "id";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            recordedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "recorded_at";
+                tableName: "lenso_audit_events";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            action: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "action";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            targetType: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "target_type";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            targetId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "target_id";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            result: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "result";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            correlationId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "correlation_id";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+            eventJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "event_json";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "SQLiteText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                length: number | undefined;
+            }>;
+        };
+        dialect: 'sqlite';
+    }>;
+};
+export declare function createSqliteAuditRepository<TSchema extends Record<string, unknown>>(db: BunSQLiteDatabase<TSchema> | DrizzleD1Database<TSchema>, options?: {
+    durableIntents?: boolean;
+}): AuditRepository;

package/dist/sqlite.js

@@ -0,0 +1,80 @@
+import {
+  tenantKey,
+  decodeEvent,
+  insertionResult
+} from "./index-9cajwcjn.js";
+
+// src/sqlite.ts
+import { and, desc, eq, lt, or, gte, lte } from "drizzle-orm";
+import { index, integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var auditEvents = sqliteTable("lenso_audit_events", {
+  tenantKey: text("tenant_key").notNull(),
+  scopeId: text("scope_id").notNull(),
+  id: text("id").notNull(),
+  recordedAt: integer("recorded_at").notNull(),
+  action: text("action").notNull(),
+  targetType: text("target_type").notNull(),
+  targetId: text("target_id").notNull(),
+  result: text("result").notNull(),
+  correlationId: text("correlation_id"),
+  eventJson: text("event_json").notNull()
+}, (table) => [
+  primaryKey({ columns: [table.tenantKey, table.scopeId, table.id] }),
+  index("lenso_audit_events_scope_order").on(table.tenantKey, table.scopeId, desc(table.recordedAt), desc(table.id))
+]);
+var auditSqliteSchema = { auditEvents };
+function createSqliteAuditRepository(db, options = {}) {
+  return {
+    durableIntents: options.durableIntents ?? false,
+    async insert(event) {
+      const rows = await db.insert(auditEvents).values({
+        tenantKey: tenantKey(event.scope),
+        scopeId: event.scope.scopeId,
+        id: event.id,
+        recordedAt: event.recordedAt,
+        action: event.action,
+        targetType: event.target.type,
+        targetId: event.target.id,
+        result: event.result,
+        correlationId: event.correlationId ?? null,
+        eventJson: JSON.stringify(event)
+      }).onConflictDoNothing({
+        target: [auditEvents.tenantKey, auditEvents.scopeId, auditEvents.id]
+      }).returning();
+      if (rows.length)
+        return "inserted";
+      return insertionResult(event, await this.get(event.scope, event.id) ?? undefined);
+    },
+    async get(scope, id) {
+      const rows = await db.select().from(auditEvents).where(and(eq(auditEvents.tenantKey, tenantKey(scope)), eq(auditEvents.scopeId, scope.scopeId), eq(auditEvents.id, id))).limit(1);
+      return rows[0] ? decodeEvent(rows[0].eventJson) : null;
+    },
+    async list(query) {
+      const terms = [
+        eq(auditEvents.tenantKey, tenantKey(query.scope)),
+        eq(auditEvents.scopeId, query.scope.scopeId)
+      ];
+      if (query.action !== undefined)
+        terms.push(eq(auditEvents.action, query.action));
+      if (query.target)
+        terms.push(eq(auditEvents.targetType, query.target.type), eq(auditEvents.targetId, query.target.id));
+      if (query.result !== undefined)
+        terms.push(eq(auditEvents.result, query.result));
+      if (query.correlationId !== undefined)
+        terms.push(eq(auditEvents.correlationId, query.correlationId));
+      if (query.recordedFrom !== undefined)
+        terms.push(gte(auditEvents.recordedAt, query.recordedFrom));
+      if (query.recordedTo !== undefined)
+        terms.push(lte(auditEvents.recordedAt, query.recordedTo));
+      if (query.cursor)
+        terms.push(or(lt(auditEvents.recordedAt, query.cursor.recordedAt), and(eq(auditEvents.recordedAt, query.cursor.recordedAt), lt(auditEvents.id, query.cursor.id))));
+      const rows = await db.select().from(auditEvents).where(and(...terms)).orderBy(desc(auditEvents.recordedAt), desc(auditEvents.id)).limit(query.limit);
+      return rows.map((row) => decodeEvent(row.eventJson));
+    }
+  };
+}
+export {
+  auditEvents,
+  auditSqliteSchema,
+  createSqliteAuditRepository
+};

package/dist/tasks.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import type { AuditScope } from "./contracts";
+import type { AuditService } from "./service";
+/**
+ * The job carries only a locator. An application-owned resolver must check the
+ * real effect and supply a stable new event ID; queue payloads grant no authority.
+ */
+export declare function createAuditReconciliationTask<P>(options: {
+    name: string;
+    audit: AuditService<P>;
+    principal(): Promise<P>;
+    reconcile(intentId: string, scope: AuditScope): Promise<{
+        id: string;
+        occurredAt: number;
+        result: "success" | "failure" | "unknown";
+        reasonCode: string;
+    }>;
+}): import("@lenso/tasks").Task<z.ZodObject<{
+    scope: z.ZodObject<{
+        tenantId: z.ZodNullable<z.ZodString>;
+        scopeId: z.ZodString;
+    }, z.core.$strict>;
+    intentId: z.ZodString;
+}, z.core.$strict>, {
+    eventId: string;
+}>;

package/dist/tasks.js

@@ -0,0 +1,40 @@
+import {
+  eventIdPattern
+} from "./index-xk4zknet.js";
+
+// src/tasks.ts
+import { defineTask } from "@lenso/tasks";
+import { z } from "zod";
+var reconciliationInput = z.strictObject({
+  scope: z.strictObject({
+    tenantId: z.string().min(1).max(128).nullable(),
+    scopeId: z.string().min(1).max(128)
+  }),
+  intentId: z.string().regex(eventIdPattern)
+});
+function createAuditReconciliationTask(options) {
+  return defineTask({
+    name: options.name,
+    input: reconciliationInput,
+    async handler(input) {
+      const principal = await options.principal();
+      const intent = await options.audit.get({ scope: input.scope, id: input.intentId }, principal);
+      if (!intent || intent.result !== "intent")
+        throw new Error("Audit reconciliation intent missing");
+      const outcome = await options.reconcile(intent.id, intent.scope);
+      const result = await options.audit.append({
+        ...outcome,
+        scope: intent.scope,
+        action: intent.action,
+        target: intent.target,
+        ...intent.correlationId ? { correlationId: intent.correlationId } : {},
+        relation: { kind: "outcome", eventId: intent.id }
+      }, principal);
+      return { eventId: result.event.id };
+    },
+    result: (value) => value
+  });
+}
+export {
+  createAuditReconciliationTask
+};

package/dist/validation.d.ts

@@ -0,0 +1,16 @@
+import { type AuditActor, type AuditInput, type AuditQuery, type AuditScope, type SummaryPolicy, type SummaryValue } from "./contracts";
+export declare const eventIdPattern: RegExp;
+export declare function invalid(): never;
+export declare function object(value: unknown, keys?: readonly string[]): Record<string, unknown>;
+export declare function identifier(value: unknown, max?: number): string;
+export declare function uuid(value: unknown): string;
+export declare function time(value: unknown): number;
+export declare function scope(value: unknown): AuditScope;
+export declare function actor(value: unknown): AuditActor;
+export declare function summaryPolicy(data: SummaryPolicy): SummaryPolicy;
+export declare function eventInput(data: AuditInput, policy: SummaryPolicy): AuditInput & {
+    summary: Readonly<Record<string, SummaryValue>>;
+};
+export declare function query(value: AuditQuery, maxPageSize: number): AuditQuery & {
+    limit: number;
+};

package/migrations/pg/0000_audit.sql

@@ -0,0 +1,15 @@
+CREATE TABLE lenso_audit_events (
+  tenant_key TEXT NOT NULL,
+  scope_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  recorded_at BIGINT NOT NULL,
+  action TEXT NOT NULL,
+  target_type TEXT NOT NULL,
+  target_id TEXT NOT NULL,
+  result TEXT NOT NULL,
+  correlation_id TEXT,
+  event_json TEXT NOT NULL,
+  PRIMARY KEY (tenant_key, scope_id, id)
+);
+CREATE INDEX lenso_audit_events_scope_order
+  ON lenso_audit_events (tenant_key, scope_id, recorded_at DESC, id DESC);

package/migrations/sqlite/0000_audit.sql

@@ -0,0 +1,15 @@
+CREATE TABLE lenso_audit_events (
+  tenant_key TEXT NOT NULL,
+  scope_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  recorded_at INTEGER NOT NULL,
+  action TEXT NOT NULL,
+  target_type TEXT NOT NULL,
+  target_id TEXT NOT NULL,
+  result TEXT NOT NULL,
+  correlation_id TEXT,
+  event_json TEXT NOT NULL,
+  PRIMARY KEY (tenant_key, scope_id, id)
+);
+CREATE INDEX lenso_audit_events_scope_order
+  ON lenso_audit_events (tenant_key, scope_id, recorded_at DESC, id DESC);