@rdlabo/workers-hono-kit 0.11.1 → 0.12.0-beta.pr48.sha371f5792ce8a

package/scripts/workspace-package-smoke.mjs

@@ -0,0 +1,206 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(fileURLToPath(new URL('../../..', import.meta.url)));
+const temporaryDirectory = mkdtempSync(join(tmpdir(), 'workers-workspace-smoke-'));
+const commandEnvironment = {
+  ...process.env,
+  npm_config_cache: join(temporaryDirectory, 'npm-cache'),
+};
+
+function pack(workspace) {
+  const args = ['pack', '--json', '--pack-destination', temporaryDirectory, '--workspace', workspace];
+  const result = JSON.parse(
+    execFileSync('npm', args, {
+      cwd: root,
+      encoding: 'utf8',
+      env: commandEnvironment,
+    }),
+  );
+  return join(temporaryDirectory, result[0].filename);
+}
+
+try {
+  const timezoneTarball = pack('@rdlabo/workers-timezone');
+  const mysqlTarball = pack('@rdlabo/workers-mysql');
+  const kitTarball = pack('@rdlabo/workers-hono-kit');
+  const rootConsumer = join(temporaryDirectory, 'root-consumer');
+  mkdirSync(rootConsumer);
+  writeFileSync(join(rootConsumer, 'package.json'), '{"private":true,"type":"module"}\n');
+  execFileSync('npm', ['install', '--ignore-scripts', kitTarball, 'ai-gateway-provider@^3.1.0'], {
+    cwd: rootConsumer,
+    stdio: 'inherit',
+    env: commandEnvironment,
+  });
+  if (existsSync(join(rootConsumer, 'node_modules', '@rdlabo', 'workers-timezone'))) {
+    throw new Error('The optional timezone peer was installed for a root consumer');
+  }
+  if (existsSync(join(rootConsumer, 'node_modules', 'drizzle-orm'))) {
+    throw new Error('The optional drizzle peer was installed for a root consumer');
+  }
+  if (existsSync(join(rootConsumer, 'node_modules', '@rdlabo', 'workers-mysql'))) {
+    throw new Error('The optional MySQL package was installed for a root consumer');
+  }
+  if (existsSync(join(rootConsumer, 'node_modules', 'mysql2'))) {
+    throw new Error('mysql2 was installed for a root consumer');
+  }
+  writeFileSync(
+    join(rootConsumer, 'smoke.mjs'),
+    `import * as kit from "@rdlabo/workers-hono-kit";
+const { HttpStatus } = kit;
+if (HttpStatus.OK !== 200) process.exit(1);
+if ("createContainerRuntime" in kit) process.exit(1);
+if ("retryWhenDeadlock" in kit) process.exit(1);
+// The legacy testing barrel intentionally requires the optional MySQL package.
+const { rejects } = await import("node:assert/strict");
+await rejects(import("@rdlabo/workers-hono-kit/testing"), (error) =>
+  error.code === "ERR_MODULE_NOT_FOUND" && error.message.includes("@rdlabo/workers-mysql"));
+`,
+  );
+  writeFileSync(
+    join(rootConsumer, 'smoke.ts'),
+    `import { HttpStatus } from "@rdlabo/workers-hono-kit";
+const ok: number = HttpStatus.OK;
+void ok;
+`,
+  );
+  writeFileSync(
+    join(rootConsumer, 'tsconfig.json'),
+    '{"compilerOptions":{"strict":true,"module":"ESNext","moduleResolution":"Bundler","target":"ES2022","noEmit":true,"skipLibCheck":true},"include":["smoke.ts"]}\n',
+  );
+  execFileSync('node', ['smoke.mjs'], { cwd: rootConsumer, stdio: 'inherit' });
+  execFileSync(join(root, 'node_modules', '.bin', 'tsc'), ['-p', 'tsconfig.json'], {
+    cwd: rootConsumer,
+    stdio: 'inherit',
+  });
+
+  const timezoneConsumer = join(temporaryDirectory, 'timezone-consumer');
+  mkdirSync(timezoneConsumer);
+  writeFileSync(join(timezoneConsumer, 'package.json'), '{"private":true,"type":"module"}\n');
+  execFileSync('npm', ['install', '--ignore-scripts', timezoneTarball, kitTarball, 'ai-gateway-provider@^3.1.0'], {
+    cwd: timezoneConsumer,
+    stdio: 'inherit',
+    env: commandEnvironment,
+  });
+  writeFileSync(
+    join(timezoneConsumer, 'smoke.mjs'),
+    `import { initializeTimezone, toLocalDateTime } from "@rdlabo/workers-timezone";
+import { getTimezoneConfig, toBusinessDateTime } from "@rdlabo/workers-hono-kit/business-time";
+initializeTimezone({ timeZone: "America/New_York" });
+const instant = new Date("2026-07-01T13:00:00Z");
+if (toLocalDateTime(instant) !== "2026-07-01 09:00:00") process.exit(1);
+if (toBusinessDateTime(instant) !== "2026-07-01 09:00:00") process.exit(1);
+if (getTimezoneConfig().timeZone !== "America/New_York") process.exit(1);
+`,
+  );
+  writeFileSync(
+    join(timezoneConsumer, 'smoke.ts'),
+    `import { type TimeZone } from "@rdlabo/workers-timezone";
+import { type BusinessTimeZone } from "@rdlabo/workers-hono-kit/business-time";
+const current: TimeZone = "Europe/London";
+const legacy: BusinessTimeZone = current;
+void legacy;
+`,
+  );
+  writeFileSync(
+    join(timezoneConsumer, 'tsconfig.json'),
+    '{"compilerOptions":{"strict":true,"module":"ESNext","moduleResolution":"Bundler","target":"ES2022","noEmit":true,"skipLibCheck":true},"include":["smoke.ts"]}\n',
+  );
+  execFileSync('node', ['smoke.mjs'], { cwd: timezoneConsumer, stdio: 'inherit' });
+  execFileSync(join(root, 'node_modules', '.bin', 'tsc'), ['-p', 'tsconfig.json'], {
+    cwd: timezoneConsumer,
+    stdio: 'inherit',
+  });
+
+  const mysqlCoreConsumer = join(temporaryDirectory, 'mysql-core-consumer');
+  mkdirSync(mysqlCoreConsumer);
+  writeFileSync(join(mysqlCoreConsumer, 'package.json'), '{"private":true,"type":"module"}\n');
+  execFileSync('npm', ['install', '--ignore-scripts', mysqlTarball, '@types/node@20.19.43'], {
+    cwd: mysqlCoreConsumer,
+    stdio: 'inherit',
+    env: commandEnvironment,
+  });
+  if (existsSync(join(mysqlCoreConsumer, 'node_modules', 'drizzle-orm'))) {
+    throw new Error('The optional drizzle peer was installed for a MySQL core consumer');
+  }
+  writeFileSync(
+    join(mysqlCoreConsumer, 'smoke.mjs'),
+    `import { MYSQL_TIMEZONE, toJstDate } from "@rdlabo/workers-mysql";
+if (MYSQL_TIMEZONE !== "+09:00") process.exit(1);
+if (toJstDate("1950-07-01T14:30:00Z") !== "1950-07-01") process.exit(1);
+`,
+  );
+  execFileSync('node', ['smoke.mjs'], { cwd: mysqlCoreConsumer, stdio: 'inherit' });
+  writeFileSync(
+    join(mysqlCoreConsumer, 'smoke.ts'),
+    'import { type Database, MYSQL_TIMEZONE } from "@rdlabo/workers-mysql";\ndeclare const db: Database<unknown>;\nvoid db; void MYSQL_TIMEZONE;\n',
+  );
+  writeFileSync(
+    join(mysqlCoreConsumer, 'tsconfig.json'),
+    '{"compilerOptions":{"strict":true,"module":"ESNext","moduleResolution":"Bundler","target":"ES2022","noEmit":true,"skipLibCheck":false},"include":["smoke.ts"]}\n',
+  );
+  execFileSync(join(root, 'node_modules', '.bin', 'tsc'), ['-p', 'tsconfig.json'], {
+    cwd: mysqlCoreConsumer,
+    stdio: 'inherit',
+  });
+
+  const databaseConsumer = join(temporaryDirectory, 'database-consumer');
+  mkdirSync(databaseConsumer);
+  writeFileSync(join(databaseConsumer, 'package.json'), '{"private":true,"type":"module"}\n');
+  execFileSync(
+    'npm',
+    ['install', '--ignore-scripts', mysqlTarball, kitTarball, 'drizzle-orm@^0.45.2', 'ai-gateway-provider@^3.1.0'],
+    {
+      cwd: databaseConsumer,
+      stdio: 'inherit',
+      env: commandEnvironment,
+    },
+  );
+  if (existsSync(join(databaseConsumer, 'node_modules', '@rdlabo', 'workers-timezone'))) {
+    throw new Error('The optional timezone peer was installed for a database-only consumer');
+  }
+  writeFileSync(
+    join(databaseConsumer, 'smoke.mjs'),
+    `import { MYSQL_TIMEZONE, toJstDate } from "@rdlabo/workers-mysql";
+import { workersDrizzleConfig } from "@rdlabo/workers-mysql/drizzle";
+import { MYSQL_TIMEZONE as legacyTimezone, toJstDate as legacyToJstDate } from "@rdlabo/workers-hono-kit/db";
+import { createContainerRuntime } from "@rdlabo/workers-hono-kit/mysql";
+import { FakeFirebaseVerifier, fakeKv } from "@rdlabo/workers-hono-kit/testing";
+if (typeof FakeFirebaseVerifier !== "function" || typeof fakeKv !== "function") process.exit(1);
+if (MYSQL_TIMEZONE !== "+09:00") process.exit(1);
+if (legacyTimezone !== MYSQL_TIMEZONE) process.exit(1);
+if (legacyToJstDate !== toJstDate) process.exit(1);
+if (toJstDate("1950-07-01T14:30:00Z") !== "1950-07-01") process.exit(1);
+if (workersDrizzleConfig({ database: "app" }).casing !== "snake_case") process.exit(1);
+if (typeof createContainerRuntime !== "function") process.exit(1);
+`,
+  );
+  writeFileSync(
+    join(databaseConsumer, 'smoke.ts'),
+    `import { MYSQL_TIMEZONE, toJstDate } from "@rdlabo/workers-mysql";
+import { workersDrizzleConfig } from "@rdlabo/workers-mysql/drizzle";
+import { createContainerRuntime } from "@rdlabo/workers-hono-kit/mysql";
+const timezone: string = MYSQL_TIMEZONE;
+const date: string | null = toJstDate("2026-07-01T00:00:00Z");
+const config = workersDrizzleConfig({ database: "app" });
+void timezone;
+void date;
+void config;
+void createContainerRuntime;
+`,
+  );
+  writeFileSync(
+    join(databaseConsumer, 'tsconfig.json'),
+    '{"compilerOptions":{"strict":true,"module":"ESNext","moduleResolution":"Bundler","target":"ES2022","noEmit":true,"skipLibCheck":true},"include":["smoke.ts"]}\n',
+  );
+  execFileSync('node', ['smoke.mjs'], { cwd: databaseConsumer, stdio: 'inherit' });
+  execFileSync(join(root, 'node_modules', '.bin', 'tsc'), ['-p', 'tsconfig.json'], {
+    cwd: databaseConsumer,
+    stdio: 'inherit',
+  });
+} finally {
+  rmSync(temporaryDirectory, { recursive: true, force: true });
+}

