@storyshelf/db-postgres 0.0.0-stage → 0.5.4

package/dist/index.mjs

@@ -0,0 +1,51 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { createDrizzlePgAdapter } from "./drizzle-factory-pg.mjs";
+import { runMigrations } from "./migrate.mjs";
+import { schema } from "./schema.mjs";
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+//#region src/index.ts
+/**
+* Create a Postgres-backed DatabaseAdapter using postgres.js and Drizzle ORM.
+*
+* Works with self-hosted Postgres, AWS RDS, GCP Cloud SQL, Supabase, Neon,
+* and Azure Database for PostgreSQL — all speak the standard wire protocol.
+* For provider-specific TLS and pooling notes, see the deployment guide.
+*/
+function createPostgresDatabase(options) {
+	const connectionString = options.connectionString ?? options.url;
+	if (!options.client && !connectionString) throw new Error("createPostgresDatabase: provide `url` (or `connectionString`) or a preconfigured `client`");
+	const client = options.client ?? postgres(connectionString, {
+		ssl: options.ssl,
+		prepare: options.prepare,
+		max: options.max,
+		idle_timeout: options.idleTimeout,
+		connect_timeout: options.connectTimeout
+	});
+	const db = drizzle(client, { schema });
+	return createDrizzlePgAdapter(db, {
+		metadata: {
+			name: "Postgres",
+			version: globalThis.__PKG_VERSION__ ?? "0.0.0",
+			description: "Postgres database adapter (postgres.js + Drizzle)",
+			kind: "postgres",
+			category: "database"
+		},
+		tables: schema,
+		migrate: async () => {
+			await runMigrations(async (sql) => await client.unsafe(sql));
+		},
+		close: async () => {
+			await client.end();
+		},
+		ping: async () => {
+			await client.unsafe("SELECT 1");
+		}
+	});
+}
+//#endregion
+export { createPostgresDatabase };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { DatabaseAdapter } from \"@storyshelf/core/adapter/database\";\nimport { drizzle } from \"drizzle-orm/postgres-js\";\nimport postgres from \"postgres\";\nimport { createDrizzlePgAdapter } from \"./drizzle-factory-pg.ts\";\nimport { runMigrations } from \"./migrate.ts\";\nimport { schema } from \"./schema/index.ts\";\n\ndeclare const __PKG_VERSION__: string | undefined;\n\n/**\n * TLS options for Postgres connections. When `true`, the driver negotiates\n * TLS with the server's default CA. When an object, `ca`/`cert`/`key` are\n * forwarded to `postgres.js` for mutual TLS (e.g. GCP Cloud SQL) or custom\n * RDS bundles.\n */\nexport type PostgresSslOptions = boolean | { ca?: string; cert?: string; key?: string };\n\n/**\n * Options for creating a Postgres-backed DatabaseAdapter.\n *\n * `url` (or `connectionString`) is the Postgres connection string\n * (`postgres://user:pass@host:5432/db`). For managed providers, see the\n * deployment guide for per-provider recipes (RDS CA bundle, Cloud SQL\n * mutual TLS, Supabase pooler port `6543` with `prepare: false`, etc.).\n *\n * When `client` is supplied, all other connection options are ignored and\n * the caller owns the lifecycle of the client. This is the hook for\n * advanced setups (IAM token refresh, pre-configured TLS, etc.) and for\n * hermetic tests.\n */\nexport interface PostgresDatabaseOptions {\n  url?: string;\n  connectionString?: string;\n  ssl?: PostgresSslOptions;\n  prepare?: boolean;\n  max?: number;\n  idleTimeout?: number;\n  connectTimeout?: number;\n  client?: ReturnType<typeof postgres>;\n}\n\n/**\n * Create a Postgres-backed DatabaseAdapter using postgres.js and Drizzle ORM.\n *\n * Works with self-hosted Postgres, AWS RDS, GCP Cloud SQL, Supabase, Neon,\n * and Azure Database for PostgreSQL — all speak the standard wire protocol.\n * For provider-specific TLS and pooling notes, see the deployment guide.\n */\nexport function createPostgresDatabase(options: PostgresDatabaseOptions): DatabaseAdapter {\n  const connectionString = options.connectionString ?? options.url;\n  if (!options.client && !connectionString) {\n    throw new Error(\n      \"createPostgresDatabase: provide `url` (or `connectionString`) or a preconfigured `client`\",\n    );\n  }\n\n  const client =\n    options.client ??\n    postgres(connectionString as string, {\n      ssl: options.ssl as never,\n      prepare: options.prepare,\n      max: options.max,\n      idle_timeout: options.idleTimeout,\n      connect_timeout: options.connectTimeout,\n    });\n\n  // oxlint-disable-next-line typescript/no-unsafe-argument -- postgres instance may be from isolated store vs workspace\n  const db = drizzle(client as never, { schema });\n\n  return createDrizzlePgAdapter(db, {\n    metadata: {\n      name: \"Postgres\",\n      version: (globalThis as unknown as { __PKG_VERSION__?: string }).__PKG_VERSION__ ?? \"0.0.0\",\n      description: \"Postgres database adapter (postgres.js + Drizzle)\",\n      kind: \"postgres\",\n      category: \"database\",\n    },\n    tables: schema as unknown as DatabaseAdapter[\"tables\"],\n    migrate: async () => {\n      await runMigrations(async (sql: string) => await client.unsafe(sql));\n    },\n    close: async () => {\n      await client.end();\n    },\n    ping: async () => {\n      await client.unsafe(\"SELECT 1\");\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgDA,SAAgB,uBAAuB,SAAmD;CACxF,MAAM,mBAAmB,QAAQ,oBAAoB,QAAQ;CAC7D,IAAI,CAAC,QAAQ,UAAU,CAAC,kBACtB,MAAM,IAAI,MACR,2FACF;CAGF,MAAM,SACJ,QAAQ,UACR,SAAS,kBAA4B;EACnC,KAAK,QAAQ;EACb,SAAS,QAAQ;EACjB,KAAK,QAAQ;EACb,cAAc,QAAQ;EACtB,iBAAiB,QAAQ;CAC3B,CAAC;CAGH,MAAM,KAAK,QAAQ,QAAiB,EAAE,OAAO,CAAC;CAE9C,OAAO,uBAAuB,IAAI;EAChC,UAAU;GACR,MAAM;GACN,SAAU,WAAuD,mBAAmB;GACpF,aAAa;GACb,MAAM;GACN,UAAU;EACZ;EACA,QAAQ;EACR,SAAS,YAAY;GACnB,MAAM,cAAc,OAAO,QAAgB,MAAM,OAAO,OAAO,GAAG,CAAC;EACrE;EACA,OAAO,YAAY;GACjB,MAAM,OAAO,IAAI;EACnB;EACA,MAAM,YAAY;GAChB,MAAM,OAAO,OAAO,UAAU;EAChC;CACF,CAAC;AACH"}

package/dist/migrate.mjs

