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

package/scripts/workspace-package-smoke.mjs

@@ -0,0 +1,206 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(fileURLToPath(new URL('../../..', import.meta.url)));
+const temporaryDirectory = mkdtempSync(join(tmpdir(), 'workers-workspace-smoke-'));
+const commandEnvironment = {
+  ...process.env,
+  npm_config_cache: join(temporaryDirectory, 'npm-cache'),
+};
+
+function pack(workspace) {
+  const args = ['pack', '--json', '--pack-destination', temporaryDirectory, '--workspace', workspace];
+  const result = JSON.parse(
+    execFileSync('npm', args, {
+      cwd: root,
+      encoding: 'utf8',
+      env: commandEnvironment,
+    }),
+  );
+  return join(temporaryDirectory, result[0].filename);
+}
+
+try {
+  const timezoneTarball = pack('@rdlabo/workers-timezone');
+  const mysqlTarball = pack('@rdlabo/workers-mysql');
+  const kitTarball = pack('@rdlabo/workers-hono-kit');
+  const rootConsumer = join(temporaryDirectory, 'root-consumer');
+  mkdirSync(rootConsumer);
+  writeFileSync(join(rootConsumer, 'package.json'), '{"private":true,"type":"module"}\n');
+  execFileSync('npm', ['install', '--ignore-scripts', kitTarball, 'ai-gateway-provider@^3.1.0'], {
+    cwd: rootConsumer,
+    stdio: 'inherit',
+    env: commandEnvironment,
+  });
+  if (existsSync(join(rootConsumer, 'node_modules', '@rdlabo', 'workers-timezone'))) {
+    throw new Error('The optional timezone peer was installed for a root consumer');
+  }
+  if (existsSync(join(rootConsumer, 'node_modules', 'drizzle-orm'))) {
+    throw new Error('The optional drizzle peer was installed for a root consumer');
+  }
+  if (existsSync(join(rootConsumer, 'node_modules', '@rdlabo', 'workers-mysql'))) {
+    throw new Error('The optional MySQL package was installed for a root consumer');
+  }
+  if (existsSync(join(rootConsumer, 'node_modules', 'mysql2'))) {
+    throw new Error('mysql2 was installed for a root consumer');
+  }
+  writeFileSync(
+    join(rootConsumer, 'smoke.mjs'),
+    `import * as kit from "@rdlabo/workers-hono-kit";
+const { HttpStatus } = kit;
+if (HttpStatus.OK !== 200) process.exit(1);
+if ("createContainerRuntime" in kit) process.exit(1);
+if ("retryWhenDeadlock" in kit) process.exit(1);
+// The legacy testing barrel intentionally requires the optional MySQL package.
+const { rejects } = await import("node:assert/strict");
+await rejects(import("@rdlabo/workers-hono-kit/testing"), (error) =>
+  error.code === "ERR_MODULE_NOT_FOUND" && error.message.includes("@rdlabo/workers-mysql"));
+`,
+  );
+  writeFileSync(
+    join(rootConsumer, 'smoke.ts'),
+    `import { HttpStatus } from "@rdlabo/workers-hono-kit";
+const ok: number = HttpStatus.OK;
+void ok;
+`,
+  );
+  writeFileSync(
+    join(rootConsumer, 'tsconfig.json'),
+    '{"compilerOptions":{"strict":true,"module":"ESNext","moduleResolution":"Bundler","target":"ES2022","noEmit":true,"skipLibCheck":true},"include":["smoke.ts"]}\n',
+  );
+  execFileSync('node', ['smoke.mjs'], { cwd: rootConsumer, stdio: 'inherit' });
+  execFileSync(join(root, 'node_modules', '.bin', 'tsc'), ['-p', 'tsconfig.json'], {
+    cwd: rootConsumer,
+    stdio: 'inherit',
+  });
+
+  const timezoneConsumer = join(temporaryDirectory, 'timezone-consumer');
+  mkdirSync(timezoneConsumer);
+  writeFileSync(join(timezoneConsumer, 'package.json'), '{"private":true,"type":"module"}\n');
+  execFileSync('npm', ['install', '--ignore-scripts', timezoneTarball, kitTarball, 'ai-gateway-provider@^3.1.0'], {
+    cwd: timezoneConsumer,
+    stdio: 'inherit',
+    env: commandEnvironment,
+  });
+  writeFileSync(
+    join(timezoneConsumer, 'smoke.mjs'),
+    `import { initializeTimezone, toLocalDateTime } from "@rdlabo/workers-timezone";
+import { getTimezoneConfig, toBusinessDateTime } from "@rdlabo/workers-hono-kit/business-time";
+initializeTimezone({ timeZone: "America/New_York" });
+const instant = new Date("2026-07-01T13:00:00Z");
+if (toLocalDateTime(instant) !== "2026-07-01 09:00:00") process.exit(1);
+if (toBusinessDateTime(instant) !== "2026-07-01 09:00:00") process.exit(1);
+if (getTimezoneConfig().timeZone !== "America/New_York") process.exit(1);
+`,
+  );
+  writeFileSync(
+    join(timezoneConsumer, 'smoke.ts'),
+    `import { type TimeZone } from "@rdlabo/workers-timezone";
+import { type BusinessTimeZone } from "@rdlabo/workers-hono-kit/business-time";
+const current: TimeZone = "Europe/London";
+const legacy: BusinessTimeZone = current;
+void legacy;
+`,
+  );
+  writeFileSync(
+    join(timezoneConsumer, 'tsconfig.json'),
+    '{"compilerOptions":{"strict":true,"module":"ESNext","moduleResolution":"Bundler","target":"ES2022","noEmit":true,"skipLibCheck":true},"include":["smoke.ts"]}\n',
+  );
+  execFileSync('node', ['smoke.mjs'], { cwd: timezoneConsumer, stdio: 'inherit' });
+  execFileSync(join(root, 'node_modules', '.bin', 'tsc'), ['-p', 'tsconfig.json'], {
+    cwd: timezoneConsumer,
+    stdio: 'inherit',
+  });
+
+  const mysqlCoreConsumer = join(temporaryDirectory, 'mysql-core-consumer');
+  mkdirSync(mysqlCoreConsumer);
+  writeFileSync(join(mysqlCoreConsumer, 'package.json'), '{"private":true,"type":"module"}\n');
+  execFileSync('npm', ['install', '--ignore-scripts', mysqlTarball, '@types/node@20.19.43'], {
+    cwd: mysqlCoreConsumer,
+    stdio: 'inherit',
+    env: commandEnvironment,
+  });
+  if (existsSync(join(mysqlCoreConsumer, 'node_modules', 'drizzle-orm'))) {
+    throw new Error('The optional drizzle peer was installed for a MySQL core consumer');
+  }
+  writeFileSync(
+    join(mysqlCoreConsumer, 'smoke.mjs'),
+    `import { MYSQL_TIMEZONE, toJstDate } from "@rdlabo/workers-mysql";
+if (MYSQL_TIMEZONE !== "+09:00") process.exit(1);
+if (toJstDate("1950-07-01T14:30:00Z") !== "1950-07-01") process.exit(1);
+`,
+  );
+  execFileSync('node', ['smoke.mjs'], { cwd: mysqlCoreConsumer, stdio: 'inherit' });
+  writeFileSync(
+    join(mysqlCoreConsumer, 'smoke.ts'),
+    'import { type Database, MYSQL_TIMEZONE } from "@rdlabo/workers-mysql";\ndeclare const db: Database<unknown>;\nvoid db; void MYSQL_TIMEZONE;\n',
+  );
+  writeFileSync(
+    join(mysqlCoreConsumer, 'tsconfig.json'),
+    '{"compilerOptions":{"strict":true,"module":"ESNext","moduleResolution":"Bundler","target":"ES2022","noEmit":true,"skipLibCheck":false},"include":["smoke.ts"]}\n',
+  );
+  execFileSync(join(root, 'node_modules', '.bin', 'tsc'), ['-p', 'tsconfig.json'], {
+    cwd: mysqlCoreConsumer,
+    stdio: 'inherit',
+  });
+
+  const databaseConsumer = join(temporaryDirectory, 'database-consumer');
+  mkdirSync(databaseConsumer);
+  writeFileSync(join(databaseConsumer, 'package.json'), '{"private":true,"type":"module"}\n');
+  execFileSync(
+    'npm',
+    ['install', '--ignore-scripts', mysqlTarball, kitTarball, 'drizzle-orm@^0.45.2', 'ai-gateway-provider@^3.1.0'],
+    {
+      cwd: databaseConsumer,
+      stdio: 'inherit',
+      env: commandEnvironment,
+    },
+  );
+  if (existsSync(join(databaseConsumer, 'node_modules', '@rdlabo', 'workers-timezone'))) {
+    throw new Error('The optional timezone peer was installed for a database-only consumer');
+  }
+  writeFileSync(
+    join(databaseConsumer, 'smoke.mjs'),
+    `import { MYSQL_TIMEZONE, toJstDate } from "@rdlabo/workers-mysql";
+import { workersDrizzleConfig } from "@rdlabo/workers-mysql/drizzle";
+import { MYSQL_TIMEZONE as legacyTimezone, toJstDate as legacyToJstDate } from "@rdlabo/workers-hono-kit/db";
+import { createContainerRuntime } from "@rdlabo/workers-hono-kit/mysql";
+import { FakeFirebaseVerifier, fakeKv } from "@rdlabo/workers-hono-kit/testing";
+if (typeof FakeFirebaseVerifier !== "function" || typeof fakeKv !== "function") process.exit(1);
+if (MYSQL_TIMEZONE !== "+09:00") process.exit(1);
+if (legacyTimezone !== MYSQL_TIMEZONE) process.exit(1);
+if (legacyToJstDate !== toJstDate) process.exit(1);
+if (toJstDate("1950-07-01T14:30:00Z") !== "1950-07-01") process.exit(1);
+if (workersDrizzleConfig({ database: "app" }).casing !== "snake_case") process.exit(1);
+if (typeof createContainerRuntime !== "function") process.exit(1);
+`,
+  );
+  writeFileSync(
+    join(databaseConsumer, 'smoke.ts'),
+    `import { MYSQL_TIMEZONE, toJstDate } from "@rdlabo/workers-mysql";
+import { workersDrizzleConfig } from "@rdlabo/workers-mysql/drizzle";
+import { createContainerRuntime } from "@rdlabo/workers-hono-kit/mysql";
+const timezone: string = MYSQL_TIMEZONE;
+const date: string | null = toJstDate("2026-07-01T00:00:00Z");
+const config = workersDrizzleConfig({ database: "app" });
+void timezone;
+void date;
+void config;
+void createContainerRuntime;
+`,
+  );
+  writeFileSync(
+    join(databaseConsumer, 'tsconfig.json'),
+    '{"compilerOptions":{"strict":true,"module":"ESNext","moduleResolution":"Bundler","target":"ES2022","noEmit":true,"skipLibCheck":true},"include":["smoke.ts"]}\n',
+  );
+  execFileSync('node', ['smoke.mjs'], { cwd: databaseConsumer, stdio: 'inherit' });
+  execFileSync(join(root, 'node_modules', '.bin', 'tsc'), ['-p', 'tsconfig.json'], {
+    cwd: databaseConsumer,
+    stdio: 'inherit',
+  });
+} finally {
+  rmSync(temporaryDirectory, { recursive: true, force: true });
+}