package/dist/business-time/types.d.ts

@@ -1,9 +0,0 @@
-/** A JST business calendar date `YYYY-MM-DD` (a calendar day, not an instant). */
-export type BusinessDate = string;
-/** A JST business date-time `YYYY-MM-DD HH:mm:ss` (a wall-clock value, MySQL `DATETIME`-compatible). */
-export type BusinessDateTime = string;
-/** JST business timezone constant. Workers run in UTC instants; business time is made explicit here. */
-export declare const BUSINESS_TIMEZONE: {
-    readonly iana: "Asia/Tokyo";
-    readonly offsetMinutes: 540;
-};

package/dist/business-time/types.js

@@ -1,5 +0,0 @@
-/** JST business timezone constant. Workers run in UTC instants; business time is made explicit here. */
-export const BUSINESS_TIMEZONE = {
-    iana: 'Asia/Tokyo',
-    offsetMinutes: 540,
-};

package/dist/db/columns.d.ts

@@ -1,38 +0,0 @@
-/**
- * SQL expression for `ON UPDATE CURRENT_TIMESTAMP` (the MySQL session clock).
- * customType columns have no `.onUpdateNow()`, so pair this with `.$onUpdateFn(() => jstOnUpdateNow(fsp))`.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `CURRENT_TIMESTAMP(fsp)`.
- */
-export declare const jstOnUpdateNow: (fsp?: number) => import("drizzle-orm").SQL<unknown>;
-/** MySQL `timestamp` — pass-through. A `Date` is formatted as JST by mysql2 via the connection `timezone:'+09:00'`. */
-export declare const jstTimestamp: (name: string, opts?: {
-    fsp?: number;
-}) => import("drizzle-orm/mysql-core").MySqlCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "MySqlCustomColumn";
-    data: string | Date;
-    driverParam: string | Date;
-    enumValues: undefined;
-}>;
-/** MySQL `datetime` — same pass-through policy as {@link jstTimestamp}. */
-export declare const jstDatetime: (name: string, opts?: {
-    fsp?: number;
-}) => import("drizzle-orm/mysql-core").MySqlCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "MySqlCustomColumn";
-    data: string | Date;
-    driverParam: string | Date;
-    enumValues: undefined;
-}>;
-/** MySQL `date` — on INSERT/UPDATE, normalizes ISO / empty strings to `YYYY-MM-DD` (via `toDriver`). */
-export declare const jstDate: (name: string) => import("drizzle-orm/mysql-core").MySqlCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "MySqlCustomColumn";
-    data: string | null;
-    driverParam: string | null;
-    enumValues: undefined;
-}>;

