@rdlabo/workers-hono-kit 0.3.7 → 0.4.2

package/src/cache/kv-cache.ts

@@ -1,316 +0,0 @@
-/**
- * Cache-aside helper backed by Cloudflare Workers KV.
- *
- * Provides a thin, JSON-serializing wrapper around a {@link KVNamespace} for the common
- * "look in cache, fall back to the source of truth" pattern. Reads and writes are best-effort:
- * any KV error, serialization failure, or oversized key is swallowed so callers transparently
- * fall through to their backing store instead of throwing.
- *
- * Cache keys are namespaced as `<appName><version><table>_<type>_<id>`, where a string `id` is
- * hashed with SHA-256 (hex) and a numeric `id` is used verbatim.
- *
- * @remarks
- * Workers KV enforces a 60-second minimum on `expirationTtl`, so every write clamps its lifetime
- * up to at least {@link KVCacheOptions.minTtlSeconds} (60 by default). Keys whose UTF-8 byte length
- * exceeds the KV 1024-byte limit are skipped entirely, leaving the value uncached.
- *
- * @example
- * ```ts
- * const cache = new KVCache(env.KV, { appName: 'myapp' });
- * const cached = await cache.get<User>('users', 'profile', userId);
- * if (!cached) {
- *   const user = await db.loadUser(userId);
- *   await cache.set('users', 'profile', userId, user);
- * }
- * ```
- */
-
-/**
- * Minimal subset of `@cloudflare/workers-types`' `KVNamespace` used by {@link KVCache}.
- *
- * Declared locally so consumers are not forced to depend on `@cloudflare/workers-types`. Only the
- * three operations the cache actually needs are modeled.
- */
-export interface KVNamespace {
-  /**
-   * Read the string value stored under `key`.
-   *
-   * @param key - Fully namespaced cache key.
-   * @returns The stored value, or `null` when the key is absent or expired.
-   */
-  get(key: string): Promise<string | null>;
-  /**
-   * Write `value` under `key`, optionally with a time-to-live.
-   *
-   * @param key - Fully namespaced cache key.
-   * @param value - String payload to store.
-   * @param options - Optional write options; `expirationTtl` is the lifetime in seconds.
-   * @returns A promise that resolves once the write is accepted.
-   */
-  put(key: string, value: string, options?: { expirationTtl?: number }): Promise<void>;
-  /**
-   * Remove the entry stored under `key`.
-   *
-   * @param key - Fully namespaced cache key.
-   * @returns A promise that resolves once the delete is accepted.
-   */
-  delete(key: string): Promise<void>;
-}
-
-/**
- * Configuration for a {@link KVCache} instance.
- */
-export interface KVCacheOptions {
-  /**
-   * Application-level key prefix used to isolate this app's entries within a shared namespace.
-   * For example `'myapp'`.
-   */
-  appName: string;
-  /**
-   * Schema/version prefix applied after {@link appName}, letting you invalidate every key at once
-   * by bumping it. Defaults to `'v8_'`.
-   */
-  version?: string;
-  /**
-   * Lower bound, in seconds, applied to every write's TTL. Matches the Workers KV 60-second
-   * minimum and defaults to `60`.
-   */
-  minTtlSeconds?: number;
-  /**
-   * Default TTL, in seconds, used by {@link KVCache.set} when no per-call `lifetime` is supplied.
-   * Defaults to `600`.
-   */
-  defaultLifetime?: number;
-}
-
-/**
- * A single entry to store via {@link KVCache.setMany}.
- *
- * @internal
- */
-interface CacheSetItem {
-  table: string;
-  type: string | number;
-  id: string | number;
-  data: unknown;
-  lifetime?: number;
-}
-
-/**
- * Key coordinates identifying a single entry for {@link KVCache.getMany}.
- *
- * @internal
- */
-interface CacheKeyItem {
-  table: string;
-  type: string | number;
-  id: string | number;
-}
-
-const encoder = new TextEncoder();
-
-/**
- * Compute the lowercase hex SHA-256 digest of a UTF-8 string.
- *
- * @param input - String to hash.
- * @returns The 64-character hex-encoded digest.
- * @internal
- */
-async function sha256Hex(input: string): Promise<string> {
-  const digest = await crypto.subtle.digest('SHA-256', encoder.encode(input));
-  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, '0')).join('');
-}
-
-/**
- * Cache-aside wrapper over a Workers {@link KVNamespace}.
- *
- * Serializes values to JSON, namespaces keys, and clamps TTLs to the KV minimum. All operations are
- * fail-soft: errors are swallowed so a cache miss or backend failure degrades to a source-of-truth
- * lookup rather than propagating.
- *
- * @example
- * ```ts
- * const cache = new KVCache(env.KV, { appName: 'myapp', defaultLifetime: 300 });
- * await cache.set('users', 'profile', 42, { name: 'Ada' });
- * const user = await cache.get<{ name: string }>('users', 'profile', 42);
- * ```
- */
-export class KVCache {
-  readonly #kv: KVNamespace;
-  readonly #appName: string;
-  readonly #version: string;
-  readonly #minTtl: number;
-  readonly #defaultLifetime: number;
-
-  /**
-   * Create a cache bound to a specific KV namespace.
-   *
-   * @param kv - The Workers KV namespace that backs this cache.
-   * @param options - Key-prefix and TTL configuration; see {@link KVCacheOptions}.
-   */
-  constructor(kv: KVNamespace, options: KVCacheOptions) {
-    this.#kv = kv;
-    this.#appName = options.appName;
-    this.#version = options.version ?? 'v8_';
-    this.#minTtl = options.minTtlSeconds ?? 60;
-    this.#defaultLifetime = options.defaultLifetime ?? 600;
-  }
-
-  /**
-   * Build the fully namespaced KV key for the given coordinates.
-   *
-   * A string `id` is hashed with SHA-256 (hex); a numeric `id` is used as-is.
-   *
-   * @param table - Logical table or entity name.
-   * @param type - Sub-key discriminator (e.g. lookup variant).
-   * @param id - Entity identifier; strings are hashed, numbers used verbatim.
-   * @returns The key, or `undefined` when it would exceed the KV 1024-byte limit.
-   * @internal
-   */
-  async #buildKey(table: string, type: string | number, id: string | number): Promise<string | undefined> {
-    const column = typeof id === 'string' ? await sha256Hex(id) : id;
-    const key = `${this.#appName}${this.#version}${table}_${type}_${column}`;
-    // KV keys are capped at 1024 bytes. Oversized keys are left uncached; cache-aside callers fall
-    // back to reading directly from their source of truth.
-    if (encoder.encode(key).byteLength > 1024) {
-      return undefined;
-    }
-    return key;
-  }
-
-  /**
-   * Read and JSON-parse a cached value.
-   *
-   * @typeParam T - Expected shape of the cached value.
-   * @param table - Logical table or entity name.
-   * @param type - Sub-key discriminator.
-   * @param id - Entity identifier.
-   * @returns The parsed value, or `undefined` on a miss, oversized key, or any read/parse error.
-   * @example
-   * ```ts
-   * const user = await cache.get<User>('users', 'profile', userId);
-   * ```
-   */
-  async get<T>(table: string, type: string | number, id: string | number): Promise<T | undefined> {
-    const key = await this.#buildKey(table, type, id);
-    if (!key) {
-      return undefined;
-    }
-    try {
-      const data = await this.#kv.get(key);
-      if (!data) {
-        return undefined;
-      }
-      return JSON.parse(data) as T;
-    } catch {
-      return undefined;
-    }
-  }
-
-  /**
-   * JSON-serialize and store a value.
-   *
-   * Falsy `data` is ignored. The effective TTL is `max(minTtlSeconds, lifetime ?? defaultLifetime)`,
-   * honoring the KV 60-second floor. Oversized keys and serialization/write failures are silently
-   * skipped.
-   *
-   * @param table - Logical table or entity name.
-   * @param type - Sub-key discriminator.
-   * @param id - Entity identifier.
-   * @param data - Value to cache; serialized with `JSON.stringify`.
-   * @param lifetime - Optional TTL in seconds; defaults to {@link KVCacheOptions.defaultLifetime}.
-   * @returns A promise that resolves once the write attempt completes.
-   * @example
-   * ```ts
-   * await cache.set('users', 'profile', userId, user, 300);
-   * ```
-   */
-  async set(
-    table: string,
-    type: string | number,
-    id: string | number,
-    data: unknown,
-    lifetime?: number,
-  ): Promise<void> {
-    if (!data) {
-      return;
-    }
-    const key = await this.#buildKey(table, type, id);
-    if (!key) {
-      return;
-    }
-    let payload: string;
-    try {
-      payload = JSON.stringify(data);
-    } catch {
-      return;
-    }
-    const ttl = Math.max(this.#minTtl, lifetime ?? this.#defaultLifetime);
-    await this.#kv.put(key, payload, { expirationTtl: ttl }).catch(() => undefined);
-  }
-
-  /**
-   * Store many values concurrently.
-   *
-   * Each item is written via {@link KVCache.set}, so the same fail-soft and TTL rules apply per item.
-   * An empty array is a no-op.
-   *
-   * @param items - Entries to store; see {@link CacheSetItem}.
-   * @returns A promise that resolves once every write attempt completes.
-   * @example
-   * ```ts
-   * await cache.setMany([
-   *   { table: 'users', type: 'profile', id: 1, data: userA },
-   *   { table: 'users', type: 'profile', id: 2, data: userB, lifetime: 120 },
-   * ]);
-   * ```
-   */
-  async setMany(items: CacheSetItem[]): Promise<void> {
-    if (items.length === 0) {
-      return;
-    }
-    await Promise.all(items.map((i) => this.set(i.table, i.type, i.id, i.data, i.lifetime)));
-  }
-
-  /**
-   * Read many values concurrently.
-   *
-   * @typeParam T - Expected shape of each cached value.
-   * @param items - Key coordinates to look up; see {@link CacheKeyItem}.
-   * @returns One `{ id, value }` pair per input item, preserving order; `value` is `undefined` on miss.
-   * @example
-   * ```ts
-   * const rows = await cache.getMany<User>([
-   *   { table: 'users', type: 'profile', id: 1 },
-   *   { table: 'users', type: 'profile', id: 2 },
-   * ]);
-   * ```
-   */
-  // The generic `T` is the caller-specified return type, mirroring `get<T>` for ergonomics.
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
-  async getMany<T>(items: CacheKeyItem[]): Promise<{ id: string | number; value: T | undefined }[]> {
-    return Promise.all(items.map(async (i) => ({ id: i.id, value: await this.get<T>(i.table, i.type, i.id) })));
-  }
-
-  /**
-   * Remove a cached entry.
-   *
-   * Oversized keys and delete failures are silently ignored.
-   *
-   * @param table - Logical table or entity name.
-   * @param type - Sub-key discriminator.
-   * @param id - Entity identifier.
-   * @returns A promise that resolves once the delete attempt completes.
-   * @example
-   * ```ts
-   * await cache.delete('users', 'profile', userId);
-   * ```
-   */
-  async delete(table: string, type: string | number, id: string | number): Promise<void> {
-    const key = await this.#buildKey(table, type, id);
-    if (!key) {
-      return;
-    }
-    await this.#kv.delete(key).catch(() => undefined);
-  }
-}

