@anabranch/db-postgres 0.1.0

package/esm/db/db.d.ts

@@ -0,0 +1,73 @@
+import { type Promisable, Source, Task } from "../anabranch/index.js";
+import type { DBAdapter, DBConnector, DBTransactionAdapter } from "./adapter.js";
+import { ConnectionFailed, ConstraintViolation, QueryFailed, TransactionFailed } from "./errors.js";
+/** Database transaction with Task semantics. */
+export declare class DBTransaction {
+    private readonly adapter;
+    constructor(adapter: DBTransactionAdapter);
+    query<T>(sql: string, params?: unknown[]): Task<T[], QueryFailed>;
+    execute(sql: string, params?: unknown[]): Task<number, QueryFailed>;
+    commit(): Task<void, TransactionFailed>;
+    rollback(): Task<void, TransactionFailed>;
+}
+/**
+ * Database wrapper with Task/Stream semantics.
+ *
+ * @example
+ * ```ts
+ * // With a connector (recommended for production)
+ * const result = await DB.withConnection(myConnector, (db) =>
+ *   db.query("SELECT * FROM users")
+ * ).run();
+ *
+ * // With a bare adapter (for testing or custom lifecycle)
+ * const db = new DB(adapter);
+ * const users = await db.query("SELECT * FROM users").run();
+ * ```
+ */
+export declare class DB {
+    private readonly adapter;
+    constructor(adapter: DBAdapter);
+    /**
+     * Execute operations with a connection acquired from the connector.
+     * The connection is automatically released after the operation completes,
+     * whether successful or failed.
+     *
+     * @example
+     * ```ts
+     * const result = await DB.withConnection(postgresConnector, (db) =>
+     *   db.withTransaction(async (tx) => {
+     *     await tx.execute("INSERT INTO orders (user_id) VALUES (?)", [userId]).run();
+     *     return tx.query("SELECT last_insert_rowid()").run();
+     *   })
+     * ).run();
+     * ```
+     */
+    static withConnection<R, E>(connector: DBConnector, fn: (db: DB) => Task<R, E>): Task<R, E | ConnectionFailed>;
+    /**
+     * Execute a SELECT query and return rows.
+     * @example
+     * const users = await db.query("SELECT * FROM users").run();
+     */
+    query<T>(sql: string, params?: unknown[]): Task<T[], QueryFailed | ConstraintViolation>;
+    /**
+     * Execute INSERT/UPDATE/DELETE and return affected row count.
+     * @example
+     * const affected = await db.execute("DELETE FROM users WHERE id = ?", [1]).run();
+     */
+    execute(sql: string, params?: unknown[]): Task<number, QueryFailed | ConstraintViolation>;
+    /**
+     * Stream rows from a SELECT query for memory-efficient processing.
+     *
+     * If the adapter supports cursor-based streaming (via the optional stream method),
+     * rows are yielded one at a time. Otherwise, the full result set is buffered
+     * in memory before streaming.
+     *
+     * @example
+     * const { successes, errors } = await db.stream("SELECT * FROM users").partition();
+     */
+    stream<T>(sql: string, params?: unknown[]): Source<T, QueryFailed>;
+    withTransaction<R>(fn: (tx: DBTransaction) => Promisable<R>): Task<R, TransactionFailed | QueryFailed | ConstraintViolation>;
+    private transaction;
+}
+//# sourceMappingURL=db.d.ts.map

package/esm/db/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,oBAAoB,EACrB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAErB,gDAAgD;AAChD,qBAAa,aAAa;IACZ,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,oBAAoB;IAE1D,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,EAAE,WAAW,CAAC;IAgBjE,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC;IAgBnE,MAAM,IAAI,IAAI,CAAC,IAAI,EAAE,iBAAiB,CAAC;IAYvC,QAAQ,IAAI,IAAI,CAAC,IAAI,EAAE,iBAAiB,CAAC;CAW1C;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,EAAE;IACD,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,SAAS;IAE/C;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,EACxB,SAAS,EAAE,WAAW,EACtB,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACzB,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,gBAAgB,CAAC;IAahC;;;;OAIG;IACH,KAAK,CAAC,CAAC,EACL,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,OAAO,EAAE,GACjB,IAAI,CAAC,CAAC,EAAE,EAAE,WAAW,GAAG,mBAAmB,CAAC;IAgB/C;;;;OAIG;IACH,OAAO,CACL,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,OAAO,EAAE,GACjB,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,mBAAmB,CAAC;IAgBlD;;;;;;;;;OASG;IACH,MAAM,CAAC,CAAC,EACN,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,OAAO,EAAE,GACjB,MAAM,CAAC,CAAC,EAAE,WAAW,CAAC;IAqBzB,eAAe,CAAC,CAAC,EACf,EAAE,EAAE,CAAC,EAAE,EAAE,aAAa,KAAK,UAAU,CAAC,CAAC,CAAC,GACvC,IAAI,CAAC,CAAC,EAAE,iBAAiB,GAAG,WAAW,GAAG,mBAAmB,CAAC;IAkBjE,OAAO,CAAC,WAAW;CAepB"}