package/dist/db/columns.js

@@ -1,38 +0,0 @@
-/**
- * Shared Drizzle column helpers. Removes the need for a thin `custom-types.ts` / `columns.ts` wrapper
- * in each repo.
- *
- * @remarks
- * `drizzle-orm` is a **peer** (the consumer resolves a single copy); the kit does not bundle it. The
- * return types are the `customType` inference as-is (`MySqlCustomColumnBuilder<…>`) with no `any`, so
- * the column's semantic type (`string | Date`, etc.) propagates to the consumer table's `$inferSelect`.
- *
- * **Precondition (a single drizzle copy)**: Drizzle's `SQL` is a **nominal** type carrying a private
- * field `shouldInlineParams`, so if the kit and the consumer resolve different copies of drizzle,
- * `jstTimestamp(…).default(sql\`…\`)` fails with `TS2345: separate declarations of a private property
- * 'shouldInlineParams'`. The fleet references the kit via a `file:` link, which tends to nest a second
- * copy of drizzle under the kit. Pin `drizzle-orm` to the consumer's **own single copy** with tsconfig
- * `paths` (see the "Drizzle column helpers" section of the README). The published package (a single
- * copy) is already unified.
- *
- * **DEFAULT / ON UPDATE CURRENT_TIMESTAMP** is a server-side default (an INSERT / UPDATE that omits the
- * column). The connection's `timezone:'+09:00'` ({@link hyperdriveConnectionOptions}) only applies when
- * the **app binds a `Date`**. Do not conflate the two (see the `datetime-wire` / `drizzle-smoke` JST
- * tests).
- */
-import { sql } from 'drizzle-orm';
-import { customType } from 'drizzle-orm/mysql-core';
-import { jstDateParams, jstDatetimeParams, jstTimestampParams } from './jst.js';
-/**
- * SQL expression for `ON UPDATE CURRENT_TIMESTAMP` (the MySQL session clock).
- * customType columns have no `.onUpdateNow()`, so pair this with `.$onUpdateFn(() => jstOnUpdateNow(fsp))`.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `CURRENT_TIMESTAMP(fsp)`.
- */
-export const jstOnUpdateNow = (fsp) => fsp != null ? sql `(CURRENT_TIMESTAMP(${sql.raw(String(fsp))}))` : sql `(CURRENT_TIMESTAMP)`;
-/** MySQL `timestamp` — pass-through. A `Date` is formatted as JST by mysql2 via the connection `timezone:'+09:00'`. */
-export const jstTimestamp = (name, opts) => customType(jstTimestampParams(opts?.fsp))(name);
-/** MySQL `datetime` — same pass-through policy as {@link jstTimestamp}. */
-export const jstDatetime = (name, opts) => customType(jstDatetimeParams(opts?.fsp))(name);
-/** MySQL `date` — on INSERT/UPDATE, normalizes ISO / empty strings to `YYYY-MM-DD` (via `toDriver`). */
-export const jstDate = (name) => customType(jstDateParams())(name);

