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

package/templates/hono-server/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-server/apps/server/src/adapters/nodejs/bootstrap.ts

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

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

@@ -1,9 +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) {
@@ -18,6 +21,10 @@ function installProcessErrorHandlers(isLocal: boolean) {
 }
 
 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,
@@ -29,12 +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 }
-  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-server/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-server/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-server/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-server/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-server/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-fullstack/apps/server/src/infra/work-runner/example → hono-server/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-server/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-server/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-server/apps/server/src/modules/example/contracts.ts

@@ -3,3 +3,7 @@ import * as v from 'valibot'
 export const processExampleInputSchema = v.object({
   message: v.pipe(v.string(), v.minLength(1)),
 })
+
+export const createExampleInputSchema = v.object({
+  message: v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(500)),
+})

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

@@ -1,13 +1,16 @@
-import { Hono } from 'hono'
+import { type Context, Hono } from 'hono'
 import { describeRoute } from 'hono-openapi'
 import * as v from 'valibot'
+import { examples, vcExamples, type SqliteDBType } from '@repo/db/sqlite/schema'
 import type { AppEnv } from '@/shared/app/types'
 import { WorkSubject } from '@/infra/work-runner/constants'
 import { E } from '@/shared/errors/defs'
 import { jsonResponse, OpenApiTags } from '@/shared/network/openapi'
 import { successJson } from '@/shared/network/utils'
 import { generalValidator } from '@/shared/network/validator'
-import { processExampleInputSchema } from './contracts'
+import { createExampleInputSchema, processExampleInputSchema } from './contracts'
+
+const getDb = (context: Context<AppEnv>) => context.get('db') as SqliteDBType
 
 export const exampleRoutes = new Hono<AppEnv>()
   .get(
@@ -20,6 +23,31 @@ export const exampleRoutes = new Hono<AppEnv>()
     }),
     (c) => successJson(c, { status: 'ok' }),
   )