package/dist/business-time/types.d.ts

@@ -1,9 +0,0 @@
-/** A JST business calendar date `YYYY-MM-DD` (a calendar day, not an instant). */
-export type BusinessDate = string;
-/** A JST business date-time `YYYY-MM-DD HH:mm:ss` (a wall-clock value, MySQL `DATETIME`-compatible). */
-export type BusinessDateTime = string;
-/** JST business timezone constant. Workers run in UTC instants; business time is made explicit here. */
-export declare const BUSINESS_TIMEZONE: {
-    readonly iana: "Asia/Tokyo";
-    readonly offsetMinutes: 540;
-};

package/dist/business-time/types.js

@@ -1,5 +0,0 @@
-/** JST business timezone constant. Workers run in UTC instants; business time is made explicit here. */
-export const BUSINESS_TIMEZONE = {
-    iana: 'Asia/Tokyo',
-    offsetMinutes: 540,
-};

package/dist/db/columns.d.ts

@@ -1,38 +0,0 @@
-/**
- * SQL expression for `ON UPDATE CURRENT_TIMESTAMP` (the MySQL session clock).
- * customType columns have no `.onUpdateNow()`, so pair this with `.$onUpdateFn(() => jstOnUpdateNow(fsp))`.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `CURRENT_TIMESTAMP(fsp)`.
- */
-export declare const jstOnUpdateNow: (fsp?: number) => import("drizzle-orm").SQL<unknown>;
-/** MySQL `timestamp` — pass-through. A `Date` is formatted as JST by mysql2 via the connection `timezone:'+09:00'`. */
-export declare const jstTimestamp: (name: string, opts?: {
-    fsp?: number;
-}) => import("drizzle-orm/mysql-core").MySqlCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "MySqlCustomColumn";
-    data: string | Date;
-    driverParam: string | Date;
-    enumValues: undefined;
-}>;
-/** MySQL `datetime` — same pass-through policy as {@link jstTimestamp}. */
-export declare const jstDatetime: (name: string, opts?: {
-    fsp?: number;
-}) => import("drizzle-orm/mysql-core").MySqlCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "MySqlCustomColumn";
-    data: string | Date;
-    driverParam: string | Date;
-    enumValues: undefined;
-}>;
-/** MySQL `date` — on INSERT/UPDATE, normalizes ISO / empty strings to `YYYY-MM-DD` (via `toDriver`). */
-export declare const jstDate: (name: string) => import("drizzle-orm/mysql-core").MySqlCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "MySqlCustomColumn";
-    data: string | null;
-    driverParam: string | null;
-    enumValues: undefined;
-}>;