package/dist/db/connection.d.ts

@@ -1,74 +0,0 @@
-import type { Connection } from 'mysql2/promise';
-import type { ExecutionContextLike } from '../http/execution-context.js';
-export type { ExecutionContextLike } from '../http/execution-context.js';
-/**
- * Minimal structural shape of a Cloudflare Hyperdrive binding.
- *
- * @remarks
- * Declared structurally to avoid a dependency on `@cloudflare/workers-types`; any object with these
- * connection fields satisfies it.
- */
-export interface HyperdriveLike {
-    /** Database host to connect to. */
-    host: string;
-    /** Database user. */
-    user: string;
-    /** Database password. */
-    password: string;
-    /** Database name. */
-    database: string;
-    /** Database port. */
-    port: number;
-}
-/**
- * Build mysql2 `createConnection` options from a Hyperdrive binding, applying the kit's defaults.
- *
- * @remarks
- * Three defaults are applied and can each be overridden via `extra`:
- *
- * - `disableEval: true` — `eval` is unavailable in the Workers runtime, so the driver's eval-based
- *   fast paths must be disabled.
- * - `decimalNumbers: true` — return `DECIMAL`/`NEWDECIMAL` columns as JS `number` rather than
- *   strings, so raw-SQL reads and Drizzle's inferred types align on a single numeric domain type.
- *   This assumes no column's precision exceeds the JS safe-integer range.
- * - `timezone: '+09:00'` — interpret and serialize JavaScript `Date` values as JST. This is a
- *   mysql2 client-side conversion option; it does not issue `SET time_zone` or change the MySQL
- *   session timezone. Non-JST deployments can override it via `extra: { timezone: '...' }`.
- *
- * @param hyperdrive - the Hyperdrive binding to derive connection fields from.
- * @param extra - additional mysql2 options merged last, overriding the defaults above.
- * @returns a plain options object to pass to mysql2 `createConnection`.
- */
-export declare function hyperdriveConnectionOptions(hyperdrive: HyperdriveLike, extra?: Record<string, unknown>): Record<string, unknown>;
-/**
- * Open primary and replica connections in parallel and run `fn` with them.
- *
- * Cloudflare Workers automatically cleans up connections created during an invocation. Calling
- * `Connection.end()` is unnecessary and can race work registered with `waitUntil`. The `ctx`
- * parameter remains for API compatibility and is intentionally not used for connection teardown.
- *
- * @typeParam T - resolved value produced by `fn`.
- * @param hyperdrives - the primary and replica Hyperdrive bindings to connect to.
- * @param ctx - the request execution context, retained for API compatibility.
- * @param fn - callback invoked with the open `primary` and `replica` connections.
- * @param connectionOptions - extra mysql2 options forwarded to {@link hyperdriveConnectionOptions}.
- * @returns the value resolved by `fn`.
- * @example
- * ```ts
- * const data = await withMysqlConnections(
- *   { primary: env.PRIMARY, replica: env.REPLICA },
- *   ctx,
- *   async ({ primary, replica }) => {
- *     const [rows] = await replica.query('SELECT 1');
- *     return rows;
- *   },
- * );
- * ```
- */
-export declare function withMysqlConnections<T>(hyperdrives: {
-    primary: HyperdriveLike;
-    replica: HyperdriveLike;
-}, ctx: ExecutionContextLike, fn: (connections: {
-    primary: Connection;
-    replica: Connection;
-}) => Promise<T>, connectionOptions?: Record<string, unknown>): Promise<T>;

