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

package/dist/db/database.js

@@ -1,146 +0,0 @@
-import { createConnection } from 'mysql2/promise';
-import { hyperdriveConnectionOptions } from './connection.js';
-import { retryWhenDeadlock } from './retry.js';
-/**
- * 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(options) {
-    return databaseFrom(options.orm, options.replica);
-}
-/**
- * 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 function createHyperdriveDatabase(options) {
-    const { primaryHyperdrive, replicaHyperdrive, createOrm, connectionOptions } = options;
-    let primaryConn;
-    let replicaConn;
-    let orm;
-    const primary = () => (primaryConn ??= connect(primaryHyperdrive, connectionOptions));
-    const replica = () => (replicaConn ??= connect(replicaHyperdrive, connectionOptions));
-    const ormFor = async () => (orm ??= createOrm(await primary()));
-    const readFrom = (connection, sql, params) => retryWhenDeadlock(async () => {
-        const [rows] = (await (await connection).query(sql, params));
-        return rows;
-    });
-    const readWithRecovery = async (connectionFor, reset, sql, params) => {
-        const connection = connectionFor();
-        const outcome = await readFrom(connection, sql, params).then((rows) => ({ ok: true, rows }), (error) => ({ ok: false, error }));
-        if (outcome.ok) {
-            return outcome.rows;
-        }
-        if (!isFatalConnectionError(outcome.error)) {
-            throw outcome.error;
-        }
-        reset(connection);
-        return readFrom(connectionFor(), sql, params);
-    };
-    return {
-        read(sql, params = []) {
-            return readWithRecovery(replica, (failedConnection) => {
-                if (replicaConn === failedConnection) {
-                    replicaConn = undefined;
-                }
-            }, sql, params);
-        },
-        query(sql, params = []) {
-            return readWithRecovery(primary, (failedConnection) => {
-                if (primaryConn === failedConnection) {
-                    primaryConn = undefined;
-                    orm = undefined;
-                }
-            }, sql, params);
-        },
-        async write(fn) {
-            const dz = await ormFor();
-            return retryWhenDeadlock(() => fn(dz));
-        },
-        async transaction(fn) {
-            const dz = (await ormFor());
-            return retryWhenDeadlock(() => dz.transaction(fn));
-        },
-        /** @deprecated Workers cleans up invocation-scoped connections automatically. */
-        async dispose() {
-            return;
-        },
-    };
-}
-/**
- * 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(orm, replica) {
-    const drizzleLike = orm;
-    return {
-        read(sql, params = []) {
-            return retryWhenDeadlock(async () => {
-                const [rows] = (await replica.query(sql, params));
-                return rows;
-            });
-        },
-        write(fn) {
-            return retryWhenDeadlock(() => fn(orm));
-        },
-        transaction(fn) {
-            return retryWhenDeadlock(() => drizzleLike.transaction(fn));
-        },
-    };
-}
-function connect(hyperdrive, extra) {
-    return createConnection(hyperdriveConnectionOptions(hyperdrive, extra));
-}
-function isFatalConnectionError(error) {
-    let current = error;
-    const seen = new Set();
-    while (typeof current === 'object' && current !== null && !seen.has(current)) {
-        seen.add(current);
-        const value = current;
-        if (value.fatal === true) {
-            return true;
-        }
-        current = value.cause;
-    }
-    return false;
-}

package/dist/db/jst.d.ts

@@ -1,45 +0,0 @@
-/**
- * JST wire conversion and DATE-column normalization for MySQL / Drizzle.
- *
- * @remarks
- * Business-time semantics are consolidated in {@link ../business-time/index.js | business-time}. This
- * module only owns the MySQL connection default, the DATE column's `toDriver`, and the column
- * `customType` params.
- */
-import type { BusinessDate } from '../business-time/index.js';
-/** Default mysql2 connection `timezone` (for the existing JST DB deployment). */
-export declare const MYSQL_TIMEZONE = "+09:00";
-/**
- * Normalize a client input to `YYYY-MM-DD` (a JST business calendar date) for a MySQL `DATE` column.
- * Accepts ISO 8601 / `YYYY-MM-DD` / empty strings. A `YYYY-MM-DD` value is passed through without
- * constructing a `Date`.
- *
- * @param value - the string or nullish input to normalize.
- * @returns the business date as `YYYY-MM-DD`, or `null` when the input cannot be resolved.
- */
-export declare function toJstDate(value: string | null | undefined): BusinessDate | null;
-/**
- * Build the params for a `customType` backing a MySQL `timestamp` column with `Date` pass-through.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `timestamp(fsp)`.
- */
-export declare const jstTimestampParams: (fsp?: number) => {
-    dataType: () => string;
-};
-/**
- * Build the params for a `customType` backing a MySQL `datetime` column with `Date` pass-through.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `datetime(fsp)`.
- */
-export declare const jstDatetimeParams: (fsp?: number) => {
-    dataType: () => string;
-};
-/**
- * Build the params for a `customType` backing a MySQL `date` column with JST normalization.
- *
- * @returns params with `toDriver` running {@link toJstDate}.
- */
-export declare const jstDateParams: () => {
-    dataType: () => string;
-    toDriver: (value: string | null) => string | null;
-};

