@rdlabo/workers-hono-kit 0.3.7 → 0.4.2

package/src/testing/auth.ts

@@ -1,110 +0,0 @@
-import type { Pool } from 'mysql2/promise';
-import type { DecodedIdToken } from '../firebase/firebase-verifier.js';
-import type { FakeFirebaseVerifier } from './fakes.js';
-
-/**
- * Build authentication headers compatible with the client interceptor convention
- * (`x-amz-security-token` + `x-amz-meta-*`).
- *
- * Consolidates the identically-shaped header boilerplate that route specs tend to duplicate.
- *
- * @remarks
- * `version` is persisted into an `app_version` column (`varchar(10)`), so keep it to 10 characters
- * or fewer. Passing `contentType: null` omits the `content-type` header entirely (e.g. for GET requests).
- *
- * @param token - Security token placed in the `x-amz-security-token` header.
- * @param opts - Optional overrides.
- * @param opts.version - App version for `x-amz-meta-version` (defaults to `'1.0.0'`).
- * @param opts.uuid - Device/client UUID for `x-amz-meta-uuid` (defaults to `'test-uuid'`).
- * @param opts.contentType - Content type; defaults to `'application/json'`. Pass `null` to omit the header.
- * @returns A plain header record suitable for `fetch`/`app.request` calls.
- * @example
- * ```ts
- * const res = await app.request('/me', { headers: authHeaders(token) });
- * // GET without a content-type header:
- * await app.request('/items', { headers: authHeaders(token, { contentType: null }) });
- * ```
- */
-export function authHeaders(
-  token: string,
-  opts: { version?: string; uuid?: string; contentType?: string | null } = {},
-): Record<string, string> {
-  const headers: Record<string, string> = {
-    'x-amz-security-token': token,
-    'x-amz-meta-version': opts.version ?? '1.0.0',
-    'x-amz-meta-uuid': opts.uuid ?? 'test-uuid',
-  };
-  if (opts.contentType !== null) {
-    headers['content-type'] = opts.contentType ?? 'application/json';
-  }
-  return headers;
-}
-
-/**
- * Register a token on a fake Firebase verifier without touching the database.
- *
- * Use this when {@link provisionUser} does not fit because the project's `users` table has a
- * non-conventional shape (for example, keyed by email rather than `firebase_uid`); pair it with a
- * project-specific provisioning step.
- *
- * @param firebase - In-memory verifier to register the token on.
- * @param uid - Firebase UID associated with the token.
- * @param record - Additional decoded-token fields to merge in (e.g. `email`).
- * @param token - Token string to register (defaults to `` `tok-${uid}` ``).
- * @returns The registered token string.
- * @example
- * ```ts
- * const token = registerFirebaseToken(firebase, 'uid-1', { email: 'a@example.com' });
- * const res = await app.request('/me', { headers: authHeaders(token) });
- * ```
- */
-export function registerFirebaseToken(
-  firebase: FakeFirebaseVerifier,
-  uid: string,
-  record: Partial<DecodedIdToken> = {},
-  token = `tok-${uid}`,
-): string {
-  firebase.register(token, { uid, ...record });
-  return token;
-}
-
-/**
- * Register a token on a fake Firebase verifier and ensure a matching `users` row exists, returning
- * its id.
- *
- * @remarks
- * Assumes a conventional `users(id, firebase_uid, agree)` table. The operation is idempotent: if a
- * row with the same `firebase_uid` already exists it is reused rather than re-inserted. For projects
- * whose `users` table has a different shape, use {@link registerFirebaseToken} plus project-specific
- * provisioning instead.
- *
- * @param pool - mysql2 pool connected to the test database.
- * @param firebase - In-memory verifier to register the token on.
- * @param opts - Provisioning options.
- * @param opts.uid - Firebase UID for the user.
- * @param opts.token - Token string to register (defaults to `` `tok-${uid}` ``).
- * @param opts.agree - Value for the `agree` column on insert (defaults to `1`).
- * @param opts.email - Optional email merged into the decoded token record.
- * @returns The resolved `userId`, along with the `uid` and registered `token`.
- * @example
- * ```ts
- * const { userId, token } = await provisionUser(pool, firebase, { uid: 'uid-1' });
- * const res = await app.request('/me', { headers: authHeaders(token) });
- * ```
- */
-export async function provisionUser(
-  pool: Pool,
-  firebase: FakeFirebaseVerifier,
-  opts: { uid: string; token?: string; agree?: number; email?: string },
-): Promise<{ userId: number; uid: string; token: string }> {
-  const token = registerFirebaseToken(firebase, opts.uid, opts.email ? { email: opts.email } : {}, opts.token);
-
-  const [existing] = await pool.query('SELECT id FROM users WHERE firebase_uid = ?', [opts.uid]);
-  const rows = existing as { id: number }[];
-  if (rows.length > 0) {
-    return { userId: rows[0].id, uid: opts.uid, token };
-  }
-
-  const [res] = await pool.query('INSERT INTO users (agree, firebase_uid) VALUES (?, ?)', [opts.agree ?? 1, opts.uid]);
-  return { userId: (res as { insertId: number }).insertId, uid: opts.uid, token };
-}