package/dist/db/connection.js

@@ -1,67 +0,0 @@
-import { createConnection } from 'mysql2/promise';
-import { MYSQL_TIMEZONE } from './jst.js';
-/**
- * Build mysql2 `createConnection` options from a Hyperdrive binding, applying the kit's defaults.
- *
- * @remarks
- * Three defaults are applied and can each be overridden via `extra`:
- *
- * - `disableEval: true` — `eval` is unavailable in the Workers runtime, so the driver's eval-based
- *   fast paths must be disabled.
- * - `decimalNumbers: true` — return `DECIMAL`/`NEWDECIMAL` columns as JS `number` rather than
- *   strings, so raw-SQL reads and Drizzle's inferred types align on a single numeric domain type.
- *   This assumes no column's precision exceeds the JS safe-integer range.
- * - `timezone: '+09:00'` — interpret and serialize JavaScript `Date` values as JST. This is a
- *   mysql2 client-side conversion option; it does not issue `SET time_zone` or change the MySQL
- *   session timezone. Non-JST deployments can override it via `extra: { timezone: '...' }`.
- *
- * @param hyperdrive - the Hyperdrive binding to derive connection fields from.
- * @param extra - additional mysql2 options merged last, overriding the defaults above.
- * @returns a plain options object to pass to mysql2 `createConnection`.
- */
-export function hyperdriveConnectionOptions(hyperdrive, extra) {
-    return {
-        host: hyperdrive.host,
-        user: hyperdrive.user,
-        password: hyperdrive.password,
-        database: hyperdrive.database,
-        port: hyperdrive.port,
-        disableEval: true,
-        decimalNumbers: true,
-        timezone: MYSQL_TIMEZONE,
-        ...extra,
-    };
-}
-/**
- * Open primary and replica connections in parallel and run `fn` with them.
- *
- * Cloudflare Workers automatically cleans up connections created during an invocation. Calling
- * `Connection.end()` is unnecessary and can race work registered with `waitUntil`. The `ctx`
- * parameter remains for API compatibility and is intentionally not used for connection teardown.
- *
- * @typeParam T - resolved value produced by `fn`.
- * @param hyperdrives - the primary and replica Hyperdrive bindings to connect to.
- * @param ctx - the request execution context, retained for API compatibility.
- * @param fn - callback invoked with the open `primary` and `replica` connections.
- * @param connectionOptions - extra mysql2 options forwarded to {@link hyperdriveConnectionOptions}.
- * @returns the value resolved by `fn`.
- * @example
- * ```ts
- * const data = await withMysqlConnections(
- *   { primary: env.PRIMARY, replica: env.REPLICA },
- *   ctx,
- *   async ({ primary, replica }) => {
- *     const [rows] = await replica.query('SELECT 1');
- *     return rows;
- *   },
- * );
- * ```
- */
-export async function withMysqlConnections(hyperdrives, ctx, fn, connectionOptions) {
-    void ctx;
-    const [primary, replica] = await Promise.all([
-        createConnection(hyperdriveConnectionOptions(hyperdrives.primary, connectionOptions)),
-        createConnection(hyperdriveConnectionOptions(hyperdrives.replica, connectionOptions)),
-    ]);
-    return fn({ primary, replica });
-}