package/dist/db/columns.js

@@ -1,38 +0,0 @@
-/**
- * Shared Drizzle column helpers. Removes the need for a thin `custom-types.ts` / `columns.ts` wrapper
- * in each repo.
- *
- * @remarks
- * `drizzle-orm` is a **peer** (the consumer resolves a single copy); the kit does not bundle it. The
- * return types are the `customType` inference as-is (`MySqlCustomColumnBuilder<…>`) with no `any`, so
- * the column's semantic type (`string | Date`, etc.) propagates to the consumer table's `$inferSelect`.
- *
- * **Precondition (a single drizzle copy)**: Drizzle's `SQL` is a **nominal** type carrying a private
- * field `shouldInlineParams`, so if the kit and the consumer resolve different copies of drizzle,
- * `jstTimestamp(…).default(sql\`…\`)` fails with `TS2345: separate declarations of a private property
- * 'shouldInlineParams'`. The fleet references the kit via a `file:` link, which tends to nest a second
- * copy of drizzle under the kit. Pin `drizzle-orm` to the consumer's **own single copy** with tsconfig
- * `paths` (see the "Drizzle column helpers" section of the README). The published package (a single
- * copy) is already unified.
- *
- * **DEFAULT / ON UPDATE CURRENT_TIMESTAMP** is a server-side default (an INSERT / UPDATE that omits the
- * column). The connection's `timezone:'+09:00'` ({@link hyperdriveConnectionOptions}) only applies when
- * the **app binds a `Date`**. Do not conflate the two (see the `datetime-wire` / `drizzle-smoke` JST
- * tests).
- */
-import { sql } from 'drizzle-orm';
-import { customType } from 'drizzle-orm/mysql-core';
-import { jstDateParams, jstDatetimeParams, jstTimestampParams } from './jst.js';
-/**
- * SQL expression for `ON UPDATE CURRENT_TIMESTAMP` (the MySQL session clock).
- * customType columns have no `.onUpdateNow()`, so pair this with `.$onUpdateFn(() => jstOnUpdateNow(fsp))`.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `CURRENT_TIMESTAMP(fsp)`.
- */
-export const jstOnUpdateNow = (fsp) => fsp != null ? sql `(CURRENT_TIMESTAMP(${sql.raw(String(fsp))}))` : sql `(CURRENT_TIMESTAMP)`;
-/** MySQL `timestamp` — pass-through. A `Date` is formatted as JST by mysql2 via the connection `timezone:'+09:00'`. */
-export const jstTimestamp = (name, opts) => customType(jstTimestampParams(opts?.fsp))(name);
-/** MySQL `datetime` — same pass-through policy as {@link jstTimestamp}. */
-export const jstDatetime = (name, opts) => customType(jstDatetimeParams(opts?.fsp))(name);
-/** MySQL `date` — on INSERT/UPDATE, normalizes ISO / empty strings to `YYYY-MM-DD` (via `toDriver`). */
-export const jstDate = (name) => customType(jstDateParams())(name);