package/esm/db/db.js

@@ -0,0 +1,194 @@
+import { Source, Task } from "../anabranch/index.js";
+import { ConnectionFailed, ConstraintViolation, QueryFailed, TransactionFailed, } from "./errors.js";
+/** Database transaction with Task semantics. */
+export class DBTransaction {
+    constructor(adapter) {
+        Object.defineProperty(this, "adapter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: adapter
+        });
+    }
+    query(sql, params) {
+        return Task.of(async () => {
+            try {
+                return await this.adapter.query(sql, params);
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes("constraint")) {
+                    throw new ConstraintViolation(sql, error.message);
+                }
+                throw new QueryFailed(sql, error instanceof Error ? error.message : String(error));
+            }
+        });
+    }
+    execute(sql, params) {
+        return Task.of(async () => {
+            try {
+                return await this.adapter.execute(sql, params);
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes("constraint")) {
+                    throw new ConstraintViolation(sql, error.message);
+                }
+                throw new QueryFailed(sql, error instanceof Error ? error.message : String(error));
+            }
+        });
+    }
+    commit() {
+        return Task.of(async () => {
+            try {
+                await this.adapter.commit();
+            }
+            catch (error) {
+                throw new TransactionFailed(error instanceof Error ? error.message : String(error));
+            }
+        });
+    }
+    rollback() {
+        return Task.of(async () => {
+            try {
+                await this.adapter.rollback();
+            }
+            catch (error) {
+                throw new TransactionFailed(error instanceof Error ? error.message : String(error));
+            }
+        });
+    }
+}
+/**
+ * Database wrapper with Task/Stream semantics.
+ *
+ * @example
+ * ```ts
+ * // With a connector (recommended for production)
+ * const result = await DB.withConnection(myConnector, (db) =>
+ *   db.query("SELECT * FROM users")
+ * ).run();
+ *
+ * // With a bare adapter (for testing or custom lifecycle)
+ * const db = new DB(adapter);
+ * const users = await db.query("SELECT * FROM users").run();
+ * ```
+ */
+export class DB {
+    constructor(adapter) {
+        Object.defineProperty(this, "adapter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: adapter
+        });
+    }
+    /**
+     * Execute operations with a connection acquired from the connector.
+     * The connection is automatically released after the operation completes,
+     * whether successful or failed.
+     *
+     * @example
+     * ```ts
+     * const result = await DB.withConnection(postgresConnector, (db) =>
+     *   db.withTransaction(async (tx) => {
+     *     await tx.execute("INSERT INTO orders (user_id) VALUES (?)", [userId]).run();
+     *     return tx.query("SELECT last_insert_rowid()").run();
+     *   })
+     * ).run();
+     * ```
+     */
+    static withConnection(connector, fn) {
+        return Task.acquireRelease({
+            acquire: (signal) => connector.connect(signal).catch((error) => {
+                throw new ConnectionFailed(error instanceof Error ? error.message : String(error));
+            }),
+            release: (adapter) => adapter.close(),
+            use: (adapter) => fn(new DB(adapter)),
+        });
+    }
+    /**
+     * Execute a SELECT query and return rows.
+     * @example
+     * const users = await db.query("SELECT * FROM users").run();
+     */
+    query(sql, params) {
+        return Task.of(async () => {
+            try {
+                return await this.adapter.query(sql, params);
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes("constraint")) {
+                    throw new ConstraintViolation(sql, error.message);
+                }
+                throw new QueryFailed(sql, error instanceof Error ? error.message : String(error));
+            }
+        });
+    }
+    /**
+     * Execute INSERT/UPDATE/DELETE and return affected row count.
+     * @example
+     * const affected = await db.execute("DELETE FROM users WHERE id = ?", [1]).run();
+     */
+    execute(sql, params) {
+        return Task.of(async () => {
+            try {
+                return await this.adapter.execute(sql, params);
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes("constraint")) {
+                    throw new ConstraintViolation(sql, error.message);
+                }
+                throw new QueryFailed(sql, error instanceof Error ? error.message : String(error));
+            }
+        });
+    }
+    /**
+     * Stream rows from a SELECT query for memory-efficient processing.
+     *
+     * If the adapter supports cursor-based streaming (via the optional stream method),
+     * rows are yielded one at a time. Otherwise, the full result set is buffered
+     * in memory before streaming.
+     *
+     * @example
+     * const { successes, errors } = await db.stream("SELECT * FROM users").partition();
+     */
+    stream(sql, params) {
+        const adapter = this.adapter;
+        return Source.from(async function* () {
+            try {
+                if (adapter.stream) {
+                    yield* adapter.stream(sql, params);
+                }
+                else {
+                    const results = await adapter.query(sql, params);
+                    for (const row of results) {
+                        yield row;
+                    }
+                }
+            }
+            catch (error) {
+                throw new QueryFailed(sql, error instanceof Error ? error.message : String(error));
+            }
+        });
+    }
+    withTransaction(fn) {
+        return Task.acquireRelease({
+            acquire: () => this.transaction().run(),
+            release: (tx) => tx.rollback().run().catch(() => { }),
+            use: (tx) => Task.of(() => {
+                const result = fn(tx);
+                return result instanceof Promise ? result : Promise.resolve(result);
+            }).flatMap((result) => tx.commit().map(() => result)),
+        });
+    }
+    transaction() {
+        return Task.of(async () => {
+            await this.adapter.execute("BEGIN");
+            return new DBTransaction({
+                query: (sql, params) => this.adapter.query(sql, params),
+                execute: (sql, params) => this.adapter.execute(sql, params),
+                commit: () => this.adapter.execute("COMMIT").then(() => { }),
+                rollback: () => this.adapter.execute("ROLLBACK").then(() => { }),
+            });
+        }).mapErr((error) => new TransactionFailed(error instanceof Error ? error.message : String(error)));
+    }
+}