@@ -0,0 +1,91 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { DDL } from "./ddl.mjs";
+//#region src/migrate.ts
+/**
+* Shared Postgres migrations for every `db-postgres` preset.
+*
+* The DDL plus idempotent follow-up ALTERs run through a minimal row-query
+* runner so all drivers (`postgres.js`, `node-postgres`, Neon, …) share one
+* migration path instead of drifting per preset.
+*/
+const STORYBOOK_META_ALTER = "ALTER TABLE projects ADD COLUMN IF NOT EXISTS storybook_meta TEXT";
+const EXECUTE_PLAY_ALTER = "ALTER TABLE projects ADD COLUMN IF NOT EXISTS execute_play BOOLEAN NOT NULL DEFAULT false";
+const PLAY_TIMEOUT_MS_ALTER = "ALTER TABLE projects ADD COLUMN IF NOT EXISTS play_timeout_ms INTEGER NOT NULL DEFAULT 10000";
+const RUN_A11Y_ALTER = "ALTER TABLE projects ADD COLUMN IF NOT EXISTS run_a11y BOOLEAN NOT NULL DEFAULT false";
+const PROJECT_BROWSER_ALTER = "ALTER TABLE projects ADD COLUMN IF NOT EXISTS browser TEXT NOT NULL DEFAULT 'chromium'";
+const PROJECT_VIEWPORTS_ALTER = "ALTER TABLE projects ADD COLUMN IF NOT EXISTS viewports TEXT";
+const PROJECT_AUTOMIGRATE_ALTER = "ALTER TABLE projects ADD COLUMN IF NOT EXISTS automigrate BOOLEAN NOT NULL DEFAULT false";
+const SNAPSHOT_INFRA_HASH_ALTER = "ALTER TABLE snapshots ADD COLUMN IF NOT EXISTS infra_hash TEXT";
+const SNAPSHOT_INHERITED_ALTER = "ALTER TABLE snapshots ADD COLUMN IF NOT EXISTS inherited BOOLEAN NOT NULL DEFAULT false";
+const SNAPSHOT_BASELINE_ID_ALTER = "ALTER TABLE snapshots ADD COLUMN IF NOT EXISTS baseline_id TEXT";
+const SNAPSHOT_BASELINE_VERSION_ALTER = "ALTER TABLE snapshots ADD COLUMN IF NOT EXISTS baseline_version TEXT";
+const BASELINE_INFRA_HASH_ALTER = "ALTER TABLE baselines ADD COLUMN IF NOT EXISTS infra_hash TEXT";
+const BUILD_AFFECTED_ONLY_ALTER = "ALTER TABLE builds ADD COLUMN IF NOT EXISTS affected_only BOOLEAN NOT NULL DEFAULT true";
+const BUILD_BASELINE_SHA_ALTER = "ALTER TABLE builds ADD COLUMN IF NOT EXISTS baseline_sha TEXT";
+const BUILD_CHANGED_FILES_ALTER = "ALTER TABLE builds ADD COLUMN IF NOT EXISTS changed_files TEXT";
+const BUILD_AFFECTED_PATHS_ALTER = "ALTER TABLE builds ADD COLUMN IF NOT EXISTS affected_import_paths TEXT";
+const WEBHOOK_SECRET_ALTER = "ALTER TABLE webhooks ADD COLUMN IF NOT EXISTS secret_encrypted TEXT NOT NULL DEFAULT ''";
+const WEBHOOK_SECRET_DROP = "ALTER TABLE webhooks DROP COLUMN IF EXISTS secret";
+const TOKEN_USER_ALTER = "ALTER TABLE tokens ADD COLUMN IF NOT EXISTS user_id TEXT REFERENCES users(id) ON DELETE CASCADE";
+const MEMBER_SOURCE_ALTER = "ALTER TABLE project_members ADD COLUMN IF NOT EXISTS source TEXT NOT NULL DEFAULT 'manual'";
+/**
+* Re-runs share `(project_id, git_sha)` by design (ULID build ids), so the
+* lookup index must not be unique. Existing databases created it UNIQUE —
+* drop and recreate it plain.
+*/
+const BUILDS_GITSHA_DEDUP = "DROP INDEX IF EXISTS builds_project_gitsha_idx";
+const BUILDS_GITSHA_INDEX = "CREATE INDEX IF NOT EXISTS builds_project_gitsha_idx ON builds (project_id, git_sha)";
+async function migrateSnapshotColumns(run) {
+	await execIgnore(run, SNAPSHOT_INFRA_HASH_ALTER);
+	await execIgnore(run, SNAPSHOT_INHERITED_ALTER);
+	await execIgnore(run, SNAPSHOT_BASELINE_ID_ALTER);
+	await execIgnore(run, SNAPSHOT_BASELINE_VERSION_ALTER);
+}
+async function migrateProjectExtras(run) {
+	await execIgnore(run, EXECUTE_PLAY_ALTER);
+	await execIgnore(run, PLAY_TIMEOUT_MS_ALTER);
+	await execIgnore(run, PROJECT_AUTOMIGRATE_ALTER);
+	await migrateSnapshotColumns(run);
+	await execIgnore(run, BASELINE_INFRA_HASH_ALTER);
+	await execIgnore(run, BUILD_AFFECTED_ONLY_ALTER);
+	await execIgnore(run, BUILD_BASELINE_SHA_ALTER);
+	await execIgnore(run, BUILD_CHANGED_FILES_ALTER);
+	await execIgnore(run, BUILD_AFFECTED_PATHS_ALTER);
+}
+/** Run the full migration set through any row-query runner. */
+async function runMigrations(run) {
+	await run(DDL);
+	await migrateCoreColumns(run);
+	await migrateProjectExtras(run);
+	await migrateCommentsTable(run);
+}
+async function migrateCoreColumns(run) {
+	await execIgnore(run, STORYBOOK_META_ALTER);
+	await execIgnore(run, RUN_A11Y_ALTER);
+	await execIgnore(run, PROJECT_BROWSER_ALTER);
+	await execIgnore(run, PROJECT_VIEWPORTS_ALTER);
+	await execIgnore(run, WEBHOOK_SECRET_ALTER);
+	await execIgnore(run, WEBHOOK_SECRET_DROP);
+	await execIgnore(run, TOKEN_USER_ALTER);
+	await execIgnore(run, MEMBER_SOURCE_ALTER);
+	await execIgnore(run, BUILDS_GITSHA_DEDUP);
+	await execIgnore(run, BUILDS_GITSHA_INDEX);
+}
+async function execIgnore(run, sql) {
+	try {
+		await run(sql);
+	} catch {}
+}
+async function migrateCommentsTable(run) {
+	try {
+		const isNullable = (await run("SELECT is_nullable FROM information_schema.columns WHERE table_name='comments' AND column_name='user_id'"))[0]?.is_nullable;
+		if (isNullable === "YES" || isNullable === void 0) return;
+		await run("ALTER TABLE comments ALTER COLUMN user_id DROP NOT NULL");
+	} catch {}
+}
+//#endregion
+export { runMigrations };
+
+//# sourceMappingURL=migrate.mjs.map

