@rdlabo/workers-mysql 0.1.0

package/dist/orm-config.js

@@ -0,0 +1,127 @@
+/**
+ * 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 workersDrizzleConfig}).
+ * 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
+ * package only 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 Workers MySQL 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 this package; 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 { workersDrizzleConfig } from '@rdlabo/workers-mysql/drizzle';
+ *
+ * export default workersDrizzleConfig({ database: 'app' });
+ * ```
+ */
+export function workersDrizzleConfig(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,
+    };
+}
+/**
+ * @deprecated Use {@link workersDrizzleConfig}; retained for source compatibility with
+ * `@rdlabo/workers-hono-kit/db`.
+ */
+export const honoDrizzleConfig = workersDrizzleConfig;
+/**
+ * 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 `workersDrizzleConfig` (db:migrate) and the compatibility baseline command use this 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/retry.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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>;

package/dist/retry.js

@@ -0,0 +1,56 @@
+/**
+ * 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 async function retryWhenDeadlock(fn, retries = 3, delay = 100) {
+    for (let attempt = 0; attempt < retries; attempt++) {
+        const invoke = async () => fn();
+        const outcome = await invoke().then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+        if (outcome.ok) {
+            return outcome.value;
+        }
+        if (isDeadlock(outcome.error) && attempt < retries - 1) {
+            await new Promise((resolve) => setTimeout(resolve, delay * (attempt + 1)));
+            continue;
+        }
+        throw outcome.error;
+    }
+    // Unreachable: the loop returns on success and throws on the final failed attempt.
+    throw new Error('retryWhenDeadlock: exhausted retries');
+}
+function isDeadlock(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.code === 'ER_LOCK_DEADLOCK') {
+            return true;
+        }
+        current = value.cause;
+    }
+    return false;
+}

package/dist/testing/db.d.ts

@@ -0,0 +1,106 @@
+import type { Pool } from 'mysql2/promise';
+/**
+ * Connection parameters for the test MySQL server.
+ *
+ * @see {@link CreateTestDbOptions.connection} for how defaults are resolved.
+ */
+export interface TestDbConnection {
+    /** Server host. */
+    host: string;
+    /** Server port. */
+    port: number;
+    /** User name. */
+    user: string;
+    /** Password. */
+    password: string;
+}
+/**
+ * Options for {@link createTestDb}.
+ */
+export interface CreateTestDbOptions {
+    /**
+     * Test database name (e.g. `'app_test'`). To isolate parallel runs per feature, resolve a per-run
+     * name on the caller side and pass it here.
+     */
+    dbName: string;
+    /**
+     * Absolute path to the Drizzle migrations folder. Resolve it on the caller side, e.g.
+     * `join(here, '..', 'drizzle')`.
+     */
+    migrationsFolder: string;
+    /**
+     * Connection overrides. Unspecified fields fall back to environment variables
+     * (`DB_HOST`/`DB_PORT`/`DB_USER`/`DB_PASSWORD`), then to `127.0.0.1`/`3306`/`root`/`root`.
+     */
+    connection?: Partial<TestDbConnection>;
+}
+/**
+ * Test database handle returned by {@link createTestDb}, bundling schema setup, pooling, and
+ * fixture helpers for a single test database.
+ */
+export interface TestDb {
+    /** The resolved test database name. */
+    readonly dbName: string;
+    /** The resolved connection parameters. */
+    readonly connection: TestDbConnection;
+    /**
+     * Drop and recreate the database, then apply the committed Drizzle migrations to build the schema.
+     *
+     * @returns A promise that resolves once migrations have been applied.
+     */
+    resetSchema(): Promise<void>;
+    /**
+     * Create a mysql2 pool connected to the test database.
+     *
+     * @remarks Call `pool.end()` (e.g. in `afterAll`) to release connections.
+     * @returns A connection pool for the test database.
+     */
+    createTestPool(): Pool;
+    /**
+     * Truncate every base table in the database.
+     *
+     * @remarks Table names are discovered dynamically from `information_schema`; the
+     * `__drizzle_migrations` bookkeeping table is excluded. Foreign-key checks are disabled for the
+     * duration so truncation order does not matter.
+     * @param pool - Pool connected to the test database.
+     */
+    truncateAll(pool: Pool): Promise<void>;
+    /**
+     * Insert a single row, mapping column names to values — a generic fixture helper for specs.
+     *
+     * @param pool - Pool connected to the test database.
+     * @param table - Target table name.
+     * @param row - Column-name to value map. A no-op if empty.
+     */
+    seed(pool: Pool, table: string, row: Record<string, unknown>): Promise<void>;
+    /**
+     * Report whether the local MySQL server is reachable.
+     *
+     * @remarks Useful as a guard, e.g. `describe.skipIf(!(await mysqlReachable()))`.
+     * @returns `true` if a connection could be opened, otherwise `false`.
+     */
+    mysqlReachable(): Promise<boolean>;
+}
+/**
+ * Create a {@link TestDb} handle for a single test database.
+ *
+ * @remarks
+ * The test schema is built from the committed Drizzle migrations as the single source of truth
+ * (the `db:generate` output under `./drizzle`), rather than a hand-written `schema.sql`. This helper
+ * is Node-only test infrastructure (run under Vitest) and is unrelated to runtime behavior.
+ *
+ * @param options - Database name, migrations folder, and optional connection overrides. See
+ *   {@link CreateTestDbOptions}.
+ * @returns A handle exposing schema setup, pooling, truncation, seeding, and a reachability probe.
+ * @example
+ * ```ts
+ * const testDb = createTestDb({ dbName: 'app_test', migrationsFolder: join(here, '..', 'drizzle') });
+ * beforeAll(async () => {
+ *   await testDb.resetSchema();
+ * });
+ * const pool = testDb.createTestPool();
+ * beforeEach(() => testDb.truncateAll(pool));
+ * afterAll(() => pool.end());
+ * ```
+ */
+export declare function createTestDb(options: CreateTestDbOptions): TestDb;

