@oyolincc/create 0.0.0-dev-20260918103756 → 0.0.0-dev-20261006065712

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oyolincc/create",
-  "version": "0.0.0-dev-20260918103756",
+  "version": "0.0.0-dev-20261006065712",
   "description": "@oyolincc/create",
   "homepage": "https://github.com/oyolincc/lib#readme",
   "bugs": {

package/templates/hono-fullstack/.vscode/launch.json

@@ -10,6 +10,20 @@
       "sourceMaps": true,
       "type": "node-terminal"
     },
+    {
+      "command": "pnpm -C apps/server dev:node-chain",
+      "name": "repo-server",
+      "request": "launch",
+      "sourceMaps": true,
+      "type": "node-terminal"
+    },
+    {
+      "command": "pnpm -C apps/stack dev:node",
+      "name": "repo-stack",
+      "request": "launch",
+      "sourceMaps": true,
+      "type": "node-terminal"
+    },
     {
       "name": "Attach to process",
       "port": 19230,
@@ -18,8 +32,5 @@
       "type": "node"
     }
   ],
-  // Use IntelliSense to learn about possible attributes.
-  // Hover to view descriptions of existing attributes.
-  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
   "version": "0.2.0"
 }

package/templates/hono-fullstack/.vscode/settings.json

@@ -20,5 +20,7 @@
   "editor.codeActionsOnSave": {
     "source.fixAll.oxc": "explicit"
   },
-  "oxc.enable.oxlint": false
+  "oxc.enable.oxlint": false,
+  "oxc.disableNestedConfig": true,
+  "oxc.fmt.disableNestedConfig": true
 }

package/templates/hono-fullstack/AGENTS.md

@@ -10,6 +10,13 @@ Docs are local at `node_modules/vite-plus/docs` or online at https://viteplus.de
 
 `vp <name>` runs a built-in command. `vp run <name>` runs a `package.json` script or a `vite.config.ts` task. Scripts cannot overwrite built-ins, so `vp dev` and `vp run dev` may do different things. Check `package.json` and `vite.config.ts` first, and run `vp run <name>` when the project defines a script or task with that name.
 
+## Tool Versions
+
+Run `vp toolchain` to show versions and relationships in the active Vite+
+release. Add a tool name to select part of the graph. For example, run
+`vp toolchain vite`. Use `--global` to ignore the local `vite-plus` package. Use
+`vp why <package>` to show the package-manager dependency graph.
+
 ## Review Checklist
 
 - [ ] Run `vp install` after pulling remote changes and before getting started.

package/templates/hono-fullstack/README.md

@@ -1,37 +1,51 @@
 # Hono fullstack monorepo
 
-TanStack Start and Nitro serve the frontend while mounting the independently buildable `@repo/server` Hono application in-process under `/api`. SQLite/Drizzle and shared definitions live in their own packages.
+TanStack Start and Nitro serve the frontend while mounting the independently buildable `@repo/server` Hono application in-process under `/api`. The same stack can run on Cloudflare Workers with D1. SQLite/Drizzle and shared definitions live in their own packages.
 
 ## Layout
 
-- `apps/stack/frontend`: TanStack Start UI, Router, React Query, Jotai, and shared API client.
-- `apps/stack/nitro`: the thin Nitro handler and shutdown adapter for `@repo/server/node`.
+- `apps/stack/frontend`: TanStack Start UI, Router, React Query, Jotai, shared API client, and the `/api/$` server route.
+- `apps/stack/backend`: runtime-specific adapters for `@repo/server/nodejs` and `@repo/server/cloudflare`.
 - `apps/server`: independently buildable and startable Hono server and worker runtime.
 - `libs/definition`: backend/frontend contracts and environment definitions.
-- `libs/db`: SQLite/Drizzle client, schema, relations, and manual migration commands.
+- `libs/db`: SQLite/Drizzle and D1 clients, schema, relations, and manual migration commands.
 
 ## Setup
 
 ```bash
 pnpm install
+pnpm --filter @repo/server cf:typegen
+pnpm --filter @repo/stack cf:typegen
+cp apps/stack/.dev.vars.example apps/stack/.dev.vars
 cp envs/.env.example.server envs/.env.server
 cp envs/.env.example.sqlite envs/.env.sqlite
+cp envs/.env.example.sqlite-d1 envs/.env.sqlite-d1
 pnpm prepare
-pnpm dev:sqlite:push
-pnpm dev
+pnpm --filter @repo/db dev:sqlite:push
+pnpm -C apps/stack dev:node-chain
 ```
 
