@oyolincc/create 0.2.0 → 0.3.0

package/templates/hono-server/apps/server/src/shared/errors/constants.ts

@@ -0,0 +1,152 @@
+import { fz } from '@/shared/utils'
+
+// /* 参考自 grpc code */
+// export const ErrorCode = fz({
+//   // 操作已被取消，通常由调用方取消。
+//   //
+//   // HTTP 映射：499 Client Closed Request
+//   CANCELLED: 'CANCELLED',
+
+//   // 未知错误。例如，当从另一个地址空间接收到的 `Status` 值
+//   // 属于本地址空间未知的错误空间时，可能返回此错误。此外，
+//   // 未返回足够错误信息的 API 所抛出的错误也可能被转换为此错误。
+//   //
+//   // HTTP 映射：500 Internal Server Error
+//   UNKNOWN: 'UNKNOWN',
+
+//   // 客户端指定了无效参数。注意这与 `FAILED_PRECONDITION` 不同。
+//   // `INVALID_ARGUMENT` 表示无论系统状态如何都有问题的参数
+//   //（例如，格式错误的文件名）。
+//   //
+//   // HTTP 映射：400 Bad Request
+//   INVALID_ARGUMENT: 'INVALID_ARGUMENT',
+
+//   // 在操作完成之前已超过截止时间。对于会改变系统状态的操作，
+//   // 即使操作已成功完成，也可能返回此错误。例如，来自服务器的
+//   // 成功响应可能延迟过久，导致截止时间已过期。
+//   //
+//   // HTTP 映射：504 Gateway Timeout
+//   DEADLINE_EXCEEDED: 'DEADLINE_EXCEEDED',
+
+//   // 未找到某些请求的实体（例如，文件或目录）。
+//   //
+//   // 给服务端开发者的说明：如果请求对某一类用户整体被拒绝，
+//   // 例如渐进式功能发布或未文档化的白名单，可以使用 `NOT_FOUND`。
+//   // 如果请求对某一类用户中的部分用户被拒绝，例如基于用户的访问控制，
+//   // 则必须使用 `PERMISSION_DENIED`。
+//   //
+//   // HTTP 映射：404 Not Found
+//   NOT_FOUND: 'NOT_FOUND',
+
+//   // 客户端尝试创建的实体（例如，文件或目录）已存在。
+//   //
+//   // HTTP 映射：409 Conflict
+//   ALREADY_EXISTS: 'ALREADY_EXISTS',
+
+//   // 调用方没有执行指定操作的权限。`PERMISSION_DENIED` 不得用于
+//   // 因资源耗尽而导致的拒绝（此类错误应使用 `RESOURCE_EXHAUSTED`）。
+//   // 如果无法识别调用方，则不得使用 `PERMISSION_DENIED`
+//   //（此类错误应使用 `UNAUTHENTICATED`）。此错误码并不表示
+//   // 请求有效，也不表示请求的实体存在或满足其他前置条件。
+//   //
+//   // HTTP 映射：403 Forbidden
+//   PERMISSION_DENIED: 'PERMISSION_DENIED',
+
+//   // 请求缺少执行该操作的有效身份验证凭据。
+//   //
+//   // HTTP 映射：401 Unauthorized
+//   UNAUTHENTICATED: 'UNAUTHENTICATED',
+
+//   // 某些资源已耗尽，可能是每用户配额，
+//   // 也可能是整个文件系统空间不足。
+//   //
+//   // HTTP 映射：429 Too Many Requests
+//   RESOURCE_EXHAUSTED: 'RESOURCE_EXHAUSTED',
+
+//   // 操作被拒绝，因为系统未处于执行该操作所需的状态。
+//   // 例如，要删除的目录非空、对非目录执行 rmdir 操作等。
+//   //
+//   // 服务实现者可以使用以下指南在 `FAILED_PRECONDITION`、
+//   // `ABORTED` 和 `UNAVAILABLE` 之间做出选择：
+//   //  (a) 如果客户端可以仅重试失败的调用，则使用 `UNAVAILABLE`。
+//   //  (b) 如果客户端应在更高层级重试，则使用 `ABORTED`。
+//   //      例如，当客户端指定的 test-and-set 失败时，表示客户端
+//   //      应重新开始读-改-写序列。
+//   //  (c) 如果客户端在系统状态被明确修复之前不应重试，
+//   //      则使用 `FAILED_PRECONDITION`。例如，如果 rmdir 因目录
+//   //      非空而失败，应返回 `FAILED_PRECONDITION`，因为除非
+//   //      目录中的文件被删除，否则客户端不应重试。
+//   //
+//   // HTTP 映射：400 Bad Request
+//   FAILED_PRECONDITION: 'FAILED_PRECONDITION',
+
+//   // 操作已中止，通常由于并发问题，例如序列号检查失败或事务中止。
+//   //
+//   // 关于在 `FAILED_PRECONDITION`、`ABORTED` 和 `UNAVAILABLE`
+//   // 之间如何选择，请参阅上述指南。
+//   //
+//   // HTTP 映射：409 Conflict
+//   ABORTED: 'ABORTED',
+
+//   // 操作超出了有效范围。例如，在文件末尾之后进行 seek 或 read。
+//   //
+//   // 与 `INVALID_ARGUMENT` 不同，此错误表示的问题可能在系统状态
+//   // 改变后得到修复。例如，32 位文件系统在被要求读取不在
+//   // [0,2^32-1] 范围内的偏移量时会生成 `INVALID_ARGUMENT`，
+//   // 但在被要求读取超过当前文件大小的偏移量时会生成 `OUT_OF_RANGE`。
+//   //
+//   // `FAILED_PRECONDITION` 与 `OUT_OF_RANGE` 之间存在一定重叠。
+//   // 我们建议在适用时使用更具体的 `OUT_OF_RANGE`，以便遍历
+//   // 某个空间的调用方可以方便地查找 `OUT_OF_RANGE` 错误来判断
+//   // 是否已完成。
+//   //
+//   // HTTP 映射：400 Bad Request
+//   OUT_OF_RANGE: 'OUT_OF_RANGE',
+
+//   // 操作未实现，或在本服务中不受支持/未启用。
+//   //
+//   // HTTP 映射：501 Not Implemented
+//   UNIMPLEMENTED: 'UNIMPLEMENTED',
+
+//   // 内部错误。这意味着底层系统预期的不变量已被破坏。
+//   // 此错误码保留用于严重错误。
+//   //
+//   // HTTP 映射：500 Internal Server Error
+//   INTERNAL: 'INTERNAL',
+
+//   // 服务当前不可用。这很可能是暂时性状况，可以通过带退避的重试来纠正。
+//   // 请注意，重试非幂等操作并不总是安全的。
+//   //
+//   // 关于在 `FAILED_PRECONDITION`、`ABORTED` 和 `UNAVAILABLE`
+//   // 之间如何选择，请参阅上述指南。
+//   //
+//   // HTTP 映射：503 Service Unavailable
+//   UNAVAILABLE: 'UNAVAILABLE',
+
+//   // 不可恢复的数据丢失或损坏。
+//   //
+//   // HTTP 映射：500 Internal Server Error
+//   DATA_LOSS: 'DATA_LOSS',
+// })
+// export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode]
+
+export const ErrorHttpStatus = fz({
+  CANCELLED: 499,
+  UNKNOWN: 500,
+  INVALID_ARGUMENT: 400,
+  UNPROCESSABLE_ENTITY: 422,
+  DEADLINE_EXCEEDED: 504,
+  NOT_FOUND: 404,
+  ALREADY_EXISTS: 409,
+  PERMISSION_DENIED: 403,
+  UNAUTHENTICATED: 401,
+  RESOURCE_EXHAUSTED: 429,
+  FAILED_PRECONDITION: 400,
+  ABORTED: 409,
+  OUT_OF_RANGE: 400,
+  UNIMPLEMENTED: 501,
+  INTERNAL: 500,
+  UNAVAILABLE: 503,
+  DATA_LOSS: 500,
+})
+export type ErrorHttpStatus = (typeof ErrorHttpStatus)[keyof typeof ErrorHttpStatus]