package/dist/testing/db.js

@@ -0,0 +1,95 @@
+import { drizzle } from 'drizzle-orm/mysql2';
+import { migrate } from 'drizzle-orm/mysql2/migrator';
+import { createConnection, createPool } from 'mysql2/promise';
+function resolveConnection(override) {
+    const env = globalThis.process?.env ?? {};
+    return {
+        host: override?.host ?? env.DB_HOST ?? '127.0.0.1',
+        port: override?.port ?? Number(env.DB_PORT ?? '3306'),
+        user: override?.user ?? env.DB_USER ?? 'root',
+        password: override?.password ?? env.DB_PASSWORD ?? 'root',
+    };
+}
+/**
+ * Create a {@link TestDb} handle for a single test database.
+ *
+ * @remarks
+ * The test schema is built from the committed Drizzle migrations as the single source of truth
+ * (the `db:generate` output under `./drizzle`), rather than a hand-written `schema.sql`. This helper
+ * is Node-only test infrastructure (run under Vitest) and is unrelated to runtime behavior.
+ *
+ * @param options - Database name, migrations folder, and optional connection overrides. See
+ *   {@link CreateTestDbOptions}.
+ * @returns A handle exposing schema setup, pooling, truncation, seeding, and a reachability probe.
+ * @example
+ * ```ts
+ * const testDb = createTestDb({ dbName: 'app_test', migrationsFolder: join(here, '..', 'drizzle') });
+ * beforeAll(async () => {
+ *   await testDb.resetSchema();
+ * });
+ * const pool = testDb.createTestPool();
+ * beforeEach(() => testDb.truncateAll(pool));
+ * afterAll(() => pool.end());
+ * ```
+ */
+export function createTestDb(options) {
+    const { dbName, migrationsFolder } = options;
+    const connection = resolveConnection(options.connection);
+    return {
+        dbName,
+        connection,
+        async resetSchema() {
+            const admin = await createConnection({ ...connection, multipleStatements: true });
+            await admin.query(`DROP DATABASE IF EXISTS \`${dbName}\`; CREATE DATABASE \`${dbName}\` DEFAULT CHARACTER SET utf8mb4;`);
+            await admin.changeUser({ database: dbName });
+            await migrate(drizzle(admin), { migrationsFolder });
+            await admin.end();
+        },
+        createTestPool() {
+            // decimalNumbers / timezone mirror the runtime hyperdriveConnectionOptions so specs read
+            // DECIMAL columns as numbers and handle datetime in +09:00 (JST), matching production.
+            const pool = createPool({
+                ...connection,
+                database: dbName,
+                connectionLimit: 5,
+                decimalNumbers: true,
+                timezone: '+09:00',
+            });
+            // Pin ONLY_FULL_GROUP_BY on every pooled connection so GROUP BY violations surface in specs
+            // regardless of the server's my.cnf (the policy is centralized here, not left to each server). CONCAT keeps
+            // the server's other sql_mode flags and is harmless if ONLY_FULL_GROUP_BY is already present.
+            // mysql2 queues this SET ahead of the consumer's first query on each new physical connection.
+            pool.on('connection', (conn) => {
+                void conn.query("SET SESSION sql_mode = CONCAT(@@SESSION.sql_mode, ',ONLY_FULL_GROUP_BY')");
+            });
+            return pool;
+        },
+        async truncateAll(pool) {
+            const [rows] = await pool.query("SELECT table_name AS t FROM information_schema.tables WHERE table_schema = ? AND table_type='BASE TABLE' AND table_name <> '__drizzle_migrations'", [dbName]);
+            const tables = rows.map((r) => r.t);
+            await pool.query('SET FOREIGN_KEY_CHECKS=0');
+            for (const t of tables) {
+                await pool.query(`TRUNCATE TABLE \`${t}\``);
+            }
+            await pool.query('SET FOREIGN_KEY_CHECKS=1');
+        },
+        async seed(pool, table, row) {
+            const cols = Object.keys(row);
+            if (cols.length === 0) {
+                return;
+            }
+            const placeholders = cols.map(() => '?').join(', ');
+            const columnList = cols.map((c) => `\`${c}\``).join(', ');
+            await pool.query(`INSERT INTO \`${table}\` (${columnList}) VALUES (${placeholders})`, Object.values(row));
+        },
+        async mysqlReachable() {
+            const connect = async () => createConnection({ ...connection });
+            const c = await connect().catch(() => undefined);
+            if (!c) {
+                return false;
+            }
+            const close = async () => c.end();
+            return close().then(() => true, () => false);
+        },
+    };
+}