package/dist/migrate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.mjs","names":[],"sources":["../src/migrate.ts"],"sourcesContent":["/**\n * Shared Postgres migrations for every `db-postgres` preset.\n *\n * The DDL plus idempotent follow-up ALTERs run through a minimal row-query\n * runner so all drivers (`postgres.js`, `node-postgres`, Neon, …) share one\n * migration path instead of drifting per preset.\n */\nimport { DDL } from \"./ddl.ts\";\n\n/** Minimal row-query surface a migration runner needs. */\nexport type MigrationRunner = (sql: string) => Promise<unknown[]>;\n\nconst STORYBOOK_META_ALTER = \"ALTER TABLE projects ADD COLUMN IF NOT EXISTS storybook_meta TEXT\";\nconst EXECUTE_PLAY_ALTER =\n  \"ALTER TABLE projects ADD COLUMN IF NOT EXISTS execute_play BOOLEAN NOT NULL DEFAULT false\";\nconst PLAY_TIMEOUT_MS_ALTER =\n  \"ALTER TABLE projects ADD COLUMN IF NOT EXISTS play_timeout_ms INTEGER NOT NULL DEFAULT 10000\";\nconst RUN_A11Y_ALTER =\n  \"ALTER TABLE projects ADD COLUMN IF NOT EXISTS run_a11y BOOLEAN NOT NULL DEFAULT false\";\nconst PROJECT_BROWSER_ALTER =\n  \"ALTER TABLE projects ADD COLUMN IF NOT EXISTS browser TEXT NOT NULL DEFAULT 'chromium'\";\nconst PROJECT_VIEWPORTS_ALTER = \"ALTER TABLE projects ADD COLUMN IF NOT EXISTS viewports TEXT\";\nconst PROJECT_AUTOMIGRATE_ALTER =\n  \"ALTER TABLE projects ADD COLUMN IF NOT EXISTS automigrate BOOLEAN NOT NULL DEFAULT false\";\nconst SNAPSHOT_INFRA_HASH_ALTER = \"ALTER TABLE snapshots ADD COLUMN IF NOT EXISTS infra_hash TEXT\";\nconst SNAPSHOT_INHERITED_ALTER =\n  \"ALTER TABLE snapshots ADD COLUMN IF NOT EXISTS inherited BOOLEAN NOT NULL DEFAULT false\";\nconst SNAPSHOT_BASELINE_ID_ALTER =\n  \"ALTER TABLE snapshots ADD COLUMN IF NOT EXISTS baseline_id TEXT\";\nconst SNAPSHOT_BASELINE_VERSION_ALTER =\n  \"ALTER TABLE snapshots ADD COLUMN IF NOT EXISTS baseline_version TEXT\";\nconst BASELINE_INFRA_HASH_ALTER = \"ALTER TABLE baselines ADD COLUMN IF NOT EXISTS infra_hash TEXT\";\nconst BUILD_AFFECTED_ONLY_ALTER =\n  \"ALTER TABLE builds ADD COLUMN IF NOT EXISTS affected_only BOOLEAN NOT NULL DEFAULT true\";\nconst BUILD_BASELINE_SHA_ALTER = \"ALTER TABLE builds ADD COLUMN IF NOT EXISTS baseline_sha TEXT\";\nconst BUILD_CHANGED_FILES_ALTER = \"ALTER TABLE builds ADD COLUMN IF NOT EXISTS changed_files TEXT\";\nconst BUILD_AFFECTED_PATHS_ALTER =\n  \"ALTER TABLE builds ADD COLUMN IF NOT EXISTS affected_import_paths TEXT\";\nconst WEBHOOK_SECRET_ALTER =\n  \"ALTER TABLE webhooks ADD COLUMN IF NOT EXISTS secret_encrypted TEXT NOT NULL DEFAULT ''\";\nconst WEBHOOK_SECRET_DROP = \"ALTER TABLE webhooks DROP COLUMN IF EXISTS secret\";\nconst TOKEN_USER_ALTER =\n  \"ALTER TABLE tokens ADD COLUMN IF NOT EXISTS user_id TEXT REFERENCES users(id) ON DELETE CASCADE\";\nconst MEMBER_SOURCE_ALTER =\n  \"ALTER TABLE project_members ADD COLUMN IF NOT EXISTS source TEXT NOT NULL DEFAULT 'manual'\";\n/**\n * Re-runs share `(project_id, git_sha)` by design (ULID build ids), so the\n * lookup index must not be unique. Existing databases created it UNIQUE —\n * drop and recreate it plain.\n */\nconst BUILDS_GITSHA_DEDUP = \"DROP INDEX IF EXISTS builds_project_gitsha_idx\";\nconst BUILDS_GITSHA_INDEX =\n  \"CREATE INDEX IF NOT EXISTS builds_project_gitsha_idx ON builds (project_id, git_sha)\";\n\nasync function migrateSnapshotColumns(run: MigrationRunner): Promise<void> {\n  await execIgnore(run, SNAPSHOT_INFRA_HASH_ALTER);\n  await execIgnore(run, SNAPSHOT_INHERITED_ALTER);\n  await execIgnore(run, SNAPSHOT_BASELINE_ID_ALTER);\n  await execIgnore(run, SNAPSHOT_BASELINE_VERSION_ALTER);\n}\n\nasync function migrateProjectExtras(run: MigrationRunner): Promise<void> {\n  await execIgnore(run, EXECUTE_PLAY_ALTER);\n  await execIgnore(run, PLAY_TIMEOUT_MS_ALTER);\n  await execIgnore(run, PROJECT_AUTOMIGRATE_ALTER);\n  await migrateSnapshotColumns(run);\n  await execIgnore(run, BASELINE_INFRA_HASH_ALTER);\n  await execIgnore(run, BUILD_AFFECTED_ONLY_ALTER);\n  await execIgnore(run, BUILD_BASELINE_SHA_ALTER);\n  await execIgnore(run, BUILD_CHANGED_FILES_ALTER);\n  await execIgnore(run, BUILD_AFFECTED_PATHS_ALTER);\n}\n\n/** Run the full migration set through any row-query runner. */\nexport async function runMigrations(run: MigrationRunner): Promise<void> {\n  await run(DDL);\n  await migrateCoreColumns(run);\n  await migrateProjectExtras(run);\n  await migrateCommentsTable(run);\n}\n\nasync function migrateCoreColumns(run: MigrationRunner): Promise<void> {\n  await execIgnore(run, STORYBOOK_META_ALTER);\n  await execIgnore(run, RUN_A11Y_ALTER);\n  await execIgnore(run, PROJECT_BROWSER_ALTER);\n  await execIgnore(run, PROJECT_VIEWPORTS_ALTER);\n  await execIgnore(run, WEBHOOK_SECRET_ALTER);\n  await execIgnore(run, WEBHOOK_SECRET_DROP);\n  await execIgnore(run, TOKEN_USER_ALTER);\n  await execIgnore(run, MEMBER_SOURCE_ALTER);\n  await execIgnore(run, BUILDS_GITSHA_DEDUP);\n  await execIgnore(run, BUILDS_GITSHA_INDEX);\n}\n\nasync function execIgnore(run: MigrationRunner, sql: string): Promise<void> {\n  try {\n    await run(sql);\n  } catch {\n    // idempotent — already migrated\n  }\n}\n\nasync function migrateCommentsTable(run: MigrationRunner): Promise<void> {\n  try {\n    const rows = (await run(\n      \"SELECT is_nullable FROM information_schema.columns WHERE table_name='comments' AND column_name='user_id'\",\n    )) as { is_nullable: string }[];\n    const isNullable = rows[0]?.is_nullable;\n    if (isNullable === \"YES\" || isNullable === undefined) {\n      return;\n    }\n    await run(\"ALTER TABLE comments ALTER COLUMN user_id DROP NOT NULL\");\n  } catch {\n    // already nullable or table missing — ignore\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAYA,MAAM,uBAAuB;AAC7B,MAAM,qBACJ;AACF,MAAM,wBACJ;AACF,MAAM,iBACJ;AACF,MAAM,wBACJ;AACF,MAAM,0BAA0B;AAChC,MAAM,4BACJ;AACF,MAAM,4BAA4B;AAClC,MAAM,2BACJ;AACF,MAAM,6BACJ;AACF,MAAM,kCACJ;AACF,MAAM,4BAA4B;AAClC,MAAM,4BACJ;AACF,MAAM,2BAA2B;AACjC,MAAM,4BAA4B;AAClC,MAAM,6BACJ;AACF,MAAM,uBACJ;AACF,MAAM,sBAAsB;AAC5B,MAAM,mBACJ;AACF,MAAM,sBACJ;;;;;;AAMF,MAAM,sBAAsB;AAC5B,MAAM,sBACJ;AAEF,eAAe,uBAAuB,KAAqC;CACzE,MAAM,WAAW,KAAK,yBAAyB;CAC/C,MAAM,WAAW,KAAK,wBAAwB;CAC9C,MAAM,WAAW,KAAK,0BAA0B;CAChD,MAAM,WAAW,KAAK,+BAA+B;AACvD;AAEA,eAAe,qBAAqB,KAAqC;CACvE,MAAM,WAAW,KAAK,kBAAkB;CACxC,MAAM,WAAW,KAAK,qBAAqB;CAC3C,MAAM,WAAW,KAAK,yBAAyB;CAC/C,MAAM,uBAAuB,GAAG;CAChC,MAAM,WAAW,KAAK,yBAAyB;CAC/C,MAAM,WAAW,KAAK,yBAAyB;CAC/C,MAAM,WAAW,KAAK,wBAAwB;CAC9C,MAAM,WAAW,KAAK,yBAAyB;CAC/C,MAAM,WAAW,KAAK,0BAA0B;AAClD;;AAGA,eAAsB,cAAc,KAAqC;CACvE,MAAM,IAAI,GAAG;CACb,MAAM,mBAAmB,GAAG;CAC5B,MAAM,qBAAqB,GAAG;CAC9B,MAAM,qBAAqB,GAAG;AAChC;AAEA,eAAe,mBAAmB,KAAqC;CACrE,MAAM,WAAW,KAAK,oBAAoB;CAC1C,MAAM,WAAW,KAAK,cAAc;CACpC,MAAM,WAAW,KAAK,qBAAqB;CAC3C,MAAM,WAAW,KAAK,uBAAuB;CAC7C,MAAM,WAAW,KAAK,oBAAoB;CAC1C,MAAM,WAAW,KAAK,mBAAmB;CACzC,MAAM,WAAW,KAAK,gBAAgB;CACtC,MAAM,WAAW,KAAK,mBAAmB;CACzC,MAAM,WAAW,KAAK,mBAAmB;CACzC,MAAM,WAAW,KAAK,mBAAmB;AAC3C;AAEA,eAAe,WAAW,KAAsB,KAA4B;CAC1E,IAAI;EACF,MAAM,IAAI,GAAG;CACf,QAAQ,CAER;AACF;AAEA,eAAe,qBAAqB,KAAqC;CACvE,IAAI;EAIF,MAAM,cAAa,MAHC,IAClB,0GACF,EAAA,CACwB,EAAE,EAAE;EAC5B,IAAI,eAAe,SAAS,eAAe,KAAA,GACzC;EAEF,MAAM,IAAI,yDAAyD;CACrE,QAAQ,CAER;AACF"}

