@rdlabo/workers-hono-kit 0.3.7 → 0.4.2

package/src/db/index.ts

@@ -1,39 +0,0 @@
-/**
- * Data-layer helpers that depend on `mysql2` (exposed under the `/db` subpath because the package
- * root is reserved for web-standard-only code).
- *
- * @remarks
- * This module never depends on the type identity of `drizzle-orm`: the ORM instance is always
- * supplied by the consumer. That keeps the kit safe to use even when the kit and the consuming app
- * resolve separate copies of `drizzle-orm`.
- *
- * @packageDocumentation
- */
-
-export { retryWhenDeadlock } from './retry.js';
-
-export { createMysqlDatabase, createHyperdriveDatabase, databaseFrom } from './database.js';
-export type {
-  Database,
-  DisposableDatabase,
-  QueryRunner,
-  TxOf,
-  CreateMysqlDatabaseOptions,
-  CreateHyperdriveDatabaseOptions,
-  Connection,
-  Pool,
-} from './database.js';
-
-export { insertIdOf, affectedRowsOf, insertedIdsOf } from './write-result.js';
-export type { DzWriteResult } from './write-result.js';
-
-export { hyperdriveConnectionOptions, withMysqlConnections } from './connection.js';
-export type { HyperdriveLike, ExecutionContextLike } from './connection.js';
-
-export { toJstDate, jstTimestampParams, jstDatetimeParams, jstDateParams } from './jst.js';
-
-export { DRIZZLE_ORM_OPTIONS, honoDrizzleConfig, resolveDbSecret } from './orm-config.js';
-export type { HonoDrizzleConfigOptions, ResolvedDbSecret } from './orm-config.js';
-
-export { baselineMigrations, readBaselineEntry } from './migrate.js';
-export type { BaselineMigrationsOptions, BaselineResult, BaselineEntry } from './migrate.js';

package/src/db/jst.ts