package/esm/db/errors.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Structured error types for database operations.
+ *
+ * @example
+ * ```ts
+ * import { DB, InMemoryDriver, DBError } from "@anabranch/db";
+ *
+ * const db = await DB.connect(InMemoryDriver.connect()).run();
+ * const result = await db.query("SELECT * FROM users").run();
+ *
+ * if (result.type === "error") {
+ *   const err = result.error;
+ *   if (err instanceof DBError) {
+ *     console.error(`${err.kind}: ${err.message}`);
+ *   }
+ * }
+ * ```
+ */
+export declare class DBError extends Error {
+    readonly kind: string;
+    readonly sql: string | undefined;
+    constructor(kind: string, sql: string | undefined, message: string);
+}
+/** Failed to establish a database connection. */
+export declare class ConnectionFailed extends DBError {
+    constructor(message: string);
+}
+/** Query execution failed. */
+export declare class QueryFailed extends DBError {
+    constructor(sql: string, message: string);
+}
+/** Constraint violation (e.g., unique, foreign key). */
+export declare class ConstraintViolation extends DBError {
+    constructor(sql: string, message: string);
+}
+/** Transaction failed. */
+export declare class TransactionFailed extends DBError {
+    constructor(message: string);
+}
+/** Failed to close the database connection. */
+export declare class CloseError extends DBError {
+    constructor(message: string);
+}
+/** Serialization failure (concurrent modification detected). */
+export declare class SerializationFailure extends DBError {
+    constructor(message?: string);
+}
+/** Registry of error constructors for `instanceof` checks. */
+export declare const DBErrors: {
+    readonly ConnectionFailed: typeof ConnectionFailed;
+    readonly QueryFailed: typeof QueryFailed;
+    readonly ConstraintViolation: typeof ConstraintViolation;
+    readonly TransactionFailed: typeof TransactionFailed;
+    readonly CloseError: typeof CloseError;
+    readonly SerializationFailure: typeof SerializationFailure;
+};
+//# sourceMappingURL=errors.d.ts.map