package/templates/hono-server/apps/server/src/shared/errors/defs/index.ts

@@ -0,0 +1,15 @@
+import { ErrorHttpStatus } from '../constants'
+import { defineErrorCategories } from '../proto'
+import type { ErrorCategoryItem } from '../types'
+
+const normalErrorCategories = {
+  INTERNAL: { status: ErrorHttpStatus.INTERNAL, message: 'Internal Server Error' },
+  CLIENT_ABORTED: { status: ErrorHttpStatus.CANCELLED, message: 'Request aborted' },
+  VALIDATION: {
+    status: ErrorHttpStatus.UNPROCESSABLE_ENTITY,
+    message: 'Request validation failed',
+  },
+  NOT_FOUND: { status: ErrorHttpStatus.NOT_FOUND, message: 'Resource not found' },
+} satisfies Record<string, ErrorCategoryItem>
+
+export const E = defineErrorCategories({ NORMAL: normalErrorCategories })

package/templates/hono-server/apps/server/src/shared/errors/handler.ts

@@ -0,0 +1,16 @@
+import { problemDetailsHandler } from 'hono-problem-details'
+import { E } from './defs'
+import { logLevelFor } from './log'
+import type { ErrorHandler } from 'hono'
+import type { AppEnv } from '@/shared/app/types'
+import { getLogger } from '@/infra/logger/getter'
+
+const problemHandler = problemDetailsHandler({
+  defaultType: E.NORMAL.INTERNAL.type,
+})
+
+export const globalErrorHandler: ErrorHandler<AppEnv> = (err, c) => {
+  const logger = getLogger()
+  logger[logLevelFor(err)](err)
+  return problemHandler(err, c)
+}