@@ -1,122 +0,0 @@
-/**
- * Shared building blocks for normalizing JST (Asia/Tokyo) date/time values.
- *
- * @remarks
- * JST normalization is applied at the column boundary as a write-time side effect, and neither
- * values nor types from `drizzle-orm` are imported here on purpose. Exporting a fully-built
- * `customType` column from the kit would cause type collisions when the kit and the consumer
- * resolve separate copies of `drizzle-orm` (the private `SQL` brand stops being nominally
- * compatible). Instead the kit ships only the params and helpers, and the consumer builds the
- * column with its own `customType`:
- *
- * ```ts
- * import { customType } from 'drizzle-orm/mysql-core';
- * import { jstTimestampParams, jstDateParams } from '@rdlabo/workers-hono-kit/db';
- *
- * export const jstTimestamp = (name: string, opts?: { fsp?: number }) =>
- *   customType<{ data: string | Date; driverData: string | Date }>(jstTimestampParams(opts?.fsp))(name);
- * export const jstDate = (name: string) =>
- *   customType<{ data: string | null; driverData: string | null }>(jstDateParams())(name);
- * ```
- *
- * `timestamp`/`datetime` columns omit `toDriver` and pass `Date` values straight through, so the
- * connection's `timezone: '+09:00'` default makes mysql2 format them as JST; pre-formatted strings
- * also pass through. Drizzle's native `mode: 'date'` is avoided because it stringifies `Date` to
- * UTC before the timezone layer, shifting values by -9h. `date` columns keep `toJstDate` because
- * MySQL `DATE` rejects ISO/empty strings and a JST day-boundary normalization is required.
- */
-
-const JST_OFFSET_MS = 9 * 60 * 60 * 1000;
-
-/**
- * Normalize a client-supplied date to the `YYYY-MM-DD` (JST) form accepted by a MySQL `DATE` column.
- *
- * Accepts ISO 8601 (`...Z`), `YYYY-MM-DD`, or an empty string. Nullish, empty, or unparseable input
- * resolves to `null`.
- *
- * @remarks
- * MySQL `DATE` rejects ISO strings with `ER_TRUNCATED_WRONG_VALUE`, so this cannot be handled by the
- * driver alone; it is needed as the `toDriver` transform for a `date` column.
- *
- * @param value - the raw date string from the client (ISO 8601, `YYYY-MM-DD`, or empty), or nullish.
- * @returns the JST calendar date as `YYYY-MM-DD`, or `null` when the input is empty or unparseable.
- */
-export function toJstDate(value: string | null | undefined): string | null {
-  if (!value) {
-    return null;
-  }
-  const ms = new Date(value).getTime();
-  if (Number.isNaN(ms)) {
-    return null;
-  }
-  const jst = new Date(ms + JST_OFFSET_MS);
-  const p = (n: number): string => String(n).padStart(2, '0');
-  return `${jst.getUTCFullYear()}-${p(jst.getUTCMonth() + 1)}-${p(jst.getUTCDate())}`;
-}
-
-/**
- * Build the params for a `customType` backing a MySQL `timestamp` column with `Date` pass-through.
- *
- * The column omits `toDriver`, so `Date` values flow straight to mysql2 and are formatted as JST by
- * the connection's `timezone: '+09:00'` default.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `timestamp(fsp)`.
- * @returns the `customType` params object exposing the column's `dataType`.
- * @example
- * ```ts
- * import { customType } from 'drizzle-orm/mysql-core';
- * import { jstTimestampParams } from '@rdlabo/workers-hono-kit/db';
- *
- * const jstTimestamp = (name: string) =>
- *   customType<{ data: string | Date; driverData: string | Date }>(jstTimestampParams())(name);
- * ```
- */
-export const jstTimestampParams = (fsp?: number): { dataType: () => string } => ({
-  dataType: () => (fsp != null ? `timestamp(${fsp})` : 'timestamp'),
-});
-
-/**
- * Build the params for a `customType` backing a MySQL `datetime` column with `Date` pass-through.
- *
- * Behaves like {@link jstTimestampParams} but emits a `datetime` data type; `Date` values pass
- * through and are formatted as JST by the connection's `timezone: '+09:00'` default.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `datetime(fsp)`.
- * @returns the `customType` params object exposing the column's `dataType`.
- * @example
- * ```ts
- * import { customType } from 'drizzle-orm/mysql-core';
- * import { jstDatetimeParams } from '@rdlabo/workers-hono-kit/db';
- *
- * const jstDatetime = (name: string) =>
- *   customType<{ data: string | Date; driverData: string | Date }>(jstDatetimeParams())(name);
- * ```
- */
-export const jstDatetimeParams = (fsp?: number): { dataType: () => string } => ({
-  dataType: () => (fsp != null ? `datetime(${fsp})` : 'datetime'),
-});
-
-/**
- * Build the params for a `customType` backing a MySQL `date` column with JST normalization.
- *
- * Unlike the timestamp/datetime params, this defines a `toDriver` transform that runs
- * {@link toJstDate} so client-supplied ISO/empty strings are normalized to a JST `YYYY-MM-DD` value
- * the column accepts.
- *
- * @returns the `customType` params object exposing the column's `dataType` and `toDriver`.
- * @example
- * ```ts
- * import { customType } from 'drizzle-orm/mysql-core';
- * import { jstDateParams } from '@rdlabo/workers-hono-kit/db';
- *
- * const jstDate = (name: string) =>
- *   customType<{ data: string | null; driverData: string | null }>(jstDateParams())(name);
- * ```
- */
-export const jstDateParams = (): {
-  dataType: () => string;
-  toDriver: (value: string | null) => string | null;
-} => ({
-  dataType: () => 'date',
-  toDriver: (value: string | null) => toJstDate(value),
-});

package/src/db/migrate.ts