package/dist/neon-http.d.mts

@@ -0,0 +1,27 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { NeonQueryFunction } from "@neondatabase/serverless";
+import { DatabaseAdapter } from "@storyshelf/core/adapter/database";
+//#region src/neon-http.d.ts
+/**
+ * Options for creating a Neon-HTTP-backed DatabaseAdapter.
+ *
+ * When `client` (a `neon()` query function) is supplied, `url` is ignored
+ * and the caller owns the lifecycle of the client (teardown is a no-op).
+ */
+interface NeonHttpDatabaseOptions {
+  url?: string;
+  connectionString?: string;
+  client?: NeonQueryFunction<false, false>;
+}
+/**
+ * Create a Neon-HTTP-backed DatabaseAdapter using Drizzle ORM.
+ *
+ * @param options - Either a connection `url` or a preconfigured `neon()`
+ * query function.
+ * @returns A DatabaseAdapter backed by the Neon database.
+ */
+declare function createNeonHttpDatabase(options: NeonHttpDatabaseOptions): DatabaseAdapter;
+//#endregion
+export { NeonHttpDatabaseOptions, createNeonHttpDatabase };
+//# sourceMappingURL=neon-http.d.mts.map

package/dist/neon-http.mjs

@@ -0,0 +1,66 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { createDrizzlePgAdapter } from "./drizzle-factory-pg.mjs";
+import { runMigrations } from "./migrate.mjs";
+import { schema } from "./schema.mjs";
+import { neon } from "@neondatabase/serverless";
+import { drizzle } from "drizzle-orm/neon-http";
+//#region src/neon-http.ts
+/**
+* Neon HTTP preset for the Postgres database adapter.
+*
+* Same schema, DDL, and Drizzle factory as the `postgres.js` default, but
+* over Neon's fetch-based HTTP driver — no sockets, so it runs in hard
+* serverless and edge runtimes (Cloudflare Workers, Vercel Edge) where
+* WebSockets are unavailable. Requires the optional
+* `@neondatabase/serverless` peer (`nub add @neondatabase/serverless`).
+*
+* Note: HTTP has no interactive transactions; drizzle emulates `transact`
+* sequentially per call. Concurrent writers should prefer `./neon`.
+*/
+/**
+* Create a Neon-HTTP-backed DatabaseAdapter using Drizzle ORM.
+*
+* @param options - Either a connection `url` or a preconfigured `neon()`
+* query function.
+* @returns A DatabaseAdapter backed by the Neon database.
+*/
+function createNeonHttpDatabase(options) {
+	const { sql } = resolveClient(options);
+	const db = drizzle(sql, { schema });
+	return createDrizzlePgAdapter(db, {
+		metadata: {
+			name: "Neon HTTP",
+			version: globalThis.__PKG_VERSION__ ?? "0.0.0",
+			description: "Neon Postgres database adapter (HTTP driver + Drizzle)",
+			kind: "neon-http",
+			category: "database"
+		},
+		tables: schema,
+		migrate: async () => {
+			await runMigrations(async (statement) => await sql.query(statement));
+		},
+		close: () => {},
+		ping: async () => {
+			await sql.query("SELECT 1");
+		}
+	});
+}
+/** Resolve the query function, distinguishing caller-owned from owned. */
+function resolveClient(options) {
+	if (options.client) return {
+		sql: options.client,
+		owned: false
+	};
+	const connectionString = options.connectionString ?? options.url;
+	if (!connectionString) throw new Error("createNeonHttpDatabase: provide `url` (or `connectionString`) or a preconfigured `client`");
+	return {
+		sql: neon(connectionString),
+		owned: true
+	};
+}
+//#endregion
+export { createNeonHttpDatabase };
+
+//# sourceMappingURL=neon-http.mjs.map

