@beignet/provider-db-drizzle 0.0.9

package/src/sqlite/index.ts

@@ -0,0 +1,547 @@
+/**
+ * @beignet/provider-db-drizzle/sqlite
+ *
+ * Drizzle ORM SQLite provider, backed by libSQL, that creates a typed
+ * database port. Works with local `file:` SQLite databases and with Turso's
+ * hosted libSQL service.
+ *
+ * Configuration:
+ * - SQLITE_DB_URL: libSQL database URL (required)
+ * - SQLITE_DB_AUTH_TOKEN: auth token for remote connections such as Turso
+ *   (optional for local dev)
+ *
+ * @example
+ * ```ts
+ * import * as schema from "@/db/schema";
+ * import { createDrizzleSqliteProvider } from "@beignet/provider-db-drizzle/sqlite";
+ *
+ * export const drizzleSqliteProvider = createDrizzleSqliteProvider({ schema });
+ *
+ * // In createNextServer:
+ * const server = await createNextServer({
+ *   ports: basePorts,
+ *   providers: [drizzleSqliteProvider],
+ *   // ...
+ * });
+ *
+ * // In infra:
+ * const todos = createDrizzleTodoRepository(ctx.ports.db.db);
+ * ```
+ */
+
+import type { IdempotencyPort } from "@beignet/core/idempotency";
+import type { OutboxPort } from "@beignet/core/outbox";
+import {
+  type BufferedDomainEventRecorder,
+  createDomainEventRecorder,
+  type EventBusPort,
+  type UnitOfWorkCallback,
+  type UnitOfWorkPort,
+} from "@beignet/core/ports";
+import {
+  createProvider,
+  createProviderInstrumentation,
+} from "@beignet/core/providers";
+import { type Client, createClient } from "@libsql/client";
+import { type ExtractTablesWithRelations, type SQL, sql } from "drizzle-orm";
+import { drizzle, type LibSQLDatabase } from "drizzle-orm/libsql";
+import type { LibSQLTransaction } from "drizzle-orm/libsql/session";
+import type { SQLiteTransactionConfig } from "drizzle-orm/sqlite-core";
+import { z } from "zod";
+import {
+  createIdempotencyPortCore,
+  formatIdempotencyMutationErrorMessage,
+  type IdempotencySqlExecutor,
+} from "../shared/idempotency-core.js";
+import { quoteIdentifier } from "../shared/identifiers.js";
+import { createDbQueryLogger } from "../shared/instrumentation.js";
+import {
+  createOutboxPortCore,
+  type OutboxSqlExecutor,
+  type SqlExecutorBase,
+} from "../shared/outbox-core.js";
+
+/**
+ * Typed database port interface.
+ * Exposes a typed Drizzle database instance for your schema.
+ *
+ * @template TSchema - The Drizzle schema type (e.g., `typeof schema`)
+ */
+export interface DbPort<
+  TSchema extends Record<string, unknown> = Record<string, unknown>,
+> {
+  /**
+   * The typed Drizzle database instance.
+   * Use this to query your database with full type safety.
+   */
+  db: LibSQLDatabase<TSchema>;
+
+  /**
+   * The underlying libSQL client instance.
+   * Use this for advanced operations not covered by Drizzle ORM.
+   */
+  client: Client;
+}
+
+/**
+ * Drizzle database or transaction client accepted by repository factories.
+ */
+export type DrizzleSqliteDatabase<
+  TSchema extends Record<string, unknown> = Record<string, unknown>,
+> =
+  | LibSQLDatabase<TSchema>
+  | LibSQLTransaction<TSchema, ExtractTablesWithRelations<TSchema>>;
+
+/**
+ * Drizzle transaction client passed to Unit of Work repository factories.
+ */
+export type DrizzleSqliteTransaction<
+  TSchema extends Record<string, unknown> = Record<string, unknown>,
+> = LibSQLTransaction<TSchema, ExtractTablesWithRelations<TSchema>>;
+
+/**
+ * Options for creating a Drizzle SQLite-backed Unit of Work port.
+ */
+export interface DrizzleSqliteUnitOfWorkOptions<
+  TSchema extends Record<string, unknown>,
+  TxPorts,
+> {
+  /**
+   * The root Drizzle database instance from `ctx.ports.db.db`.
+   */
+  db: LibSQLDatabase<TSchema>;
+
+  /**
+   * Create transaction-scoped ports from the Drizzle transaction client.
+   *
+   * The event recorder is transaction-local. Record domain events inside the
+   * callback and pass `eventBus` to publish them after the database commit.
+   */
+  createTransactionPorts: (
+    db: DrizzleSqliteTransaction<TSchema>,
+    events: BufferedDomainEventRecorder,
+  ) => TxPorts;
+
+  /**
+   * Optional event bus used to flush recorded domain events after commit.
+   */
+  eventBus?: EventBusPort;
+
+  /**
+   * Optional Drizzle transaction configuration.
+   */
+  transactionConfig?: SQLiteTransactionConfig;
+}
+
+/**
+ * Create a Unit of Work port backed by Drizzle's libSQL transaction API.
+ *
+ * Beignet does not own your repository interfaces. This helper only
+ * provides the transaction boundary and post-commit event flushing; your app
+ * decides which transaction-scoped ports to create.
+ */
+export function createDrizzleSqliteUnitOfWork<
+  TSchema extends Record<string, unknown>,
+  TxPorts,
+>(
+  options: DrizzleSqliteUnitOfWorkOptions<TSchema, TxPorts>,
+): UnitOfWorkPort<TxPorts> {
+  return {
+    async transaction<Result>(
+      work: UnitOfWorkCallback<TxPorts, Result>,
+    ): Promise<Result> {
+      const events = createDomainEventRecorder();
+
+      const result = await options.db.transaction(async (tx) => {
+        const txPorts = options.createTransactionPorts(
+          tx as DrizzleSqliteTransaction<TSchema>,
+          events,
+        );
+        return work(txPorts);
+      }, options.transactionConfig);
+
+      if (options.eventBus) {
+        await events.flush(options.eventBus);
+      }
+
+      return result;
+    },
+  };
+}
+
+/**
+ * Options for a Drizzle SQLite-backed outbox port.
+ */
+export interface DrizzleSqliteOutboxOptions {
+  /**
+   * Table that stores outbox messages.
+   *
+   * Default: "outbox_messages".
+   */
+  tableName?: string;
+
+  /**
+   * Clock used by tests and deterministic environments.
+   */
+  now?: () => Date;
+}
+
+function readRowsAffected(result: unknown): number | undefined {
+  const rowsAffected = (result as { rowsAffected?: unknown }).rowsAffected;
+  return typeof rowsAffected === "number" ? rowsAffected : undefined;
+}
+
+/**
+ * SQLite executor implementing both the outbox and idempotency seams of the
+ * shared database cores.
+ */
+interface DrizzleSqliteSqlExecutor
+  extends SqlExecutorBase<DrizzleSqliteSqlExecutor> {
+  claimLockSuffix: SQL;
+  insertPrefix: SQL;
+  insertConflictSuffix: SQL;
+}
+
+function createSqliteExecutor<TSchema extends Record<string, unknown>>(
+  db: DrizzleSqliteDatabase<TSchema>,
+  table: SQL,
+): DrizzleSqliteSqlExecutor {
+  return {
+    table,
+    // SQLite serializes writers; no row-locking clause exists or is needed.
+    claimLockSuffix: sql.raw(""),
+    insertPrefix: sql.raw("insert or ignore into"),
+    insertConflictSuffix: sql.raw(""),
+
+    async rows(query) {
+      return db.all<Record<string, unknown>>(query);
+    },
+
+    async row(query) {
+      return db.get<Record<string, unknown> | undefined>(query);
+    },
+
+    async run(query) {
+      return readRowsAffected(await db.run(query));
+    },
+
+    withTransaction(fn) {
+      if ("transaction" in db && typeof db.transaction === "function") {
+        return db.transaction((tx) =>
+          fn(createSqliteExecutor(tx as DrizzleSqliteDatabase<TSchema>, table)),
+        );
+      }
+
+      return undefined;
+    },
+  };
+}
+
+/**
+ * Create idempotent SQL statements for the Drizzle SQLite outbox table.
+ *
+ * Run these during migrations or local setup before using
+ * `createDrizzleSqliteOutboxPort(...)`.
+ */
+export function createDrizzleSqliteOutboxSetupStatements(
+  options: DrizzleSqliteOutboxOptions = {},
+): readonly string[] {
+  const tableName = options.tableName ?? "outbox_messages";
+  const table = quoteIdentifier(tableName, '"');
+  const indexPrefix = tableName.replaceAll(/[^A-Za-z0-9_]/g, "_");
+
+  return [
+    `CREATE TABLE IF NOT EXISTS ${table} (
+      id text PRIMARY KEY NOT NULL,
+      kind text NOT NULL,
+      name text NOT NULL,
+      payload_json text NOT NULL,
+      status text NOT NULL,
+      attempts integer DEFAULT 0 NOT NULL,
+      max_attempts integer DEFAULT 3 NOT NULL,
+      available_at text NOT NULL,
+      claimed_at text,
+      locked_until text,
+      claim_token text,
+      delivered_at text,
+      last_error_json text,
+      created_at text NOT NULL,
+      updated_at text NOT NULL
+    )`,
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(`${indexPrefix}_available_idx`, '"')} ON ${table} (status, available_at)`,
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(`${indexPrefix}_locked_idx`, '"')} ON ${table} (status, locked_until)`,
+  ];
+}
+
+/**
+ * Create a Beignet outbox port backed by a Drizzle SQLite database.
+ *
+ * Claiming uses a claim-token lease so concurrent workers can safely compete
+ * for eligible messages.
+ */
+export function createDrizzleSqliteOutboxPort<
+  TSchema extends Record<string, unknown>,
+>(
+  db: DrizzleSqliteDatabase<TSchema>,
+  adapterOptions: DrizzleSqliteOutboxOptions = {},
+): OutboxPort {
+  const table = sql.raw(
+    quoteIdentifier(adapterOptions.tableName ?? "outbox_messages", '"'),
+  );
+  const executor: OutboxSqlExecutor = createSqliteExecutor(db, table);
+
+  return createOutboxPortCore(executor, { now: adapterOptions.now });
+}
+
+/**
+ * Options for a Drizzle SQLite-backed idempotency port.
+ */
+export interface DrizzleSqliteIdempotencyOptions {
+  /**
+   * Table that stores idempotency records.
+   *
+   * Default: "idempotency_records".
+   */
+  tableName?: string;
+
+  /**
+   * Clock used by tests and deterministic environments.
+   */
+  now?: () => Date;
+}
+
+/**
+ * Error thrown when `complete(...)` or `fail(...)` does not match an
+ * in-progress idempotency reservation with the provided fingerprint.
+ *
+ * This usually signals a workflow bug: the reservation was never made, was
+ * already completed or released, expired and was cleaned up, or the caller
+ * passed a different fingerprint than the one used to reserve.
+ */
+export class DrizzleSqliteIdempotencyMutationError extends Error {
+  readonly action: "complete" | "fail";
+  readonly namespace: string;
+  readonly key: string;
+  readonly scopeKey: string;
+
+  constructor(args: {
+    action: "complete" | "fail";
+    namespace: string;
+    key: string;
+    scopeKey: string;
+  }) {
+    super(formatIdempotencyMutationErrorMessage(args));
+    this.name = "DrizzleSqliteIdempotencyMutationError";
+    this.action = args.action;
+    this.namespace = args.namespace;
+    this.key = args.key;
+    this.scopeKey = args.scopeKey;
+  }
+}
+
+/**
+ * Create idempotent SQL statements for the Drizzle SQLite idempotency table.
+ *
+ * Run these during migrations or local setup before using
+ * `createDrizzleSqliteIdempotencyPort(...)`.
+ */
+export function createDrizzleSqliteIdempotencySetupStatements(
+  options: DrizzleSqliteIdempotencyOptions = {},
+): readonly string[] {
+  const tableName = options.tableName ?? "idempotency_records";
+  const table = quoteIdentifier(tableName, '"');
+  const indexPrefix = tableName.replaceAll(/[^A-Za-z0-9_]/g, "_");
+
+  return [
+    `CREATE TABLE IF NOT EXISTS ${table} (
+      storage_key text PRIMARY KEY NOT NULL,
+      namespace text NOT NULL,
+      idempotency_key text NOT NULL,
+      scope_key text NOT NULL,
+      fingerprint text NOT NULL,
+      status text NOT NULL,
+      result_json text,
+      reserved_at text NOT NULL,
+      completed_at text,
+      expires_at text,
+      updated_at text NOT NULL
+    )`,
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(`${indexPrefix}_lookup_idx`, '"')} ON ${table} (namespace, scope_key, idempotency_key)`,
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(`${indexPrefix}_expires_idx`, '"')} ON ${table} (expires_at)`,
+  ];
+}
+
+/**
+ * Create a Beignet idempotency port backed by a Drizzle SQLite database.
+ *
+ * The port accepts both the root Drizzle database and transaction clients, so
+ * applications can expose root idempotency for ordinary retry-safe commands and
+ * transaction-scoped idempotency from Unit of Work.
+ */
+export function createDrizzleSqliteIdempotencyPort<
+  TSchema extends Record<string, unknown>,
+>(
+  db: DrizzleSqliteDatabase<TSchema>,
+  adapterOptions: DrizzleSqliteIdempotencyOptions = {},
+): IdempotencyPort {
+  const table = sql.raw(
+    quoteIdentifier(adapterOptions.tableName ?? "idempotency_records", '"'),
+  );
+  const executor: IdempotencySqlExecutor = createSqliteExecutor(db, table);
+
+  return createIdempotencyPortCore(
+    executor,
+    { now: adapterOptions.now },
+    DrizzleSqliteIdempotencyMutationError,
+  );
+}
+
+const SQLITE_DB_URL_PREFIXES = [
+  "libsql://",
+  "file:",
+  "http://",
+  "https://",
+  "ws://",
+  "wss://",
+] as const;
+
+/**
+ * Configuration schema for the Drizzle SQLite provider.
+ * Validates environment variables with SQLITE_ prefix.
+ */
+const SqliteConfigSchema = z.object({
+  /**
+   * libSQL database URL.
+   * Accepts every URL scheme @libsql/client accepts: "libsql://" and "file:"
+   * plus "http(s)://" and "ws(s)://" for local sqld instances.
+   * Example: "libsql://<org>-<db>.turso.io" or "file:local.db"
+   */
+  DB_URL: z
+    .string()
+    .min(1)
+    .refine(
+      (val) => SQLITE_DB_URL_PREFIXES.some((prefix) => val.startsWith(prefix)),
+      {
+        message:
+          'DB_URL must start with "libsql://", "file:", "http://", "https://", "ws://", or "wss://" (e.g., "libsql://<org>-<db>.turso.io", "file:local.db", or "http://127.0.0.1:8080")',
+      },
+    ),
+
+  /**
+   * Auth token for remote libSQL connections (optional for local dev).
+   * Required when connecting to Turso's hosted libSQL service.
+   */
+  DB_AUTH_TOKEN: z.string().optional(),
+});
+
+/**
+ * SQLite provider config loaded from `SQLITE_*` env vars.
+ */
+export type SqliteConfig = z.infer<typeof SqliteConfigSchema>;
+
+/**
+ * Options for creating a Drizzle SQLite provider.
+ *
+ * @template TSchema - The Drizzle schema type
+ */
+export interface DrizzleSqliteProviderOptions<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+> {
+  /**
+   * The Drizzle schema object (e.g. `import * as schema from '@/db/schema'`).
+   * This schema is used to create a typed Drizzle database instance.
+   */
+  schema: TSchema;
+
+  /**
+   * Optional port name. Defaults to "db".
+   * Renames the contributed port. The provider always reads its connection
+   * from `SQLITE_DB_URL`; for a second database, wire an app-owned provider
+   * with its own env prefix instead.
+   */
+  portName?: PortName;
+}
+
+/**
+ * Create a Drizzle SQLite provider factory.
+ *
+ * This factory creates a service provider that:
+ * - Uses libSQL via @libsql/client, for local `file:` SQLite databases and
+ *   Turso's hosted libSQL service
+ * - Uses Drizzle ORM via drizzle-orm/libsql
+ * - Exposes a typed DbPort<TSchema> on ports
+ * - Uses SQLITE_-prefixed env vars for connection config
+ *
+ * @template TSchema - The Drizzle schema type (inferred from the schema parameter)
+ * @param options - Configuration options including the schema
+ * @returns A service provider that can be used with createNextServer
+ *
+ * @example
+ * ```ts
+ * import * as schema from "@/db/schema";
+ * import { createDrizzleSqliteProvider } from "@beignet/provider-db-drizzle/sqlite";
+ *
+ * export const drizzleSqliteProvider = createDrizzleSqliteProvider({ schema });
+ * ```
+ */
+export function createDrizzleSqliteProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+>(options: DrizzleSqliteProviderOptions<TSchema, PortName>) {
+  const { schema, portName = "db" } = options;
+
+  return createProvider({
+    name: "drizzle-sqlite",
+
+    config: {
+      schema: SqliteConfigSchema,
+      envPrefix: "SQLITE_",
+    },
+
+    async setup({ ports, config }) {
+      if (!config) {
+        throw new Error(
+          "[drizzleSqliteProvider] Missing config. Set SQLITE_DB_URL (and optional SQLITE_DB_AUTH_TOKEN).",
+        );
+      }
+
+      // 1. Create libSQL client
+      const client: Client = createClient({
+        url: config.DB_URL,
+        authToken: config.DB_AUTH_TOKEN,
+      });
+
+      const instrumentation = createProviderInstrumentation(ports, {
+        providerName: "drizzle-sqlite",
+        watcher: "db",
+      });
+
+      const logger = createDbQueryLogger(instrumentation, portName);
+
+      // 2. Create typed Drizzle instance
+      const db: LibSQLDatabase<TSchema> = logger
+        ? drizzle(client, { schema, logger })
+        : drizzle(client, { schema });
+
+      // 3. Build a typed DbPort
+      const dbPort: DbPort<TSchema> = { db, client };
+
+      return {
+        ports: { [portName]: dbPort } as Record<PortName, DbPort<TSchema>>,
+        async stop() {
+          // Gracefully close the database connection
+          try {
+            await dbPort.client.close();
+          } catch (error) {
+            // Log error but don't throw - we're shutting down anyway
+            console.error(
+              "[drizzleSqliteProvider] Error closing database connection:",
+              error,
+            );
+          }
+        },
+      };
+    },
+  });
+}