@@ -1,155 +0,0 @@
-/**
- * Brownfield baseline for Drizzle MySQL migrations.
- *
- * 既存（現行サービス）の DB は先にスキーマが存在するため、コミット済みの baseline マイグレーション
- * （`drizzle/0000_*.sql` = 現行スキーマを introspect した CREATE TABLE 群）を `db:migrate` で流すと
- * 全テーブルが衝突して失敗する。そこで 0000 を **実行せず「適用済み」として記録**する。
- *
- * 適用判定の根拠（drizzle-orm/mysql-core dialect.migrate）: `__drizzle_migrations(id, hash,
- * created_at)` の **`created_at` 最大値のみ**で未適用判定し、`max(created_at) < entry.when` の
- * migration だけ実行する。hash は保存されるが判定には使われない。よって 0000 の marker として
- * `(hash, created_at=当該 when)` を 1 行入れれば、以後 `db:migrate` は when がより大きい 0001+ だけを
- * 適用し、0000 は skip する。新規/テスト DB は marker が無いのでフルチェーンが走る（挙動不変）。
- *
- * この関数は `drizzle-orm` に依存しない（journal/SQL を自前で読み、hash は drizzle と同じ sha256）。
- * QueryRunner（mysql2 の `Connection`/`Pool` が構造的に代入可能）に対して生 SQL を実行する。
- *
- * @packageDocumentation
- */
-import { createHash } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-import type { QueryRunner } from './database.js';
-
-/** drizzle が使う既定のマイグレーション管理テーブル名。 */
-const MIGRATIONS_TABLE = '__drizzle_migrations';
-
-/** `meta/_journal.json` の 1 エントリ（必要なフィールドのみ）。 */
-interface JournalEntry {
-  idx: number;
-  when: number;
-  tag: string;
-}
-
-/** baseline（=最初の）マイグレーションの識別情報。 */
-export interface BaselineEntry {
-  /** マイグレーション tag（例 `0000_melted_weapon_omega`）。 */
-  tag: string;
-  /** `_journal.json` の `when`（= drizzle の `created_at`／`folderMillis`）。 */
-  when: number;
-  /** `<tag>.sql` の生内容の sha256（drizzle と同一アルゴリズム）。 */
-  hash: string;
-}
-
-/**
- * `migrationsFolder`（drizzle の `out`、例 `./drizzle`）から baseline（最初の）エントリを読む。
- *
- * @param migrationsFolder - `meta/_journal.json` と `<tag>.sql` を含むフォルダ。
- * @returns baseline エントリ（tag/when/hash）。
- * @throws journal が無い / エントリが空 / `<tag>.sql` が無い場合。
- */
-export function readBaselineEntry(migrationsFolder: string): BaselineEntry {
-  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')) as { entries?: JournalEntry[] };
-  const entries = journal.entries ?? [];
-  if (entries.length === 0) {
-    throw new Error(`No migration entries in ${journalPath}.`);
-  }
-  // 起点は必ず最初のエントリ（0000）。以降 0001+ は「新しい変更」なので既存 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') };
-}
-
-/** {@link baselineMigrations} のオプション。 */
-export interface BaselineMigrationsOptions {
-  /** 生 SQL を実行する QueryRunner（mysql2 `Connection`/`Pool` が代入可能）。対象 DB に接続済みのこと。 */
-  db: QueryRunner;
-  /** drizzle の `out` フォルダ（既定 `./drizzle`）。 */
-  migrationsFolder?: string;
-}
-
-/** {@link baselineMigrations} の結果。 */
-export type BaselineResult =
-  | { status: 'inserted'; tag: string; when: number; hash: string }
-  | { status: 'already-baselined'; tag: string; when: number };
-
-async function rowsOf(db: QueryRunner, sql: string, params?: unknown[]): Promise<Record<string, unknown>[]> {
-  const result = (await db.query(sql, params)) as [Record<string, unknown>[] | undefined, unknown];
-  return result[0] ?? [];
-}
-
-/**
- * 既存 DB へ baseline（0000）を「適用済み」として記録する。冪等・安全ガード付き。
- *
- * @remarks
- * ガード:
- * - 既に baseline marker（`created_at = when`）が在れば **no-op**（`already-baselined`）。
- * - marker は無いが `__drizzle_migrations` に別の行が在る → **中断**（想定外の状態）。
- * - 対象 DB に base table が 1 つも無い（空 DB）→ **中断**（空 DB は 0000 を skip すると
- *   テーブルが作られない。新規 DB には `db:migrate` を使う）。
- *
- * @param options - 接続と migrations フォルダ。{@link BaselineMigrationsOptions} 参照。
- * @returns 挿入したか既に baseline 済みか。
- * @throws 上記ガードに該当する場合。
- */
-export async function baselineMigrations(options: BaselineMigrationsOptions): Promise<BaselineResult> {
-  const { db, migrationsFolder = './drizzle' } = options;
-  const baseline = readBaselineEntry(migrationsFolder);
-
-  // migrator と同一 DDL（存在すれば no-op）。
-  await db.query(
-    `create table if not exists \`${MIGRATIONS_TABLE}\` (
-      id serial primary key,
-      hash text not null,
-      created_at bigint
-    )`,
-  );
-
-  // 既に baseline marker があれば冪等 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 };
-  }
-
-  // marker は無いが行が在る＝既に別の状態。誤爆防止で中断。
-  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.`,
-    );
-  }
-
-  // 空 DB への baseline は危険（0000 を skip 扱いにするとテーブルが作られない）。brownfield 確認。
-  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/src/db/orm-config.ts

@@ -1,171 +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' } as const;
-
-/**
- * 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 function honoDrizzleConfig(options: HonoDrizzleConfigOptions) {
-  const {
-    database,
-    host,
-    port,
-    user,
-    password,
-    schema = './src/db/schemes',
-    out = './drizzle',
-    tablesFilter,
-    introspect,
-  } = options;
-  // CI/本番の migrate は AWS Secrets Manager の RDS マネージド secret（キー
-  // host/port/dbname/username/password）を `DB_SECRET` にまるごと渡す運用を吸収する。JSON.parse で
-  // 解釈するので secret のキー名（host≠DB_HOST）差を map でき、password の特殊文字もシェル安全。
-  // 未設定（ローカル/db:generate）は従来どおり個別 env → デフォルトにフォールバック。
-  // DB_SECRET が在れば「完全な secret」として全接続情報をそれで確定する（欠損/不正は throw）。
-  // 未設定時のみ従来の個別 env → デフォルトにフォールバックする。
-  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' as const,
-    schema,
-    out,
-    casing: 'snake_case' as const,
-    ...(tablesFilter ? { tablesFilter } : {}),
-    ...(introspect ? { introspect } : {}),
-    dbCredentials,
-  };
-}
-
-/** {@link resolveDbSecret} の戻り値（正規化済みの接続情報）。 */
-export interface ResolvedDbSecret {
-  host: string;
-  port: number;
-  dbname: string;
-  username: string;
-  password: string;
-}
-
-/**
- * AWS RDS マネージド secret（`DB_SECRET` に入れた JSON 文字列）を解決する。
- *
- * @remarks
- * - `DB_SECRET` 未設定 → `undefined`（ローカル/`db:generate` の正常フォールバック）。
- * - 設定されている場合は「完全な接続情報」であることを要求し、**不正 JSON / 必須キー欠損は throw**
- *   （静かに localhost へフォールバックして事故らせない）。`port` のみ欠損時は 3306 を補う。
- *
- * `honoDrizzleConfig`（db:migrate）と `workers-hono-kit-db-baseline` bin の双方が同じ解釈を使う。
- */
-export function resolveDbSecret(): ResolvedDbSecret | undefined {
-  const raw = process.env.DB_SECRET;
-  if (!raw) {
-    return undefined;
-  }
-  let parsed: Record<string, unknown>;
-  try {
-    parsed = JSON.parse(raw) as Record<string, unknown>;
-  } 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/src/db/retry.ts

@@ -1,43 +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 async function retryWhenDeadlock<T>(fn: () => Promise<T>, retries = 3, delay = 100): Promise<T> {
-  for (let attempt = 0; attempt < retries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      const code = (error as { code?: string }).code;
-      if (code === 'ER_LOCK_DEADLOCK' && attempt < retries - 1) {
-        await new Promise((resolve) => setTimeout(resolve, delay * (attempt + 1)));
-        continue;
-      }
-      throw error;
-    }
-  }
-  // Unreachable: the loop returns on success and throws on the final failed attempt.
-  throw new Error('retryWhenDeadlock: exhausted retries');
-}

package/src/db/write-result.ts

@@ -1,46 +0,0 @@
-/**
- * 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 function insertIdOf(result: DzWriteResult): number {
-  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: DzWriteResult): number {
-  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: DzWriteResult, count: number): number[] {
-  const base = result[0].insertId;
-  return Array.from({ length: count }, (_, i) => base + i);
-}

package/src/firebase/firebase-verifier.ts

@@ -1,76 +0,0 @@
-/**
- * Decoded Firebase ID token payload.
- *
- * Shaped to match the subset of `firebase-admin`'s `DecodedIdToken` that consumers
- * typically rely on: a stable `uid` plus an optional `email`. The index signature keeps
- * every other JWT claim (e.g. `name`, `picture`, custom claims) accessible without
- * enumerating them here.
- *
- * @remarks
- * This is the return type of {@link FirebaseVerifier.verifyIdToken}. The `uid` is derived
- * from the token's `sub` claim.
- */
-export interface DecodedIdToken {
-  /** The authenticated user's unique id, taken from the token's `sub` claim. */
-  uid: string;
-  /** The user's email address, when present on the token. */
-  email?: string;
-  /** Any additional JWT claim carried by the token (custom claims, `name`, `picture`, ...). */
-  [claim: string]: unknown;
-}
-
-/**
- * Abstract authentication boundary that replaces the `firebase-admin` Auth surface
- * (`verifyIdToken` / `getUser` / `deleteUser`) for environments where the Node SDK cannot
- * run, such as Cloudflare Workers.
- *
- * @remarks
- * Implementations verify Firebase ID tokens and look up or delete accounts without the
- * `firebase-admin` Node dependency. See `JoseFirebaseVerifier` for the `jose`-based
- * implementation and the `createRemoteFirebaseVerifier` / `createServiceAccountVerifier`
- * factories for ready-made instances.
- */
-export interface FirebaseVerifier {
-  /**
-   * Verify a Firebase ID token and return its decoded payload.
-   *
-   * Mirrors `firebase-admin` `getAuth().verifyIdToken()`.
-   *
-   * @param idToken - The raw Firebase ID token (JWT) to verify.
-   * @returns The decoded token payload.
-   * @throws If the token signature, issuer, audience, expiry, or other required claims are invalid.
-   */
-  verifyIdToken(idToken: string): Promise<DecodedIdToken>;
-  /**
-   * Look up a user record by uid.
-   *
-   * Mirrors `firebase-admin` `getAuth().getUser()`.
-   *
-   * @param uid - The user's unique id.
-   * @returns The user's `uid` and optional `email`, or `null` when the user does not exist.
-   * @throws If the backing user-management service is not configured or the lookup fails.
-   */
-  getUser(uid: string): Promise<{ uid: string; email?: string } | null>;
-  /**
-   * Look up multiple user records by uid in as few requests as the backing service allows.
-   *
-   * Batched equivalent of {@link getUser}, intended to replace N single-uid lookups with a
-   * handful of requests.
-   *
-   * @param uids - The users' unique ids to look up.
-   * @returns The `uid`/`email` of every matching user. Uids that do not resolve to a user are
-   *   simply absent from the result (never `null` entries).
-   * @throws If the backing user-management service is not configured or the lookup fails.
-   */
-  getUsers(uids: string[]): Promise<{ uid: string; email?: string }[]>;
-  /**
-   * Delete a user by uid.
-   *
-   * Mirrors `firebase-admin` `getAuth().deleteUser()`.
-   *
-   * @param uid - The user's unique id.
-   * @returns A promise that resolves once the user has been deleted.
-   * @throws If the backing user-management service is not configured or the deletion fails.
-   */
-  deleteUser(uid: string): Promise<void>;
-}