package/src/testing/configurable-fake.ts

@@ -1,45 +0,0 @@
-/**
- * Build a test double from a partial implementation: configured members are returned as-is, while
- * calling any unconfigured member fails explicitly with `` `${name}.${method} not configured` ``.
- *
- * @remarks
- * Replaces the hand-written "accept a `Partial<impl>` and throw on anything unset" fake classes that
- * tend to proliferate per gateway. Because gateway interfaces differ by domain (Stripe, etc.), this
- * lets you stub only the members a given test exercises in a single line.
- *
- * @typeParam T - The interface being faked.
- * @param impl - Partial implementation; only the members the test needs.
- * @param name - Label used in the "not configured" error message (defaults to `'fake'`).
- * @returns A proxy typed as `T` that delegates to `impl` and throws on unconfigured members.
- * @throws Error `` `${name}.${method} not configured` `` when an unconfigured string-keyed member is called.
- * @example
- * ```ts
- * const stripe = configurableFake<StripeGateway>(
- *   { listPaymentIntents: async () => fakeApiList([fakePaymentIntent()]) },
- *   'FakeStripeGateway',
- * );
- * await stripe.listPaymentIntents(); // ok
- * await stripe.cancelPaymentIntent('pi_1'); // throws: FakeStripeGateway.cancelPaymentIntent not configured
- * ```
- */
-export function configurableFake<T extends object>(impl: Partial<T>, name = 'fake'): T {
-  return new Proxy(impl, {
-    get(target, prop) {
-      if (prop in target) {
-        return (target as Record<string | symbol, unknown>)[prop];
-      }
-      // Never return the "unconfigured member" function for Promise-interop properties. Doing so would
-      // make the fake itself look thenable, so accidentally awaiting it (or passing it to
-      // Promise.resolve) would invoke then() and throw — a subtle footgun.
-      if (prop === 'then' || prop === 'catch' || prop === 'finally') {
-        return undefined;
-      }
-      if (typeof prop === 'string') {
-        return () => {
-          throw new Error(`${name}.${prop} not configured`);
-        };
-      }
-      return undefined;
-    },
-  }) as T;
-}

package/src/testing/db.ts