package/dist/db/jst.js

@@ -1,47 +0,0 @@
-/**
- * JST wire conversion and DATE-column normalization for MySQL / Drizzle.
- *
- * @remarks
- * Business-time semantics are consolidated in {@link ../business-time/index.js | business-time}. This
- * module only owns the MySQL connection default, the DATE column's `toDriver`, and the column
- * `customType` params.
- */
-import { normalizeBusinessDate } from '../business-time/index.js';
-/** Default mysql2 connection `timezone` (for the existing JST DB deployment). */
-export const MYSQL_TIMEZONE = '+09:00';
-/**
- * Normalize a client input to `YYYY-MM-DD` (a JST business calendar date) for a MySQL `DATE` column.
- * Accepts ISO 8601 / `YYYY-MM-DD` / empty strings. A `YYYY-MM-DD` value is passed through without
- * constructing a `Date`.
- *
- * @param value - the string or nullish input to normalize.
- * @returns the business date as `YYYY-MM-DD`, or `null` when the input cannot be resolved.
- */
-export function toJstDate(value) {
-    return normalizeBusinessDate(value ?? null);
-}
-/**
- * Build the params for a `customType` backing a MySQL `timestamp` column with `Date` pass-through.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `timestamp(fsp)`.
- */
-export const jstTimestampParams = (fsp) => ({
-    dataType: () => (fsp != null ? `timestamp(${fsp})` : 'timestamp'),
-});
-/**
- * Build the params for a `customType` backing a MySQL `datetime` column with `Date` pass-through.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `datetime(fsp)`.
- */
-export const jstDatetimeParams = (fsp) => ({
-    dataType: () => (fsp != null ? `datetime(${fsp})` : 'datetime'),
-});
-/**
- * Build the params for a `customType` backing a MySQL `date` column with JST normalization.
- *
- * @returns params with `toDriver` running {@link toJstDate}.
- */
-export const jstDateParams = () => ({
-    dataType: () => 'date',
-    toDriver: (value) => toJstDate(value),
-});

package/dist/db/migrate.d.ts

