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

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

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

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

@@ -0,0 +1,47 @@
+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 { ExampleWorkRunner } from '@/infra/work-runner/example/runner'
+import { getLogger, 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)
+
+export const exampleWorkRunner = ExampleWorkRunner.getInstance(appConfig.worker)
+export const sqliteClient = createSqliteClient(sqliteConfig.dbPath)
+
+let dependencies: AppDependencies | undefined
+const app = createApp(() => {
+  dependencies ||= { appConfig, loggerHandler, exampleWorkRunner, db: sqliteClient.db }
+  return dependencies
+})
+
+export default app

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

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vite-plus/test'
+import { createApp } from './app'
+import type { AppDependencies, AppLogger } from './shared/app/types'
+
+const logger = new Proxy(
+  { assign() {} },
+  { get: (target, key) => Reflect.get(target, key) || (() => {}) },
+) as AppLogger
+const dependencies = {
+  appConfig: { middleware: { cors: { domains: ['*'] } } },
+  loggerHandler: async (c: any, next: () => Promise<void>) => {
+    c.set('logger', logger)
+    await next()
+  },
+  exampleWorkRunner: {
+    async run(task: any) {
+      const original = task.input.message
+      const normalized = original.trim().replace(/\s+/g, ' ')
+      return { ok: true as const, data: { original, normalized, length: normalized.length } }
+    },
+    async shutdown() {},
+  },
+} as unknown as AppDependencies
+
+describe('HTTP contracts', () => {
+  const app = createApp(() => dependencies)
+
+  it('wraps successful responses in data', async () => {
+    const response = await app.request('/health')
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toEqual({ data: { status: 'ok' } })
+  })
+
+  it('returns Problem Details for missing routes', async () => {
+    const response = await app.request('/missing')
+    expect(response.status).toBe(404)
+    await expect(response.json()).resolves.toMatchObject({ status: 404, type: 'NORMAL.NOT_FOUND' })
+  })
+
+  it('returns validation Problem Details with status 422', async () => {
+    const response = await app.request('/examples/process', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ message: '' }),
+    })
+    expect(response.status).toBe(422)
+    await expect(response.json()).resolves.toMatchObject({
+      status: 422,
+      type: 'NORMAL.VALIDATION',
+    })
+  })
+})

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