package/dist/db/database.d.ts

@@ -1,222 +0,0 @@
-import type { Connection, Pool } from 'mysql2/promise';
-import type { HyperdriveLike } from './connection.js';
-/**
- * Dual-connection data layer that separates reads from writes.
- *
- * @remarks
- * The two sides of the database are deliberately handled differently:
- *
- * - Reads go to the **replica** as raw SQL (`QueryRunner.query`) by default, returning plain rows.
- *   Hyperdrive-backed databases also expose `query()` for freshness-sensitive primary SELECTs.
- * - Writes and transactions go to the **primary** through the Drizzle ORM for type safety, but only
- *   via `write(fn)` / `transaction(fn)` — the raw query builder is never exposed. The builder is
- *   awaited inside those methods, which removes a foot-gun: a Drizzle builder is a lazy thenable, so
- *   a bare `return builder` would silently become a no-op.
- *
- * Both sides retry on `ER_LOCK_DEADLOCK`.
- *
- * The kit deliberately avoids depending on the type identity of `drizzle-orm`: the consumer creates
- * the ORM instance with its own copy of `drizzle-orm` and passes it in, and {@link Database} is
- * generic over that ORM type (`TDrizzle`). This keeps the ORM's `MySqlTable`/`SQL` brands from
- * clashing even when the kit and the consumer resolve separate copies of `drizzle-orm`.
- */
-/**
- * Minimal connection interface used for reads.
- *
- * @remarks
- * A mysql2 `Connection` or `Pool` satisfies this structurally.
- */
-export interface QueryRunner {
-    /**
-     * Run a parameterized SQL query.
-     *
-     * @param sql - the SQL text, with `?` placeholders for `params`.
-     * @param params - optional positional parameters.
-     * @returns the driver's raw result (typically `[rows, fields]`).
-     */
-    query(sql: string, params?: unknown[]): Promise<unknown>;
-}
-/**
- * Extract the transaction-handle type that a Drizzle instance passes to its `.transaction(cb)`
- * callback.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- */
-export type TxOf<TDrizzle> = TDrizzle extends {
-    transaction(cb: (tx: infer Tx) => Promise<unknown>): Promise<unknown>;
-} ? Tx : unknown;
-/**
- * The read/write surface of the data layer.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type used for writes and transactions.
- * @typeParam TTx - the transaction-handle type, inferred from `TDrizzle` by default.
- */
-export interface Database<TDrizzle, TTx = TxOf<TDrizzle>> {
-    /**
-     * Run a raw SQL read against the replica. Hyperdrive-backed databases retry deadlocks and repeat
-     * the SELECT once on a fresh connection after mysql2 reports a fatal connection error.
-     *
-     * @typeParam T - the row shape.
-     * @param sql - the SQL text, with `?` placeholders for `params`.
-     * @param params - optional positional parameters.
-     * @returns the rows returned by the query.
-     */
-    read<T>(sql: string, params?: unknown[]): Promise<T[]>;
-    /**
-     * Run a single INSERT/UPDATE/DELETE against the primary, awaited with deadlock retry.
-     *
-     * @typeParam T - the value resolved by `fn`.
-     * @param fn - callback that receives the Drizzle ORM and returns the awaited write.
-     * @returns the value resolved by `fn`.
-     */
-    write<T>(fn: (dz: TDrizzle) => Promise<T>): Promise<T>;
-    /**
-     * Run multiple writes inside a single transaction; the whole transaction is retried on deadlock.
-     *
-     * @typeParam T - the value resolved by `fn`.
-     * @param fn - callback that receives the transaction handle and returns the awaited work.
-     * @returns the value resolved by `fn`.
-     */
-    transaction<T>(fn: (tx: TTx) => Promise<T>): Promise<T>;
-}
-/**
- * A {@link Database} that opens its own connections.
- *
- * @remarks
- * Used by variants that open connections internally. Lifecycle behavior depends on the backing
- * implementation: pool-backed databases close their pool, while Hyperdrive-backed databases leave
- * invocation-scoped connection cleanup to the Workers runtime.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @typeParam TTx - the transaction-handle type, inferred from `TDrizzle` by default.
- */
-export interface DisposableDatabase<TDrizzle, TTx = TxOf<TDrizzle>> extends Database<TDrizzle, TTx> {
-    /**
-     * Release resources owned by the implementation. Hyperdrive-backed databases keep this method as
-     * a compatibility no-op; pool-backed databases use it to close their pool.
-     *
-     * @returns a promise that resolves after implementation-specific cleanup.
-     */
-    dispose(): Promise<void>;
-}
-/**
- * A Hyperdrive-backed database with an explicit primary query path.
- *
- * @remarks
- * Use `query()` only for SELECTs that require read-after-write consistency or cannot use the
- * configured replica. Fatal connection errors recreate the primary connection and repeat the
- * SELECT at most once. Writes and transactions are never repeated for connection errors.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @typeParam TTx - the transaction-handle type, inferred from `TDrizzle` by default.
- */
-export interface HyperdriveDatabase<TDrizzle, TTx = TxOf<TDrizzle>> extends DisposableDatabase<TDrizzle, TTx> {
-    /**
-     * Run a raw SQL SELECT against the primary database.
-     *
-     * @typeParam T - the complete rows result type (for example, `User[]`).
-     * @param sql - the SQL text, with `?` placeholders for `params`.
-     * @param params - optional positional parameters.
-     * @returns the rows returned by the query, typed as `T`.
-     */
-    query<T = unknown>(sql: string, params?: unknown[]): Promise<T>;
-}
-/**
- * Options for {@link createMysqlDatabase}.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- */
-export interface CreateMysqlDatabaseOptions<TDrizzle> {
-    /**
-     * The Drizzle ORM used for writes, created by the consumer with its own `drizzle-orm`
-     * (e.g. `drizzle(primary, { schema, ... })`).
-     */
-    orm: TDrizzle;
-    /** The connection used for reads (raw SQL). */
-    replica: QueryRunner;
-}
-/**
- * Assemble a {@link Database} from an already-connected ORM and replica.
- *
- * @remarks
- * The caller (typically the worker entry point) owns creating the connections and the ORM, and is
- * responsible for closing the connections; this variant does not manage their lifecycle.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @param options - the write ORM and the read connection.
- * @returns a {@link Database} backed by the supplied ORM and replica.
- * @example
- * ```ts
- * const db = createMysqlDatabase({
- *   orm: drizzle(primary, { schema, ...DRIZZLE_ORM_OPTIONS }),
- *   replica,
- * });
- * const rows = await db.read<User>('SELECT * FROM users WHERE id = ?', [id]);
- * ```
- */
-export declare function createMysqlDatabase<TDrizzle>(options: CreateMysqlDatabaseOptions<TDrizzle>): Database<TDrizzle>;
-/**
- * Options for {@link createHyperdriveDatabase}.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- */
-export interface CreateHyperdriveDatabaseOptions<TDrizzle> {
-    /** The Hyperdrive binding for the primary (write) connection. */
-    primaryHyperdrive: HyperdriveLike;
-    /** The Hyperdrive binding for the replica (read) connection. */
-    replicaHyperdrive: HyperdriveLike;
-    /**
-     * Factory that builds the write ORM from the primary connection, using the consumer's
-     * `drizzle-orm`.
-     */
-    createOrm: (primary: Connection) => TDrizzle;
-    /**
-     * Extra options forwarded to mysql2 `createConnection`, merged on top of the defaults applied by
-     * {@link hyperdriveConnectionOptions} (`disableEval: true`, `decimalNumbers: true`, and
-     * `timezone: '+09:00'`). Pass a field here to override any of those defaults.
-     */
-    connectionOptions?: Record<string, unknown>;
-}
-/**
- * Create a {@link HyperdriveDatabase} that lazily opens its connections from Hyperdrive bindings.
- *
- * @remarks
- * Construct one per request. Connections and the ORM are created on first use and reused for the
- * lifetime of the instance. `read()` uses the replica, while `query()` provides an explicit
- * primary SELECT path. Workers automatically cleans up connections at the end of the invocation,
- * so callers do not need to close them manually. Either SELECT path is repeated once on a fresh
- * connection after a fatal mysql2 connection error. Writes and transactions are never repeated
- * for connection errors because their commit state can be ambiguous.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @param options - the primary/replica Hyperdrive bindings, the ORM factory, and connection options.
- * @returns a {@link HyperdriveDatabase} whose compatibility `dispose()` method is a no-op; Workers
- *   cleans up its invocation-scoped connections automatically.
- * @example
- * ```ts
- * const db = createHyperdriveDatabase({
- *   primaryHyperdrive: env.PRIMARY,
- *   replicaHyperdrive: env.REPLICA,
- *   createOrm: (primary) => drizzle(primary, { schema, ...DRIZZLE_ORM_OPTIONS }),
- * });
- * await db.write((dz) => dz.insert(users).values(user));
- * ```
- */
-export declare function createHyperdriveDatabase<TDrizzle>(options: CreateHyperdriveDatabaseOptions<TDrizzle>): HyperdriveDatabase<TDrizzle>;
-/**
- * Internal helper that assembles a {@link Database} from an ORM and a replica connection.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @param orm - the Drizzle ORM used for writes and transactions.
- * @param replica - the connection used for reads.
- * @returns a {@link Database} wiring reads to `replica` and writes to `orm`, both with deadlock retry.
- * @internal
- */
-export declare function databaseFrom<TDrizzle>(orm: TDrizzle, replica: QueryRunner): Database<TDrizzle>;
-/**
- * Re-export of the mysql2 `Connection` and `Pool` types.
- *
- * @remarks
- * Both are structurally assignable to the kit's {@link QueryRunner}.
- */
-export type { Connection, Pool };