@@ -1,51 +0,0 @@
-import type { QueryRunner } from './database.js';
-/** Identifying info for the baseline (i.e. first) migration. */
-export interface BaselineEntry {
-    /** The migration tag (e.g. `0000_melted_weapon_omega`). */
-    tag: string;
-    /** The `when` from `_journal.json` (= drizzle's `created_at` / `folderMillis`). */
-    when: number;
-    /** The sha256 of the raw `<tag>.sql` contents (the same algorithm as drizzle). */
-    hash: string;
-}
-/**
- * Read the baseline (first) entry from `migrationsFolder` (drizzle's `out`, e.g. `./drizzle`).
- *
- * @param migrationsFolder - the folder containing `meta/_journal.json` and `<tag>.sql`.
- * @returns the baseline entry (tag/when/hash).
- * @throws Error when the journal is missing, the entries are empty, or `<tag>.sql` is missing.
- */
-export declare function readBaselineEntry(migrationsFolder: string): BaselineEntry;
-/** Options for {@link baselineMigrations}. */
-export interface BaselineMigrationsOptions {
-    /** A QueryRunner for raw SQL (a mysql2 `Connection`/`Pool` is assignable). Must already be connected to the target DB. */
-    db: QueryRunner;
-    /** Drizzle's `out` folder (defaults to `./drizzle`). */
-    migrationsFolder?: string;
-}
-/** The result of {@link baselineMigrations}. */
-export type BaselineResult = {
-    status: 'inserted';
-    tag: string;
-    when: number;
-    hash: string;
-} | {
-    status: 'already-baselined';
-    tag: string;
-    when: number;
-};
-/**
- * Record the baseline (0000) as "applied" on an existing DB. Idempotent, with safety guards.
- *
- * @remarks
- * Guards:
- * - If a baseline marker (`created_at = when`) already exists → **no-op** (`already-baselined`).
- * - If there is no marker but `__drizzle_migrations` has other rows → **abort** (unexpected state).
- * - If the target DB has no base tables (an empty DB) → **abort** (skipping 0000 on an empty DB would
- *   never create the tables; use `db:migrate` for a fresh DB).
- *
- * @param options - the connection and migrations folder; see {@link BaselineMigrationsOptions}.
- * @returns whether a marker was inserted or the DB was already baselined.
- * @throws Error when one of the guards above trips.
- */
-export declare function baselineMigrations(options: BaselineMigrationsOptions): Promise<BaselineResult>;

package/dist/db/migrate.js

