@lenso/audit 0.0.0-stage → 0.2.0

package/dist/postgres.d.ts

@@ -0,0 +1,361 @@
+import type { BunSQLDatabase } from "drizzle-orm/bun-sql";
+import type { AuditRepository } from "./contracts";
+export declare const auditEvents: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "lenso_audit_events";
+    schema: undefined;
+    columns: {
+        tenantKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tenant_key";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scopeId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scope_id";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        recordedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "recorded_at";
+            tableName: "lenso_audit_events";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        action: import("drizzle-orm/pg-core").PgColumn<{
+            name: "action";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        targetType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "target_type";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        targetId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "target_id";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        result: import("drizzle-orm/pg-core").PgColumn<{
+            name: "result";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        correlationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "correlation_id";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        eventJson: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_json";
+            tableName: "lenso_audit_events";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;
+export declare const auditPostgresSchema: {
+    auditEvents: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "lenso_audit_events";
+        schema: undefined;
+        columns: {
+            tenantKey: import("drizzle-orm/pg-core").PgColumn<{
+                name: "tenant_key";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            scopeId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "scope_id";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            recordedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: "recorded_at";
+                tableName: "lenso_audit_events";
+                dataType: "number";
+                columnType: "PgBigInt53";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            action: import("drizzle-orm/pg-core").PgColumn<{
+                name: "action";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            targetType: import("drizzle-orm/pg-core").PgColumn<{
+                name: "target_type";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            targetId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "target_id";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            result: import("drizzle-orm/pg-core").PgColumn<{
+                name: "result";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            correlationId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "correlation_id";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            eventJson: import("drizzle-orm/pg-core").PgColumn<{
+                name: "event_json";
+                tableName: "lenso_audit_events";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: 'pg';
+    }>;
+};
+export declare function createPostgresAuditRepository<TSchema extends Record<string, unknown>>(db: BunSQLDatabase<TSchema>, options?: {
+    durableIntents?: boolean;
+}): AuditRepository;

package/dist/postgres.js

@@ -0,0 +1,80 @@
+import {
+  tenantKey,
+  decodeEvent,
+  insertionResult
+} from "./index-9cajwcjn.js";
+
+// src/postgres.ts
+import { and, desc, eq, gte, lte, lt, or } from "drizzle-orm";
+import { bigint, index, pgTable, primaryKey, text } from "drizzle-orm/pg-core";
+var auditEvents = pgTable("lenso_audit_events", {
+  tenantKey: text("tenant_key").notNull(),
+  scopeId: text("scope_id").notNull(),
+  id: text("id").notNull(),
+  recordedAt: bigint("recorded_at", { mode: "number" }).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, table.recordedAt.desc(), table.id.desc())
+]);
+var auditPostgresSchema = { auditEvents };
+function createPostgresAuditRepository(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({ id: auditEvents.id });
+      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({ eventJson: auditEvents.eventJson }).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({ eventJson: auditEvents.eventJson }).from(auditEvents).where(and(...terms)).orderBy(desc(auditEvents.recordedAt), desc(auditEvents.id)).limit(query.limit);
+      return rows.map((row) => decodeEvent(row.eventJson));
+    }
+  };
+}
+export {
+  auditEvents,
+  auditPostgresSchema,
+  createPostgresAuditRepository
+};

package/dist/repository-helpers.d.ts

@@ -0,0 +1,4 @@
+import type { AuditEvent, AuditScope } from "./contracts";
+export declare function tenantKey(scope: AuditScope): string;
+export declare function decodeEvent(value: string): AuditEvent;
+export declare function insertionResult(event: AuditEvent, existing: AuditEvent | undefined): "conflict" | "duplicate";

package/dist/service.d.ts

@@ -0,0 +1,49 @@
+import { type AuditAuthority, type AuditEvent, type AuditInput, type AuditPage, type AuditQuery, type AuditReporter, type AuditRepository, type AuditScope, type SummaryPolicy } from "./contracts";
+declare const receiptBrand: unique symbol;
+export interface AuditIntentReceipt {
+    readonly intentId: string;
+    readonly [receiptBrand]: true;
+}
+export interface AuditOutcome {
+    readonly id: string;
+    readonly occurredAt: number;
+    readonly result: "success" | "failure" | "denied" | "unknown";
+    readonly reasonCode: string;
+    readonly summary?: AuditInput["summary"];
+}
+export interface AuditService<P> {
+    append(input: AuditInput, principal: P): Promise<{
+        status: "inserted" | "duplicate";
+        event: AuditEvent;
+    }>;
+    appendBestEffort(input: AuditInput, principal: P): Promise<{
+        status: "inserted" | "duplicate";
+        event: AuditEvent;
+    } | {
+        status: "unconfirmed";
+        code: "storage-failed";
+    }>;
+    get(input: {
+        scope: AuditScope;
+        id: string;
+    }, principal: P): Promise<AuditEvent | null>;
+    query(input: AuditQuery, principal: P): Promise<AuditPage>;
+    prepare(input: AuditInput, principal: P): Promise<{
+        status: "ready";
+        receipt: AuditIntentReceipt;
+    } | {
+        status: "already-recorded";
+        intentId: string;
+    }>;
+    complete(receipt: AuditIntentReceipt, outcome: AuditOutcome): Promise<AuditEvent>;
+}
+export interface AuditServiceOptions<P> {
+    repository: AuditRepository;
+    authority: AuditAuthority<P>;
+    summaryPolicy?: SummaryPolicy;
+    maxPageSize?: number;
+    report?: AuditReporter;
+    clock?: () => number;
+}
+export declare function createAuditService<P>(options: AuditServiceOptions<P>): AuditService<P>;
+export {};