package/templates/hono-server/apps/server/src/shared/errors/log.ts

@@ -0,0 +1,67 @@
+import { HTTPException } from 'hono/http-exception'
+import { ProblemDetailsError } from 'hono-problem-details'
+import { isEmpty, objectEntries } from '../utils'
+
+const MAX_CAUSE_DEPTH = 5
+
+function compact(input: Record<string, unknown>) {
+  const out: Record<string, unknown> = {}
+  for (const [key, value] of objectEntries(input)) {
+    if (isEmpty(value)) continue
+    out[key] = value
+  }
+  return out
+}
+
+function serializeUnknown(value: unknown, seen: Set<object>, depth: number): unknown {
+  if (!(value instanceof Error)) return isEmpty(value) ? undefined : value
+  return compact({
+    name: value.name,
+    message: value.message,
+    stack: value.stack,
+    cause: serializeError(value.cause, seen, depth + 1),
+  })
+}
+
+function serializeError(value: unknown, seen: Set<object>, depth: number): unknown {
+  if (!(value instanceof Error)) return isEmpty(value) ? undefined : value
+  if (seen.has(value)) return { truncated: 'circular-cause' }
+  if (depth > MAX_CAUSE_DEPTH) return { truncated: 'max-cause-depth' }
+
+  seen.add(value)
+
+  if (value instanceof ProblemDetailsError) {
+    const { type, status, detail, instance, extensions } = value.problemDetails
+    return compact({
+      ...extensions,
+      type,
+      status,
+      detail,
+      instance,
+      cause: serializeError(value.cause, seen, depth + 1),
+    })
+  }
+  if (value instanceof HTTPException) {
+    return compact({
+      status: value.status,
+      detail: value.message,
+      cause: serializeError(value.cause, seen, depth + 1),
+    })
+  }
+  return serializeUnknown(value, seen, depth)
+}
+
+export function serializeErr(value: unknown) {
+  // 业务错误不需要堆栈信息，未知未捕获错误才需要
+  return serializeError(value, new Set(), 0)
+}
+
+export function logLevelFor(err: unknown): 'warn' | 'error' {
+  if (err instanceof ProblemDetailsError) {
+    return err.problemDetails.status < 500 ? 'warn' : 'error'
+  }
+  if (err instanceof HTTPException) {
+    return err.status < 500 ? 'warn' : 'error'
+  }
+  return 'error'
+}

package/templates/hono-server/apps/server/src/shared/errors/proto.ts