+  .get(
+    '/examples',
+    describeRoute({
+      operationId: 'listExamples',
+      tags: [OpenApiTags.Example],
+      summary: 'List example rows',
+      responses: { 200: { description: 'Example rows' } },
+    }),
+    async (c) => successJson(c, await getDb(c).select(vcExamples.default).from(examples)),
+  )
+  .post(
+    '/examples',
+    describeRoute({
+      operationId: 'createExample',
+      tags: [OpenApiTags.Example],
+      summary: 'Create an example row',
+      responses: { 200: { description: 'Created example row' } },
+    }),
+    generalValidator('json', createExampleInputSchema),
+    async (c) => {
+      const input = c.req.valid('json')
+      const [row] = await getDb(c).insert(examples).values(input).returning(vcExamples.default)
+      return successJson(c, row)
+    },
+  )
   .post(
     '/examples/process',
     describeRoute({
@@ -30,10 +58,9 @@ export const exampleRoutes = new Hono<AppEnv>()
     }),
     generalValidator('json', processExampleInputSchema),
     async (c) => {
-      const input = c.req.valid('json')
-      const result = await c.get('exampleWorkRunner').run({
+      const result = await c.get('workRunner').run({
         subject: WorkSubject.PROCESS_EXAMPLE,
-        input,
+        input: c.req.valid('json'),
       })
       if (!result.ok) {
         throw E.NORMAL.INTERNAL.create({

package/templates/hono-server/apps/server/src/modules/example/work-task/tasks.test.ts

@@ -18,19 +18,31 @@ describe('Example worker task', () => {
       expect.arrayContaining([
         expect.objectContaining({ type: 'log' }),
         expect.objectContaining({ type: 'progress', value: 100 }),
+        expect.objectContaining({ type: 'result' }),
       ]),
     )
     port1.close()
     port2.close()
   })
 
-  it('preserves a business exception model', async () => {
+  it('serializes a business exception and reports it', async () => {
     const { port1, port2 } = new MessageChannel()
-    await expect(executeExampleTask({ message: '  ' }, port2)).rejects.toMatchObject({
-      name: 'WorkerTaskBusinessError',
-      message: 'Message must not be empty',
-      details: { field: 'message' },
+    const messages: unknown[] = []
+    port1.on('message', (message) => messages.push(message))
+    const result = await executeExampleTask({ message: '  ' }, port2)
+    await new Promise<void>((resolve) => setImmediate(resolve))
+
+    expect(result).toEqual({
+      ok: false,
+      error: {
+        code: 'EXAMPLE_PROCESS_FAILED',
+        message: 'Message must not be empty',
+        details: { field: 'message' },
+      },
     })
+    expect(messages).toEqual(
+      expect.arrayContaining([expect.objectContaining({ type: 'error' })]),
+    )
     port1.close()
     port2.close()
   })

package/templates/hono-server/apps/server/src/modules/example/work-task/tasks.ts

@@ -1,9 +1,15 @@
 import type { ProcessExampleInput, ProcessExampleOutput } from '@repo/definition/backend'
 import { type WorkSubject } from '@/infra/work-runner/constants'
-import type { DefineRunnerTaskModel, RunnerTaskResult } from '@/infra/work-runner/types'
-import { WorkerTaskBusinessError } from '@/infra/work-runner/utils/business-error'
+import type {
+  DefineRunnerTaskModel,
+  RunnerTaskResult,
+  WorkerMessagePort,
+} from '@/infra/work-runner/types'
+import {
+  isWorkerTaskBusinessError,
+  WorkerTaskBusinessError,
+} from '@/infra/work-runner/utils/business-error'
 import { workerLog, workerProgress } from '@/infra/work-runner/utils/message'
-import type { MessagePort } from 'node:worker_threads'
 
 export type ExampleTaskErrorCode = 'EXAMPLE_PROCESS_FAILED'
 
@@ -16,20 +22,37 @@ export type ExampleRunnerTaskModel = DefineRunnerTaskModel<
 
 export async function executeExampleTask(
   input: ExampleRunnerTaskModel['input'],
-  messagePort: MessagePort,
+  messagePort: WorkerMessagePort,
 ): Promise<RunnerTaskResult<ProcessExampleOutput, ExampleTaskErrorCode>> {
-  workerLog(messagePort, 'debug', 'Example task started')
-  workerProgress(messagePort, 0, 'Validating input')
+  try {
+    workerLog(messagePort, 'debug', 'Example task started')
+    workerProgress(messagePort, 0, 'Validating input')
 
-  const original = input.message
-  const normalized = original.trim().replace(/\s+/g, ' ')
-  if (!normalized) {
-    throw new WorkerTaskBusinessError('Message must not be empty', { field: 'message' })
-  }
+    const original = input.message
+    const normalized = original.trim().replace(/\s+/g, ' ')
+    if (!normalized) {
+      throw new WorkerTaskBusinessError('Message must not be empty', { field: 'message' })
+    }
+
+    workerProgress(messagePort, 100, 'Example task completed')
+    const result = {
+      ok: true,
+      data: { original, normalized, length: normalized.length },
+    } as const
+    messagePort.postMessage({ type: 'result', data: result.data })
+    return result
+  } catch (error) {
+    if (!isWorkerTaskBusinessError(error)) throw error
 
-  workerProgress(messagePort, 100, 'Example task completed')
-  return {
-    ok: true,
-    data: { original, normalized, length: normalized.length },
+    const result: RunnerTaskResult<ProcessExampleOutput, ExampleTaskErrorCode> = {
+      ok: false,
+      error: {
+        code: 'EXAMPLE_PROCESS_FAILED',
+        message: error.message,
+        ...(error.details ? { details: error.details } : {}),
+      },
+    }
+    messagePort.postMessage({ type: 'error', error: result.error })
+    return result
   }
 }

package/templates/hono-server/apps/server/src/shared/app/types.ts

@@ -8,7 +8,7 @@ import type {
   WorkerConfig,
 } from '@repo/definition/backend'
 import type { AppWorkRunner } from '@/infra/work-runner/types'
-import type { MiddlewareHandler } from 'hono'
+import type { MiddlewareHandler, Context } from 'hono'
 import type { PinoLogger as HonoPinoLogger } from 'hono-pino'
 import type { RequestIdVariables } from 'hono/request-id'
 
@@ -30,11 +30,15 @@ export type AppConfig = {
 export type AppDependencies = {
   appConfig: AppConfig
   loggerHandler: MiddlewareHandler<{ Variables: { logger: AppLogger } }>
-  exampleWorkRunner: AppWorkRunner
-  /** Fullstack injects its SQLite database; standalone intentionally leaves this absent. */
-  db?: unknown
+  workRunner: AppWorkRunner
+  db: unknown
 }
 
 export type AppEnv = {
   Variables: RequestIdVariables & AppDependencies & { logger?: AppLogger }
 }
+
+export type CreateAppOptions = {
+  serverBasePath: string
+  makeDependencies: (c: Context<AppEnv>) => Promise<AppDependencies> | AppDependencies
+}

package/templates/hono-server/apps/server/src/shared/network/validator.ts

@@ -1,6 +1,6 @@
-import type { ValidationTargets } from 'hono'
+import type { Env, MiddlewareHandler, ValidationTargets } from 'hono'
 import { validator } from 'hono-openapi'
-import { flatten, type GenericSchema } from 'valibot'
+import { flatten, type GenericSchema, type InferInput, type InferOutput } from 'valibot'
 import { E } from '@/shared/errors/defs'
 
 export const generalValidator = <
@@ -9,7 +9,14 @@ export const generalValidator = <
 >(
   target: TTarget,
   schema: TSchema,
-) =>
+): MiddlewareHandler<
+  Env,
+  string,
+  {
+    in: { [K in TTarget]: InferInput<TSchema> }
+    out: { [K in TTarget]: InferOutput<TSchema> }
+  }
+> =>
   validator(target, schema, (result, _c) => {
     if (!result.success) {
       throw E.NORMAL.VALIDATION.create({

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

@@ -1,6 +1,7 @@
 {
   "extends": "@oyolincc/dev-config/tsconfig.bundler.json",
   "compilerOptions": {
+    "types": ["node", "./worker-configuration.d.ts"],
     "verbatimModuleSyntax": true,
     "jsx": "react-jsx",
     "jsxImportSource": "hono/jsx",

package/templates/hono-server/apps/server/vite.config.ts

@@ -52,14 +52,19 @@ export default defineConfig(() => {
     pack: {
       ...packConfig,
       plugins: [virtualWorkers('pack')],
+      deps: {
+        neverBundle: ['cloudflare:workers'],
+      },
       entry: {
         ...(isServe
           ? {}
           : {
-              nodeMain: './src/adapters/nodejs/bootstrap.ts',
+              nodejsMain: './src/adapters/nodejs/bootstrap.ts',
             }),
-        nodeEntry: './src/adapters/nodejs/entry.ts',
-        'workers/example-worker': './src/infra/work-runner/example/worker-entry.ts',
+        nodejsEntry: './src/adapters/nodejs/entry.ts',
+        cloudflareEntry: './src/adapters/cloudflare/entry.ts',
+        // Enable this entry together with PiscinaWorkRunner in the Node.js adapter.
+        // 'workers/example-worker': './src/infra/work-runner/example/worker-entry.ts',
       },
       // deps: {
       //   neverBundle: [...builtinModules],