package/esm/db/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/db/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,OAAQ,SAAQ,KAAK;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;gBAErB,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM;CAKnE;AAED,iDAAiD;AACjD,qBAAa,gBAAiB,SAAQ,OAAO;gBAC/B,OAAO,EAAE,MAAM;CAG5B;AAED,8BAA8B;AAC9B,qBAAa,WAAY,SAAQ,OAAO;gBAC1B,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAGzC;AAED,wDAAwD;AACxD,qBAAa,mBAAoB,SAAQ,OAAO;gBAClC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAGzC;AAED,0BAA0B;AAC1B,qBAAa,iBAAkB,SAAQ,OAAO;gBAChC,OAAO,EAAE,MAAM;CAG5B;AAED,+CAA+C;AAC/C,qBAAa,UAAW,SAAQ,OAAO;gBACzB,OAAO,EAAE,MAAM;CAG5B;AAED,gEAAgE;AAChE,qBAAa,oBAAqB,SAAQ,OAAO;gBACnC,OAAO,GAAE,MAAgC;CAGtD;AAED,8DAA8D;AAC9D,eAAO,MAAM,QAAQ;;;;;;;CAOX,CAAC"}

package/esm/db/errors.js

@@ -0,0 +1,82 @@
+/**
+ * Structured error types for database operations.
+ *
+ * @example
+ * ```ts
+ * import { DB, InMemoryDriver, DBError } from "@anabranch/db";
+ *
+ * const db = await DB.connect(InMemoryDriver.connect()).run();
+ * const result = await db.query("SELECT * FROM users").run();
+ *
+ * if (result.type === "error") {
+ *   const err = result.error;
+ *   if (err instanceof DBError) {
+ *     console.error(`${err.kind}: ${err.message}`);
+ *   }
+ * }
+ * ```
+ */
+export class DBError extends Error {
+    constructor(kind, sql, message) {
+        super(message);
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sql", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.kind = kind;
+        this.sql = sql;
+    }
+}
+/** Failed to establish a database connection. */
+export class ConnectionFailed extends DBError {
+    constructor(message) {
+        super("ConnectionFailed", undefined, message);
+    }
+}
+/** Query execution failed. */
+export class QueryFailed extends DBError {
+    constructor(sql, message) {
+        super("QueryFailed", sql, message);
+    }
+}
+/** Constraint violation (e.g., unique, foreign key). */
+export class ConstraintViolation extends DBError {
+    constructor(sql, message) {
+        super("ConstraintViolation", sql, message);
+    }
+}
+/** Transaction failed. */
+export class TransactionFailed extends DBError {
+    constructor(message) {
+        super("TransactionFailed", undefined, message);
+    }
+}
+/** Failed to close the database connection. */
+export class CloseError extends DBError {
+    constructor(message) {
+        super("CloseError", undefined, message);
+    }
+}
+/** Serialization failure (concurrent modification detected). */
+export class SerializationFailure extends DBError {
+    constructor(message = "serialization failure") {
+        super("SerializationFailure", undefined, message);
+    }
+}
+/** Registry of error constructors for `instanceof` checks. */
+export const DBErrors = {
+    ConnectionFailed,
+    QueryFailed,
+    ConstraintViolation,
+    TransactionFailed,
+    CloseError,
+    SerializationFailure,
+};