@@ -1,109 +0,0 @@
-/**
- * Brownfield baseline for Drizzle MySQL migrations.
- *
- * An existing (in-production) DB already has its schema, so running the committed baseline migration
- * (`drizzle/0000_*.sql` = the CREATE TABLE statements introspected from the current schema) via
- * `db:migrate` fails as every table collides. Instead, 0000 is **recorded as "applied" without being
- * executed**.
- *
- * How "applied" is decided (drizzle-orm/mysql-core dialect.migrate): it determines the pending set from
- * **only the maximum `created_at`** in `__drizzle_migrations(id, hash, created_at)`, running just the
- * migrations where `max(created_at) < entry.when`. The hash is stored but not used for the decision. So
- * inserting one row as the 0000 marker — `(hash, created_at = that entry's when)` — makes subsequent
- * `db:migrate` runs apply only the later 0001+ (larger `when`) and skip 0000. A fresh / test DB has no
- * marker, so the full chain runs (behavior unchanged).
- *
- * This function does not depend on `drizzle-orm` (it reads the journal/SQL itself and hashes with the
- * same sha256 as drizzle). It runs raw SQL against a QueryRunner (a mysql2 `Connection`/`Pool` is
- * structurally assignable).
- *
- * @packageDocumentation
- */
-import { createHash } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-/** The default migration-tracking table name used by drizzle. */
-const MIGRATIONS_TABLE = '__drizzle_migrations';
-/**
- * Read the baseline (first) entry from `migrationsFolder` (drizzle's `out`, e.g. `./drizzle`).
- *
- * @param migrationsFolder - the folder containing `meta/_journal.json` and `<tag>.sql`.
- * @returns the baseline entry (tag/when/hash).
- * @throws Error when the journal is missing, the entries are empty, or `<tag>.sql` is missing.
- */
-export function readBaselineEntry(migrationsFolder) {
-    const journalPath = join(migrationsFolder, 'meta', '_journal.json');
-    if (!existsSync(journalPath)) {
-        throw new Error(`Can't find meta/_journal.json under ${migrationsFolder}. Run \`drizzle-kit generate\` first.`);
-    }
-    const journal = JSON.parse(readFileSync(journalPath, 'utf8'));
-    const entries = journal.entries ?? [];
-    if (entries.length === 0) {
-        throw new Error(`No migration entries in ${journalPath}.`);
-    }
-    // The origin is always the first entry (0000). Later 0001+ are "new changes" that should run even on
-    // an existing DB.
-    const first = entries[0];
-    const sqlPath = join(migrationsFolder, `${first.tag}.sql`);
-    if (!existsSync(sqlPath)) {
-        throw new Error(`Can't find ${first.tag}.sql under ${migrationsFolder}.`);
-    }
-    const sql = readFileSync(sqlPath, 'utf8');
-    return { tag: first.tag, when: first.when, hash: createHash('sha256').update(sql).digest('hex') };
-}
-async function rowsOf(db, sql, params) {
-    const result = (await db.query(sql, params));
-    return result[0] ?? [];
-}
-/**
- * Record the baseline (0000) as "applied" on an existing DB. Idempotent, with safety guards.
- *
- * @remarks
- * Guards:
- * - If a baseline marker (`created_at = when`) already exists → **no-op** (`already-baselined`).
- * - If there is no marker but `__drizzle_migrations` has other rows → **abort** (unexpected state).
- * - If the target DB has no base tables (an empty DB) → **abort** (skipping 0000 on an empty DB would
- *   never create the tables; use `db:migrate` for a fresh DB).
- *
- * @param options - the connection and migrations folder; see {@link BaselineMigrationsOptions}.
- * @returns whether a marker was inserted or the DB was already baselined.
- * @throws Error when one of the guards above trips.
- */
-export async function baselineMigrations(options) {
-    const { db, migrationsFolder = './drizzle' } = options;
-    const baseline = readBaselineEntry(migrationsFolder);
-    // Same DDL as the migrator (a no-op if it already exists).
-    await db.query(`create table if not exists \`${MIGRATIONS_TABLE}\` (
-      id serial primary key,
-      hash text not null,
-      created_at bigint
-    )`);
-    // If a baseline marker already exists, this is an idempotent no-op.
-    const existing = await rowsOf(db, `select id from \`${MIGRATIONS_TABLE}\` where created_at = ? limit 1`, [
-        baseline.when,
-    ]);
-    if (existing.length > 0) {
-        return { status: 'already-baselined', tag: baseline.tag, when: baseline.when };
-    }
-    // No marker but rows exist = already in some other state. Abort to avoid misfiring.
-    const countRows = await rowsOf(db, `select count(*) as n from \`${MIGRATIONS_TABLE}\``);
-    const rowCount = Number(countRows[0]?.n ?? 0);
-    if (rowCount > 0) {
-        throw new Error(`${MIGRATIONS_TABLE} already has ${rowCount} row(s) but no baseline marker (created_at=${baseline.when}). ` +
-            `Migration state is unexpected — refusing to insert. Inspect \`${MIGRATIONS_TABLE}\` manually.`);
-    }
-    // Baselining an empty DB is dangerous (treating 0000 as skipped would never create the tables).
-    // Confirm this is a brownfield DB.
-    const tableRows = await rowsOf(db, `select count(*) as n from information_schema.tables
-      where table_schema = DATABASE() and table_type = 'BASE TABLE' and table_name <> ?`, [MIGRATIONS_TABLE]);
-    const baseTableCount = Number(tableRows[0]?.n ?? 0);
-    if (baseTableCount === 0) {
-        throw new Error(`Target DB has no base tables. baseline records 0000 as applied WITHOUT creating tables — this is only ` +
-            `for existing (brownfield) DBs. For a fresh/empty DB run \`drizzle-kit migrate\` instead.`);
-    }
-    await db.query(`insert into \`${MIGRATIONS_TABLE}\` (\`hash\`, \`created_at\`) values (?, ?)`, [
-        baseline.hash,
-        baseline.when,
-    ]);
-    return { status: 'inserted', tag: baseline.tag, when: baseline.when, hash: baseline.hash };
-}

package/dist/db/orm-config.d.ts