-Database schema changes remain manual: use `dev:sqlite:gen`, `dev:sqlite:migrate`, or `dev:sqlite:push`; startup never mutates the schema.
+Database schema changes remain manual. Cloudflare D1 uses the same SQLite schema and migration directory with separate credentials and commands. Production Worker variables are configured in the Cloudflare dashboard; `.dev.vars` is only for local development.
+
+Cloudflare runtime and binding types are generated from each runnable Worker's Wrangler config. Rerun the corresponding `cf:typegen` command after changing compatibility settings or bindings.
+
+Before deploying, replace the placeholder D1 `database_id` and `database_name` in both Wrangler configs. Keep production variables in the Cloudflare dashboard rather than committing them.
+
+Example tasks run in-process through `PassThroughWorkRunner` by default. The complete Piscina implementation remains available: enable `PiscinaWorkRunner` in the Node.js adapter and the adjacent worker pack entry in `apps/server/vite.config.ts` to use worker threads.
 
 ## Commands
 
-- `pnpm dev`: perform the initial dependency build, then watch definition, DB, server artifacts, and Stack together.
+- `pnpm -C apps/stack dev:node-chain`: build upstream dependencies, then watch the Node stack and its dependencies.
+- `pnpm -C apps/stack dev:cloudflare-chain`: build upstream dependencies, then watch the Cloudflare stack and its dependencies.
 - `pnpm build`: build all workspace packages, including Nitro's `.output`.
-- `pnpm dev:sqlite:push`: push the SQLite schema manually for local development.
-- `pnpm dev:sqlite:gen` / `pnpm dev:sqlite:migrate`: generate or apply migrations manually.
-- `pnpm --filter @repo/server dev`: start Hono independently.
-- `pnpm --filter @repo/server test`: run server contract and worker tests.
-
-Nitro exposes health at `/api/health`, OpenAPI YAML at `/api/docs/openapi.yaml`, Swagger at `/api/swagger`, CRUD at `/api/examples`, and worker processing at `/api/examples/process`. `pnpm --filter @repo/server dev` starts the same Hono application independently without the `/api` prefix.
+- `pnpm --filter @repo/db dev:sqlite:push`: push the local SQLite schema manually.
+- `pnpm --filter @repo/db dev:sqlite:gen` / `pnpm --filter @repo/db dev:sqlite:migrate`: generate or apply SQLite migrations manually.
+- `pnpm --filter @repo/db dev:d1:gen` / `pnpm --filter @repo/db dev:d1:migrate`: generate or apply D1 migrations manually.
+- `pnpm --filter @repo/server cf:typegen` / `pnpm --filter @repo/stack cf:typegen`: generate Cloudflare runtime and binding types.
+- `pnpm --filter @repo/server dev`: start Hono independently on Node.js.
+- `pnpm --filter @repo/server dev:cloudflare`: start Hono independently on local workerd and D1.
+- `pnpm --filter @repo/server test`: run the retained server tests.
+
+The stack exposes health at `/api/health`, OpenAPI YAML at `/api/docs/openapi.yaml`, Swagger at `/api/swagger`, CRUD at `/api/examples`, and worker processing at `/api/examples/process`. The independently started Hono app uses `SERVER_BASE_PATH`.
 
 The example vertical slice may be removed after replacing its definition, table, Hono routes, worker task, API hooks, and page together. Docker and CI are intentionally not included in this Fullstack template.

package/templates/hono-fullstack/_gitignore

@@ -10,6 +10,7 @@ lerna-debug.log*
 node_modules
 dist
 dist-ssr
+.output
 *.local
 
 # Editor directories and files
@@ -28,3 +29,6 @@ dist-ssr
 .worktrees/
 **/temp/
 .turbo
+.wrangler
+.dev.vars
+db-data

package/templates/hono-fullstack/apps/server/.dev.vars.example