package/esm/db/index.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @abranch/db
+ *
+ * Database primitives with Task/Stream semantics for error-tolerant async operations.
+ *
+ * ## Adapters vs Connectors
+ *
+ * A **DBConnector** produces connected **DBAdapter** instances. Use connectors for
+ * production code to properly manage connection lifecycles:
+ *
+ * ```ts
+ * import { DB, createInMemory } from "@anabranch/db";
+ *
+ * // Idiomatic usage with connector (recommended)
+ * const result = await DB.withConnection(createInMemory(), (db) =>
+ *   db.query("SELECT * FROM users")
+ * ).run();
+ *
+ * // Bare adapter for testing or custom lifecycle management
+ * const adapter = await createInMemory().connect();
+ * const db = new DB(adapter);
+ * ```
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { DB, createInMemory } from "@anabranch/db";
+ *
+ * // Using withConnection for automatic lifecycle management
+ * await DB.withConnection(createInMemory(), async (db) => {
+ *   await db.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)").run();
+ *   await db.execute("INSERT INTO users (name) VALUES (?)", ["Alice"]).run();
+ *   return db.query("SELECT * FROM users").run();
+ * }).run();
+ *
+ * // Stream large result sets
+ * const { successes, errors } = await db.stream("SELECT * FROM users")
+ *   .map(u => processUser(u))
+ *   .partition();
+ *
+ * // Transactions with automatic rollback on error
+ * const result = await DB.withConnection(createInMemory(), (db) =>
+ *   db.withTransaction(async (tx) => {
+ *     await tx.execute("INSERT INTO users (name) VALUES (?)", ["Bob"]).run();
+ *     return tx.query("SELECT last_insert_rowid()").run();
+ *   })
+ * ).run();
+ * ```
+ *
+ * ## Error Types
+ *
+ * The following error types are exported for adapter implementors:
+ *
+ * - {@link ConnectionFailed} - Throw from connector's `connect()` on failure
+ * - {@link CloseError} - Throw from adapter's `close()` on failure
+ * - {@link QueryFailed} - Thrown for query execution errors
+ * - {@link ConstraintViolation} - Thrown for constraint violations (e.g., UNIQUE, FOREIGN KEY)
+ * - {@link TransactionFailed} - Thrown for transaction errors
+ *
+ * @module
+ */
+export { DB, DBTransaction } from "./db.js";
+export type { DBAdapter, DBConnector, DBTransactionAdapter, } from "./adapter.js";
+export * from "./errors.js";
+export { createInMemory } from "./sqlite.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/db/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/db/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,OAAO,EAAE,EAAE,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC5C,YAAY,EACV,SAAS,EACT,WAAW,EACX,oBAAoB,GACrB,MAAM,cAAc,CAAC;AACtB,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

package/esm/db/index.js

@@ -0,0 +1,64 @@
+/**
+ * @abranch/db
+ *
+ * Database primitives with Task/Stream semantics for error-tolerant async operations.
+ *
+ * ## Adapters vs Connectors
+ *
+ * A **DBConnector** produces connected **DBAdapter** instances. Use connectors for
+ * production code to properly manage connection lifecycles:
+ *
+ * ```ts
+ * import { DB, createInMemory } from "@anabranch/db";
+ *
+ * // Idiomatic usage with connector (recommended)
+ * const result = await DB.withConnection(createInMemory(), (db) =>
+ *   db.query("SELECT * FROM users")
+ * ).run();
+ *
+ * // Bare adapter for testing or custom lifecycle management
+ * const adapter = await createInMemory().connect();
+ * const db = new DB(adapter);
+ * ```
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { DB, createInMemory } from "@anabranch/db";
+ *
+ * // Using withConnection for automatic lifecycle management
+ * await DB.withConnection(createInMemory(), async (db) => {
+ *   await db.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)").run();
+ *   await db.execute("INSERT INTO users (name) VALUES (?)", ["Alice"]).run();
+ *   return db.query("SELECT * FROM users").run();
+ * }).run();
+ *
+ * // Stream large result sets
+ * const { successes, errors } = await db.stream("SELECT * FROM users")
+ *   .map(u => processUser(u))
+ *   .partition();
+ *
+ * // Transactions with automatic rollback on error
+ * const result = await DB.withConnection(createInMemory(), (db) =>
+ *   db.withTransaction(async (tx) => {
+ *     await tx.execute("INSERT INTO users (name) VALUES (?)", ["Bob"]).run();
+ *     return tx.query("SELECT last_insert_rowid()").run();
+ *   })
+ * ).run();
+ * ```
+ *
+ * ## Error Types
+ *
+ * The following error types are exported for adapter implementors:
+ *
+ * - {@link ConnectionFailed} - Throw from connector's `connect()` on failure
+ * - {@link CloseError} - Throw from adapter's `close()` on failure
+ * - {@link QueryFailed} - Thrown for query execution errors
+ * - {@link ConstraintViolation} - Thrown for constraint violations (e.g., UNIQUE, FOREIGN KEY)
+ * - {@link TransactionFailed} - Thrown for transaction errors
+ *
+ * @module
+ */
+export { DB, DBTransaction } from "./db.js";
+export * from "./errors.js";
+export { createInMemory } from "./sqlite.js";

