@oyolincc/create 0.3.0 → 0.5.0

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

@@ -8,18 +8,19 @@ import type {
   WorkerMessage,
 } from '../types'
 import { WorkerErrorCode, WorkSubject } from '../constants'
-import { isWorkerTaskError, WorkerTaskError } from '../errors'
+import { serializeWorkerTaskError, WorkerTaskError } from '../errors'
 import Piscina from 'piscina'
 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 '../example/worker-entry'
+import type * as PiscinaWorker from './worker-entry'
 import { handleWorkerMessage } from '../utils/message'
+import { extractTransferables } from '../utils/transfer'
 
 const taskNameMap = {
   [WorkSubject.PROCESS_EXAMPLE]: 'executeExampleTask',
-} satisfies Partial<Record<WorkSubject, keyof typeof ExampleWorker>>
+} satisfies Partial<Record<WorkSubject, keyof typeof PiscinaWorker>>
 
 export class PiscinaWorkRunner implements AppWorkRunner {
   static #instance: PiscinaWorkRunner | null = null
@@ -31,7 +32,7 @@ export class PiscinaWorkRunner implements AppWorkRunner {
       throw new Error('[PiscinaWorkRunner] config is required')
     }
     this.#pool = new Piscina({
-      filename: path.join(workersDir, 'example-worker.mjs'),
+      filename: path.join(workersDir, 'piscina-worker.mjs'),
       minThreads: config.minThreads,
       maxThreads: config.maxThreads,
       concurrentTasksPerWorker: config.concurrentTasksPerWorker,
@@ -61,15 +62,14 @@ export class PiscinaWorkRunner implements AppWorkRunner {
     let result: RunnerTaskRunResult<TSubject>
     let workerMessagePort: MessagePort | undefined
 
-    const { signal: optSignal, transferList } = options || {}
-    const logger = getLogger()
+    const { signal: optSignal } = options || {}
     // pool当前状态
     const poolStats = {
       idleThreads: this.#pool.idleThreads,
       threads: this.#pool.threads.length,
       queueSize: this.#pool.queueSize,
     }
-    logger.assign({
+    const logger = getLogger().child({
       pool: poolStats,
       subject: taskParams.subject,
     })
@@ -123,45 +123,22 @@ export class PiscinaWorkRunner implements AppWorkRunner {
       }
 
       // 开始调用
+      const { input, transferList } = extractTransferables(taskParams.input)
       const invocation: RunnerTaskInvocation<(typeof taskParams)['input']> = {
-        input: taskParams.input,
+        input,
         messagePort: workerMessagePort,
       }
       const taskPromise = this.#pool.run(invocation, {
         name: targetName,
         signal: taskSignal,
-        transferList: [...(transferList || []), workerMessagePort],
+        transferList: [...transferList, workerMessagePort],
       }) as Promise<RunnerTaskRunResult<TSubject>>
 
       result = timeoutPromise
         ? await Promise.race([taskPromise, timeoutPromise])
         : await taskPromise
     } catch (error) {
-      if (isWorkerTaskError(error)) {
-        result = {
-          ok: false,
-          error: error.serialize(),
-        }
-      } else if (error instanceof Error && error.name === 'AbortError') {
-        result = {
-          ok: false,
-          error: new WorkerTaskError(
-            WorkerErrorCode.TASK_ABORTED,
-            error.message,
-            undefined,
-          ).serialize(),
-        }
-      } else {
-        result = {
-          ok: false,
-          error: new WorkerTaskError(
-            WorkerErrorCode.UNKNOWN,
-            'Worker task failed unexpectedly',
-            undefined,
-            error,
-          ).serialize(),
-        }
-      }
+      result = { ok: false, error: serializeWorkerTaskError(error) }
     } finally {
       if (timeoutTimer) clearTimeout(timeoutTimer)
       try {

package/templates/hono-server/apps/server/src/infra/work-runner/{example → piscina}/worker-entry.ts

@@ -5,9 +5,13 @@ import {
   type ExampleRunnerTaskModel,
 } from '@/modules/example/work-task/tasks'
 
-export function executeExampleTask({
+export async function executeExampleTask({
   input,
   messagePort,
 }: RunnerTaskInvocation<ExampleRunnerTaskModel['input']>): ReturnType<typeof runExampleTask> {
-  return runExampleTask(input, messagePort).finally(() => messagePort.close())
+  try {
+    return await runExampleTask(input)
+  } finally {
+    messagePort.close()
+  }
 }

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 { Transferable } from 'node:worker_threads'
+import type { MessagePort } 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: WorkerMessagePort
+  messagePort: MessagePort
 }
 
 export type RunnerTaskJsonValue =
@@ -69,19 +69,6 @@ export type WorkerMessage =
       value: number
       message?: string
     }
-  | {
-      type: 'result'
-      data: RunnerTaskJsonValue
-    }
-  | {
-      type: 'error'
-      error: RunnerTaskError
-    }
-
-export interface WorkerMessagePort {
-  postMessage(message: WorkerMessage): void
-  close(): void
-}
 
 export type RunnerTaskError<TCode extends string = string> = {
   code: TCode
@@ -102,7 +89,6 @@ export type RunnerTaskRunResult<TSubject extends WorkSubject> = RunnerTaskResult
 
 export type RunnerTaskRunOptions = {
   signal?: AbortSignal
-  transferList?: Transferable[]
 }
 
 export interface AppWorkRunner {

package/templates/hono-server/apps/server/src/infra/work-runner/utils/business-error.ts

@@ -2,18 +2,23 @@ import { hasProp } from '@/shared/utils'
 import type { RunnerTaskErrorDetails } from '../types'
 
 export class WorkerTaskBusinessError extends Error {
-  readonly details?: RunnerTaskErrorDetails
+  declare readonly cause: {
+    type: 'WorkerTaskBusinessError'
+    details?: RunnerTaskErrorDetails
+    cause?: unknown
+  }
 
   constructor(message: string, details?: RunnerTaskErrorDetails, cause?: unknown) {
-    super(message, { cause })
+    super(message, { cause: { type: 'WorkerTaskBusinessError', details, cause } })
     this.name = 'WorkerTaskBusinessError'
-    this.details = details
   }
 }
 
 export function isWorkerTaskBusinessError(error: unknown): error is WorkerTaskBusinessError {
   return (
-    error instanceof WorkerTaskBusinessError ||
-    (error instanceof Error && hasProp(error, 'name') && error.name === 'WorkerTaskBusinessError')
+    error instanceof Error &&
+    !!error.cause &&
+    hasProp(error.cause, 'type') &&
+    error.cause.type === 'WorkerTaskBusinessError'
   )
 }

package/templates/hono-server/apps/server/src/infra/work-runner/utils/message.ts

@@ -1,9 +1,10 @@
-import type { AppLogger } from '@/shared/app/types'
-import type { RunnerTaskErrorDetails, WorkerMessage, WorkerMessagePort } from '../types'
+import type { AppLogger } from '@/shared/types/app'
+import type { RunnerTaskErrorDetails, WorkerMessage } from '../types'
+import type { MessagePort } from 'node:worker_threads'
 import type { WorkSubject } from '../constants'
 
 export function workerLog(
-  messagePort: WorkerMessagePort,
+  messagePort: MessagePort,
   level: Extract<WorkerMessage, { type: 'log' }>['level'],
   message: string,
   data?: RunnerTaskErrorDetails,
@@ -11,11 +12,7 @@ export function workerLog(
   messagePort.postMessage({ type: 'log', level, message, data } satisfies WorkerMessage)
 }
 
-export function workerProgress(
-  messagePort: WorkerMessagePort,
-  value: number,
-  message?: string,
-): void {
+export function workerProgress(messagePort: MessagePort, value: number, message?: string): void {
   messagePort.postMessage({ type: 'progress', value, message } satisfies WorkerMessage)
 }
 
@@ -36,14 +33,5 @@ export function handleWorkerMessage(
         message.message || 'Worker progress',
       )
       break
-    case 'result':
-      logger.debug({ subject: context.subject }, 'Worker result delivered')
-      break
-    case 'error':
-      logger.warn(
-        { subject: context.subject, workerError: message.error },
-        'Worker error delivered',
-      )
-      break
   }
 }

package/templates/hono-server/apps/server/src/middlewares/cors.ts

@@ -1,26 +1,20 @@
-import type { AppEnv } from '@/shared/app/types'
+import type { CORSConfig } from '@repo/definition/backend'
 import { cors } from 'hono/cors'
-import { createMiddleware } from 'hono/factory'
 
-export const corsMiddleware = () => {
-  return createMiddleware<AppEnv>(async (c, next) => {
-    const corsConfig = c.get('appConfig')
-    const domains = corsConfig.middleware.cors.domains
-    const middleware = cors({
-      origin: (origin) => {
-        const isAllowedDomain = domains.some((domain) => {
-          try {
-            return domain === '*' || new URL(origin).host === domain
-          } catch {
-            return false
-          }
-        })
-        return isAllowedDomain ? origin : null
-      },
-      allowHeaders: ['Content-Type'],
-      allowMethods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
-      credentials: true,
-    })
-    return middleware(c, next)
+export const corsMiddleware = ({ domains }: CORSConfig) => {
+  return cors({
+    origin: (origin) => {
+      const isAllowedDomain = domains.some((domain) => {
+        try {
+          return domain === '*' || new URL(origin).host === domain
+        } catch {
+          return false
+        }
+      })
+      return isAllowedDomain ? origin : null
+    },
+    allowHeaders: ['Content-Type'],
+    allowMethods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+    credentials: true,
   })
 }

package/templates/hono-server/apps/server/src/middlewares/logger.ts

@@ -0,0 +1,34 @@
+import type { AppEnv } from '@/shared/types/app'
+import { structuredLogger } from '@hono/structured-logger'
+import type { Logger } from 'pino'
+
+export const loggerMiddleware = (rootLogger: Logger) => {
+  const logResponse = (logger: Logger, response: Response, responseTime: number) => {
+    // access log 只记请求完成；错误细节由 onError 走 serializers.err。
+    // 错误请求仍记 info 级别的完成日志，避免与 globalErrorHandler 重复记录 error。
+    logger.info(
+      {
+        res: {
+          status: response.status,
+          headers: Object.fromEntries(response.headers),
+        },
+        responseTime: Math.round(responseTime),
+      },
+      'Request completed',
+    )
+  }
+
+  return structuredLogger<AppEnv, Logger>({
+    createLogger: (c) =>
+      rootLogger.child({
+        req: {
+          url: c.req.path,
+          method: c.req.method,
+          headers: c.req.header(),
+        },
+        reqId: c.get('requestId'),
+      }),
+    onResponse: (logger, c, responseTime) => logResponse(logger, c.res, responseTime),
+    onError: (logger, _error, c, responseTime) => logResponse(logger, c.res, responseTime),
+  })
+}

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

@@ -0,0 +1,8 @@
+import type { Module, SpecMap } from '@inferdi/inferdi'
+import type { Database } from '@/shared/types/db'
+import { ExampleService } from './service'
+
+export const exampleModule: Module<
+  SpecMap<{ database: Database }>,
+  SpecMap<{ exampleService: ExampleService }>
+> = (container) => container.registerClass('exampleService', ExampleService, ['database'])

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

@@ -0,0 +1,8 @@
+import { examples, vcExamples } from '@repo/db/sqlite/schema'
+import { Model } from '@/shared/utils/data-access/model'
+import { createQueries } from '@/shared/utils/data-access/query'
+
+const model = new Model(examples, vcExamples)
+const queries = createQueries(model, { orderBy: { id: 'asc' } })
+
+export const { query, findOne, findPage, insert, update, deleteRecords } = queries

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

@@ -1,73 +1,79 @@
-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 { Hono } from 'hono'
 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 type { AppEnv } from '@/shared/types/app'
+
+import * as v from 'valibot'
+import {
+  Example$CreateOne,
+  Example$UpdateOne,
+  Example$FindOne,
+  Example$FindMany,
+  Example$Process,
+} from '@repo/definition/backend'
 import { generalValidator } from '@/shared/network/validator'
-import { createExampleInputSchema, processExampleInputSchema } from './contracts'
+import { successJson } from '@/shared/network/utils'
+
+export const routes = new Hono<AppEnv>()
+
+routes.post('/', generalValidator('json', Example$CreateOne), async (c) => {
+  const body = c.req.valid('json')
+  const exampleService = c.var.di.get('exampleService')
+  return successJson(c, await exampleService.createOne(body))
+})
+
+routes.get('/', generalValidator('query', Example$FindMany), async (c) => {
+  const query = c.req.valid('query')
+  const exampleService = c.var.di.get('exampleService')
+  return successJson(c, await exampleService.findMany(query))
+})
+
+routes.get(
+  '/:id',
+  generalValidator('param', v.required(v.pick(Example$FindOne, ['id']))),
+  generalValidator('query', Example$FindOne),
+  async (c) => {
+    const { id } = c.req.valid('param')
+    const query = c.req.valid('query')
+    const exampleService = c.var.di.get('exampleService')
+    return successJson(c, await exampleService.findOne({ ...query, id }))
+  },
+)
 
-const getDb = (context: Context<AppEnv>) => context.get('db') as SqliteDBType
+routes.patch(
+  '/:id',
+  generalValidator('param', v.required(v.pick(Example$FindOne, ['id']))),
+  generalValidator('json', Example$UpdateOne),
+  async (c) => {
+    const { id } = c.req.valid('param')
+    const body = c.req.valid('json')
+    const exampleService = c.var.di.get('exampleService')
+    return successJson(c, await exampleService.updateOneById(id, body))
+  },
+)
+routes.delete(
+  '/',
+  generalValidator(
+    'json',
+    v.object({ ids: v.array(v.required(v.pick(Example$FindOne, ['id'])).entries.id) }),
+  ),
+  async (c) => {
+    const { ids } = c.req.valid('json')
+    const exampleService = c.var.di.get('exampleService')
+    return successJson(c, await exampleService.deleteRecords(ids))
+  },
+)
 
-export const exampleRoutes = new Hono<AppEnv>()
-  .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' }),
-  )
-  .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({
-      operationId: 'processExample',
-      tags: [OpenApiTags.Example],
-      summary: 'Process an example message in the worker pool',
-      responses: { 200: jsonResponse(v.object({ data: v.object({ normalized: v.string() }) })) },
-    }),
-    generalValidator('json', processExampleInputSchema),
-    async (c) => {
-      const result = await c.get('workRunner').run({
-        subject: WorkSubject.PROCESS_EXAMPLE,
-        input: c.req.valid('json'),
-      })
-      if (!result.ok) {
-        throw E.NORMAL.INTERNAL.create({
-          cause: result.error,
-          extensions: { workerCode: result.error.code },
-        })
-      }
-      return successJson(c, result.data)
-    },
-  )
+routes.post('/process', generalValidator('json', Example$Process), async (c) => {
+  const result = await c.var.di.get('workRunner').run({
+    subject: WorkSubject.PROCESS_EXAMPLE,
+    input: c.req.valid('json'),
+  })
+  if (!result.ok) {
+    throw E.NORMAL.INTERNAL.create({
+      cause: result.error,
+      extensions: { workerCode: result.error.code },
+    })
+  }
+  return successJson(c, result.data)
+})

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

@@ -0,0 +1,53 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vite-plus/test'
+import { Container } from '@inferdi/inferdi'
+import { createSqliteClient } from '@repo/db/sqlite/sqlite'
+import { sql } from 'drizzle-orm'
+import { exampleModule } from './module'
+import { ExampleService } from './service'
+
+describe('ExampleService', () => {
+  let client: ReturnType<typeof createSqliteClient>
+  let service: ExampleService
+
+  beforeEach(() => {
+    client = createSqliteClient(':memory:')
+    client.db.run(sql`
+      CREATE TABLE examples (
+        id INTEGER PRIMARY KEY,
+        message TEXT NOT NULL,
+        created_at INTEGER NOT NULL DEFAULT 0,
+        updated_at INTEGER NOT NULL DEFAULT 0
+      )
+    `)
+    service = new Container()
+      .registerValue('database', { db: client.db })
+      .use(exampleModule)
+      .get('exampleService')
+  })
+
+  afterEach(() => {
+    client?.close()
+  })
+
+  it('分页返回总数，不存在的示例返回 null', async () => {
+    await service.createOne({ message: 'A' })
+    await service.createOne({ message: 'B' })
+    const page = await service.findMany({ page: 2, limit: 1 })
+    expect(page.results.map((example) => example.message)).toEqual(['B'])
+    expect(page.meta).toMatchObject({ total: 2, offset: 1, limit: 1 })
+    const filtered = await service.findMany({ page: 1, limit: 10, message: 'B' })
+    expect(filtered.results.map((example) => example.message)).toEqual(['B'])
+    expect(filtered.meta.total).toBe(1)
+    expect(await service.findOne({ message: 'missing' })).toBeNull()
+  })
+
+  it('更新不存在的记录或提交空更新均抛错', async () => {
+    await expect(service.updateOneById('999', { message: 'missing' })).rejects.toMatchObject({
+      problemDetails: { type: 'EXAMPLES.NOT_FOUND' },
+    })
+    const {
+      result: [example],
+    } = await service.createOne({ message: 'Example' })
+    await expect(service.updateOneById(example!.id, {})).rejects.toThrow('no update fields')
+  })
+})

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

@@ -0,0 +1,54 @@
+import type { IExamplesIdVO } from '@repo/definition/backend'
+import { E } from '@/shared/errors/defs'
+import type { Database } from '@/shared/types/db'
+import * as exampleQueries from './queries'
+import type {
+  CreateOneExampleDto,
+  FindManyExamplesDto,
+  FindOneExampleDto,
+  UpdateOneExampleDto,
+} from './types'
+
+export class ExampleService {
+  private readonly db: Database['db']
+
+  constructor(database: Database) {
+    this.db = database.db
+  }
+
+  async createOne(params: CreateOneExampleDto) {
+    return exampleQueries.insert(this.db, {
+      values: { message: params.message },
+      voType: 'id',
+    })
+  }
+
+  async findMany({ page, limit, ...whereParams }: FindManyExamplesDto) {
+    return exampleQueries.findPage(this.db, {
+      page,
+      limit,
+      where: whereParams,
+      voType: 'list',
+    })
+  }
+
+  async findOne(whereParams: FindOneExampleDto) {
+    return exampleQueries.findOne(this.db, { where: whereParams, voType: 'list' })
+  }
+
+  async updateOneById(id: IExamplesIdVO['id'], params: UpdateOneExampleDto) {
+    const current = await exampleQueries.findOne(this.db, { where: { id }, voType: 'id' })
+    if (!current) throw E.EXAMPLES.NOT_FOUND.create()
+    const result = await exampleQueries.update(this.db, {
+      where: { id },
+      value: { message: params.message },
+    })
+    if (!result.updated) throw E.EXAMPLES.NOT_FOUND.create()
+    return result
+  }
+
+  async deleteRecords(ids: IExamplesIdVO['id'][]) {
+    if (!ids.length) return { deleted: 0 }
+    return exampleQueries.deleteRecords(this.db, { where: { id: { in: ids } } })
+  }
+}

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

@@ -0,0 +1,12 @@
+import type * as v from 'valibot'
+import type {
+  Example$CreateOne,
+  Example$UpdateOne,
+  Example$FindOne,
+  Example$FindMany,
+} from '@repo/definition/backend'
+
+export type CreateOneExampleDto = v.InferOutput<typeof Example$CreateOne>
+export type UpdateOneExampleDto = v.InferOutput<typeof Example$UpdateOne>
+export type FindOneExampleDto = v.InferOutput<typeof Example$FindOne>
+export type FindManyExamplesDto = v.InferOutput<typeof Example$FindMany>

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

@@ -1,49 +1,23 @@
-import { MessageChannel } from 'node:worker_threads'
 import { describe, expect, it } from 'vite-plus/test'
 import { executeExampleTask } from './tasks'
 
 describe('Example worker task', () => {
-  it('normalizes a message and reports progress', async () => {
-    const { port1, port2 } = new MessageChannel()
-    const messages: unknown[] = []
-    port1.on('message', (message) => messages.push(message))
-    const result = await executeExampleTask({ message: '  hello   worker  ' }, port2)
-    await new Promise<void>((resolve) => setImmediate(resolve))
-
+  it('normalizes a message', async () => {
+    const result = await executeExampleTask({ message: '  hello   worker  ' })
     expect(result).toEqual({
       ok: true,
       data: { original: '  hello   worker  ', normalized: 'hello worker', length: 12 },
     })
-    expect(messages).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ type: 'log' }),
-        expect.objectContaining({ type: 'progress', value: 100 }),
-        expect.objectContaining({ type: 'result' }),
-      ]),
-    )
-    port1.close()
-    port2.close()
   })
 
-  it('serializes a business exception and reports it', async () => {
-    const { port1, port2 } = new MessageChannel()
-    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' },
+  it('wraps a business exception for the runner to serialize', async () => {
+    await expect(executeExampleTask({ message: '  ' })).rejects.toMatchObject({
+      name: 'WorkerTaskBusinessError',
+      message: 'Message must not be empty',
+      cause: {
+        type: 'WorkerTaskBusinessError',
+        details: { code: 'EXAMPLE_PROCESS_FAILED', field: 'message' },
       },
     })
-    expect(messages).toEqual(
-      expect.arrayContaining([expect.objectContaining({ type: 'error' })]),
-    )
-    port1.close()
-    port2.close()
   })
 })