@@ -0,0 +1,42 @@
+import format from 'string-template'
+import { problemDetails } from 'hono-problem-details'
+import { fz, hasProp } from '../utils'
+import type { ErrorCategoryItem, ErrorCreateInput, Recursive, WithErrorType } from './types'
+
+export function isErrorCategoryItem(obj: unknown): obj is ErrorCategoryItem {
+  return !!obj && typeof obj === 'object' && hasProp(obj, 'status') && hasProp(obj, 'message')
+}
+
+export function defineErrorCategories<T extends Recursive<ErrorCategoryItem>>(
+  value: T,
+): WithErrorType<T> {
+  function traverse(obj: any, currentPath: string): any {
+    if (isErrorCategoryItem(obj)) {
+      const { status, message } = obj
+      return fz({
+        ...obj,
+        type: currentPath,
+        create(input: ErrorCreateInput = {}) {
+          const { msgContext, message: messageOverride, cause, ...rest } = input
+          const error = problemDetails({
+            ...rest,
+            status,
+            type: currentPath,
+            detail: messageOverride || format(message, msgContext || {}),
+          })
+          if (cause !== undefined) error.cause = cause
+          return error
+        },
+      })
+    }
+
+    const result: any = {}
+    for (const key of Object.keys(obj)) {
+      const nextPath = currentPath ? `${currentPath}.${key}` : key
+      result[key] = traverse(obj[key], nextPath)
+    }
+    return fz(result)
+  }
+
+  return traverse(value, '')
+}

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

@@ -0,0 +1,29 @@
+import type { ProblemDetailsError, ProblemDetailsInput } from 'hono-problem-details'
+import type { ErrorHttpStatus } from './constants'
+
+export interface Recursive<T> {
+  [key: string]: Recursive<T> | T
+}
+
+export type ErrorCategoryItem = {
+  status: ErrorHttpStatus
+  message: string
+}
+
+export type ErrorCreateInput = {
+  msgContext?: Record<string, unknown>
+  message?: string
+  cause?: unknown
+} & Omit<ProblemDetailsInput, 'status' | 'type' | 'message'>
+
+export type WithErrorType<T, Prefix extends string = ''> = T extends ErrorCategoryItem
+  ? T & {
+      type: Prefix
+      create: (input?: ErrorCreateInput) => ProblemDetailsError
+    }
+  : {
+      [K in keyof T]: WithErrorType<
+        T[K],
+        Prefix extends '' ? K & string : `${Prefix}.${K & string}`
+      >
+    }

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

@@ -0,0 +1,35 @@
+import ky, { type Options, type KyInstance, isKyError, isTimeoutError } from 'ky'
+import { defu } from 'defu'
+
+const defaultBaseOptions: Options = {
+  // 默认手动处理重定向，避免ky自动重定向导致请求失败
+  redirect: 'manual',
+  retry: {
+    // 默认不重试
+    limit: 0,
+    // 如果配置了重试，则 如果是http错误或超时，超时则重试，否则走默认行为；
+    // 其他情况可能是hooks内代码逻辑报错，不重试
+    shouldRetry({ error }) {
+      if (isKyError(error)) {
+        if (isTimeoutError(error)) {
+          return true
+        }
+        return undefined
+      }
+      return false
+    },
+  },
+}
+
+export function getOptions(options?: Options): Options {
+  return defu({}, defaultBaseOptions, options)
+}
+
+/**
+ * 创建基础请求器
+ * 适用于Node.js和浏览器环境，不包含业务逻辑
+ * beforeRequest -> afterResponse -> beforeError -> shouldRetry -> beforeRetry -> beforeRequest -> ...
+ */
+export function createFetcher(options?: Options): KyInstance {
+  return ky.create(getOptions(options))
+}

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

@@ -0,0 +1,50 @@
+import type { Hono } from 'hono'
+import { swaggerUI } from '@hono/swagger-ui'
+import { generateSpecs } from 'hono-openapi'
+import type { AppEnv } from '@/shared/app/types'
+import { stringify } from 'yaml'
+
+export * from './res-defs'
+
+export const OpenApiTags = {
+  System: 'System',
+  Example: 'Example',
+} as const
+
+const DOCS_YAML_PATH = '/docs/openapi.yaml'
+
+const openApiSpecOptions = {
+  documentation: {
+    info: {
+      title: '@repo/server',
+      version: '0.0.0',
+      description: 'Hono API Server',
+    },
+    tags: [
+      { name: OpenApiTags.System, description: 'Server infrastructure' },
+      { name: OpenApiTags.Example, description: 'Example vertical slice' },
+    ],
+  },
+  exclude: [DOCS_YAML_PATH, '/swagger'],
+  defaultOptions: {
+    ALL: {
+      responses: {
+        422: {
+          description: '请求参数校验失败',
+        },
+      },
+    },
+  },
+}
+
+export const configureOpenAPI = (app: Hono<AppEnv>) => {
+  let yamlSpecs: string | undefined
+  app.get(DOCS_YAML_PATH, async (c) => {
+    if (!yamlSpecs) {
+      yamlSpecs = stringify(await generateSpecs(app, openApiSpecOptions, c))
+    }
+    return c.text(yamlSpecs, 200, { 'Content-Type': 'application/yaml; charset=utf-8' })
+  })
+
+  app.get('/swagger', swaggerUI({ url: DOCS_YAML_PATH }))
+}