@@ -1,127 +0,0 @@
-/**
- * Centralizes Drizzle column-name casing so it is fixed (standard: `snake_case`) in both the
- * config and the runtime ORM.
- *
- * @remarks
- * Casing is configured in two distinct places:
- *
- * 1. The top-level `casing` in `drizzle.config.ts` decides the column names that `db:generate`
- *    **creates** (see {@link honoDrizzleConfig}).
- * 2. The `drizzle(conn, { …casing })` call decides the column names the **runtime write builder**
- *    resolves to (see {@link DRIZZLE_ORM_OPTIONS}).
- *
- * If these two disagree, a multi-word camelCase column without an explicit column name will be
- * generated with one name but queried with another, producing a runtime `Unknown column` error —
- * something neither the type-check nor the migration surface, so it is caught late. Sourcing both
- * from here makes the mismatch structurally impossible. Casing is ignored for columns that declare
- * an explicit name, so this is a pure safety net that does not change existing behavior.
- *
- * The runtime `drizzle()` call itself is made by the consuming app with its own `drizzle-orm`; the
- * kit only ever provides values, never the ORM instance, to avoid splitting `drizzle-orm` into two
- * copies and breaking type identity.
- */
-/**
- * Runtime ORM options shared by the consuming app's `drizzle()` call.
- *
- * Spread into the runtime ORM as `drizzle(conn, { schema, ...DRIZZLE_ORM_OPTIONS })` so the write
- * builder resolves column names as `snake_case`, matching what `db:generate` creates.
- *
- * @remarks
- * Fixes `mode: 'default'` and `casing: 'snake_case'`. See the module-level documentation for why
- * the same casing must be used by both the config and the runtime ORM.
- */
-export declare const DRIZZLE_ORM_OPTIONS: {
-    readonly mode: "default";
-    readonly casing: "snake_case";
-};
-/**
- * Options for {@link honoDrizzleConfig}.
- */
-export interface HonoDrizzleConfigOptions {
-    /** drizzle-kit `dbCredentials.database` — the database name to connect to. */
-    database: string;
-    /** Database host; defaults to `process.env.DB_HOST` then `127.0.0.1`. */
-    host?: string;
-    /** Database port; defaults to `process.env.DB_PORT` then `3306`. */
-    port?: number;
-    /** Database user; defaults to `process.env.DB_USER` then `root`. */
-    user?: string;
-    /** Database password; defaults to `process.env.DB_PASSWORD` then `root`. */
-    password?: string;
-    /** Path to the schema directory; defaults to `'./src/db/schemes'`. */
-    schema?: string;
-    /** Output directory for generated migrations; defaults to `'./drizzle'`. */
-    out?: string;
-    /**
-     * Optional table allow-list. Use this to restrict drizzle-kit to the schema's own tables when the
-     * database is shared with another application.
-     */
-    tablesFilter?: string[];
-    /**
-     * Optional `db:introspect` (DB → JS) casing. This is an independent axis from the generation-side
-     * `casing: 'snake_case'` and only affects introspection output.
-     */
-    introspect?: {
-        casing: 'camel' | 'preserve';
-    };
-}
-/**
- * Build a `drizzle.config.ts` configuration object with the kit's standard defaults.
- *
- * Fixes `casing: 'snake_case'`, the `schema`/`out` paths, and `dbCredentials` (with env-based
- * defaults), while leaving `tablesFilter` and `introspect` opt-in.
- *
- * @remarks
- * Returns a plain object rather than a typed drizzle-kit config so that `drizzle-kit` need not be a
- * dependency of the kit; the drizzle-kit CLI only reads the default export.
- *
- * @param options - configuration overrides; only `database` is required.
- * @returns a plain configuration object suitable for `export default` in `drizzle.config.ts`.
- * @example
- * ```ts
- * // drizzle.config.ts
- * import { honoDrizzleConfig } from '@rdlabo/workers-hono-kit/db';
- *
- * export default honoDrizzleConfig({ database: 'app' });
- * ```
- */
-export declare function honoDrizzleConfig(options: HonoDrizzleConfigOptions): {
-    dbCredentials: {
-        host: string;
-        port: number;
-        user: string;
-        password: string;
-        database: string;
-    };
-    introspect?: {
-        casing: "camel" | "preserve";
-    } | undefined;
-    tablesFilter?: string[] | undefined;
-    dialect: "mysql";
-    schema: string;
-    out: string;
-    casing: "snake_case";
-};
-/** The return value of {@link resolveDbSecret} (normalized connection info). */
-export interface ResolvedDbSecret {
-    host: string;
-    port: number;
-    dbname: string;
-    username: string;
-    password: string;
-}
-/**
- * Resolve an AWS RDS managed secret (a JSON string placed in `DB_SECRET`).
- *
- * @remarks
- * - `DB_SECRET` unset → `undefined` (the normal local / `db:generate` fallback).
- * - When set, it must be complete connection info: **invalid JSON / a missing required key throws**
- *   (rather than silently falling back to localhost and causing an incident). A missing `port` alone
- *   defaults to 3306.
- *
- * Both `honoDrizzleConfig` (db:migrate) and the `workers-hono-kit-db-baseline` bin use this same logic.
- *
- * @returns the resolved connection info, or `undefined` when `DB_SECRET` is unset.
- * @throws Error when `DB_SECRET` is set but is not valid JSON or is missing a required key.
- */
-export declare function resolveDbSecret(): ResolvedDbSecret | undefined;