package/dist/db/connection.d.ts

@@ -1,74 +0,0 @@
-import type { Connection } from 'mysql2/promise';
-import type { ExecutionContextLike } from '../http/execution-context.js';
-export type { ExecutionContextLike } from '../http/execution-context.js';
-/**
- * Minimal structural shape of a Cloudflare Hyperdrive binding.
- *
- * @remarks
- * Declared structurally to avoid a dependency on `@cloudflare/workers-types`; any object with these
- * connection fields satisfies it.
- */
-export interface HyperdriveLike {
-    /** Database host to connect to. */
-    host: string;
-    /** Database user. */
-    user: string;
-    /** Database password. */
-    password: string;
-    /** Database name. */
-    database: string;
-    /** Database port. */
-    port: number;
-}
-/**
- * Build mysql2 `createConnection` options from a Hyperdrive binding, applying the kit's defaults.
- *
- * @remarks
- * Three defaults are applied and can each be overridden via `extra`:
- *
- * - `disableEval: true` — `eval` is unavailable in the Workers runtime, so the driver's eval-based
- *   fast paths must be disabled.
- * - `decimalNumbers: true` — return `DECIMAL`/`NEWDECIMAL` columns as JS `number` rather than
- *   strings, so raw-SQL reads and Drizzle's inferred types align on a single numeric domain type.
- *   This assumes no column's precision exceeds the JS safe-integer range.
- * - `timezone: '+09:00'` — interpret and serialize JavaScript `Date` values as JST. This is a
- *   mysql2 client-side conversion option; it does not issue `SET time_zone` or change the MySQL
- *   session timezone. Non-JST deployments can override it via `extra: { timezone: '...' }`.
- *
- * @param hyperdrive - the Hyperdrive binding to derive connection fields from.
- * @param extra - additional mysql2 options merged last, overriding the defaults above.
- * @returns a plain options object to pass to mysql2 `createConnection`.
- */
-export declare function hyperdriveConnectionOptions(hyperdrive: HyperdriveLike, extra?: Record<string, unknown>): Record<string, unknown>;
-/**
- * Open primary and replica connections in parallel and run `fn` with them.
- *
- * Cloudflare Workers automatically cleans up connections created during an invocation. Calling
- * `Connection.end()` is unnecessary and can race work registered with `waitUntil`. The `ctx`
- * parameter remains for API compatibility and is intentionally not used for connection teardown.
- *
- * @typeParam T - resolved value produced by `fn`.
- * @param hyperdrives - the primary and replica Hyperdrive bindings to connect to.
- * @param ctx - the request execution context, retained for API compatibility.
- * @param fn - callback invoked with the open `primary` and `replica` connections.
- * @param connectionOptions - extra mysql2 options forwarded to {@link hyperdriveConnectionOptions}.
- * @returns the value resolved by `fn`.
- * @example
- * ```ts
- * const data = await withMysqlConnections(
- *   { primary: env.PRIMARY, replica: env.REPLICA },
- *   ctx,
- *   async ({ primary, replica }) => {
- *     const [rows] = await replica.query('SELECT 1');
- *     return rows;
- *   },
- * );
- * ```
- */
-export declare function withMysqlConnections<T>(hyperdrives: {
-    primary: HyperdriveLike;
-    replica: HyperdriveLike;
-}, ctx: ExecutionContextLike, fn: (connections: {
-    primary: Connection;
-    replica: Connection;
-}) => Promise<T>, connectionOptions?: Record<string, unknown>): Promise<T>;