package/templates/hono-server/apps/server/src/shared/network/openapi/res-defs.ts

@@ -0,0 +1,39 @@
+import { type DescribeRouteOptions, resolver } from 'hono-openapi'
+import type { GenericSchema } from 'valibot'
+
+type OpenApiResponse = NonNullable<DescribeRouteOptions['responses']>[string]
+
+export const jsonResponse = (schema: GenericSchema, description = '请求成功'): OpenApiResponse => ({
+  description,
+  content: {
+    'application/json': {
+      schema: resolver(schema),
+    },
+  },
+})
+
+export type BinaryResponseOptions = {
+  description?: string
+  mediaType?: string
+  headers?: Record<
+    string,
+    {
+      description?: string
+      schema: { type: 'string'; format?: string }
+    }
+  >
+}
+
+export const binaryResponse = ({
+  description = '二进制响应',
+  mediaType = 'application/octet-stream',
+  headers,
+}: BinaryResponseOptions = {}): OpenApiResponse => ({
+  description,
+  ...(headers ? { headers } : {}),
+  content: {
+    [mediaType]: {
+      schema: { type: 'string', format: 'binary' },
+    },
+  },
+})

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

@@ -0,0 +1,3 @@
+export interface SuccessResObjBody<TData> {
+  data: TData
+}

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