package/src/db/connection.ts

@@ -1,107 +0,0 @@
-import { createConnection } from 'mysql2/promise';
-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'` — set the driver's session timezone to JST. mysql2 defaults to `'local'`,
- *   which is UTC in the Workers runtime; pinning the driver timezone keeps `datetime`/`timestamp`
- *   round-trips independent of the database's session timezone (only the internally stored UTC
- *   value differs, which is invisible to the application). Non-JST deployments can override this
- *   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: HyperdriveLike,
-  extra?: Record<string, unknown>,
-): Record<string, unknown> {
-  return {
-    host: hyperdrive.host,
-    user: hyperdrive.user,
-    password: hyperdrive.password,
-    database: hyperdrive.database,
-    port: hyperdrive.port,
-    disableEval: true,
-    decimalNumbers: true,
-    timezone: '+09:00',
-    ...extra,
-  };
-}
-
-/**
- * Open primary and replica connections, run `fn` with them, and close both afterwards.
- *
- * The connections are always closed in a `finally` block; closing is scheduled through
- * `ctx.waitUntil` so it can complete after the response has been returned, without blocking it.
- *
- * @typeParam T - resolved value produced by `fn`.
- * @param hyperdrives - the primary and replica Hyperdrive bindings to connect to.
- * @param ctx - the execution context whose `waitUntil` defers connection teardown past the response.
- * @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<T>(
-  hyperdrives: { primary: HyperdriveLike; replica: HyperdriveLike },
-  ctx: ExecutionContextLike,
-  fn: (connections: { primary: Connection; replica: Connection }) => Promise<T>,
-  connectionOptions?: Record<string, unknown>,
-): Promise<T> {
-  let primary: Connection | undefined;
-  let replica: Connection | undefined;
-  try {
-    primary = await createConnection(hyperdriveConnectionOptions(hyperdrives.primary, connectionOptions));
-    replica = await createConnection(hyperdriveConnectionOptions(hyperdrives.replica, connectionOptions));
-    return await fn({ primary, replica });
-  } finally {
-    const closing = [primary, replica].filter((c): c is Connection => c !== undefined).map((c) => c.end());
-    if (closing.length > 0) {
-      ctx.waitUntil(Promise.allSettled(closing));
-    }
-  }
-}

package/src/db/database.ts

@@ -1,269 +0,0 @@
-import { createConnection } from 'mysql2/promise';
-import type { Connection, Pool } from 'mysql2/promise';
-import { hyperdriveConnectionOptions } from './connection.js';
-import type { HyperdriveLike } from './connection.js';
-import { retryWhenDeadlock } from './retry.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`) for transparency, returning plain
- *   rows.
- * - 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, with deadlock retry.
-   *
-   * @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 owns its connections and must be disposed.
- *
- * @remarks
- * Used by the variants that open connections internally (Hyperdrive- or Pool-backed).
- *
- * @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> {
-  /**
-   * Close the connections opened by this database.
-   *
-   * @returns a promise that settles once both connections are closed.
-   */
-  dispose(): Promise<void>;
-}
-
-interface DrizzleLike<TTx> {
-  transaction<T>(cb: (tx: TTx) => Promise<T>): 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 function createMysqlDatabase<TDrizzle>(options: CreateMysqlDatabaseOptions<TDrizzle>): Database<TDrizzle> {
-  return databaseFrom(options.orm, options.replica);
-}
-
-/**
- * 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 DisposableDatabase} that lazily opens its connections from Hyperdrive bindings.
- *
- * @remarks
- * Construct one per request and call `dispose()` after the response to close the connections.
- * Connections and the ORM are created on first use and reused for the lifetime of the instance; the
- * read/write/transaction surface is identical to {@link createMysqlDatabase}.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @param options - the primary/replica Hyperdrive bindings, the ORM factory, and connection options.
- * @returns a {@link DisposableDatabase} that must be disposed when done.
- * @example
- * ```ts
- * const db = createHyperdriveDatabase({
- *   primaryHyperdrive: env.PRIMARY,
- *   replicaHyperdrive: env.REPLICA,
- *   createOrm: (primary) => drizzle(primary, { schema, ...DRIZZLE_ORM_OPTIONS }),
- * });
- * try {
- *   await db.write((dz) => dz.insert(users).values(user));
- * } finally {
- *   await db.dispose();
- * }
- * ```
- */
-export function createHyperdriveDatabase<TDrizzle>(
-  options: CreateHyperdriveDatabaseOptions<TDrizzle>,
-): DisposableDatabase<TDrizzle> {
-  const { primaryHyperdrive, replicaHyperdrive, createOrm, connectionOptions } = options;
-  let primaryConn: Promise<Connection> | undefined;
-  let replicaConn: Promise<Connection> | undefined;
-  let orm: TDrizzle | undefined;
-
-  const primary = (): Promise<Connection> => (primaryConn ??= connect(primaryHyperdrive, connectionOptions));
-  const replica = (): Promise<Connection> => (replicaConn ??= connect(replicaHyperdrive, connectionOptions));
-  const ormFor = async (): Promise<TDrizzle> => (orm ??= createOrm(await primary()));
-
-  return {
-    read<T>(sql: string, params: unknown[] = []): Promise<T[]> {
-      return retryWhenDeadlock(async () => {
-        const [rows] = (await (await replica()).query(sql, params)) as [unknown, unknown];
-        return rows as T[];
-      });
-    },
-    async write<T>(fn: (dz: TDrizzle) => Promise<T>): Promise<T> {
-      const dz = await ormFor();
-      return retryWhenDeadlock(() => fn(dz));
-    },
-    async transaction<T>(fn: (tx: TxOf<TDrizzle>) => Promise<T>): Promise<T> {
-      const dz = (await ormFor()) as DrizzleLike<TxOf<TDrizzle>>;
-      return retryWhenDeadlock(() => dz.transaction(fn));
-    },
-    async dispose(): Promise<void> {
-      await Promise.all([primaryConn?.then((c) => c.end()), replicaConn?.then((c) => c.end())]);
-    },
-  };
-}
-
-/**
- * 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 function databaseFrom<TDrizzle>(orm: TDrizzle, replica: QueryRunner): Database<TDrizzle> {
-  const drizzleLike = orm as DrizzleLike<TxOf<TDrizzle>>;
-  return {
-    read<T>(sql: string, params: unknown[] = []): Promise<T[]> {
-      return retryWhenDeadlock(async () => {
-        const [rows] = (await replica.query(sql, params)) as [unknown, unknown];
-        return rows as T[];
-      });
-    },
-    write<T>(fn: (dz: TDrizzle) => Promise<T>): Promise<T> {
-      return retryWhenDeadlock(() => fn(orm));
-    },
-    transaction<T>(fn: (tx: TxOf<TDrizzle>) => Promise<T>): Promise<T> {
-      return retryWhenDeadlock(() => drizzleLike.transaction(fn));
-    },
-  };
-}
-
-/**
- * Re-export of the mysql2 `Connection` and `Pool` types.
- *
- * @remarks
- * Both are structurally assignable to the kit's {@link QueryRunner}.
- */
-export type { Connection, Pool };
-
-function connect(hyperdrive: HyperdriveLike, extra?: Record<string, unknown>): Promise<Connection> {
-  return createConnection(hyperdriveConnectionOptions(hyperdrive, extra));
-}