@@ -0,0 +1,9 @@
+SERVER_BASE_PATH=/api
+SERVER_ENV=local
+LOGGER_LEVEL=debug
+CORS_DOMAINS='*'
+# MIN_THREADS=1
+# MAX_THREADS=4
+# CONCURRENT_TASKS_PER_WORKER=1
+# MAX_QUEUE=12
+# WORKER_TASK_TIMEOUT_MS=30000

package/templates/hono-fullstack/apps/server/package.json

@@ -2,19 +2,25 @@
   "name": "@repo/server",
   "version": "0.0.0",
   "private": true,
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "type": "module",
   "exports": {
-    "./node": "./dist/nodeEntry.mjs",
+    "./nodejs": "./dist/nodejsEntry.mjs",
+    "./cloudflare": "./dist/cloudflareEntry.mjs",
     "./package.json": "./package.json"
   },
   "scripts": {
-    "dev": "concurrently -k -n dev,pack -c blue,green \"vp dev\" \"VITE_PUBLIC_DEV_SERVE=1 vp pack --watch\"",
-    "dev:pack": "VITE_PUBLIC_DEV_SERVE=1 vp pack --watch",
-    "start": "oyo env server -- node dist/nodeMain.mjs",
-    "build": "vp pack",
+    "dev": "pnpm dev:node",
+    "build": "pnpm build:node",
+    "dev:node-chain": "turbo watch dev:node --filter=@repo/server",
+    "dev:node": "concurrently -k -n dev,pack -c blue,green \"vp dev\" \"VITE_PUBLIC_DEV_SERVE=1 vp pack --watch\"",
+    "dev:cloudflare-chain": "turbo watch dev:cloudflare --filter=@repo/server",
+    "dev:cloudflare": "wrangler dev --config wrangler.jsonc --persist-to ../../.wrangler/state",
+    "db:migrate:cloudflare:local": "wrangler d1 migrations apply DB --local --config wrangler.jsonc --persist-to ../../.wrangler/state",
+    "build:node-chain": "turbo build:node --filter=@repo/server",
+    "build:node": "vp pack",
+    "cf:typegen": "wrangler types --config wrangler.jsonc",
+    "cf:typecheck": "wrangler types --config wrangler.jsonc --check",
     "test": "vp test",
     "check": "vp check"
   },
@@ -28,7 +34,7 @@
     "change-case": "catalog:shared",
     "defu": "catalog:shared",
     "dotenv": "catalog:",
-    "drizzle-orm": "catalog:drizzle",
+    "drizzle-orm": "catalog:db",
     "hono": "catalog:server",
     "hono-openapi": "catalog:server",
     "hono-pino": "catalog:server",
@@ -51,6 +57,7 @@
     "pino-pretty": "catalog:server",
     "tsx": "catalog:",
     "typescript": "catalog:",
-    "vite-plus": "catalog:"
+    "vite-plus": "catalog:",
+    "wrangler": "catalog:"
   }
 }

package/templates/hono-fullstack/apps/server/src/adapters/cloudflare/entry.ts

@@ -0,0 +1,36 @@
+import { createD1Client } from '@repo/db/sqlite/d1-client'
+import { env } from 'cloudflare:workers'
+import { getRuntimeKey } from 'hono/adapter'
+import { createApp } from '@/app'
+import { resolveConfig } from '@/config'
+import { setRootLogger } from '@/infra/logger/getter'
+import { createPinoLogger } from '@/infra/logger/pino'
+import { PassThroughWorkRunner } from '@/infra/work-runner/pass-through/runner'
+import type { AppDependencies, AppLogger } from '@/shared/app/types'
+
+const appConfig = resolveConfig(env as any)
+const { runtime, log } = appConfig
+const { rootLogger, loggerHandler } = createPinoLogger({
+  isLocal: runtime.isLocal,
+  logBase: log.base,
+  runtime: getRuntimeKey(),
+  logRoll: log.roll,
+  logPretty: log.pretty,
+})
+setRootLogger(rootLogger as unknown as AppLogger)
+
+export const workRunner = new PassThroughWorkRunner()
+const d1Client = createD1Client(env.DB)
+const dependencies: AppDependencies = {
+  appConfig,
+  loggerHandler,
+  workRunner,
+  db: d1Client.db,
+}
+
+const app = createApp({
+  serverBasePath: appConfig.runtime.serverBasePath,
+  makeDependencies: () => dependencies,
+})
+
+export default app