@@ -0,0 +1,45 @@
+import { type Context, 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 { 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>()
+
+  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('*', secureHeaders())
+  app.use('*', corsMiddleware())
+  app.use('*', csrf())
+
+  app.route('/', exampleRoutes)
+  configureOpenAPI(app)
+
+  app.notFound(() => {
+    throw E.NORMAL.NOT_FOUND.create()
+  })
+  app.onError(globalErrorHandler)
+  return app
+}

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

@@ -0,0 +1,74 @@
+import type { AppEnv, AppLogger } from '@/shared/app/types'
+import { hasProp } from '@/shared/utils'
+import { getContext } from 'hono/context-storage'
+
+// 1. 创建无限递归的空代理，用于抹平高级日志库独有的非核心属性/方法（如 logger.bindings(), logger.flush()）
+const dummyFn = () => noopProxy
+const noopProxy: any = new Proxy(dummyFn, {
+  get: () => noopProxy,
+  apply: () => noopProxy,
+})
+
+// 2. 自定义日志级别到 Console 方法的映射
+const mapToConsoleMethod: Record<string, string> = {
+  trace: 'trace',
+  debug: 'debug',
+  info: 'info',
+  warn: 'warn',
+  error: 'error',
+  fatal: 'error', // Console 没有 fatal，将其降级映射为 error
+  silent: 'debug', // 理论上不该输出，但做个兜底防崩溃
+}
+
+export const fallbackLogger = new Proxy(console, {
+  get(target, prop, receiver) {
+    if (prop === 'child') {
+      return () => fallbackLogger
+    }
+
+    if (typeof prop === 'string' && hasProp(mapToConsoleMethod, prop)) {
+      const consoleMethod = Reflect.get(target, mapToConsoleMethod[prop], receiver)
+      if (typeof consoleMethod === 'function') {
+        return consoleMethod.bind(target)
+      }
+    }
+
+    const value = Reflect.get(target, prop, receiver)
+    if (typeof value === 'function') {
+      return value.bind(target)
+    }
+
+    // 如果原生具有该属性（不为 undefined），则直接返回
+    if (value !== undefined) {
+      return value
+    }
+
+    // --- 核心改造点 D：未知的扩展属性/链式调用 ---
+    // 比如 logger.bindings().xxx()，返回无限安全代理，杜绝 Cannot read properties of xxx 报错
+    return noopProxy
+  },
+
+  // 拦截写入操作（如业务代码修改 logger.level = 'debug'）
+  set(_target, _prop, _value) {
+    // 静默吞掉修改操作，防止污染原生的 console 对象
+    return true
+  },
+}) as unknown as AppLogger
+
+let rootLogger: AppLogger | undefined
+
+export const setRootLogger = (logger: AppLogger) => {
+  rootLogger = logger
+}
+
+export const getLogger = (): AppLogger => {
+  try {
+    const contextLogger = getContext<AppEnv>().var.logger
+    if (contextLogger) {
+      return contextLogger
+    }
+  } catch {
+    // outside hono context-storage
+  }
+  return rootLogger || fallbackLogger
+}

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

@@ -0,0 +1,122 @@
+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 { serializeErr } from '@/shared/errors/log'
+
+// const pinoInstance = pino({
+//   hooks: {
+//     logMethod(args: any[], method) {
+//       if (
+//         args.length !== 2 ||
+//         args[0] instanceof Error ||
+//         typeof args[1] !== 'string'
+//       ) {
+//         return method.apply(this, args)
+//       }
+//       const firstArg = args[0]
+//       if (firstArg && typeof firstArg === 'object') {
+//         const { context, ...rest } = firstArg
+//         const arg1: any = { p: rest }
+//         if (context) arg1.context = context
+//         return method.apply(this, [{}, args[1]])
+//       }
+//       return method.apply(this, args)
+//     },
+//   },
+// })
+
+export const createPinoOptions = ({
+  isLocal,
+  baseConfig,
+}: {
+  isLocal: boolean
+  baseConfig: AppConfig['log']['base']
+}) => {
+  const pinoOptions: LoggerOptions = {
+    level: baseConfig.loggerLevel || (isLocal ? 'debug' : 'info'),
+    serializers: {
+      req: (req) => {
+        return {
+          method: req.method,
+          url: req.url,
+          headers: {
+            'content-type': req.headers?.['content-type'],
+            'user-agent': req.headers?.['user-agent'],
+            referer: req.headers?.['referer'],
+          },
+        }
+      },
+      res: (res) => {
+        return {
+          status: res.status,
+          headers: {
+            'content-type': res.headers?.['content-type'],
+            'content-length': res.headers?.['content-length'],
+          },
+        }
+      },
+      err: serializeErr,
+    },
+  }
+
+  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 })
+  const level = pinoOptions.level
+  if (runtime === 'node' || runtime === 'bun') {
+    if (isLocal && logPretty) {
+      try {
+        createRequire(import.meta.url).resolve('pino-pretty')
+        pinoOptions.transport = { target: 'pino-pretty', level, options: logPretty }
+      } catch {
+        console.warn('[logger] pino-pretty is not installed; falling back to JSON stdout')
+      }
+    } else if (logRoll) {
+      const { loggerDir, loggerFileBase } = logRoll
+      pinoOptions.transport = {
+        targets: [
+          {
+            target: 'pino-roll',
+            level,
+            options: {
+              ...logRoll,
+              file: join(
+                isAbsolute(loggerDir) ? loggerDir : resolve(process.cwd(), loggerDir),
+                loggerFileBase,
+              ),
+            },
+          },
+          { target: 'pino/file', level, options: { destination: 1 } },
+        ],
+      }
+    }
+  }
+  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 { rootLogger, loggerHandler }
+}

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