package/dist/testing/fakes.d.ts

@@ -0,0 +1,13 @@
+import type { Pool } from 'mysql2/promise';
+import type { DisposableDatabase } from '../database.js';
+/** Options for {@link createPoolDatabase}. */
+export interface CreatePoolDatabaseOptions<TDrizzle> {
+    /** Test pool used as both primary and replica. */
+    pool: Pool;
+    /** Drizzle instance built by the consumer with its own `drizzle-orm`. */
+    orm: TDrizzle;
+}
+/** Create a `Database` backed by one pool used as both primary and replica. */
+export declare function createPoolDatabase<TDrizzle>(options: CreatePoolDatabaseOptions<TDrizzle>): DisposableDatabase<TDrizzle>;
+/** Create a no-op database stub that fails on unexpected writes. */
+export declare function createNoopDatabase<TDrizzle = unknown>(): DisposableDatabase<TDrizzle>;

package/dist/testing/fakes.js

@@ -0,0 +1,25 @@
+import { databaseFrom } from '../database.js';
+/** Create a `Database` backed by one pool used as both primary and replica. */
+export function createPoolDatabase(options) {
+    const { pool, orm } = options;
+    const base = databaseFrom(orm, pool);
+    return {
+        ...base,
+        async dispose() {
+            await pool.end();
+        },
+    };
+}
+/** Create a no-op database stub that fails on unexpected writes. */
+export function createNoopDatabase() {
+    return {
+        read: async () => [],
+        write: () => {
+            throw new Error('noopDatabase.write accessed unexpectedly');
+        },
+        transaction: () => {
+            throw new Error('noopDatabase.transaction accessed unexpectedly');
+        },
+        dispose: async () => { },
+    };
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,5 @@
+export { createTestDb } from './db.js';
+export type { TestDb, CreateTestDbOptions, TestDbConnection } from './db.js';
+export { createPoolDatabase, createNoopDatabase } from './fakes.js';
+export type { CreatePoolDatabaseOptions } from './fakes.js';
+export type { Database, DisposableDatabase, QueryRunner, TxOf } from '../database.js';

package/dist/testing/index.js

@@ -0,0 +1,2 @@
+export { createTestDb } from './db.js';
+export { createPoolDatabase, createNoopDatabase } from './fakes.js';

package/dist/write-result.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shape of a Drizzle (mysql2) write result, narrowed to the fields callers actually read.
+ *
+ * @remarks
+ * A mysql2 INSERT/UPDATE/DELETE result is the tuple `[ResultSetHeader, FieldPacket[]]`. Typing the
+ * result this way lets repositories extract the common values without exposing the raw query
+ * builder or the full `ResultSetHeader` to the rest of the codebase.
+ */
+export type DzWriteResult = readonly [{
+    insertId: number;
+    affectedRows: number;
+}, ...unknown[]];
+/**
+ * Extract the auto-increment `insertId` from a write result.
+ *
+ * @param result - the result of a Drizzle (mysql2) INSERT/UPDATE/DELETE.
+ * @returns the `insertId` reported by mysql2 (the id of the first inserted row).
+ */
+export declare function insertIdOf(result: DzWriteResult): number;
+/**
+ * Extract the number of affected rows from a write result.
+ *
+ * @param result - the result of a Drizzle (mysql2) INSERT/UPDATE/DELETE.
+ * @returns the `affectedRows` count reported by mysql2.
+ */
+export declare function affectedRowsOf(result: DzWriteResult): number;
+/**
+ * Reconstruct the auto-increment ids assigned by a bulk INSERT.
+ *
+ * @remarks
+ * mysql2 reports only the first `insertId` for a multi-row INSERT, so the remaining ids are derived
+ * by assuming a contiguous sequence (`base`, `base + 1`, …). This holds for tables with a standard
+ * `AUTO_INCREMENT` column and the default `innodb_autoinc_lock_mode`.
+ *
+ * @param result - the result of a bulk INSERT.
+ * @param count - the number of rows that were inserted.
+ * @returns an array of the `count` auto-increment ids, starting at the reported `insertId`.
+ */
+export declare function insertedIdsOf(result: DzWriteResult, count: number): number[];

package/dist/write-result.js

@@ -0,0 +1,34 @@
+/**
+ * Extract the auto-increment `insertId` from a write result.
+ *
+ * @param result - the result of a Drizzle (mysql2) INSERT/UPDATE/DELETE.
+ * @returns the `insertId` reported by mysql2 (the id of the first inserted row).
+ */
+export function insertIdOf(result) {
+    return result[0].insertId;
+}
+/**
+ * Extract the number of affected rows from a write result.
+ *
+ * @param result - the result of a Drizzle (mysql2) INSERT/UPDATE/DELETE.
+ * @returns the `affectedRows` count reported by mysql2.
+ */
+export function affectedRowsOf(result) {
+    return result[0].affectedRows;
+}
+/**
+ * Reconstruct the auto-increment ids assigned by a bulk INSERT.
+ *
+ * @remarks
+ * mysql2 reports only the first `insertId` for a multi-row INSERT, so the remaining ids are derived
+ * by assuming a contiguous sequence (`base`, `base + 1`, …). This holds for tables with a standard
+ * `AUTO_INCREMENT` column and the default `innodb_autoinc_lock_mode`.
+ *
+ * @param result - the result of a bulk INSERT.
+ * @param count - the number of rows that were inserted.
+ * @returns an array of the `count` auto-increment ids, starting at the reported `insertId`.
+ */
+export function insertedIdsOf(result, count) {
+    const base = result[0].insertId;
+    return Array.from({ length: count }, (_, i) => base + i);
+}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@rdlabo/workers-mysql",
+  "version": "0.1.0",
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "description": "MySQL and Hyperdrive utilities for Cloudflare Workers",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rdlabo-dev/workers-hono-kit.git",
+    "directory": "packages/mysql"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "bin": {
+    "workers-mysql-db-baseline": "./bin/db-baseline.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./drizzle": {
+      "types": "./dist/drizzle.d.ts",
+      "import": "./dist/drizzle.js",
+      "default": "./dist/drizzle.js"
+    },
+    "./migrations": {
+      "types": "./dist/migrations.d.ts",
+      "import": "./dist/migrations.js",
+      "default": "./dist/migrations.js"
+    },
+    "./baseline-cli": {
+      "types": "./dist/baseline-cli.d.ts",
+      "import": "./dist/baseline-cli.js",
+      "default": "./dist/baseline-cli.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js",
+      "default": "./dist/testing/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:package": "node scripts/package-smoke.mjs",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "mysql2": "^3.24.3"
+  },
+  "peerDependencies": {
+    "@types/node": ">=20.19.43",
+    "drizzle-orm": "^0.45.2"
+  },
+  "peerDependenciesMeta": {
+    "drizzle-orm": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@hono/eslint-config": "^2.1.0",
+    "@rdlabo/workers-timezone": "^0.1.0",
+    "drizzle-orm": "^0.45.2",
+    "eslint": "^9.39.4",
+    "prettier": "^3.8.4",
+    "typescript": "~5.6.2",
+    "typescript-eslint": "^8.61.1",
+    "vitest": "^2.1.0"
+  }
+}