@beignet/provider-db-drizzle 0.0.9

package/src/postgres/index.ts

@@ -0,0 +1,572 @@
+/**
+ * @beignet/provider-db-drizzle/postgres
+ *
+ * Drizzle ORM Postgres provider, backed by node-postgres (pg), that creates
+ * a typed database port. Works with any Postgres-compatible server reachable
+ * through a standard connection string.
+ *
+ * Configuration:
+ * - POSTGRES_DB_URL: Postgres connection string (required)
+ *
+ * @example
+ * ```ts
+ * import * as schema from "@/db/schema";
+ * import { createDrizzlePostgresProvider } from "@beignet/provider-db-drizzle/postgres";
+ *
+ * export const drizzlePostgresProvider = createDrizzlePostgresProvider({ schema });
+ *
+ * // In createNextServer:
+ * const server = await createNextServer({
+ *   ports: basePorts,
+ *   providers: [drizzlePostgresProvider],
+ *   // ...
+ * });
+ *
+ * // 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 ExtractTablesWithRelations, type SQL, sql } from "drizzle-orm";
+import { drizzle, type NodePgDatabase } from "drizzle-orm/node-postgres";
+import {
+  type PgDatabase,
+  type PgQueryResultHKT,
+  PgTransaction,
+  type PgTransactionConfig,
+} from "drizzle-orm/pg-core";
+import pg, { type Pool, type PoolConfig } from "pg";
+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: NodePgDatabase<TSchema>;
+
+  /**
+   * The underlying node-postgres connection pool.
+   * Use this for advanced operations not covered by Drizzle ORM.
+   */
+  pool: Pool;
+}
+
+/**
+ * Drizzle database or transaction client accepted by repository factories.
+ *
+ * `PgTransaction` extends `PgDatabase`, so this single seam covers the root
+ * database, transaction clients, and Postgres-protocol drivers such as
+ * node-postgres and PGlite.
+ */
+export type DrizzlePostgresDatabase<
+  TSchema extends Record<string, unknown> = Record<string, unknown>,
+> = PgDatabase<PgQueryResultHKT, TSchema>;
+
+/**
+ * Drizzle transaction client passed to Unit of Work repository factories.
+ */
+export type DrizzlePostgresTransaction<
+  TSchema extends Record<string, unknown> = Record<string, unknown>,
+> = PgTransaction<
+  PgQueryResultHKT,
+  TSchema,
+  ExtractTablesWithRelations<TSchema>
+>;
+
+/**
+ * Options for creating a Drizzle Postgres-backed Unit of Work port.
+ */
+export interface DrizzlePostgresUnitOfWorkOptions<
+  TSchema extends Record<string, unknown>,
+  TxPorts,
+> {
+  /**
+   * The root Drizzle database instance from `ctx.ports.db.db`.
+   */
+  db: DrizzlePostgresDatabase<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: DrizzlePostgresTransaction<TSchema>,
+    events: BufferedDomainEventRecorder,
+  ) => TxPorts;
+
+  /**
+   * Optional event bus used to flush recorded domain events after commit.
+   */
+  eventBus?: EventBusPort;
+
+  /**
+   * Optional Drizzle transaction configuration.
+   */
+  transactionConfig?: PgTransactionConfig;
+}
+
+/**
+ * Create a Unit of Work port backed by Drizzle's Postgres 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 createDrizzlePostgresUnitOfWork<
+  TSchema extends Record<string, unknown>,
+  TxPorts,
+>(
+  options: DrizzlePostgresUnitOfWorkOptions<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, events);
+        return work(txPorts);
+      }, options.transactionConfig);
+
+      if (options.eventBus) {
+        await events.flush(options.eventBus);
+      }
+
+      return result;
+    },
+  };
+}
+
+/**
+ * Options for a Drizzle Postgres-backed outbox port.
+ */
+export interface DrizzlePostgresOutboxOptions {
+  /**
+   * 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 { rowCount, affectedRows } = result as {
+    rowCount?: unknown;
+    affectedRows?: unknown;
+  };
+  if (typeof rowCount === "number") {
+    return rowCount;
+  }
+  if (typeof affectedRows === "number") {
+    return affectedRows;
+  }
+  return undefined;
+}
+
+function readRows(result: unknown): Record<string, unknown>[] {
+  const rows = (result as { rows?: Record<string, unknown>[] }).rows;
+  return rows ?? [];
+}
+
+/**
+ * Postgres executor implementing both the outbox and idempotency seams of the
+ * shared database cores.
+ */
+interface DrizzlePostgresSqlExecutor
+  extends SqlExecutorBase<DrizzlePostgresSqlExecutor> {
+  claimLockSuffix: SQL;
+  insertPrefix: SQL;
+  insertConflictSuffix: SQL;
+}
+
+function createPostgresExecutor<TSchema extends Record<string, unknown>>(
+  db: DrizzlePostgresDatabase<TSchema>,
+  table: SQL,
+): DrizzlePostgresSqlExecutor {
+  return {
+    table,
+    // Postgres supports row locking, so competing claim workers skip rows
+    // another transaction already locked.
+    claimLockSuffix: sql.raw(" for update skip locked"),
+    insertPrefix: sql.raw("insert into"),
+    insertConflictSuffix: sql.raw(" on conflict (storage_key) do nothing"),
+
+    async rows(query) {
+      return readRows(await db.execute(query));
+    },
+
+    async row(query) {
+      return readRows(await db.execute(query))[0];
+    },
+
+    async run(query) {
+      return readRowsAffected(await db.execute(query));
+    },
+
+    withTransaction(fn) {
+      // Already transaction-scoped: the core runs directly on this executor
+      // instead of opening a nested savepoint.
+      if (db instanceof PgTransaction) {
+        return undefined;
+      }
+
+      if ("transaction" in db && typeof db.transaction === "function") {
+        return db.transaction((tx) =>
+          fn(
+            createPostgresExecutor(
+              tx as DrizzlePostgresDatabase<TSchema>,
+              table,
+            ),
+          ),
+        );
+      }
+
+      return undefined;
+    },
+  };
+}
+
+/**
+ * Create idempotent SQL statements for the Drizzle Postgres outbox table.
+ *
+ * Run these during migrations or local setup before using
+ * `createDrizzlePostgresOutboxPort(...)`.
+ */
+export function createDrizzlePostgresOutboxSetupStatements(
+  options: DrizzlePostgresOutboxOptions = {},
+): 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 Postgres database.
+ *
+ * Claiming uses a claim-token lease so concurrent workers can safely compete
+ * for eligible messages, with `for update skip locked` row locking inside the
+ * claim transaction.
+ */
+export function createDrizzlePostgresOutboxPort<
+  TSchema extends Record<string, unknown>,
+>(
+  db: DrizzlePostgresDatabase<TSchema>,
+  adapterOptions: DrizzlePostgresOutboxOptions = {},
+): OutboxPort {
+  const table = sql.raw(
+    quoteIdentifier(adapterOptions.tableName ?? "outbox_messages", '"'),
+  );
+  const executor: OutboxSqlExecutor = createPostgresExecutor(db, table);
+
+  return createOutboxPortCore(executor, { now: adapterOptions.now });
+}
+
+/**
+ * Options for a Drizzle Postgres-backed idempotency port.
+ */
+export interface DrizzlePostgresIdempotencyOptions {
+  /**
+   * 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 DrizzlePostgresIdempotencyMutationError 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 = "DrizzlePostgresIdempotencyMutationError";
+    this.action = args.action;
+    this.namespace = args.namespace;
+    this.key = args.key;
+    this.scopeKey = args.scopeKey;
+  }
+}
+
+/**
+ * Create idempotent SQL statements for the Drizzle Postgres idempotency table.
+ *
+ * Run these during migrations or local setup before using
+ * `createDrizzlePostgresIdempotencyPort(...)`.
+ */
+export function createDrizzlePostgresIdempotencySetupStatements(
+  options: DrizzlePostgresIdempotencyOptions = {},
+): 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 Postgres 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 createDrizzlePostgresIdempotencyPort<
+  TSchema extends Record<string, unknown>,
+>(
+  db: DrizzlePostgresDatabase<TSchema>,
+  adapterOptions: DrizzlePostgresIdempotencyOptions = {},
+): IdempotencyPort {
+  const table = sql.raw(
+    quoteIdentifier(adapterOptions.tableName ?? "idempotency_records", '"'),
+  );
+  const executor: IdempotencySqlExecutor = createPostgresExecutor(db, table);
+
+  return createIdempotencyPortCore(
+    executor,
+    { now: adapterOptions.now },
+    DrizzlePostgresIdempotencyMutationError,
+  );
+}
+
+const POSTGRES_DB_URL_PREFIXES = ["postgres://", "postgresql://"] as const;
+
+/**
+ * Configuration schema for the Drizzle Postgres provider.
+ * Validates environment variables with POSTGRES_ prefix.
+ */
+export const PostgresConfigSchema = z.object({
+  /**
+   * Postgres connection string.
+   * Example: "postgres://user:password@127.0.0.1:5432/app"
+   */
+  DB_URL: z
+    .string()
+    .min(1)
+    .refine(
+      (val) =>
+        POSTGRES_DB_URL_PREFIXES.some((prefix) => val.startsWith(prefix)),
+      {
+        message:
+          'DB_URL must start with "postgres://" or "postgresql://" (e.g., "postgres://user:password@127.0.0.1:5432/app")',
+      },
+    ),
+});
+
+/**
+ * Postgres provider config loaded from `POSTGRES_*` env vars.
+ */
+export type PostgresConfig = z.infer<typeof PostgresConfigSchema>;
+
+/**
+ * Options for creating a Drizzle Postgres provider.
+ *
+ * @template TSchema - The Drizzle schema type
+ */
+export interface DrizzlePostgresProviderOptions<
+  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 `POSTGRES_DB_URL`; for a second database, wire an app-owned provider
+   * with its own env prefix instead.
+   */
+  portName?: PortName;
+
+  /**
+   * Optional node-postgres pool configuration merged into the pool created
+   * from `POSTGRES_DB_URL`, e.g. `max`, `ssl`, or timeouts.
+   */
+  pool?: Omit<PoolConfig, "connectionString">;
+}
+
+/**
+ * Create a Drizzle Postgres provider factory.
+ *
+ * This factory creates a service provider that:
+ * - Uses a node-postgres (pg) connection pool
+ * - Uses Drizzle ORM via drizzle-orm/node-postgres
+ * - Exposes a typed DbPort<TSchema> on ports
+ * - Uses POSTGRES_-prefixed env vars for connection config
+ *
+ * The pool connects lazily, so provider setup does not open a connection.
+ *
+ * @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 { createDrizzlePostgresProvider } from "@beignet/provider-db-drizzle/postgres";
+ *
+ * export const drizzlePostgresProvider = createDrizzlePostgresProvider({ schema });
+ * ```
+ */
+export function createDrizzlePostgresProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+>(options: DrizzlePostgresProviderOptions<TSchema, PortName>) {
+  const { schema, portName = "db" } = options;
+
+  return createProvider({
+    name: "drizzle-postgres",
+
+    config: {
+      schema: PostgresConfigSchema,
+      envPrefix: "POSTGRES_",
+    },
+
+    async setup({ ports, config }) {
+      if (!config) {
+        throw new Error(
+          "[drizzlePostgresProvider] Missing config. Set POSTGRES_DB_URL.",
+        );
+      }
+
+      // 1. Create the node-postgres pool (lazy: connects on first query)
+      const pool: Pool = new pg.Pool({
+        connectionString: config.DB_URL,
+        ...options.pool,
+      });
+
+      const instrumentation = createProviderInstrumentation(ports, {
+        providerName: "drizzle-postgres",
+        watcher: "db",
+      });
+
+      const logger = createDbQueryLogger(instrumentation, portName);
+
+      // 2. Create typed Drizzle instance
+      const db: NodePgDatabase<TSchema> = logger
+        ? drizzle(pool, { schema, logger })
+        : drizzle(pool, { schema });
+
+      // 3. Build a typed DbPort
+      const dbPort: DbPort<TSchema> = { db, pool };
+
+      return {
+        ports: { [portName]: dbPort } as Record<PortName, DbPort<TSchema>>,
+        async stop() {
+          // Gracefully close the connection pool
+          try {
+            await dbPort.pool.end();
+          } catch (error) {
+            // Log error but don't throw - we're shutting down anyway
+            console.error(
+              "[drizzlePostgresProvider] Error closing database connection:",
+              error,
+            );
+          }
+        },
+      };
+    },
+  });
+}