@@ -0,0 +1,23 @@
+// 所有工作任务标识
+export const WorkSubject = Object.freeze({
+  PROCESS_EXAMPLE: 'PROCESS_EXAMPLE',
+} as const)
+export type WorkSubject = (typeof WorkSubject)[keyof typeof WorkSubject]
+
+export const WorkerErrorCode = Object.freeze({
+  /** Worker 等待队列已满。 */
+  QUEUE_FULL: 'WORKER_QUEUE_FULL',
+  /** Worker 任务从提交到完成超过允许时限。 */
+  TASK_TIMEOUT: 'WORKER_TASK_TIMEOUT',
+  /** Worker 任务被取消。 */
+  TASK_ABORTED: 'WORKER_TASK_ABORTED',
+  /** Worker 任务内部错误。 */
+  TASK_INTERNAL: 'WORKER_TASK_INTERNAL',
+  /** Worker 未知错误。 */
+  UNKNOWN: 'UNKNOWN',
+  /** Worker 异常退出或 Pool 暂时没有可用 Worker。 */
+  WORKER_UNAVAILABLE: 'WORKER_UNAVAILABLE',
+  /** Worker Pool 已进入关闭流程，无法接受新任务。 */
+  WORKER_CLOSED: 'WORKER_CLOSED',
+} as const)
+export type WorkerErrorCode = (typeof WorkerErrorCode)[keyof typeof WorkerErrorCode]

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

@@ -0,0 +1,40 @@
+import { hasProp } from '@/shared/utils'
+import { WorkerErrorCode } from './constants'
+import type { RunnerTaskError, RunnerTaskErrorDetails } from './types'
+
+const workerErrorCodes = Object.values(WorkerErrorCode)
+
+export class WorkerTaskError extends Error {
+  readonly code: WorkerErrorCode
+  readonly details?: RunnerTaskErrorDetails
+
+  constructor(
+    code: WorkerErrorCode,
+    message: string,
+    details?: RunnerTaskErrorDetails,
+    cause?: unknown,
+  ) {
+    super(message, { cause })
+    this.name = 'WorkerTaskError'
+    this.code = code
+    this.details = details
+  }
+
+  serialize(): RunnerTaskError<WorkerErrorCode> {
+    return {
+      code: this.code,
+      message: this.message,
+      ...(this.details ? { details: this.details } : {}),
+      ...(this.cause ? { cause: this.cause } : {}),
+    }
+  }
+}
+
+export function isWorkerTaskError(error: unknown): error is WorkerTaskError {
+  return (
+    error instanceof WorkerTaskError ||
+    (error instanceof Error &&
+      hasProp(error, 'code') &&
+      workerErrorCodes.includes(error.code as WorkerErrorCode))
+  )
+}

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

@@ -0,0 +1,56 @@
+import { afterEach, describe, expect, it, vi } from 'vite-plus/test'
+import { WorkerErrorCode, WorkSubject } from '../constants'
+import { ExampleWorkRunner } from './runner'
+
+vi.mock('@/infra/logger/getter', () => ({
+  getLogger: () =>
+    new Proxy({ assign() {} }, { get: (target, key) => Reflect.get(target, key) || (() => {}) }),
+}))
+vi.mock('virtual:workers', () => ({ default: '/tmp' }))
+vi.mock('piscina', () => ({
+  default: class PiscinaMock {
+    idleThreads = 1
+    threads: unknown[] = []
+    queueSize = 0
+    options = { maxQueue: 1 }
+
+    run() {
+      throw new Error('An aborted task must not reach the worker pool')
+    }
+
+    async close() {}
+  },
+}))
+
+const config = {
+  minThreads: 1,
+  maxThreads: 1,
+  concurrentTasksPerWorker: 1,
+  maxQueue: 1,
+  workerTaskTimeoutMs: 1_000,
+}
+
+describe('ExampleWorkRunner cancellation', () => {
+  let runner: ExampleWorkRunner | undefined
+
+  afterEach(async () => {
+    await runner?.shutdown()
+    runner = undefined
+  })
+
+  it('returns the task-aborted error model for an aborted signal', async () => {
+    runner = ExampleWorkRunner.getInstance(config)
+    const controller = new AbortController()
+    controller.abort()
+
+    await expect(
+      runner.run(
+        { subject: WorkSubject.PROCESS_EXAMPLE, input: { message: 'hello' } },
+        { signal: controller.signal },
+      ),
+    ).resolves.toMatchObject({
+      ok: false,
+      error: { code: WorkerErrorCode.TASK_ABORTED },
+    })
+  })
+})