@oyolincc/create 0.4.0 → 0.5.0

package/templates/hono-server/README.md

@@ -28,7 +28,7 @@ Database schema changes remain manual. Production Worker variables are configure
 
 Before deploying, replace the placeholder D1 `database_id` and `database_name` in `apps/server/wrangler.jsonc`.
 
-Example tasks run in-process through `PassThroughWorkRunner` by default. To use worker threads, enable `PiscinaWorkRunner` in the Node.js adapter and the adjacent worker pack entry in `apps/server/vite.config.ts`.
+Example tasks run in-process through `PassThroughRunner` by default. To use worker threads, enable `PiscinaWorkRunner` in apps/server/src/di-container.ts and the adjacent worker pack entry in `apps/server/vite.config.ts`.
 
 ## Commands
 
@@ -42,3 +42,11 @@ Example tasks run in-process through `PassThroughWorkRunner` by default. To use
 - `pnpm --filter @repo/server test`: run the retained server tests.
 
 The server base path is configured by `SERVER_BASE_PATH`. Health, OpenAPI YAML, Swagger, CRUD, and worker processing are available below that base path. Docker supports local Compose under `docker/local` and production Compose under `docker/prod`. CI is intentionally not included.
+
+## 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, 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-server/_gitignore

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

package/templates/hono-server/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",
@@ -28,7 +31,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",
@@ -38,7 +44,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-server/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-server/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-server/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-server/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-server/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-server/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-server/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-server/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-server/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-server/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> {}