package/dist/db/connection.js

@@ -1,67 +0,0 @@
-import { createConnection } from 'mysql2/promise';
-import { MYSQL_TIMEZONE } from './jst.js';
-/**
- * Build mysql2 `createConnection` options from a Hyperdrive binding, applying the kit's defaults.
- *
- * @remarks
- * Three defaults are applied and can each be overridden via `extra`:
- *
- * - `disableEval: true` — `eval` is unavailable in the Workers runtime, so the driver's eval-based
- *   fast paths must be disabled.
- * - `decimalNumbers: true` — return `DECIMAL`/`NEWDECIMAL` columns as JS `number` rather than
- *   strings, so raw-SQL reads and Drizzle's inferred types align on a single numeric domain type.
- *   This assumes no column's precision exceeds the JS safe-integer range.
- * - `timezone: '+09:00'` — interpret and serialize JavaScript `Date` values as JST. This is a
- *   mysql2 client-side conversion option; it does not issue `SET time_zone` or change the MySQL
- *   session timezone. Non-JST deployments can override it via `extra: { timezone: '...' }`.
- *
- * @param hyperdrive - the Hyperdrive binding to derive connection fields from.
- * @param extra - additional mysql2 options merged last, overriding the defaults above.
- * @returns a plain options object to pass to mysql2 `createConnection`.
- */
-export function hyperdriveConnectionOptions(hyperdrive, extra) {
-    return {
-        host: hyperdrive.host,
-        user: hyperdrive.user,
-        password: hyperdrive.password,
-        database: hyperdrive.database,
-        port: hyperdrive.port,
-        disableEval: true,
-        decimalNumbers: true,
-        timezone: MYSQL_TIMEZONE,
-        ...extra,
-    };
-}
-/**
- * Open primary and replica connections in parallel and run `fn` with them.
- *
- * Cloudflare Workers automatically cleans up connections created during an invocation. Calling
- * `Connection.end()` is unnecessary and can race work registered with `waitUntil`. The `ctx`
- * parameter remains for API compatibility and is intentionally not used for connection teardown.
- *
- * @typeParam T - resolved value produced by `fn`.
- * @param hyperdrives - the primary and replica Hyperdrive bindings to connect to.
- * @param ctx - the request execution context, retained for API compatibility.
- * @param fn - callback invoked with the open `primary` and `replica` connections.
- * @param connectionOptions - extra mysql2 options forwarded to {@link hyperdriveConnectionOptions}.
- * @returns the value resolved by `fn`.
- * @example
- * ```ts
- * const data = await withMysqlConnections(
- *   { primary: env.PRIMARY, replica: env.REPLICA },
- *   ctx,
- *   async ({ primary, replica }) => {
- *     const [rows] = await replica.query('SELECT 1');
- *     return rows;
- *   },
- * );
- * ```
- */
-export async function withMysqlConnections(hyperdrives, ctx, fn, connectionOptions) {
-    void ctx;
-    const [primary, replica] = await Promise.all([
-        createConnection(hyperdriveConnectionOptions(hyperdrives.primary, connectionOptions)),
-        createConnection(hyperdriveConnectionOptions(hyperdrives.replica, connectionOptions)),
-    ]);
-    return fn({ primary, replica });
-}