@coffre/db 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Erwin Kuhn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,15 @@
 # @coffre/db
 
-A placeholder that holds the name. The first release of
-[coffre](https://github.com/erwinkn/coffre), a self-hosted secrets manager,
-replaces it, published from GitHub Actions with provenance.
+coffre's database: the Drizzle schemas for Postgres and for SQLite, which
+coffre uses in tests and local development, their migrations and the
+migrator, the helpers for what the two engines do differently, and the
+connections, Hyperdrive's included.
+
+A deployment does not import it. `@coffre/server` runs its migrations with
+`coffre-server migrate`. The server and vault open the same database with
+separate logins, `coffre_runtime` and `coffre_vault_runtime`. The migrations
+grant each its own rights; only the owner runs migrations.
+
+Part of [coffre](https://github.com/erwinkn/coffre), a secrets manager you
+deploy as a small project of your own. Its eight `@coffre/*` packages are
+released together, at one version. MIT licensed.

package/dist/commits-BuW-NL3n.js

@@ -0,0 +1,30 @@
+//#region src/commits.ts
+const pending = /* @__PURE__ */ new WeakMap();
+/**
+* Run `then` once `tx` has committed, all the way out. Returns false, and
+* never runs it, for a transaction this package did not open.
+*/
+function afterCommit(tx, then) {
+	const list = pending.get(tx);
+	if (list === void 0) return false;
+	list.push(then);
+	return true;
+}
+/** `db`, its transactions tracked for `afterCommit`. */
+function trackCommits(db, outer = null) {
+	const run = db.transaction.bind(db);
+	const transaction = async (work, ...rest) => {
+		const list = [];
+		const result = await run((tx) => {
+			pending.set(tx, list);
+			return work(trackCommits(tx, list));
+		}, ...rest);
+		if (outer !== null) outer.push(...list);
+		else for (const then of list) then();
+		return result;
+	};
+	db.transaction = transaction;
+	return db;
+}
+//#endregion
+export { trackCommits as n, afterCommit as t };

package/dist/connect.d.ts

@@ -0,0 +1,21 @@
+import { t as Database } from "./database-CWpo5aF0.js";
+import { Engine } from "./dialect.js";
+//#region src/connect.d.ts
+/**
+ * Open a database from its URL, on a Node server:
+ *
+ *   postgres://… or postgresql://…   node-postgres
+ *   file:… or libsql:…                @libsql/client (SQLite)
+ *
+ * The SQLite driver loads only when asked for. The Worker does not
+ * come through here; it builds its Postgres database from the Hyperdrive
+ * pool with createDatabase.
+ */
+export declare function openDatabase(url: string): Promise<OpenDatabase>;
+export type OpenDatabase = {
+  engine: Engine;
+  db: Database;
+  close: () => Promise<void>;
+};
+export declare function engineOfUrl(url: string): Engine;
+//#endregion

package/dist/connect.js

@@ -0,0 +1,155 @@
+import { createDatabase } from "./index.js";
+import { asPostgresDatabase } from "./portable.js";
+import pg from "pg";
+import { resolve } from "node:path";
+//#region src/connect.ts
+/**
+* Open a database from its URL, on a Node server:
+*
+*   postgres://… or postgresql://…   node-postgres
+*   file:… or libsql:…                @libsql/client (SQLite)
+*
+* The SQLite driver loads only when asked for. The Worker does not
+* come through here; it builds its Postgres database from the Hyperdrive
+* pool with createDatabase.
+*/
+async function openDatabase(url) {
+	switch (engineOfUrl(url)) {
+		case "postgres": {
+			const pool = new pg.Pool({ connectionString: url });
+			return {
+				engine: "postgres",
+				db: createDatabase(pool),
+				close: () => pool.end()
+			};
+		}
+		case "sqlite": {
+			const [{ createClient }, { drizzle }, schema] = await Promise.all([
+				import("@libsql/client"),
+				import("drizzle-orm/libsql"),
+				import("./schema-sqlite.js")
+			]);
+			const client = createClient({
+				url,
+				timeout: 5e3,
+				intMode: "bigint"
+			});
+			if (url.startsWith("file:")) await client.execute("PRAGMA journal_mode = WAL");
+			const db = drizzle({
+				client: oneTransactionAtATime(client, writeQueueFor(url)),
+				schema
+			});
+			return {
+				engine: "sqlite",
+				db: asPostgresDatabase(db),
+				close: async () => client.close()
+			};
+		}
+	}
+}
+function engineOfUrl(url) {
+	const scheme = url.slice(0, url.indexOf(":"));
+	if (scheme === "postgres" || scheme === "postgresql") return "postgres";
+	if (scheme === "mysql") throw new Error("coffre supports Postgres; MySQL support was removed");
+	if (scheme === "file" || scheme === "libsql") return "sqlite";
+	throw new Error(`unsupported database URL scheme: ${scheme}:`);
+}
+/**
+* SQLite lets one connection write at a time and fails the others at once
+* with SQLITE_BUSY rather than queueing them; 24 concurrent audit appends were
+* enough to see it. So transactions queue here instead, in the order they
+* asked, one open at a time per database file, however many clients or
+* connections reach it. Each begins IMMEDIATE (libsql's default), taking the
+* write lock with its first statement, which is what makes a read inside it
+* as good as a locked one (see forUpdate).
+*/
+var WriteQueue = class {
+	#tail = Promise.resolve();
+	/** Wait for our turn; the returned function ends it. */
+	acquire() {
+		let release;
+		const turn = new Promise((done) => release = done);
+		const ready = this.#tail.then(() => release);
+		this.#tail = this.#tail.then(() => turn);
+		return ready;
+	}
+};
+const queues = /* @__PURE__ */ new Map();
+function writeQueueFor(url) {
+	const key = url.startsWith("file:") ? resolve(url.replace(/^file:(\/\/)?/, "").split("?")[0]) : url;
+	let queue = queues.get(key);
+	if (queue === void 0) queues.set(key, queue = new WriteQueue());
+	return queue;
+}
+function oneTransactionAtATime(client, queue) {
+	return new Proxy(client, { get(target, key) {
+		if (key === "execute") return async (...args) => numbers(await target.execute(...args));
+		if (key === "transaction") return async (mode) => {
+			const release = await queue.acquire();
+			try {
+				return settling(await target.transaction(mode), release);
+			} catch (error) {
+				release();
+				throw error;
+			}
+		};
+		if (key === "batch" || key === "migrate" || key === "executeMultiple") return async (...args) => {
+			const release = await queue.acquire();
+			try {
+				return (await target[key](...args))?.map(numbers);
+			} finally {
+				release();
+			}
+		};
+		const value = Reflect.get(target, key, target);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+}
+/** Ends the transaction's turn when it commits, rolls back or closes. */
+function settling(tx, release) {
+	let settled = false;
+	const settle = () => {
+		if (settled) return;
+		settled = true;
+		release();
+	};
+	const { commit, rollback, close, execute, batch } = tx;
+	tx.execute = async (...args) => numbers(await execute.apply(tx, args));
+	tx.batch = async (...args) => (await batch.apply(tx, args)).map(numbers);
+	tx.commit = async () => {
+		try {
+			return await commit.call(tx);
+		} finally {
+			settle();
+		}
+	};
+	tx.rollback = async () => {
+		try {
+			return await rollback.call(tx);
+		} finally {
+			settle();
+		}
+	};
+	tx.close = () => {
+		try {
+			close.call(tx);
+		} finally {
+			settle();
+		}
+	};
+	return tx;
+}
+/** Keep large counters exact; Drizzle's booleans and dates still need safe numbers. */
+function numbers(result) {
+	result.rows = result.rows.map((row) => {
+		const properties = Object.getOwnPropertyDescriptors(row);
+		for (const property of Object.values(properties)) {
+			const value = property.value;
+			if (typeof value === "bigint" && value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)) property.value = Number(value);
+		}
+		return Object.create(Object.getPrototypeOf(row), properties);
+	});
+	return result;
+}
+//#endregion
+export { engineOfUrl, openDatabase };

package/dist/database-CWpo5aF0.d.ts

@@ -0,0 +1,39 @@
+import { l as schema_d_exports } from "./schema-Cd4WOnB5.js";
+import { Table } from "drizzle-orm";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import pg from "pg";
+//#region src/database.d.ts
+/**
+ * A database, typed as Postgres whichever it is; see portable.ts for why
+ * that holds. connect.ts opens one of each from a URL.
+ */
+type Database = NodePgDatabase<typeof schema_d_exports>;
+type Transaction = Parameters<Parameters<Database['transaction']>[0]>[0];
+/** Anything a read can run on: the database, or an open transaction. */
+type Queryable = Database | Transaction;
+/**
+ * What Drizzle needs from a connection pool. A `pg.Pool` fits, and so does the
+ * per-invocation Hyperdrive pool, whose class name ends in `Pool` for the
+ * same reason: that is how Drizzle knows to check out a client for a
+ * transaction rather than run BEGIN on a shared connection.
+ */
+type PoolLike = pg.Pool | {
+  query: pg.Pool['query'];
+  connect: () => Promise<Pick<pg.PoolClient, 'query'> & {
+    release: () => void;
+  }>;
+};
+declare function createDatabase(pool: PoolLike): Database;
+/**
+ * The tables of the database's own dialect: the Postgres ones on Postgres,
+ * the SQLite ones on SQLite. Every query builds on these.
+ */
+declare function tablesOf(db: Queryable): typeof schema_d_exports;
+/**
+ * The database's own twin of `table`, which may be another dialect's: the
+ * server names tables by importing schema.ts, and the database decides
+ * which one that means.
+ */
+declare function own<T extends Table>(db: Queryable, table: T): T;
+//#endregion
+export { createDatabase as a, Transaction as i, PoolLike as n, own as o, Queryable as r, tablesOf as s, Database as t };

package/dist/dialect.d.ts

@@ -0,0 +1,88 @@
+import { r as Queryable } from "./database-CWpo5aF0.js";
+import { SQL } from "drizzle-orm";
+import { PgTable } from "drizzle-orm/pg-core";
+//#region src/dialect.d.ts
+/**
+ * Differences between Postgres and the SQLite used for tests and local dev.
+ * Queries stay in the server's queries.ts; it never asks which database it has.
+ *
+ *                     Postgres                SQLite
+ *   isolation         READ COMMITTED          one writer at a time
+ *   lock a row        SELECT … FOR UPDATE     one writer at a time
+ *   rows changed      rowCount                rowsAffected
+ *   duplicate key     SQLSTATE 23505          SQLITE_CONSTRAINT_UNIQUE
+ *   clock             CURRENT_TIMESTAMP       strftime(…, 'now')
+ *   clock, in ms      clock_timestamp()       unixepoch('subsec')
+ *   a condition read  true / false            1 / 0
+ *
+ * Nothing here imports SQLite code, so the Worker bundles none.
+ */
+export type Table = PgTable;
+export type Engine = 'postgres' | 'sqlite';
+/** Which database this is, from the Drizzle dialect it was opened with. */
+export declare function engineOf(db: Queryable): Engine;
+/**
+ * Lock the rows a select reads until the transaction ends. SQLite has no row
+ * locks and needs none: connect.ts runs one transaction at a time, and each
+ * holds the database's write lock from its first statement.
+ *
+ * `no key update` is for rows others reference by foreign key: it keeps out
+ * every other writer of the row, but not an insert that points at it.
+ */
+export declare function forUpdate<Query extends {
+  for: (strength: 'update' | 'no key update') => unknown;
+}>(db: Queryable, query: Query, strength?: 'update' | 'no key update'): ReturnType<Query['for']>;
+/** Insert the rows whose unique keys are free; returns how many that was. */
+export declare function insertIfAbsent(db: Queryable, table: Table, rows: object[]): Promise<number>;
+/**
+ * Insert the rows, or where one repeats the unique key `target`, overwrite
+ * `columns` of the existing row with the values it was about to insert.
+ */
+export declare function upsert<T extends Table>(db: Queryable, table: T, rows: object[], target: (keyof T['$inferSelect'])[], columns: (keyof T['$inferSelect'])[]): Promise<void>;
+/** A condition read as a boolean: Postgres returns true or false, SQLite 1 or 0. */
+export declare function truth(condition: SQL): SQL<boolean>;
+/** How many rows an insert, update or delete touched. */
+export declare function changedRows(result: unknown): number;
+/** Whether an insert or update failed on a unique constraint. */
+export declare function isUniqueViolation(error: unknown): boolean;
+/**
+ * A consistent read of several statements that cannot write, such as
+ * verifying the chain. SQLite ignores it: its transactions already see one
+ * snapshot, and connect.ts runs them one at a time.
+ */
+export declare const SNAPSHOT: {
+  readonly isolationLevel: "repeatable read";
+  readonly accessMode: "read only";
+};
+/**
+ * The database clock as text, for canonicalTimestamp. Entries from several
+ * servers order by it, so it is never an application server's.
+ */
+export declare function clock(db: Queryable): SQL<string>;
+/**
+ * The database clock as milliseconds since the epoch, as the statement runs:
+ * Postgres's `clock_timestamp()`, not `CURRENT_TIMESTAMP`, which is the
+ * transaction's start and would date an entry that waited for the log's lock
+ * before one written while it waited. Read it in a statement after the lock.
+ */
+export declare function clockMillis(db: Queryable): SQL<number>;
+/**
+ * The migrator's own ledger, read by readiness to tell a database that is
+ * up but not yet migrated from one that is ready. Drizzle keeps it in a
+ * `drizzle` schema on Postgres, and in a plain table elsewhere.
+ */
+export declare function migrationLedger(db: Queryable): SQL;
+/**
+ * The one rendering of a timestamp read as text: UTC, microseconds, `Z`.
+ *
+ * The audit chain covers occurred_at as text, so reading a row back has to
+ * reproduce it byte for byte. Databases hand timestamps back in their own
+ * shapes (`2026-09-27 12:34:56.1+02` from Postgres, ISO text from SQLite),
+ * and a Date would drop the microseconds, so every value goes through here
+ * on the way in and out:
+ *
+ *   2026-09-27 12:34:56.1+02  ->  2026-09-27T10:34:56.100000Z
+ *   2026-09-27T10:34:56.1Z   ->  2026-09-27T10:34:56.100000Z
+ */
+export declare function canonicalTimestamp(raw: string): string;
+//#endregion

package/dist/dialect.js

@@ -0,0 +1,128 @@
+import { entityKind, getTableColumns, sql } from "drizzle-orm";
+//#region src/dialect.ts
+/** Which database this is, from the Drizzle dialect it was opened with. */
+function engineOf(db) {
+	const kind = db.dialect.constructor[entityKind];
+	if (kind.startsWith("Pg")) return "postgres";
+	if (kind.startsWith("SQLite")) return "sqlite";
+	throw new Error(`unsupported database: ${kind}`);
+}
+/**
+* Lock the rows a select reads until the transaction ends. SQLite has no row
+* locks and needs none: connect.ts runs one transaction at a time, and each
+* holds the database's write lock from its first statement.
+*
+* `no key update` is for rows others reference by foreign key: it keeps out
+* every other writer of the row, but not an insert that points at it.
+*/
+function forUpdate(db, query, strength = "update") {
+	if (engineOf(db) === "sqlite") return query;
+	return query.for(strength);
+}
+/** Insert the rows whose unique keys are free; returns how many that was. */
+async function insertIfAbsent(db, table, rows) {
+	return changedRows(await db.insert(table).values(rows).onConflictDoNothing());
+}
+/**
+* Insert the rows, or where one repeats the unique key `target`, overwrite
+* `columns` of the existing row with the values it was about to insert.
+*/
+async function upsert(db, table, rows, target, columns) {
+	const all = getTableColumns(table);
+	const incoming = (name) => sql`excluded.${sql.identifier(all[name].name)}`;
+	const set = Object.fromEntries(columns.map((name) => [name, incoming(name)]));
+	await db.insert(table).values(rows).onConflictDoUpdate({
+		target: target.map((name) => all[name]),
+		set
+	});
+}
+/** A condition read as a boolean: Postgres returns true or false, SQLite 1 or 0. */
+function truth(condition) {
+	return condition.mapWith((value) => Number(value) === 1);
+}
+/** How many rows an insert, update or delete touched. */
+function changedRows(result) {
+	const header = result;
+	return header.rowCount ?? header.rowsAffected ?? 0;
+}
+const DUPLICATE_KEY = /* @__PURE__ */ new Set([
+	"23505",
+	"SQLITE_CONSTRAINT_UNIQUE",
+	"SQLITE_CONSTRAINT_PRIMARYKEY"
+]);
+/** Whether an insert or update failed on a unique constraint. */
+function isUniqueViolation(error) {
+	for (let cause = error; typeof cause === "object" && cause !== null;) {
+		const { code, extendedCode } = cause;
+		if (DUPLICATE_KEY.has(code) || DUPLICATE_KEY.has(extendedCode)) return true;
+		cause = cause.cause;
+	}
+	return false;
+}
+/**
+* A consistent read of several statements that cannot write, such as
+* verifying the chain. SQLite ignores it: its transactions already see one
+* snapshot, and connect.ts runs them one at a time.
+*/
+const SNAPSHOT = {
+	isolationLevel: "repeatable read",
+	accessMode: "read only"
+};
+/**
+* The database clock as text, for canonicalTimestamp. Entries from several
+* servers order by it, so it is never an application server's.
+*/
+function clock(db) {
+	switch (engineOf(db)) {
+		case "postgres": return sql`CURRENT_TIMESTAMP`;
+		case "sqlite": return sql`strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+	}
+}
+/**
+* The database clock as milliseconds since the epoch, as the statement runs:
+* Postgres's `clock_timestamp()`, not `CURRENT_TIMESTAMP`, which is the
+* transaction's start and would date an entry that waited for the log's lock
+* before one written while it waited. Read it in a statement after the lock.
+*/
+function clockMillis(db) {
+	switch (engineOf(db)) {
+		case "postgres": return sql`(extract(epoch from clock_timestamp()) * 1000)::bigint`.mapWith(Number);
+		case "sqlite": return sql`CAST(unixepoch('subsec') * 1000 AS INTEGER)`.mapWith(Number);
+	}
+}
+/**
+* The migrator's own ledger, read by readiness to tell a database that is
+* up but not yet migrated from one that is ready. Drizzle keeps it in a
+* `drizzle` schema on Postgres, and in a plain table elsewhere.
+*/
+function migrationLedger(db) {
+	const table = sql.identifier("__drizzle_migrations");
+	return engineOf(db) === "postgres" ? sql`${sql.identifier("drizzle")}.${table}` : sql`${table}`;
+}
+const TIMESTAMP = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,6}))?(Z|[+-]\d{2}(?::?\d{2})?)?$/;
+/**
+* The one rendering of a timestamp read as text: UTC, microseconds, `Z`.
+*
+* The audit chain covers occurred_at as text, so reading a row back has to
+* reproduce it byte for byte. Databases hand timestamps back in their own
+* shapes (`2026-09-27 12:34:56.1+02` from Postgres, ISO text from SQLite),
+* and a Date would drop the microseconds, so every value goes through here
+* on the way in and out:
+*
+*   2026-09-27 12:34:56.1+02  ->  2026-09-27T10:34:56.100000Z
+*   2026-09-27T10:34:56.1Z   ->  2026-09-27T10:34:56.100000Z
+*/
+function canonicalTimestamp(raw) {
+	const match = TIMESTAMP.exec(raw);
+	if (match === null) throw new Error(`unexpected timestamp from the database: ${raw}`);
+	const [, year, month, day, hour, minute, second, fraction = "", zone = "Z"] = match;
+	let offsetMinutes = 0;
+	if (zone !== "Z") {
+		const sign = zone.startsWith("-") ? -1 : 1;
+		const digits = zone.slice(1).replace(":", "");
+		offsetMinutes = sign * (Number(digits.slice(0, 2)) * 60 + Number(digits.slice(2) || "0"));
+	}
+	return `${(/* @__PURE__ */ new Date(Date.UTC(+year, +month - 1, +day, +hour, +minute, +second) - offsetMinutes * 6e4)).toISOString().slice(0, 19)}.${fraction.padEnd(6, "0")}Z`;
+}
+//#endregion
+export { SNAPSHOT, canonicalTimestamp, changedRows, clock, clockMillis, engineOf, forUpdate, insertIfAbsent, isUniqueViolation, migrationLedger, truth, upsert };

package/dist/hyperdrive.d.ts

@@ -0,0 +1,32 @@
+import { n as PoolLike } from "./database-CWpo5aF0.js";
+import pg from "pg";
+//#region src/hyperdrive.d.ts
+/** Postgres through a Hyperdrive binding: `postgres(env.HYPERDRIVE)`. */
+export type PostgresDatabase = {
+  readonly engine: 'postgres';
+  readonly hyperdrive: {
+    readonly connectionString: string;
+  };
+};
+/** Postgres through Hyperdrive, the one database a Worker runs on, the app's and the vault's. */
+export declare function postgres(hyperdrive: {
+  readonly connectionString: string;
+}): PostgresDatabase;
+/**
+ * Request-scoped node-postgres adapter for Hyperdrive.
+ *
+ * Hyperdrive owns the durable origin pool. The Worker creates edge clients
+ * only inside one invocation, which prevents I/O objects from leaking across
+ * Worker request contexts while keeping the Pool shape Drizzle expects. The
+ * class name must end in `Pool`: that is how Drizzle knows to check out a
+ * client for each transaction.
+ */
+export declare class HyperdrivePool implements Exclude<PoolLike, pg.Pool> {
+  #private;
+  constructor(connectionString: string);
+  readonly query: pg.Pool['query'];
+  connect(): Promise<Pick<pg.PoolClient, 'query'> & {
+    release: () => void;
+  }>;
+}
+//#endregion

package/dist/hyperdrive.js

@@ -0,0 +1,53 @@
+import pg from "pg";
+//#region src/hyperdrive.ts
+/** Postgres through Hyperdrive, the one database a Worker runs on, the app's and the vault's. */
+function postgres(hyperdrive) {
+	if (typeof hyperdrive?.connectionString !== "string") throw new Error("postgres() takes the Hyperdrive binding, e.g. postgres(env.HYPERDRIVE)");
+	return {
+		engine: "postgres",
+		hyperdrive
+	};
+}
+/**
+* Request-scoped node-postgres adapter for Hyperdrive.
+*
+* Hyperdrive owns the durable origin pool. The Worker creates edge clients
+* only inside one invocation, which prevents I/O objects from leaking across
+* Worker request contexts while keeping the Pool shape Drizzle expects. The
+* class name must end in `Pool`: that is how Drizzle knows to check out a
+* client for each transaction.
+*/
+var HyperdrivePool = class {
+	#connectionString;
+	constructor(connectionString) {
+		if (connectionString.trim().length === 0) throw new Error("Hyperdrive returned an empty connection string");
+		this.#connectionString = connectionString;
+	}
+	query = (async (...args) => {
+		const client = await this.#connectClient();
+		try {
+			return await client.query(...args);
+		} finally {
+			await client.end();
+		}
+	});
+	async connect() {
+		const client = await this.#connectClient();
+		let released = false;
+		return {
+			query: client.query.bind(client),
+			release: () => {
+				if (released) return;
+				released = true;
+				client.end().catch(() => {});
+			}
+		};
+	}
+	async #connectClient() {
+		const client = new pg.Client({ connectionString: this.#connectionString });
+		await client.connect();
+		return client;
+	}
+};
+//#endregion
+export { HyperdrivePool, postgres };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { l as schema_d_exports } from "./schema-Cd4WOnB5.js";
+import { a as createDatabase, i as Transaction, n as PoolLike, o as own, r as Queryable, s as tablesOf, t as Database } from "./database-CWpo5aF0.js";
+export { Database, PoolLike, Queryable, Transaction, createDatabase, own, schema_d_exports as schema, tablesOf };

package/dist/index.js

@@ -0,0 +1,34 @@
+import { n as trackCommits } from "./commits-BuW-NL3n.js";
+import { t as schema_exports } from "./schema.js";
+import { Table, getTableName, is } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/node-postgres";
+//#region src/database.ts
+function createDatabase(pool) {
+	return trackCommits(drizzle(pool, { schema: schema_exports }));
+}
+/**
+* The tables of the database's own dialect: the Postgres ones on Postgres,
+* the SQLite ones on SQLite. Every query builds on these.
+*/
+function tablesOf(db) {
+	return db._.fullSchema;
+}
+const byName = /* @__PURE__ */ new WeakMap();
+/**
+* The database's own twin of `table`, which may be another dialect's: the
+* server names tables by importing schema.ts, and the database decides
+* which one that means.
+*/
+function own(db, table) {
+	const tables = tablesOf(db);
+	let named = byName.get(tables);
+	if (named === void 0) {
+		named = new Map(Object.values(tables).filter((value) => is(value, Table)).map((value) => [getTableName(value), value]));
+		byName.set(tables, named);
+	}
+	const found = named.get(getTableName(table));
+	if (found === void 0) throw new Error(`no table ${getTableName(table)} in this database`);
+	return found;
+}
+//#endregion
+export { createDatabase, own, schema_exports as schema, tablesOf };