package/dist/db/orm-config.js

@@ -1,122 +0,0 @@
-/**
- * Centralizes Drizzle column-name casing so it is fixed (standard: `snake_case`) in both the
- * config and the runtime ORM.
- *
- * @remarks
- * Casing is configured in two distinct places:
- *
- * 1. The top-level `casing` in `drizzle.config.ts` decides the column names that `db:generate`
- *    **creates** (see {@link honoDrizzleConfig}).
- * 2. The `drizzle(conn, { …casing })` call decides the column names the **runtime write builder**
- *    resolves to (see {@link DRIZZLE_ORM_OPTIONS}).
- *
- * If these two disagree, a multi-word camelCase column without an explicit column name will be
- * generated with one name but queried with another, producing a runtime `Unknown column` error —
- * something neither the type-check nor the migration surface, so it is caught late. Sourcing both
- * from here makes the mismatch structurally impossible. Casing is ignored for columns that declare
- * an explicit name, so this is a pure safety net that does not change existing behavior.
- *
- * The runtime `drizzle()` call itself is made by the consuming app with its own `drizzle-orm`; the
- * kit only ever provides values, never the ORM instance, to avoid splitting `drizzle-orm` into two
- * copies and breaking type identity.
- */
-/**
- * Runtime ORM options shared by the consuming app's `drizzle()` call.
- *
- * Spread into the runtime ORM as `drizzle(conn, { schema, ...DRIZZLE_ORM_OPTIONS })` so the write
- * builder resolves column names as `snake_case`, matching what `db:generate` creates.
- *
- * @remarks
- * Fixes `mode: 'default'` and `casing: 'snake_case'`. See the module-level documentation for why
- * the same casing must be used by both the config and the runtime ORM.
- */
-export const DRIZZLE_ORM_OPTIONS = { mode: 'default', casing: 'snake_case' };
-/**
- * Build a `drizzle.config.ts` configuration object with the kit's standard defaults.
- *
- * Fixes `casing: 'snake_case'`, the `schema`/`out` paths, and `dbCredentials` (with env-based
- * defaults), while leaving `tablesFilter` and `introspect` opt-in.
- *
- * @remarks
- * Returns a plain object rather than a typed drizzle-kit config so that `drizzle-kit` need not be a
- * dependency of the kit; the drizzle-kit CLI only reads the default export.
- *
- * @param options - configuration overrides; only `database` is required.
- * @returns a plain configuration object suitable for `export default` in `drizzle.config.ts`.
- * @example
- * ```ts
- * // drizzle.config.ts
- * import { honoDrizzleConfig } from '@rdlabo/workers-hono-kit/db';
- *
- * export default honoDrizzleConfig({ database: 'app' });
- * ```
- */
-export function honoDrizzleConfig(options) {
-    const { database, host, port, user, password, schema = './src/db/schemes', out = './drizzle', tablesFilter, introspect, } = options;
-    // CI/production migrate absorbs the pattern of passing a whole AWS Secrets Manager RDS managed secret
-    // (keys host/port/dbname/username/password) via `DB_SECRET`. It is parsed with JSON.parse, so key-name
-    // differences (host ≠ DB_HOST) can be mapped and special characters in the password stay shell-safe.
-    // When `DB_SECRET` is set, it is treated as a complete secret and fully determines the connection
-    // (missing/invalid → throw). Only when it is unset do we fall back to the individual DB_* env vars
-    // and then the defaults (the local / db:generate path).
-    const secret = resolveDbSecret();
-    const dbCredentials = secret
-        ? {
-            host: secret.host,
-            port: secret.port,
-            user: secret.username,
-            password: secret.password,
-            database: secret.dbname,
-        }
-        : {
-            host: host ?? process.env.DB_HOST ?? '127.0.0.1',
-            port: port ?? Number(process.env.DB_PORT ?? 3306),
-            user: user ?? process.env.DB_USER ?? 'root',
-            password: password ?? process.env.DB_PASSWORD ?? 'root',
-            database,
-        };
-    return {
-        dialect: 'mysql',
-        schema,
-        out,
-        casing: 'snake_case',
-        ...(tablesFilter ? { tablesFilter } : {}),
-        ...(introspect ? { introspect } : {}),
-        dbCredentials,
-    };
-}
-/**
- * Resolve an AWS RDS managed secret (a JSON string placed in `DB_SECRET`).
- *
- * @remarks
- * - `DB_SECRET` unset → `undefined` (the normal local / `db:generate` fallback).
- * - When set, it must be complete connection info: **invalid JSON / a missing required key throws**
- *   (rather than silently falling back to localhost and causing an incident). A missing `port` alone
- *   defaults to 3306.
- *
- * Both `honoDrizzleConfig` (db:migrate) and the `workers-hono-kit-db-baseline` bin use this same logic.
- *
- * @returns the resolved connection info, or `undefined` when `DB_SECRET` is unset.
- * @throws Error when `DB_SECRET` is set but is not valid JSON or is missing a required key.
- */
-export function resolveDbSecret() {
-    const raw = process.env.DB_SECRET;
-    if (!raw) {
-        return undefined;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        throw new Error('DB_SECRET is set but is not valid JSON (expected an AWS RDS managed secret string).');
-    }
-    const { host, dbname, username, password } = parsed;
-    if (typeof host !== 'string' ||
-        typeof dbname !== 'string' ||
-        typeof username !== 'string' ||
-        typeof password !== 'string') {
-        throw new Error('DB_SECRET must contain string host, dbname, username, password (AWS RDS managed secret shape).');
-    }
-    return { host, dbname, username, password, port: parsed.port === undefined ? 3306 : Number(parsed.port) };
-}