package/esm/db/sqlite.d.ts

@@ -0,0 +1,4 @@
+import type { DBConnector } from "./adapter.js";
+/** Creates an in-memory SQLite connector for testing. */
+export declare function createInMemory(): DBConnector;
+//# sourceMappingURL=sqlite.d.ts.map

package/esm/db/sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/db/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,yDAAyD;AACzD,wBAAgB,cAAc,IAAI,WAAW,CAyB5C"}

package/esm/db/sqlite.js

@@ -0,0 +1,24 @@
+import { DatabaseSync } from "node:sqlite";
+/** Creates an in-memory SQLite connector for testing. */
+export function createInMemory() {
+    return {
+        connect: () => {
+            const db = new DatabaseSync(":memory:");
+            return Promise.resolve({
+                query: (sql, params) => {
+                    const stmt = db.prepare(sql);
+                    return Promise.resolve(stmt.all(...(params ?? [])));
+                },
+                execute: (sql, params) => {
+                    const stmt = db.prepare(sql);
+                    const { changes } = stmt.run(...(params ?? []));
+                    return Promise.resolve(Number(changes));
+                },
+                close: () => {
+                    db.close();
+                    return Promise.resolve();
+                },
+            });
+        },
+    };
+}

package/esm/db-postgres/index.d.ts

@@ -0,0 +1,17 @@
+import type { DBConnector } from "../db/index.js";
+export interface PostgresOptions {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+    connectionString?: string;
+    max?: number;
+    idleTimeoutMillis?: number;
+    connectionTimeoutMillis?: number;
+}
+export interface PostgresConnector extends DBConnector {
+    end(): Promise<void>;
+}
+export declare function createPostgres(options?: PostgresOptions): PostgresConnector;
+//# sourceMappingURL=index.d.ts.map

package/esm/db-postgres/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/db-postgres/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAK7D,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACtB;AAuBD,wBAAgB,cAAc,CAC5B,OAAO,GAAE,eAAoB,GAC5B,iBAAiB,CA4CnB"}

package/esm/db-postgres/index.js

@@ -0,0 +1,64 @@
+import pg from "pg";
+import Cursor from "pg-cursor";
+import process from "node:process";
+const { Pool } = pg;
+function toPoolConfig(options) {
+    if (options.connectionString) {
+        return {
+            connectionString: options.connectionString,
+            max: options.max,
+            idleTimeoutMillis: options.idleTimeoutMillis,
+            connectionTimeoutMillis: options.connectionTimeoutMillis,
+        };
+    }
+    return {
+        host: options.host ?? process.env.PGHOST ?? "localhost",
+        port: options.port ?? parseInt(process.env.PGPORT ?? "5432"),
+        user: options.user ?? process.env.PGUSER ?? "postgres",
+        password: options.password ?? process.env.PGPASSWORD ?? "",
+        database: options.database ?? process.env.PGDATABASE ?? "postgres",
+        max: options.max,
+        idleTimeoutMillis: options.idleTimeoutMillis,
+        connectionTimeoutMillis: options.connectionTimeoutMillis,
+    };
+}
+export function createPostgres(options = {}) {
+    const pool = new Pool(toPoolConfig(options));
+    return {
+        async connect(signal) {
+            const client = await pool.connect();
+            const onAbort = () => client.release(true);
+            signal?.addEventListener("abort", onAbort, { once: true });
+            return {
+                query: (sql, params) => client
+                    .query(sql, params)
+                    .then((r) => r.rows),
+                execute: (sql, params) => client
+                    .query(sql, params)
+                    .then((r) => Number(r.rowCount ?? 0)),
+                close: () => {
+                    signal?.removeEventListener("abort", onAbort);
+                    client.release();
+                    return Promise.resolve();
+                },
+                stream: async function* (sql, params) {
+                    const cursor = client.query(new Cursor(sql, params));
+                    try {
+                        while (true) {
+                            const rows = await cursor.read(100);
+                            if (rows.length === 0)
+                                break;
+                            yield* rows;
+                        }
+                    }
+                    finally {
+                        await cursor.close();
+                    }
+                },
+            };
+        },
+        end() {
+            return pool.end();
+        },
+    };
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}