@@ -1,194 +0,0 @@
-import { drizzle } from 'drizzle-orm/mysql2';
-import { migrate } from 'drizzle-orm/mysql2/migrator';
-import { createConnection, createPool } from 'mysql2/promise';
-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>;
-}
-
-function resolveConnection(override?: Partial<TestDbConnection>): TestDbConnection {
-  const env = (globalThis as { process?: { env?: Record<string, string | undefined> } }).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: CreateTestDbOptions): TestDb {
-  const { dbName, migrationsFolder } = options;
-  const connection = resolveConnection(options.connection);
-
-  return {
-    dbName,
-    connection,
-
-    async resetSchema(): Promise<void> {
-      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(): Pool {
-      // 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: Pool): Promise<void> {
-      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 as { t: string }[]).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: Pool, table: string, row: Record<string, unknown>): Promise<void> {
-      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(): Promise<boolean> {
-      try {
-        const c = await createConnection({ ...connection });
-        await c.end();
-        return true;
-      } catch {
-        return false;
-      }
-    },
-  };
-}

package/src/testing/fakes.ts

@@ -1,153 +0,0 @@
-import type { Pool } from 'mysql2/promise';
-import { databaseFrom } from '../db/database.js';
-import type { DisposableDatabase } from '../db/database.js';
-import type { DecodedIdToken, FirebaseVerifier } from '../firebase/firebase-verifier.js';
-
-/**
- * In-memory {@link FirebaseVerifier} implementation for offline route tests.
- *
- * Seed fake identities with {@link FakeFirebaseVerifier.register | register(token, { uid })}, then
- * verification resolves the registered decoded token instead of calling a real Firebase backend.
- *
- * @example
- * ```ts
- * const firebase = new FakeFirebaseVerifier();
- * firebase.register('tok-1', { uid: 'uid-1' });
- * const decoded = await firebase.verifyIdToken('tok-1'); // { uid: 'uid-1' }
- * ```
- */
-export class FakeFirebaseVerifier implements FirebaseVerifier {
-  private readonly tokens = new Map<string, DecodedIdToken>();
-  /** UIDs passed to {@link FakeFirebaseVerifier.deleteUser}, in call order, for assertions. */
-  readonly deleted: string[] = [];
-
-  /**
-   * Register a fake decoded token so that {@link FakeFirebaseVerifier.verifyIdToken} resolves it.
-   *
-   * @param token - Token string clients will present.
-   * @param record - Decoded token returned on verification (must include `uid`).
-   */
-  register(token: string, record: DecodedIdToken): void {
-    this.tokens.set(token, record);
-  }
-
-  /**
-   * Resolve the decoded token previously registered for `idToken`.
-   *
-   * @param idToken - Token string to verify.
-   * @returns The registered decoded token.
-   * @throws Error if the token was never registered.
-   */
-  async verifyIdToken(idToken: string): Promise<DecodedIdToken> {
-    const record = this.tokens.get(idToken);
-    if (!record) {
-      throw new Error('invalid firebase id token');
-    }
-    return record;
-  }
-
-  /**
-   * Return a minimal user record echoing the requested UID.
-   *
-   * @param uid - UID to look up.
-   * @returns An object containing the `uid` (never `null` in this fake).
-   */
-  async getUser(uid: string): Promise<{ uid: string; email?: string } | null> {
-    return { uid };
-  }
-
-  /**
-   * Return minimal user records echoing each requested UID.
-   *
-   * @param uids - UIDs to look up.
-   * @returns One `{ uid }` entry per requested uid (never omits any, in this fake).
-   */
-  async getUsers(uids: string[]): Promise<{ uid: string; email?: string }[]> {
-    return uids.map((uid) => ({ uid }));
-  }
-
-  /**
-   * Record a user deletion by appending the UID to {@link FakeFirebaseVerifier.deleted}.
-   *
-   * @param uid - UID being deleted.
-   */
-  async deleteUser(uid: string): Promise<void> {
-    this.deleted.push(uid);
-  }
-}
-
-/**
- * Options for {@link createPoolDatabase}.
- *
- * @typeParam TDrizzle - The Drizzle instance type, supplied by the consumer so that type identity is
- *   not coupled to this package's copy of `drizzle-orm`.
- */
-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`, e.g. `drizzle(pool, { schema, ... })`. */
-  orm: TDrizzle;
-}
-
-/**
- * Create a `Database` backed by a single pool used as both primary and replica, suitable for tests.
- *
- * @remarks
- * `dispose()` ends the pool. The `orm` is provided by the caller (rather than constructed here) so
- * the returned database uses the consumer's own `drizzle-orm` types, avoiding type-identity clashes
- * across duplicated `drizzle-orm` installs.
- *
- * @typeParam TDrizzle - The Drizzle instance type provided by the consumer.
- * @param options - Pool and Drizzle instance. See {@link CreatePoolDatabaseOptions}.
- * @returns A {@link DisposableDatabase} whose `dispose()` closes the pool.
- * @example
- * ```ts
- * const pool = testDb.createTestPool();
- * const db = createPoolDatabase({ pool, orm: drizzle(pool, { schema }) });
- * // ... run tests ...
- * await db.dispose();
- * ```
- */
-export function createPoolDatabase<TDrizzle>(
-  options: CreatePoolDatabaseOptions<TDrizzle>,
-): DisposableDatabase<TDrizzle> {
-  const { pool, orm } = options;
-  const base = databaseFrom(orm, pool);
-  return {
-    ...base,
-    async dispose(): Promise<void> {
-      await pool.end();
-    },
-  };
-}
-
-/**
- * Create a no-op `Database` stub for routes that never touch the database (e.g. plain GET handlers).
- *
- * @remarks
- * `read` resolves to an empty array, while `write` and `transaction` throw so that any unexpected
- * database access is caught as a misuse. `dispose` is a no-op, so this can stand in for a
- * {@link DisposableDatabase} backing (e.g. a Hyperdrive- or pool-based one) without changes.
- *
- * @typeParam TDrizzle - The Drizzle instance type the consumer expects (defaults to `unknown`).
- * @returns A {@link DisposableDatabase} that reads empty and throws on writes/transactions.
- * @throws Error from `write`/`transaction` if they are accessed.
- * @example
- * ```ts
- * const db = createNoopDatabase();
- * await db.read('SELECT 1'); // []
- * await db.write(async (dz) => dz); // throws: noopDatabase.write accessed unexpectedly
- * ```
- */
-export function createNoopDatabase<TDrizzle = unknown>(): DisposableDatabase<TDrizzle> {
-  return {
-    read: async () => [],
-    write: () => {
-      throw new Error('noopDatabase.write accessed unexpectedly');
-    },
-    transaction: () => {
-      throw new Error('noopDatabase.transaction accessed unexpectedly');
-    },
-    dispose: async () => {},
-  };
-}

package/src/testing/index.ts

@@ -1,31 +0,0 @@
-/**
- * Shared test infrastructure for Hono on Cloudflare Workers projects (depends on `mysql2`/`drizzle-orm`).
- *
- * Test-only helpers that are never loaded at runtime. This subpath consolidates the duplicated
- * test boilerplate (test DB setup, in-memory fakes, auth header builders, Stripe fixtures) that
- * tends to be copy-pasted across projects into a single, importable surface.
- */
-
-export { createTestDb } from './db.js';
-export type { TestDb, CreateTestDbOptions, TestDbConnection } from './db.js';
-
-export { FakeFirebaseVerifier, createPoolDatabase, createNoopDatabase } from './fakes.js';
-export type { CreatePoolDatabaseOptions } from './fakes.js';
-export type { Database, DisposableDatabase, QueryRunner, TxOf } from '../db/database.js';
-
-// Authentication test helpers (route-spec header builders and user provisioning).
-export { authHeaders, registerFirebaseToken, provisionUser } from './auth.js';
-
-// Test double helper (partial-implementation fake that throws explicitly on unconfigured members).
-export { configurableFake } from './configurable-fake.js';
-
-// Test fixture factories for Stripe objects.
-export {
-  fakeApiList,
-  fakePaymentIntent,
-  fakeStripeEvent,
-  fakeCheckoutSession,
-  fakeCustomer,
-  fakePrice,
-  fakeSubscription,
-} from './stripe-fixtures.js';