package/templates/hono-fullstack/apps/server/src/adapters/nodejs/bootstrap.ts

@@ -1,5 +1,5 @@
 import { serve } from '@hono/node-server'
-import app, { exampleWorkRunner, sqliteClient } from './entry'
+import app, { closeNodeDependencies } from './entry'
 
 function main() {
   const port = Number(process.env.NODE_PORT)
@@ -38,11 +38,8 @@ function main() {
       })
       console.log('✔ HTTP server successfully closed.')
 
-      await exampleWorkRunner.shutdown()
-      console.log('✔ ExampleWorkRunner successfully shut down.')
-
-      sqliteClient.close()
-      console.log('✔ SQLite client successfully closed.')
+      await closeNodeDependencies()
+      console.log('✔ Node dependencies successfully closed.')
 
       console.log('Graceful shutdown completed.')
       process.exit(0)

package/templates/hono-fullstack/apps/server/src/adapters/nodejs/entry.ts

@@ -1,11 +1,12 @@
 import { createSqliteClient } from '@repo/db/sqlite/sqlite'
 import { sqliteSchemaConfig } from '@repo/definition/backend'
 import { createApp } from '@/app'
-import { resolveConfig } from './config'
+import { resolveConfig } from '@/config'
 import { createPinoLogger } from '@/infra/logger/pino'
 import { getRuntimeKey } from 'hono/adapter'
 import type { AppDependencies, AppLogger } from '@/shared/app/types'