package/dist/neon-http.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"neon-http.mjs","names":[],"sources":["../src/neon-http.ts"],"sourcesContent":["/**\n * Neon HTTP preset for the Postgres database adapter.\n *\n * Same schema, DDL, and Drizzle factory as the `postgres.js` default, but\n * over Neon's fetch-based HTTP driver — no sockets, so it runs in hard\n * serverless and edge runtimes (Cloudflare Workers, Vercel Edge) where\n * WebSockets are unavailable. Requires the optional\n * `@neondatabase/serverless` peer (`nub add @neondatabase/serverless`).\n *\n * Note: HTTP has no interactive transactions; drizzle emulates `transact`\n * sequentially per call. Concurrent writers should prefer `./neon`.\n */\nimport { neon, type NeonQueryFunction } from \"@neondatabase/serverless\";\nimport type { DatabaseAdapter } from \"@storyshelf/core/adapter/database\";\nimport { drizzle } from \"drizzle-orm/neon-http\";\nimport { createDrizzlePgAdapter } from \"./drizzle-factory-pg.ts\";\nimport { runMigrations } from \"./migrate.ts\";\nimport { schema } from \"./schema/index.ts\";\n\ndeclare const __PKG_VERSION__: string | undefined;\n\n/**\n * Options for creating a Neon-HTTP-backed DatabaseAdapter.\n *\n * When `client` (a `neon()` query function) is supplied, `url` is ignored\n * and the caller owns the lifecycle of the client (teardown is a no-op).\n */\nexport interface NeonHttpDatabaseOptions {\n  url?: string;\n  connectionString?: string;\n  client?: NeonQueryFunction<false, false>;\n}\n\n/**\n * Create a Neon-HTTP-backed DatabaseAdapter using Drizzle ORM.\n *\n * @param options - Either a connection `url` or a preconfigured `neon()`\n * query function.\n * @returns A DatabaseAdapter backed by the Neon database.\n */\nexport function createNeonHttpDatabase(options: NeonHttpDatabaseOptions): DatabaseAdapter {\n  const { sql } = resolveClient(options);\n  const db = drizzle(sql, { schema });\n\n  return createDrizzlePgAdapter(db, {\n    metadata: {\n      name: \"Neon HTTP\",\n      version: (globalThis as unknown as { __PKG_VERSION__?: string }).__PKG_VERSION__ ?? \"0.0.0\",\n      description: \"Neon Postgres database adapter (HTTP driver + Drizzle)\",\n      kind: \"neon-http\",\n      category: \"database\",\n    },\n    tables: schema,\n    migrate: async () => {\n      await runMigrations(async (statement) => await sql.query(statement));\n    },\n    close: () => {\n      // no-op: fetch-based queries hold no connections (owned or not)\n    },\n    ping: async () => {\n      await sql.query(\"SELECT 1\");\n    },\n  });\n}\n\n/** Resolve the query function, distinguishing caller-owned from owned. */\nfunction resolveClient(options: NeonHttpDatabaseOptions): {\n  sql: NeonQueryFunction<false, false>;\n  owned: boolean;\n} {\n  if (options.client) {\n    return { sql: options.client, owned: false };\n  }\n  const connectionString = options.connectionString ?? options.url;\n  if (!connectionString) {\n    throw new Error(\n      \"createNeonHttpDatabase: provide `url` (or `connectionString`) or a preconfigured `client`\",\n    );\n  }\n  return { sql: neon(connectionString), owned: true };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,uBAAuB,SAAmD;CACxF,MAAM,EAAE,QAAQ,cAAc,OAAO;CACrC,MAAM,KAAK,QAAQ,KAAK,EAAE,OAAO,CAAC;CAElC,OAAO,uBAAuB,IAAI;EAChC,UAAU;GACR,MAAM;GACN,SAAU,WAAuD,mBAAmB;GACpF,aAAa;GACb,MAAM;GACN,UAAU;EACZ;EACA,QAAQ;EACR,SAAS,YAAY;GACnB,MAAM,cAAc,OAAO,cAAc,MAAM,IAAI,MAAM,SAAS,CAAC;EACrE;EACA,aAAa,CAEb;EACA,MAAM,YAAY;GAChB,MAAM,IAAI,MAAM,UAAU;EAC5B;CACF,CAAC;AACH;;AAGA,SAAS,cAAc,SAGrB;CACA,IAAI,QAAQ,QACV,OAAO;EAAE,KAAK,QAAQ;EAAQ,OAAO;CAAM;CAE7C,MAAM,mBAAmB,QAAQ,oBAAoB,QAAQ;CAC7D,IAAI,CAAC,kBACH,MAAM,IAAI,MACR,2FACF;CAEF,OAAO;EAAE,KAAK,KAAK,gBAAgB;EAAG,OAAO;CAAK;AACpD"}

package/dist/neon.d.mts

@@ -0,0 +1,29 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Pool, PoolClient } from "@neondatabase/serverless";
+import { DatabaseAdapter } from "@storyshelf/core/adapter/database";
+//#region src/neon.d.ts
+/**
+ * Options for creating a Neon-backed DatabaseAdapter.
+ *
+ * When `client` (a `Pool` or `PoolClient`) is supplied, all other
+ * connection options are ignored and the caller owns the lifecycle of the
+ * client (teardown is a no-op). This is the hook for custom WebSocket
+ * constructors and hermetic tests.
+ */
+interface NeonDatabaseOptions {
+  url?: string;
+  connectionString?: string;
+  client?: Pool | PoolClient;
+}
+/**
+ * Create a Neon-backed DatabaseAdapter using Drizzle ORM.
+ *
+ * @param options - Either a connection `url` or a preconfigured Neon
+ * `client`.
+ * @returns A DatabaseAdapter backed by the Neon database.
+ */
+declare function createNeonDatabase(options: NeonDatabaseOptions): DatabaseAdapter;
+//#endregion
+export { NeonDatabaseOptions, createNeonDatabase };
+//# sourceMappingURL=neon.d.mts.map

package/dist/neon.mjs

@@ -0,0 +1,59 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { createDrizzlePgAdapter } from "./drizzle-factory-pg.mjs";
+import { runMigrations } from "./migrate.mjs";
+import { schema } from "./schema.mjs";
+import { Pool } from "@neondatabase/serverless";
+import { drizzle } from "drizzle-orm/neon-serverless";
+//#region src/neon.ts
+/**
+* Neon (WebSocket pool) preset for the Postgres database adapter.
+*
+* Same schema, DDL, and Drizzle factory as the `postgres.js` default; only
+* the driver differs (`@neondatabase/serverless` pooled connections work on
+* Node and edge runtimes with a WebSocket constructor). Requires the
+* optional `@neondatabase/serverless` peer (`nub add @neondatabase/serverless`).
+*/
+/**
+* Create a Neon-backed DatabaseAdapter using Drizzle ORM.
+*
+* @param options - Either a connection `url` or a preconfigured Neon
+* `client`.
+* @returns A DatabaseAdapter backed by the Neon database.
+*/
+function createNeonDatabase(options) {
+	const connectionString = options.connectionString ?? options.url;
+	if (!options.client && !connectionString) throw new Error("createNeonDatabase: provide `url` (or `connectionString`) or a preconfigured `client`");
+	const owned = !options.client;
+	const pool = options.client ?? new Pool({ connectionString });
+	const db = drizzle(pool, { schema });
+	return createDrizzlePgAdapter(db, {
+		metadata: {
+			name: "Neon",
+			version: globalThis.__PKG_VERSION__ ?? "0.0.0",
+			description: "Neon Postgres database adapter (serverless driver + Drizzle)",
+			kind: "neon",
+			category: "database"
+		},
+		tables: schema,
+		migrate: async () => {
+			await runMigrations(async (sql) => (await pool.query(sql)).rows);
+		},
+		close: async () => {
+			if (owned) await endClient(pool);
+		},
+		ping: async () => {
+			await pool.query("SELECT 1");
+		}
+	});
+}
+/** Close an owned client: pools end, checked-out clients release. */
+async function endClient(pool) {
+	if ("end" in pool && typeof pool.end === "function") await pool.end();
+	else if ("release" in pool && typeof pool.release === "function") pool.release();
+}
+//#endregion
+export { createNeonDatabase };
+
+//# sourceMappingURL=neon.mjs.map