package/dist/db/retry.d.ts

@@ -1,28 +0,0 @@
-/**
- * Run an async unit of work, retrying it on MySQL deadlock errors with exponential backoff.
- *
- * Retries are triggered only by the `ER_LOCK_DEADLOCK` error code. Each failed attempt waits
- * `delay * attempt` milliseconds (linear growth of the base delay) before the next try, and any
- * non-deadlock error is rethrown immediately without retrying.
- *
- * @remarks
- * MySQL rolls back the entire transaction when it detects a deadlock, so re-running the same unit
- * of work is safe. Pass a `fn` that represents one complete unit — a single statement or an entire
- * transaction — because the whole `fn` is re-executed on each retry.
- *
- * @typeParam T - resolved value produced by `fn`.
- * @param fn - the unit of work to execute; it is invoked again from scratch on each retry.
- * @param retries - maximum number of attempts (default `3`).
- * @param delay - base backoff in milliseconds; attempt N waits `delay * N` (default `100`).
- * @returns the value resolved by the first successful call to `fn`.
- * @throws the last error thrown by `fn` once retries are exhausted, or any non-deadlock error on
- * the first occurrence.
- * @example
- * ```ts
- * await retryWhenDeadlock(() => db.transaction(async (tx) => {
- *   await tx.insert(orders).values(order);
- *   await tx.update(stock).set({ qty: sql`qty - 1` }).where(eq(stock.id, order.itemId));
- * }));
- * ```
- */
-export declare function retryWhenDeadlock<T>(fn: () => Promise<T>, retries?: number, delay?: number): Promise<T>;