-import { ExampleWorkRunner } from '@/infra/work-runner/example/runner'
+// import { PiscinaWorkRunner } from '@/infra/work-runner/piscina/runner'
+import { PassThroughWorkRunner } from '@/infra/work-runner/pass-through/runner'
 import { getLogger, setRootLogger } from '@/infra/logger/getter'
 
 function installProcessErrorHandlers(isLocal: boolean) {
@@ -35,13 +36,27 @@ const { rootLogger, loggerHandler } = createPinoLogger({
 setRootLogger(rootLogger as unknown as AppLogger)
 installProcessErrorHandlers(runtime.isLocal)
 
-export const exampleWorkRunner = ExampleWorkRunner.getInstance(appConfig.worker)
+// To enable Piscina, use PiscinaWorkRunner and enable the worker pack entry in vite.config.ts.
+// export const workRunner = PiscinaWorkRunner.getInstance(appConfig.worker)
+export const workRunner = new PassThroughWorkRunner()
 export const sqliteClient = createSqliteClient(sqliteConfig.dbPath)
 
 let dependencies: AppDependencies | undefined
-const app = createApp(() => {
-  dependencies ||= { appConfig, loggerHandler, exampleWorkRunner, db: sqliteClient.db }
-  return dependencies
+let closePromise: Promise<void> | undefined
+const app = createApp({
+  serverBasePath: appConfig.runtime.serverBasePath,
+  makeDependencies: () => {
+    dependencies ||= { appConfig, loggerHandler, workRunner, db: sqliteClient.db }
+    return dependencies
+  },
 })
 
+export const closeNodeDependencies = (): Promise<void> => {
+  closePromise ||= (async () => {
+    await workRunner.shutdown()
+    sqliteClient.close()
+  })()
+  return closePromise
+}
+
 export default app

package/templates/hono-fullstack/apps/server/src/app.ts

@@ -1,20 +1,18 @@
-import { type Context, Hono } from 'hono'
+import { Hono } from 'hono'
 import { contextStorage } from 'hono/context-storage'
 import { csrf } from 'hono/csrf'
 import { secureHeaders } from 'hono/secure-headers'
 import { requestId } from 'hono/request-id'
 import { corsMiddleware } from './middlewares/cors'
 import { exampleRoutes } from './modules/example/routes'
-import type { AppDependencies, AppEnv } from './shared/app/types'
+import type { CreateAppOptions, AppEnv } from './shared/app/types'
 import { E } from './shared/errors/defs'
 import { globalErrorHandler } from './shared/errors/handler'
 import { configureOpenAPI } from './shared/network/openapi'
 import { objectEntries } from './shared/utils'
 
-export const createApp = (
-  makeDependencies: (c: Context<AppEnv>) => Promise<AppDependencies> | AppDependencies,
-): Hono<AppEnv> => {
-  const app = new Hono<AppEnv>()
+export const createApp = ({ serverBasePath, makeDependencies }: CreateAppOptions): Hono<AppEnv> => {
+  const app = new Hono<AppEnv>().basePath(serverBasePath)
 
   app.use('*', async (c, next) => {
     const deps = await makeDependencies(c)

package/templates/hono-fullstack/apps/server/src/config.ts

@@ -0,0 +1,47 @@
+import {
+  corsConfig,
+  logBaseConfig,
+  logPrettyRawConfig,
+  logRollRawConfig,
+  logRollSchemaConfig,
+  runtimeConfig,
+  workerConfig,
+} from '@repo/definition/backend'
+import { getRuntimeKey } from 'hono/adapter'
+import { flatten as flattenValiIssues, isValiError } from 'valibot'
+import type { AppConfig } from '@/shared/app/types'
+
+export function resolveConfig(context: Record<string, unknown>): AppConfig {
+  try {
+    const fromEnv = { context, matchContextKey: 'constantCase' as const }
+    const runtime = runtimeConfig.resolve(fromEnv)
+    const runtimeKey = getRuntimeKey()
+    const isNodejsLike = runtimeKey === 'node' || runtimeKey === 'bun'
+    const log: AppConfig['log'] = { base: logBaseConfig.resolve(fromEnv) }
+
+    if (isNodejsLike) {
+      log.roll = {
+        ...logRollSchemaConfig.resolve(fromEnv),
+        ...logRollRawConfig.resolve(),
+      }
+      log.pretty = logPrettyRawConfig.resolve()
+    }
+
+    return {
+      runtime: { ...runtime, isLocal: runtime.serverEnv === 'local' },
+      log,
+      worker: workerConfig.resolve(fromEnv),
+      middleware: {
+        cors: corsConfig.resolve({
+          context: { domains: context.CORS_DOMAINS },
+          matchContextKey: 'camel',
+        }),
+      },
+    }
+  } catch (error) {
+    if (isValiError(error)) {
+      throw new Error(`[resolveConfig] ${JSON.stringify(flattenValiIssues(error.issues))}`)
+    }
+    throw error
+  }
+}

package/templates/hono-fullstack/apps/server/src/infra/logger/pino.ts

@@ -37,6 +37,10 @@ export const createPinoOptions = ({
 }) => {
   const pinoOptions: LoggerOptions = {
     level: baseConfig.loggerLevel || (isLocal ? 'debug' : 'info'),
+    browser: {
+      asObject: true,
+      serialize: ['!stdSerializers.err', 'req', 'res', 'err'],
+    },
     serializers: {
       req: (req) => {
         return {

package/templates/hono-fullstack/apps/server/src/infra/work-runner/example/worker-entry.ts

@@ -1,34 +1,13 @@
 /** WORKER 打包入口 */
-import type { RunnerTaskInvocation, RunnerTaskResult } from '../types'
+import type { RunnerTaskInvocation } from '../types'
 import {
   executeExampleTask as runExampleTask,
   type ExampleRunnerTaskModel,
 } from '@/modules/example/work-task/tasks'
-import { isWorkerTaskBusinessError } from '../utils/business-error'
 
-export async function executeExampleTask({
+export function executeExampleTask({
   input,
   messagePort,
-}: RunnerTaskInvocation<ExampleRunnerTaskModel['input']>): Promise<
-  RunnerTaskResult<ExampleRunnerTaskModel['output'], ExampleRunnerTaskModel['errorCode']>
-> {
-  try {
-    const result = await runExampleTask(input, messagePort)
-    messagePort.postMessage({ type: 'result', data: result.data })
-    return result
-  } catch (error) {
-    if (!isWorkerTaskBusinessError(error)) throw error
-    const result = {
-      ok: false,
-      error: {
-        code: 'EXAMPLE_PROCESS_FAILED' as const,
-        message: error.message,
-        ...(error.details ? { details: error.details } : {}),
-      },
-    }
-    messagePort.postMessage({ type: 'error', error: result.error })
-    return result
-  } finally {
-    messagePort.close()
-  }
+}: RunnerTaskInvocation<ExampleRunnerTaskModel['input']>): ReturnType<typeof runExampleTask> {
+  return runExampleTask(input, messagePort).finally(() => messagePort.close())
 }

package/templates/hono-fullstack/apps/server/src/infra/work-runner/pass-through/runner.ts

@@ -0,0 +1,42 @@
+import { executeExampleTask } from '../example/worker-entry'
+import { getLogger } from '@/infra/logger/getter'
+import { WorkSubject } from '../constants'
+import type {
+  AppWorkRunner,
+  RunnerTaskParams,
+  RunnerTaskRunOptions,
+  RunnerTaskRunResult,
+  WorkerMessage,
+  WorkerMessagePort,
+} from '../types'
+import { handleWorkerMessage } from '../utils/message'
+
+function createMessagePort(subject: WorkSubject): WorkerMessagePort {
+  const logger = getLogger()
+  return {
+    postMessage(message: WorkerMessage) {
+      handleWorkerMessage(message, logger, { subject })
+    },
+    close() {},
+  }
+}
+
+export class PassThroughWorkRunner implements AppWorkRunner {
+  async run<TSubject extends WorkSubject>(
+    taskParams: RunnerTaskParams<TSubject>,
+    options?: RunnerTaskRunOptions,
+  ): Promise<RunnerTaskRunResult<TSubject>> {
+    if (taskParams.subject !== WorkSubject.PROCESS_EXAMPLE) {
+      throw new Error(`[PassThroughWorkRunner] task name not found: ${String(taskParams.subject)}`)
+    }
+
+    options?.signal?.throwIfAborted()
+
+    return executeExampleTask({
+      input: taskParams.input,
+      messagePort: createMessagePort(taskParams.subject),
+    }) as Promise<RunnerTaskRunResult<TSubject>>
+  }
+
+  async shutdown(): Promise<void> {}
+}

package/templates/{hono-server/apps/server/src/infra/work-runner/example → hono-fullstack/apps/server/src/infra/work-runner/piscina}/runner.ts

@@ -14,21 +14,21 @@ import path from 'node:path'
 import { MessageChannel, type MessagePort } from 'node:worker_threads'
 import workersDir from 'virtual:workers'
 import { getLogger } from '@/infra/logger/getter'
-import type * as ExampleWorker from './worker-entry'
+import type * as ExampleWorker from '../example/worker-entry'
 import { handleWorkerMessage } from '../utils/message'
 
 const taskNameMap = {
   [WorkSubject.PROCESS_EXAMPLE]: 'executeExampleTask',
 } satisfies Partial<Record<WorkSubject, keyof typeof ExampleWorker>>
 
-export class ExampleWorkRunner implements AppWorkRunner {
-  static #instance: ExampleWorkRunner | null = null
+export class PiscinaWorkRunner implements AppWorkRunner {
+  static #instance: PiscinaWorkRunner | null = null
   readonly #pool: Piscina
   readonly #config: WorkerConfig
 
   private constructor(config: WorkerConfig) {
     if (!config) {
-      throw new Error('[ExampleWorkRunner] config is required')
+      throw new Error('[PiscinaWorkRunner] config is required')
     }
     this.#pool = new Piscina({
       filename: path.join(workersDir, 'example-worker.mjs'),
@@ -40,10 +40,10 @@ export class ExampleWorkRunner implements AppWorkRunner {
     this.#config = config
   }
 
-  public static getInstance(config: WorkerConfig): ExampleWorkRunner {
+  public static getInstance(config: WorkerConfig): PiscinaWorkRunner {
     if (!this.#instance) {
-      getLogger().info({ worker: config }, 'ExampleWorkRunner initialized')
-      this.#instance = new ExampleWorkRunner(config)
+      getLogger().info({ worker: config }, 'PiscinaWorkRunner initialized')
+      this.#instance = new PiscinaWorkRunner(config)
     }
     return this.#instance
   }
@@ -54,7 +54,7 @@ export class ExampleWorkRunner implements AppWorkRunner {
   ): Promise<RunnerTaskRunResult<TSubject>> {
     const targetName = taskNameMap[taskParams.subject]
     if (!targetName) {
-      throw new Error(`[ExampleWorkRunner] task name not found: ${taskParams.subject}`)
+      throw new Error(`[PiscinaWorkRunner] task name not found: ${taskParams.subject}`)
     }
 
     let timeoutTimer: ReturnType<typeof setTimeout> | undefined
@@ -180,6 +180,6 @@ export class ExampleWorkRunner implements AppWorkRunner {
 
   async shutdown(): Promise<void> {
     await this.#pool.close()
-    if (ExampleWorkRunner.#instance === this) ExampleWorkRunner.#instance = null
+    if (PiscinaWorkRunner.#instance === this) PiscinaWorkRunner.#instance = null
   }
 }

package/templates/hono-fullstack/apps/server/src/infra/work-runner/types.ts

@@ -1,5 +1,5 @@
 import type { ExampleRunnerTaskModel } from '@/modules/example/work-task/tasks'
-import type { MessagePort, Transferable } from 'node:worker_threads'
+import type { Transferable } from 'node:worker_threads'
 import type { WorkerErrorCode, WorkSubject } from './constants'
 
 // export const WorkerInvocationType = Object.freeze({
@@ -43,7 +43,7 @@ export type RunnerTaskErrorCode<TSubject extends WorkSubject> =
 
 export type RunnerTaskInvocation<TInput> = {
   input: TInput
-  messagePort: MessagePort
+  messagePort: WorkerMessagePort
 }
 
 export type RunnerTaskJsonValue =
@@ -78,6 +78,11 @@ export type WorkerMessage =
       error: RunnerTaskError
     }
 
+export interface WorkerMessagePort {
+  postMessage(message: WorkerMessage): void
+  close(): void
+}
+
 export type RunnerTaskError<TCode extends string = string> = {
   code: TCode
   /** 仅供服务端诊断，不应直接作为 HTTP 响应文案。 */

package/templates/hono-fullstack/apps/server/src/infra/work-runner/utils/message.ts

@@ -1,10 +1,9 @@
 import type { AppLogger } from '@/shared/app/types'
-import type { RunnerTaskErrorDetails, WorkerMessage } from '../types'
-import type { MessagePort } from 'node:worker_threads'
+import type { RunnerTaskErrorDetails, WorkerMessage, WorkerMessagePort } from '../types'
 import type { WorkSubject } from '../constants'
 
 export function workerLog(
-  messagePort: MessagePort,
+  messagePort: WorkerMessagePort,
   level: Extract<WorkerMessage, { type: 'log' }>['level'],
   message: string,
   data?: RunnerTaskErrorDetails,
@@ -12,7 +11,11 @@ export function workerLog(
   messagePort.postMessage({ type: 'log', level, message, data } satisfies WorkerMessage)
 }
 
-export function workerProgress(messagePort: MessagePort, value: number, message?: string): void {
+export function workerProgress(
+  messagePort: WorkerMessagePort,
+  value: number,
+  message?: string,
+): void {
   messagePort.postMessage({ type: 'progress', value, message } satisfies WorkerMessage)
 }
 

package/templates/hono-fullstack/apps/server/src/modules/example/routes.ts

@@ -43,10 +43,8 @@ export const exampleRoutes = new Hono<AppEnv>()
     }),
     generalValidator('json', createExampleInputSchema),
     async (c) => {
-      const [row] = await getDb(c)
-        .insert(examples)
-        .values(c.req.valid('json'))
-        .returning(vcExamples.default)
+      const input = c.req.valid('json')
+      const [row] = await getDb(c).insert(examples).values(input).returning(vcExamples.default)
       return successJson(c, row)
     },
   )
@@ -60,7 +58,7 @@ export const exampleRoutes = new Hono<AppEnv>()
     }),
     generalValidator('json', processExampleInputSchema),
     async (c) => {
-      const result = await c.get('exampleWorkRunner').run({
+      const result = await c.get('workRunner').run({
         subject: WorkSubject.PROCESS_EXAMPLE,
         input: c.req.valid('json'),
       })