package/dist/neon.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"neon.mjs","names":[],"sources":["../src/neon.ts"],"sourcesContent":["/**\n * Neon (WebSocket pool) preset for the Postgres database adapter.\n *\n * Same schema, DDL, and Drizzle factory as the `postgres.js` default; only\n * the driver differs (`@neondatabase/serverless` pooled connections work on\n * Node and edge runtimes with a WebSocket constructor). Requires the\n * optional `@neondatabase/serverless` peer (`nub add @neondatabase/serverless`).\n */\nimport { Pool, type PoolClient } from \"@neondatabase/serverless\";\nimport type { DatabaseAdapter } from \"@storyshelf/core/adapter/database\";\nimport { drizzle } from \"drizzle-orm/neon-serverless\";\nimport { createDrizzlePgAdapter } from \"./drizzle-factory-pg.ts\";\nimport { runMigrations } from \"./migrate.ts\";\nimport { schema } from \"./schema/index.ts\";\n\ndeclare const __PKG_VERSION__: string | undefined;\n\n/**\n * Options for creating a Neon-backed DatabaseAdapter.\n *\n * When `client` (a `Pool` or `PoolClient`) is supplied, all other\n * connection options are ignored and the caller owns the lifecycle of the\n * client (teardown is a no-op). This is the hook for custom WebSocket\n * constructors and hermetic tests.\n */\nexport interface NeonDatabaseOptions {\n  url?: string;\n  connectionString?: string;\n  client?: Pool | PoolClient;\n}\n\n/**\n * Create a Neon-backed DatabaseAdapter using Drizzle ORM.\n *\n * @param options - Either a connection `url` or a preconfigured Neon\n * `client`.\n * @returns A DatabaseAdapter backed by the Neon database.\n */\nexport function createNeonDatabase(options: NeonDatabaseOptions): DatabaseAdapter {\n  const connectionString = options.connectionString ?? options.url;\n  if (!options.client && !connectionString) {\n    throw new Error(\n      \"createNeonDatabase: provide `url` (or `connectionString`) or a preconfigured `client`\",\n    );\n  }\n\n  const owned = !options.client;\n  const pool = options.client ?? new Pool({ connectionString });\n  const db = drizzle(pool, { schema });\n\n  return createDrizzlePgAdapter(db, {\n    metadata: {\n      name: \"Neon\",\n      version: (globalThis as unknown as { __PKG_VERSION__?: string }).__PKG_VERSION__ ?? \"0.0.0\",\n      description: \"Neon Postgres database adapter (serverless driver + Drizzle)\",\n      kind: \"neon\",\n      category: \"database\",\n    },\n    tables: schema,\n    migrate: async () => {\n      await runMigrations(async (sql) => (await pool.query(sql)).rows as unknown[]);\n    },\n    close: async () => {\n      if (owned) {\n        await endClient(pool);\n      }\n    },\n    ping: async () => {\n      await pool.query(\"SELECT 1\");\n    },\n  });\n}\n\n/** Close an owned client: pools end, checked-out clients release. */\nasync function endClient(pool: Pool | PoolClient): Promise<void> {\n  if (\"end\" in pool && typeof pool.end === \"function\") {\n    await pool.end();\n  } else if (\"release\" in pool && typeof pool.release === \"function\") {\n    pool.release();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,mBAAmB,SAA+C;CAChF,MAAM,mBAAmB,QAAQ,oBAAoB,QAAQ;CAC7D,IAAI,CAAC,QAAQ,UAAU,CAAC,kBACtB,MAAM,IAAI,MACR,uFACF;CAGF,MAAM,QAAQ,CAAC,QAAQ;CACvB,MAAM,OAAO,QAAQ,UAAU,IAAI,KAAK,EAAE,iBAAiB,CAAC;CAC5D,MAAM,KAAK,QAAQ,MAAM,EAAE,OAAO,CAAC;CAEnC,OAAO,uBAAuB,IAAI;EAChC,UAAU;GACR,MAAM;GACN,SAAU,WAAuD,mBAAmB;GACpF,aAAa;GACb,MAAM;GACN,UAAU;EACZ;EACA,QAAQ;EACR,SAAS,YAAY;GACnB,MAAM,cAAc,OAAO,SAAS,MAAM,KAAK,MAAM,GAAG,EAAA,CAAG,IAAiB;EAC9E;EACA,OAAO,YAAY;GACjB,IAAI,OACF,MAAM,UAAU,IAAI;EAExB;EACA,MAAM,YAAY;GAChB,MAAM,KAAK,MAAM,UAAU;EAC7B;CACF,CAAC;AACH;;AAGA,eAAe,UAAU,MAAwC;CAC/D,IAAI,SAAS,QAAQ,OAAO,KAAK,QAAQ,YACvC,MAAM,KAAK,IAAI;MACV,IAAI,aAAa,QAAQ,OAAO,KAAK,YAAY,YACtD,KAAK,QAAQ;AAEjB"}

package/dist/pg.d.mts

@@ -0,0 +1,33 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { Client, Pool, PoolClient } from "pg";
+import { DatabaseAdapter } from "@storyshelf/core/adapter/database";
+//#region src/pg.d.ts
+/**
+ * Options for creating a node-postgres-backed DatabaseAdapter.
+ *
+ * When `client` (a `Pool`, `Client`, or `PoolClient`) is supplied, all other
+ * connection options are ignored and the caller owns the lifecycle of the
+ * client (teardown is a no-op). This is the hook for IAM token refresh,
+ * Cloud SQL connectors, and hermetic tests.
+ */
+interface PgDatabaseOptions {
+  url?: string;
+  connectionString?: string;
+  ssl?: unknown;
+  max?: number;
+  idleTimeoutMillis?: number;
+  connectionTimeoutMillis?: number;
+  client?: Pool | Client | PoolClient;
+}
+/**
+ * Create a node-postgres-backed DatabaseAdapter using Drizzle ORM.
+ *
+ * @param options - Either a connection `url` (plus pooling/TLS options) or
+ * a preconfigured `pg` `client`.
+ * @returns A DatabaseAdapter backed by Postgres.
+ */
+declare function createPgDatabase(options: PgDatabaseOptions): DatabaseAdapter;
+//#endregion
+export { PgDatabaseOptions, createPgDatabase };
+//# sourceMappingURL=pg.d.mts.map

package/dist/pg.mjs