@@ -0,0 +1,36 @@
+import type { Context } from 'hono'
+import type { ContentfulStatusCode } from 'hono/utils/http-status'
+import type { SuccessResObjBody } from './types'
+
+export function createContentDisposition(
+  filename?: string,
+  options?: {
+    asciiFallback?: string
+  },
+): string {
+  if (!filename) {
+    return 'inline'
+  }
+  const { asciiFallback = 'download' } = options || {}
+
+  // 1. 去除换行、引号、反斜杠及正斜杠，防止 Header 注入和路径遍历
+  const safeFilename = String(filename).replace(/[\r\n"\\/]/g, '_')
+
+  // 4. RFC 5987 编码：补充 encodeURIComponent 未编码的特殊字符 ( ' ( ) * )
+  const rfc5987Filename = encodeURIComponent(safeFilename).replace(
+    /['()*]/g,
+    (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`,
+  )
+
+  return `attachment; filename="${asciiFallback}"; filename*=UTF-8''${rfc5987Filename}`
+}
+
+// 成功响应体
+export function createSuccessObjBody<TData = any>(data: TData): SuccessResObjBody<TData> {
+  return {
+    data,
+  }
+}
+
+export const successJson = <T>(c: Context, data: T, status: ContentfulStatusCode = 200) =>
+  c.json(createSuccessObjBody(data), status)

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

@@ -0,0 +1,28 @@
+import type { Env, MiddlewareHandler, ValidationTargets } from 'hono'
+import { validator } from 'hono-openapi'
+import { flatten, type GenericSchema, type InferInput, type InferOutput } from 'valibot'
+import { E } from '@/shared/errors/defs'
+
+export const generalValidator = <
+  TTarget extends keyof ValidationTargets,
+  TSchema extends GenericSchema,
+>(
+  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({
+        extensions: {
+          validationError: flatten(result.error as any),
+        },
+      })
+    }
+  })

package/templates/hono-server/apps/server/src/shared/utils/index.ts

@@ -0,0 +1,30 @@
+export const fz = Object.freeze
+
+export const hasProp = <P extends string>(
+  item: object,
+  prop: P,
+): item is { [key in P]: unknown } => {
+  return Object.prototype.hasOwnProperty.call(item, prop)
+}
+
+export function isEmpty(value: unknown) {
+  return value === undefined || value === null || value === ''
+}
+
+export function createSingleton<T, Args extends any[]>(
+  factory: (...args: Args) => T,
+): (...args: Args) => T {
+  let instance: T | null = null
+
+  return (...args: Args): T => {
+    if (!instance) {
+      instance = factory(...args)
+    }
+    return instance
+  }
+}
+
+export const objectEntries = <T extends object>(obj: T) =>
+  Object.entries(obj) as {
+    [K in keyof T]-?: [K extends string | number ? `${K}` : never, T[K]]
+  }[keyof T][]

package/templates/hono-server/apps/server/src/virtual-modules.d.ts

@@ -0,0 +1,5 @@
+declare module 'virtual:workers' {
+  /** Absolute filesystem path to the packed workers directory (`dist/workers`). */
+  const workersDir: string
+  export default workersDir
+}

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

@@ -0,0 +1,17 @@
+{
+  "extends": "@oyolincc/dev-config/tsconfig.bundler.json",
+  "compilerOptions": {
+    "types": ["node", "./worker-configuration.d.ts"],
+    "verbatimModuleSyntax": true,
+    "jsx": "react-jsx",
+    "jsxImportSource": "hono/jsx",
+    "outDir": "./dist",
+    "paths": {
+      "@/*": ["./src/*"],
+      "@error-categories": ["./src/shared/errors/defs/index.ts"]
+    }
+  },
+  "files": [],
+  "include": ["src", "./*.ts", "./*.mts"],
+  "exclude": ["node_modules"]
+}

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

@@ -0,0 +1,87 @@
+import { defineConfig, type Plugin } from 'vite-plus'
+import { packConfig } from '@oyolincc/dev-config'
+import devServer from '@hono/vite-dev-server'
+import nodeAdapter from '@hono/vite-dev-server/node'
+import { loadEnvSync } from '@oyolincc/env-loader'
+import path from 'node:path'
+// import { builtinModules } from 'node:module'
+
+const __dirname = import.meta.dirname
+const isServe = !!process.env.VITE_PUBLIC_DEV_SERVE
+const workersDir = path.resolve(__dirname, 'dist/workers')
+
+function virtualWorkers(kind: 'dev' | 'pack'): Plugin {
+  const virtualId = 'virtual:workers'
+  const resolvedId = `\0${virtualId}`
+
+  return {
+    name: 'virtual-workers',
+    resolveId(id) {
+      if (id === virtualId) return resolvedId
+      return null
+    },
+    load(id) {
+      if (id !== resolvedId) return null
+      // vp dev / test: Piscina cannot follow Vite's module graph; pack --watch writes dist/workers.
+      if (kind === 'dev') {
+        return `export default ${JSON.stringify(workersDir)}`
+      }
+      // vp pack: inlined into the server entry, so import.meta.dirname is dist/.
+      return "import path from 'node:path'\nexport default path.join(import.meta.dirname, 'workers')"
+    },
+  }
+}
+
+export default defineConfig(() => {
+  return {
+    test: {
+      clearMocks: false,
+    },
+    plugins: [
+      virtualWorkers('dev'),
+      {
+        name: 'node-bootstrap',
+        async configureServer() {
+          loadEnvSync({
+            preset: 'server',
+          })
+        },
+      },
+      devServer({
+        entry: './src/adapters/nodejs/entry.ts',
+        adapter: nodeAdapter(),
+      }) as Plugin,
+    ],
+    pack: {
+      ...packConfig,
+      plugins: [virtualWorkers('pack')],
+      deps: {
+        neverBundle: ['cloudflare:workers'],
+      },
+      entry: {
+        ...(isServe
+          ? {}
+          : {
+              nodejsMain: './src/adapters/nodejs/bootstrap.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],
+      // },
+    },
+    resolve: {
+      alias: {
+        '@': path.resolve(__dirname, './src'),
+        '@error-categories': path.resolve(__dirname, './src/shared/errors/defs/index.ts'),
+      },
+    },
+    server: {
+      port: Number(process.env.NODE_PORT) || 6464,
+      host: true,
+    },
+  }
+})