@oyolincc/create 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oyolincc/create",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "@oyolincc/create",
   "homepage": "https://github.com/oyolincc/lib#readme",
   "bugs": {
@@ -33,7 +33,7 @@
     "tsx": "4.21.0",
     "typescript": "7.0.2",
     "vite-plus": "0.2.8",
-    "@oyolincc/dev-config": "0.1.1"
+    "@oyolincc/dev-config": "0.2.0"
   },
   "createConfig": {
     "templates": [

package/templates/hono-fullstack/.codegraph/.gitignore

@@ -0,0 +1,5 @@
+# CodeGraph data files — local to each machine, not for committing.
+# Ignore everything in .codegraph/ except this file itself, so transient
+# files (the database, daemon.pid, sockets, logs) never show up in git.
+*
+!.gitignore

package/templates/hono-fullstack/README.md

@@ -9,6 +9,7 @@ TanStack Start and Nitro serve the frontend while mounting the independently bui
 - `apps/server`: independently buildable and startable Hono server and worker runtime.
 - `libs/definition`: backend/frontend contracts and environment definitions.
 - `libs/db`: SQLite/Drizzle and D1 clients, schema, relations, and manual migration commands.
+- `libs/ui`: shared React components, Panda design system, and Storybook previews.
 
 ## Setup
 
@@ -31,7 +32,7 @@ Cloudflare runtime and binding types are generated from each runnable Worker's W
 
 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.
+Example tasks run in-process through `PassThroughRunner` by default. The complete Piscina implementation remains available: enable `PiscinaWorkRunner` in apps/server/src/di-container.ts and the adjacent worker pack entry in `apps/server/vite.config.ts` to use worker threads.
 
 ## Commands
 
@@ -45,7 +46,27 @@ Example tasks run in-process through `PassThroughWorkRunner` by default. The com
 - `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.
+- `pnpm -C apps/stack codegen`: generate the application's Panda helpers.
+- `pnpm --filter @repo/ui storybook`: preview UI components on port 6006 without building the UI package first.
+- `pnpm --filter @repo/ui storybook:check`: generate the preview helpers and type-check Storybook.
+- `pnpm --filter @repo/ui storybook:build`: build the static component previews.
+
+## UI development
+
+The stack consumes the built `@repo/ui` design system through Panda's `designSystem` setting. Application styles live in `frontend/assets/styles.css`; document-level reset and global styles belong to the application's `panda.config.ts`. Component recipes retain the `app-` class prefix.
+
+Stack chain commands prepare upstream packages through Turbo's `build:dev` tasks. When actively editing the UI library, its three watchers have separate responsibilities: `dev:codegen` updates local Panda helpers, `dev` updates component modules, and `dev:panda` updates the design-system manifest. Run them in separate terminals as needed; `dev` alone does not watch the complete design system.
+
+Storybook has its own Vite and Panda configuration and generated helpers under `libs/ui/.storybook/styled-system`. See `libs/ui/stories/README.md` for preview conventions. Generated `styled-system`, `dist`, `.output`, and `storybook-static` contents are not committed.
 
 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.
+
+## Contracts and database development
+
+Example routes validate shared contracts and call the inferDI-managed ExampleService; queries use the shared data-access layer and explicit id/list VOs. List responses contain results and pagination meta; create responses contain result and write meta. PATCH /examples/:id updates message, DELETE /examples accepts a JSON ids array, and POST /examples/process uses the configured work runner.
+
+Run codegen:contracts and codegen:vo in libs/definition only after manually updating the DB package artifacts. These commands use IS_OVERRIDE=1 and can overwrite hand-edited contracts; review the diff and restore custom rules. See libs/definition/README.md.
+
+IS_D1_LOCAL=1 selects the shared local metadata.sqlite database for Drizzle D1 commands. First run db:warmup:cloudflare:local in apps/server or apps/stack, then run dev:d1:push in libs/db manually. Remove IS_D1_LOCAL for remote D1 and provide Cloudflare credentials. The switch follows process.env truthiness: even the string 0 enables local mode. No schema push is run automatically.

package/templates/hono-fullstack/_gitignore

@@ -11,6 +11,7 @@ node_modules
 dist
 dist-ssr
 .output
+styled-system
 *.local
 
 # Editor directories and files

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

@@ -2,7 +2,9 @@
   "name": "@repo/server",
   "version": "0.0.0",
   "private": true,
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "type": "module",
   "exports": {
     "./nodejs": "./dist/nodejsEntry.mjs",
@@ -17,6 +19,7 @@
     "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",
+    "db:warmup:cloudflare:local": "wrangler d1 execute DB --local --config wrangler.jsonc --persist-to ../../.wrangler/state --command \"SELECT 1\"",
     "build:node-chain": "turbo build:node --filter=@repo/server",
     "build:node": "vp pack",
     "cf:typegen": "wrangler types --config wrangler.jsonc",
@@ -27,7 +30,10 @@
   "dependencies": {
     "@hono/node-server": "catalog:server",
     "@hono/standard-validator": "catalog:server",
+    "@hono/structured-logger": "catalog:server",
     "@hono/swagger-ui": "catalog:server",
+    "@inferdi/hono": "catalog:server",
+    "@inferdi/inferdi": "catalog:",
     "@repo/db": "workspace:*",
     "@repo/definition": "workspace:*",
     "@valibot/to-json-schema": "catalog:server",
@@ -37,7 +43,6 @@
     "drizzle-orm": "catalog:db",
     "hono": "catalog:server",
     "hono-openapi": "catalog:server",
-    "hono-pino": "catalog:server",
     "hono-problem-details": "catalog:server",
     "ky": "catalog:shared",
     "pino": "catalog:server",

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

@@ -1,36 +1,10 @@
-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,
+const instance = createApp({
+  env: { ...env },
 })
-setRootLogger(rootLogger as unknown as AppLogger)
+setRootLogger(instance.logger)
 
-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
+export default instance.app

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

@@ -1,11 +1,11 @@
 import { serve } from '@hono/node-server'
-import app, { closeNodeDependencies } from './entry'
 
-function main() {
+async function main() {
   const port = Number(process.env.NODE_PORT)
   if (!port || Number.isNaN(port)) {
     throw new Error(`Invalid port: ${process.env.NODE_PORT}`)
   }
+  const { default: app, disposeApp, rootLogger } = await import('./entry')
 
   const server = serve(
     {
@@ -18,8 +18,10 @@ function main() {
   )
 
   let isShuttingDown = false
+  let shutdownExitCode = 0
 
-  const gracefulShutdown = async (signal: string) => {
+  const gracefulShutdown = async (signal: string, exitCode = 0) => {
+    shutdownExitCode ||= exitCode
     if (isShuttingDown) return
     isShuttingDown = true
 
@@ -38,24 +40,30 @@ function main() {
       })
       console.log('✔ HTTP server successfully closed.')
 
-      await closeNodeDependencies()
-      console.log('✔ Node dependencies successfully closed.')
+      await disposeApp()
+      console.log('✔ App successfully disposed.')
 
       console.log('Graceful shutdown completed.')
-      process.exit(0)
+      process.exit(shutdownExitCode)
     } catch (err) {
       console.error('Error during shutdown:', err)
       process.exit(1)
     }
   }
 
-  process.on('SIGTERM', () => gracefulShutdown('SIGTERM'))
-  process.on('SIGINT', () => gracefulShutdown('SIGINT'))
+  process.on('SIGTERM', () => void gracefulShutdown('SIGTERM'))
+  process.on('SIGINT', () => void gracefulShutdown('SIGINT'))
+  process.on('unhandledRejection', (reason) => {
+    rootLogger.fatal({ err: reason }, 'unhandledRejection')
+    void gracefulShutdown('unhandledRejection', 1)
+  })
+  process.on('uncaughtException', (error) => {
+    rootLogger.fatal({ err: error }, 'uncaughtException')
+    void gracefulShutdown('uncaughtException', 1)
+  })
 }
 
-try {
-  main()
-} catch (error) {
+void main().catch((error) => {
   console.error('[server] failed to start', error)
   process.exit(1)
-}
+})

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

@@ -1,62 +1,12 @@
-import { createSqliteClient } from '@repo/db/sqlite/sqlite'
-import { sqliteSchemaConfig } from '@repo/definition/backend'
 import { createApp } from '@/app'
-import { resolveConfig } from '@/config'
-import { createPinoLogger } from '@/infra/logger/pino'
-import { getRuntimeKey } from 'hono/adapter'
-import type { AppDependencies, AppLogger } from '@/shared/app/types'
-// import { PiscinaWorkRunner } from '@/infra/work-runner/piscina/runner'
-import { PassThroughWorkRunner } from '@/infra/work-runner/pass-through/runner'
-import { getLogger, setRootLogger } from '@/infra/logger/getter'
+import { setRootLogger } from '@/infra/logger/getter'
 
-function installProcessErrorHandlers(isLocal: boolean) {
-  process.on('unhandledRejection', (reason) => {
-    getLogger().error({ err: reason }, 'unhandledRejection')
-    if (isLocal) process.exit(1)
-  })
-  process.on('uncaughtException', (error) => {
-    getLogger().fatal({ err: error }, 'uncaughtException')
-    process.exit(1)
-  })
-}
-
-const appConfig = resolveConfig(process.env)
-const sqliteConfig = sqliteSchemaConfig.resolve({
-  context: process.env,
-  matchContextKey: 'constantCase',
-})
-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)
-installProcessErrorHandlers(runtime.isLocal)
-
-// 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
-let closePromise: Promise<void> | undefined
-const app = createApp({
-  serverBasePath: appConfig.runtime.serverBasePath,
-  makeDependencies: () => {
-    dependencies ||= { appConfig, loggerHandler, workRunner, db: sqliteClient.db }
-    return dependencies
-  },
+const instance = createApp({
+  env: process.env,
 })
+setRootLogger(instance.logger)
 
-export const closeNodeDependencies = (): Promise<void> => {
-  closePromise ||= (async () => {
-    await workRunner.shutdown()
-    sqliteClient.close()
-  })()
-  return closePromise
-}
+export const rootLogger = instance.logger
+export const disposeApp = instance.dispose
 
-export default app
+export default instance.app

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

@@ -1,43 +1,59 @@
 import { Hono } from 'hono'
+import { inferdiHono } from '@inferdi/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 { describeRoute } from 'hono-openapi'
+import * as v from 'valibot'
 import { corsMiddleware } from './middlewares/cors'
-import { exampleRoutes } from './modules/example/routes'
-import type { CreateAppOptions, AppEnv } from './shared/app/types'
+import type { CreateAppOptions, AppEnv, AppInstance } from './shared/types/app'
 import { E } from './shared/errors/defs'
 import { globalErrorHandler } from './shared/errors/handler'
-import { configureOpenAPI } from './shared/network/openapi'
-import { objectEntries } from './shared/utils'
+import { configureOpenAPI, jsonResponse, OpenApiTags } from './shared/network/openapi'
+import { successJson } from './shared/network/utils'
+import { loggerMiddleware } from './middlewares/logger'
+import { createDIContainer } from './di-container'
+import { flushPino } from './infra/logger/pino'
+import { routes as exampleRoutes } from './modules/example/routes'
 
-export const createApp = ({ serverBasePath, makeDependencies }: CreateAppOptions): Hono<AppEnv> => {
-  const app = new Hono<AppEnv>().basePath(serverBasePath)
+export const createApp = ({ serverBasePath, env }: CreateAppOptions): AppInstance => {
+  const diContainer = createDIContainer({ env })
+  const rootLogger = diContainer.get('rootLogger')
+  const appConfig = diContainer.get('appConfig')
+  const app = new Hono<AppEnv>().basePath(serverBasePath ?? appConfig.runtime.serverBasePath)
 
-  app.use('*', async (c, next) => {
-    const deps = await makeDependencies(c)
-    objectEntries(deps).forEach(([key, value]) => c.set(key, value))
-    await next()
-  })
   app.use(contextStorage())
   app.use('*', requestId())
-  app.use('*', async (c, next) => {
-    const loggerHandler = c.get('loggerHandler')
-    await loggerHandler(c as never, async () => {
-      c.get('logger')?.assign({ reqId: c.get('requestId') })
-      await next()
-    })
-  })
+  app.use('*', loggerMiddleware(rootLogger))
+  app.use('*', inferdiHono({ container: diContainer }))
   app.use('*', secureHeaders())
-  app.use('*', corsMiddleware())
+  app.use('*', corsMiddleware(appConfig.middleware.cors))
   app.use('*', csrf())
 
-  app.route('/', exampleRoutes)
+  app.get(
+    '/health',
+    describeRoute({
+      operationId: 'getHealth',
+      tags: [OpenApiTags.System],
+      summary: 'Health check',
+      responses: { 200: jsonResponse(v.object({ data: v.object({ status: v.string() }) })) },
+    }),
+    (c) => successJson(c, { status: 'ok' }),
+  )
+  app.route('/examples', exampleRoutes)
   configureOpenAPI(app)
 
   app.notFound(() => {
     throw E.NORMAL.NOT_FOUND.create()
   })
   app.onError(globalErrorHandler)
-  return app
+  return {
+    app,
+    logger: rootLogger,
+    dispose: async () => {
+      await diContainer.dispose()
+      await flushPino(rootLogger)
+    },
+  }
 }

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

@@ -9,7 +9,7 @@ import {
 } from '@repo/definition/backend'
 import { getRuntimeKey } from 'hono/adapter'
 import { flatten as flattenValiIssues, isValiError } from 'valibot'
-import type { AppConfig } from '@/shared/app/types'
+import type { AppConfig } from '@/shared/types/app'
 
 export function resolveConfig(context: Record<string, unknown>): AppConfig {
   try {

package/templates/hono-fullstack/apps/server/src/di-container.ts

@@ -0,0 +1,51 @@
+import { getRuntimeKey } from 'hono/adapter'
+import { Container } from '@inferdi/inferdi'
+import { resolveConfig } from './config'
+import { createPino } from './infra/logger/pino'
+import { sqliteSchemaConfig } from '@repo/definition/backend'
+import { createD1Client, type D1Binding } from '@repo/db/sqlite/d1-client'
+import { createSqliteClient } from '@repo/db/sqlite/sqlite'
+import type { Database } from './shared/types/db'
+import { exampleModule } from './modules/example/module'
+import { PassThroughRunner } from './infra/work-runner/pass-through/runner'
+// import { PiscinaWorkRunner } from './infra/work-runner/piscina/runner'
+import type { AppWorkRunner } from './infra/work-runner/types'
+
+export const createDIContainer = ({ env }: { env: Record<string, unknown> }) => {
+  const runtimeKey = getRuntimeKey()
+  return new Container()
+    .registerValue('appConfig', resolveConfig(env))
+    .registerFactory('rootLogger', (c) => {
+      const { runtime, log } = c.get('appConfig')
+      return createPino({
+        isLocal: runtime.isLocal,
+        logConfig: log,
+      })
+    })
+    .registerFactory('database', (): Database => {
+      if (runtimeKey === 'workerd') return createD1Client(env.DB as D1Binding)
+
+      const { dbPath } = sqliteSchemaConfig.resolve({
+        context: env,
+        matchContextKey: 'constantCase',
+      })
+      const client = createSqliteClient(dbPath)
+      return {
+        db: client.db,
+        [Symbol.dispose]() {
+          client.close()
+        },
+      }
+    })
+    .registerFactory('workRunner', (_c) => {
+      // Enable together with the worker pack entry in vite.config.ts.
+      // const runner: AppWorkRunner = PiscinaWorkRunner.getInstance(_c.get('appConfig').worker)
+      const runner: AppWorkRunner = new PassThroughRunner()
+      return Object.assign(runner, {
+        [Symbol.asyncDispose]: () => runner.shutdown(),
+      })
+    })
+    .use(exampleModule)
+}
+
+export type DIContainer = ReturnType<typeof createDIContainer>

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

@@ -1,4 +1,4 @@
-import type { AppEnv, AppLogger } from '@/shared/app/types'
+import type { AppEnv, AppLogger } from '@/shared/types/app'
 import { hasProp } from '@/shared/utils'
 import { getContext } from 'hono/context-storage'
 

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

@@ -1,9 +1,8 @@
 import { createRequire } from 'node:module'
 import { isAbsolute, join, resolve } from 'node:path'
-import { type Runtime } from 'hono/adapter'
-import { pinoLogger } from 'hono-pino'
-import pino, { type LoggerOptions } from 'pino'
-import type { AppConfig } from '@/shared/app/types'
+import { getRuntimeKey } from 'hono/adapter'
+import pino, { type Logger, type LoggerOptions } from 'pino'
+import type { LogConfig } from '@/shared/types/app'
 import { serializeErr } from '@/shared/errors/log'
 
 // const pinoInstance = pino({
@@ -33,7 +32,7 @@ export const createPinoOptions = ({
   baseConfig,
 }: {
   isLocal: boolean
-  baseConfig: AppConfig['log']['base']
+  baseConfig: LogConfig['base']
 }) => {
   const pinoOptions: LoggerOptions = {
     level: baseConfig.loggerLevel || (isLocal ? 'debug' : 'info'),
@@ -69,38 +68,28 @@ export const createPinoOptions = ({
   return pinoOptions
 }
 
-export const createPinoLogger = ({
-  isLocal,
-  logBase,
-  runtime,
-  logRoll,
-  logPretty,
-}: {
-  isLocal: boolean
-  logBase: AppConfig['log']['base']
-  runtime: Runtime
-  logRoll?: AppConfig['log']['roll']
-  logPretty?: AppConfig['log']['pretty']
-}) => {
-  const pinoOptions = createPinoOptions({ isLocal, baseConfig: logBase })
+export const createPino = ({ isLocal, logConfig }: { isLocal: boolean; logConfig: LogConfig }) => {
+  const runtime = getRuntimeKey()
+  const { base, roll, pretty } = logConfig
+  const pinoOptions = createPinoOptions({ isLocal, baseConfig: base })
   const level = pinoOptions.level
   if (runtime === 'node' || runtime === 'bun') {
-    if (isLocal && logPretty) {
+    if (isLocal && pretty) {
       try {
         createRequire(import.meta.url).resolve('pino-pretty')
-        pinoOptions.transport = { target: 'pino-pretty', level, options: logPretty }
+        pinoOptions.transport = { target: 'pino-pretty', level, options: pretty }
       } catch {
         console.warn('[logger] pino-pretty is not installed; falling back to JSON stdout')
       }
-    } else if (logRoll) {
-      const { loggerDir, loggerFileBase } = logRoll
+    } else if (roll) {
+      const { loggerDir, loggerFileBase } = roll
       pinoOptions.transport = {
         targets: [
           {
             target: 'pino-roll',
             level,
             options: {
-              ...logRoll,
+              ...roll,
               file: join(
                 isAbsolute(loggerDir) ? loggerDir : resolve(process.cwd(), loggerDir),
                 loggerFileBase,
@@ -112,15 +101,13 @@ export const createPinoLogger = ({
       }
     }
   }
-  const rootLogger = pino(pinoOptions)
-  const loggerHandler = pinoLogger({
-    pino: rootLogger,
-    // access log 只记请求完成；错误细节由 onError 走 serializers.err。
-    // 默认在 c.error 时升 error 且 msg=error.message，会打出一条无结构的重复 error。
-    http: {
-      onResLevel: () => 'info',
-      onResMessage: () => 'Request completed',
-    },
+  return pino(pinoOptions)
+}
+
+export const flushPino = async (logger: Logger) => {
+  const runtime = getRuntimeKey()
+  if (runtime !== 'node' && runtime !== 'bun') return
+  await new Promise<void>((resolve, reject) => {
+    logger.flush((error) => (error ? reject(error) : resolve()))
   })
-  return { rootLogger, loggerHandler }
 }

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

@@ -1,6 +1,7 @@
 import { hasProp } from '@/shared/utils'
 import { WorkerErrorCode } from './constants'
 import type { RunnerTaskError, RunnerTaskErrorDetails } from './types'
+import { isWorkerTaskBusinessError } from './utils/business-error'
 
 const workerErrorCodes = Object.values(WorkerErrorCode)
 
@@ -38,3 +39,24 @@ export function isWorkerTaskError(error: unknown): error is WorkerTaskError {
       workerErrorCodes.includes(error.code as WorkerErrorCode))
   )
 }
+
+export function serializeWorkerTaskError(error: unknown): RunnerTaskError<WorkerErrorCode> {
+  if (isWorkerTaskError(error)) return error.serialize()
+  if (isWorkerTaskBusinessError(error)) {
+    return new WorkerTaskError(
+      WorkerErrorCode.TASK_INTERNAL,
+      error.message,
+      error.cause.details,
+      error.cause.cause,
+    ).serialize()
+  }
+  if (error instanceof Error && error.name === 'AbortError') {
+    return new WorkerTaskError(WorkerErrorCode.TASK_ABORTED, error.message, undefined).serialize()
+  }
+  return new WorkerTaskError(
+    WorkerErrorCode.UNKNOWN,
+    'Worker task failed unexpectedly',
+    undefined,
+    error,
+  ).serialize()
+}

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

@@ -1,41 +1,47 @@
-import { executeExampleTask } from '../example/worker-entry'
+import { executeExampleTask as runExampleTask } from '@/modules/example/work-task/tasks'
 import { getLogger } from '@/infra/logger/getter'
 import { WorkSubject } from '../constants'
+import { serializeWorkerTaskError } from '../errors'
 import type {
   AppWorkRunner,
+  RunnerTaskInput,
   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() {},
-  }
+const taskMap = {
+  [WorkSubject.PROCESS_EXAMPLE]: runExampleTask,
+} satisfies {
+  [TSubject in WorkSubject]?: (
+    input: RunnerTaskInput<TSubject>,
+  ) => Promise<RunnerTaskRunResult<TSubject>>
 }
 
-export class PassThroughWorkRunner implements AppWorkRunner {
+export class PassThroughRunner implements AppWorkRunner {
   async run<TSubject extends WorkSubject>(
-    taskParams: RunnerTaskParams<TSubject>,
+    task: RunnerTaskParams<TSubject>,
     options?: RunnerTaskRunOptions,
   ): Promise<RunnerTaskRunResult<TSubject>> {
-    if (taskParams.subject !== WorkSubject.PROCESS_EXAMPLE) {
-      throw new Error(`[PassThroughWorkRunner] task name not found: ${String(taskParams.subject)}`)
+    const targetTask = taskMap[task.subject]
+    if (!targetTask) {
+      throw new Error(`[PassThroughRunner] task name not found: ${String(task.subject)}`)
     }
 
-    options?.signal?.throwIfAborted()
-
-    return executeExampleTask({
-      input: taskParams.input,
-      messagePort: createMessagePort(taskParams.subject),
-    }) as Promise<RunnerTaskRunResult<TSubject>>
+    const logger = getLogger().child({ subject: task.subject })
+    logger.debug('Task executing in current thread')
+    let result: RunnerTaskRunResult<TSubject>
+    try {
+      options?.signal?.throwIfAborted()
+      result = (await targetTask(task.input)) as RunnerTaskRunResult<TSubject>
+    } catch (error) {
+      result = { ok: false, error: serializeWorkerTaskError(error) }
+    }
+    logger[result.ok ? 'info' : 'error'](
+      { subject: task.subject, ok: result.ok },
+      `Task ${result.ok ? 'completed' : 'failed'}`,
+    )
+    return result
   }
 
   async shutdown(): Promise<void> {}