@@ -0,0 +1,56 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { createDrizzlePgAdapter } from "./drizzle-factory-pg.mjs";
+import { runMigrations } from "./migrate.mjs";
+import { schema } from "./schema.mjs";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+//#region src/pg.ts
+/**
+* Create a node-postgres-backed DatabaseAdapter using Drizzle ORM.
+*
+* @param options - Either a connection `url` (plus pooling/TLS options) or
+* a preconfigured `pg` `client`.
+* @returns A DatabaseAdapter backed by Postgres.
+*/
+function createPgDatabase(options) {
+	const connectionString = options.connectionString ?? options.url;
+	if (!options.client && !connectionString) throw new Error("createPgDatabase: provide `url` (or `connectionString`) or a preconfigured `client`");
+	const owned = !options.client;
+	const pool = options.client ?? new Pool({
+		connectionString,
+		ssl: options.ssl,
+		max: options.max,
+		idleTimeoutMillis: options.idleTimeoutMillis,
+		connectionTimeoutMillis: options.connectionTimeoutMillis
+	});
+	const db = drizzle(pool, { schema });
+	return createDrizzlePgAdapter(db, {
+		metadata: {
+			name: "Postgres (pg)",
+			version: globalThis.__PKG_VERSION__ ?? "0.0.0",
+			description: "Postgres database adapter (node-postgres + Drizzle)",
+			kind: "pg",
+			category: "database"
+		},
+		tables: schema,
+		migrate: async () => {
+			await runMigrations(async (sql) => (await pool.query(sql)).rows);
+		},
+		close: async () => {
+			if (owned) await endClient(pool);
+		},
+		ping: async () => {
+			await pool.query("SELECT 1");
+		}
+	});
+}
+/** Close an owned client: pools end, bare clients disconnect. */
+async function endClient(pool) {
+	if ("end" in pool && typeof pool.end === "function") await pool.end();
+}
+//#endregion
+export { createPgDatabase };
+
+//# sourceMappingURL=pg.mjs.map

package/dist/pg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg.mjs","names":[],"sources":["../src/pg.ts"],"sourcesContent":["/**\n * node-postgres preset for the Postgres database adapter.\n *\n * Same schema, DDL, and Drizzle factory as the `postgres.js` default; only\n * the driver differs. `node-postgres` uses unnamed portals, so it works\n * behind transaction-mode poolers (PgBouncer, Supavisor, Neon pooled)\n * without `prepare: false`, and it plugs into IAM flows (RDS token\n * password, Cloud SQL connector) that hand out `pg`-shaped clients.\n * Requires the optional `pg` peer (`nub add pg`).\n */\nimport type { DatabaseAdapter } from \"@storyshelf/core/adapter/database\";\nimport { drizzle } from \"drizzle-orm/node-postgres\";\nimport { Pool, type Client, type PoolClient } from \"pg\";\nimport { createDrizzlePgAdapter } from \"./drizzle-factory-pg.ts\";\nimport { runMigrations } from \"./migrate.ts\";\nimport { schema } from \"./schema/index.ts\";\n\ndeclare const __PKG_VERSION__: string | undefined;\n\n/**\n * Options for creating a node-postgres-backed DatabaseAdapter.\n *\n * When `client` (a `Pool`, `Client`, or `PoolClient`) is supplied, all other\n * connection options are ignored and the caller owns the lifecycle of the\n * client (teardown is a no-op). This is the hook for IAM token refresh,\n * Cloud SQL connectors, and hermetic tests.\n */\nexport interface PgDatabaseOptions {\n  url?: string;\n  connectionString?: string;\n  ssl?: unknown;\n  max?: number;\n  idleTimeoutMillis?: number;\n  connectionTimeoutMillis?: number;\n  client?: Pool | Client | PoolClient;\n}\n\n/**\n * Create a node-postgres-backed DatabaseAdapter using Drizzle ORM.\n *\n * @param options - Either a connection `url` (plus pooling/TLS options) or\n * a preconfigured `pg` `client`.\n * @returns A DatabaseAdapter backed by Postgres.\n */\nexport function createPgDatabase(options: PgDatabaseOptions): DatabaseAdapter {\n  const connectionString = options.connectionString ?? options.url;\n  if (!options.client && !connectionString) {\n    throw new Error(\n      \"createPgDatabase: provide `url` (or `connectionString`) or a preconfigured `client`\",\n    );\n  }\n\n  const owned = !options.client;\n  const pool =\n    options.client ??\n    new Pool({\n      connectionString,\n      ssl: options.ssl,\n      max: options.max,\n      idleTimeoutMillis: options.idleTimeoutMillis,\n      connectionTimeoutMillis: options.connectionTimeoutMillis,\n    });\n  const db = drizzle(pool, { schema });\n\n  return createDrizzlePgAdapter(db, {\n    metadata: {\n      name: \"Postgres (pg)\",\n      version: (globalThis as unknown as { __PKG_VERSION__?: string }).__PKG_VERSION__ ?? \"0.0.0\",\n      description: \"Postgres database adapter (node-postgres + Drizzle)\",\n      kind: \"pg\",\n      category: \"database\",\n    },\n    tables: schema,\n    migrate: async () => {\n      await runMigrations(async (sql) => (await pool.query(sql)).rows);\n    },\n    close: async () => {\n      if (owned) {\n        await endClient(pool);\n      }\n    },\n    ping: async () => {\n      await pool.query(\"SELECT 1\");\n    },\n  });\n}\n\n/** Close an owned client: pools end, bare clients disconnect. */\nasync function endClient(pool: Pool | Client | PoolClient): Promise<void> {\n  if (\"end\" in pool && typeof pool.end === \"function\") {\n    await (pool as Pool).end();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA4CA,SAAgB,iBAAiB,SAA6C;CAC5E,MAAM,mBAAmB,QAAQ,oBAAoB,QAAQ;CAC7D,IAAI,CAAC,QAAQ,UAAU,CAAC,kBACtB,MAAM,IAAI,MACR,qFACF;CAGF,MAAM,QAAQ,CAAC,QAAQ;CACvB,MAAM,OACJ,QAAQ,UACR,IAAI,KAAK;EACP;EACA,KAAK,QAAQ;EACb,KAAK,QAAQ;EACb,mBAAmB,QAAQ;EAC3B,yBAAyB,QAAQ;CACnC,CAAC;CACH,MAAM,KAAK,QAAQ,MAAM,EAAE,OAAO,CAAC;CAEnC,OAAO,uBAAuB,IAAI;EAChC,UAAU;GACR,MAAM;GACN,SAAU,WAAuD,mBAAmB;GACpF,aAAa;GACb,MAAM;GACN,UAAU;EACZ;EACA,QAAQ;EACR,SAAS,YAAY;GACnB,MAAM,cAAc,OAAO,SAAS,MAAM,KAAK,MAAM,GAAG,EAAA,CAAG,IAAI;EACjE;EACA,OAAO,YAAY;GACjB,IAAI,OACF,MAAM,UAAU,IAAI;EAExB;EACA,MAAM,YAAY;GAChB,MAAM,KAAK,MAAM,UAAU;EAC7B;CACF,CAAC;AACH;;AAGA,eAAe,UAAU,MAAiD;CACxE,IAAI,SAAS,QAAQ,OAAO,KAAK,QAAQ,YACvC,MAAO,KAAc,IAAI;AAE7B"}

package/dist/pglite.d.mts

@@ -0,0 +1,28 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { PGlite } from "@electric-sql/pglite";
+import { DatabaseAdapter } from "@storyshelf/core/adapter/database";
+//#region src/pglite.d.ts
+/**
+ * Options for creating a PGlite-backed DatabaseAdapter.
+ *
+ * When `client` (a `PGlite` instance) is supplied, `dataDir` is ignored and
+ * the caller owns the lifecycle of the client (teardown is a no-op). This is
+ * the hook for shared instances and for waiting on `client.waitReady` in
+ * tests. With no options, an ephemeral in-memory database is created.
+ */
+interface PgliteDatabaseOptions {
+  dataDir?: string;
+  client?: PGlite;
+}
+/**
+ * Create a PGlite-backed DatabaseAdapter using Drizzle ORM.
+ *
+ * @param options - Either a `dataDir` (use `"memory://"` for an ephemeral
+ * in-memory database, the default) or a preconfigured `PGlite` `client`.
+ * @returns A DatabaseAdapter backed by the embedded Postgres instance.
+ */
+declare function createPgliteDatabase(options?: PgliteDatabaseOptions): DatabaseAdapter;
+//#endregion
+export { PgliteDatabaseOptions, createPgliteDatabase };
+//# sourceMappingURL=pglite.d.mts.map

package/dist/pglite.mjs

@@ -0,0 +1,54 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { createDrizzlePgAdapter } from "./drizzle-factory-pg.mjs";
+import { runMigrations } from "./migrate.mjs";
+import { schema } from "./schema.mjs";
+import { PGlite } from "@electric-sql/pglite";
+import { drizzle } from "drizzle-orm/pglite";
+//#region src/pglite.ts
+/**
+* PGlite (embedded Postgres/WASM) preset for the Postgres database adapter.
+*
+* Same schema, DDL, and Drizzle factory as the `postgres.js` default; only
+* the driver differs (in-memory or `memory://` WASM Postgres, no server or
+* sockets). Useful for hermetic tests and zero-infra local dev. Requires
+* the optional `@electric-sql/pglite` peer (`nub add @electric-sql/pglite`).
+*/
+/**
+* Create a PGlite-backed DatabaseAdapter using Drizzle ORM.
+*
+* @param options - Either a `dataDir` (use `"memory://"` for an ephemeral
+* in-memory database, the default) or a preconfigured `PGlite` `client`.
+* @returns A DatabaseAdapter backed by the embedded Postgres instance.
+*/
+function createPgliteDatabase(options = {}) {
+	const owned = !options.client;
+	const client = options.client ?? new PGlite(options.dataDir ?? "memory://");
+	const db = drizzle(client, { schema });
+	return createDrizzlePgAdapter(db, {
+		metadata: {
+			name: "PGlite",
+			version: globalThis.__PKG_VERSION__ ?? "0.0.0",
+			description: "PGlite database adapter (embedded Postgres/WASM + Drizzle)",
+			kind: "pglite",
+			category: "database"
+		},
+		tables: schema,
+		migrate: async () => {
+			await runMigrations(async (sql) => {
+				return (await client.query(sql)).rows;
+			});
+		},
+		close: async () => {
+			if (owned) await client.close();
+		},
+		ping: async () => {
+			await client.query("SELECT 1");
+		}
+	});
+}
+//#endregion
+export { createPgliteDatabase };
+
+//# sourceMappingURL=pglite.mjs.map

package/dist/pglite.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pglite.mjs","names":[],"sources":["../src/pglite.ts"],"sourcesContent":["/**\n * PGlite (embedded Postgres/WASM) preset for the Postgres database adapter.\n *\n * Same schema, DDL, and Drizzle factory as the `postgres.js` default; only\n * the driver differs (in-memory or `memory://` WASM Postgres, no server or\n * sockets). Useful for hermetic tests and zero-infra local dev. Requires\n * the optional `@electric-sql/pglite` peer (`nub add @electric-sql/pglite`).\n */\nimport { PGlite } from \"@electric-sql/pglite\";\nimport type { DatabaseAdapter } from \"@storyshelf/core/adapter/database\";\nimport { drizzle } from \"drizzle-orm/pglite\";\nimport { createDrizzlePgAdapter } from \"./drizzle-factory-pg.ts\";\nimport { runMigrations } from \"./migrate.ts\";\nimport { schema } from \"./schema/index.ts\";\n\ndeclare const __PKG_VERSION__: string | undefined;\n\n/**\n * Options for creating a PGlite-backed DatabaseAdapter.\n *\n * When `client` (a `PGlite` instance) is supplied, `dataDir` is ignored and\n * the caller owns the lifecycle of the client (teardown is a no-op). This is\n * the hook for shared instances and for waiting on `client.waitReady` in\n * tests. With no options, an ephemeral in-memory database is created.\n */\nexport interface PgliteDatabaseOptions {\n  dataDir?: string;\n  client?: PGlite;\n}\n\n/**\n * Create a PGlite-backed DatabaseAdapter using Drizzle ORM.\n *\n * @param options - Either a `dataDir` (use `\"memory://\"` for an ephemeral\n * in-memory database, the default) or a preconfigured `PGlite` `client`.\n * @returns A DatabaseAdapter backed by the embedded Postgres instance.\n */\nexport function createPgliteDatabase(options: PgliteDatabaseOptions = {}): DatabaseAdapter {\n  const owned = !options.client;\n  const client = options.client ?? new PGlite(options.dataDir ?? \"memory://\");\n  const db = drizzle(client, { schema });\n\n  return createDrizzlePgAdapter(db, {\n    metadata: {\n      name: \"PGlite\",\n      version: (globalThis as unknown as { __PKG_VERSION__?: string }).__PKG_VERSION__ ?? \"0.0.0\",\n      description: \"PGlite database adapter (embedded Postgres/WASM + Drizzle)\",\n      kind: \"pglite\",\n      category: \"database\",\n    },\n    tables: schema,\n    migrate: async () => {\n      await runMigrations(async (sql) => {\n        const result = await client.query(sql);\n        // oxlint-disable-next-line typescript/no-unnecessary-type-assertion -- PGlite Row[] vs unknown[]\n        return result.rows as unknown as unknown[];\n      });\n    },\n    close: async () => {\n      if (owned) {\n        await client.close();\n      }\n    },\n    ping: async () => {\n      await client.query(\"SELECT 1\");\n    },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,qBAAqB,UAAiC,CAAC,GAAoB;CACzF,MAAM,QAAQ,CAAC,QAAQ;CACvB,MAAM,SAAS,QAAQ,UAAU,IAAI,OAAO,QAAQ,WAAW,WAAW;CAC1E,MAAM,KAAK,QAAQ,QAAQ,EAAE,OAAO,CAAC;CAErC,OAAO,uBAAuB,IAAI;EAChC,UAAU;GACR,MAAM;GACN,SAAU,WAAuD,mBAAmB;GACpF,aAAa;GACb,MAAM;GACN,UAAU;EACZ;EACA,QAAQ;EACR,SAAS,YAAY;GACnB,MAAM,cAAc,OAAO,QAAQ;IAGjC,QAAO,MAFc,OAAO,MAAM,GAAG,EAAA,CAEvB;GAChB,CAAC;EACH;EACA,OAAO,YAAY;GACjB,IAAI,OACF,MAAM,OAAO,MAAM;EAEvB;EACA,MAAM,YAAY;GAChB,MAAM,OAAO,MAAM,UAAU;EAC/B;CACF,CAAC;AACH"}