zod-codegen 1.5.0 → 1.6.1

package/package.json

@@ -17,7 +17,7 @@
     "typescript": "^5.9.3",
     "url-pattern": "^1.0.3",
     "yargs": "^18.0.0",
-    "zod": "^4.2.1"
+    "zod": "^4.3.5"
   },
   "description": "A powerful TypeScript code generator that creates Zod schemas and type-safe clients from OpenAPI specifications",
   "keywords": [
@@ -32,8 +32,8 @@
     "validation"
   ],
   "devDependencies": {
-    "@commitlint/cli": "^20.1.0",
-    "@commitlint/config-conventional": "^20.0.0",
+    "@commitlint/cli": "^20.3.0",
+    "@commitlint/config-conventional": "^20.3.0",
     "@eslint/js": "^9.39.2",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
@@ -41,9 +41,9 @@
     "@types/jest": "^30.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/jsonpath": "^0.2.4",
-    "@types/node": "^25.0.2",
+    "@types/node": "^25.0.3",
     "@types/yargs": "^17.0.35",
-    "@vitest/coverage-v8": "^4.0.14",
+    "@vitest/coverage-v8": "^4.0.16",
     "cross-env": "^10.1.0",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
@@ -51,13 +51,10 @@
     "lint-staged": "^16.2.7",
     "semantic-release": "^25.0.2",
     "ts-node": "^10.9.2",
-    "typescript-eslint": "^8.46.4",
+    "typescript-eslint": "^8.51.0",
     "undici": "^7.16.0",
     "vitest": "^4.0.14"
   },
-  "optionalDependencies": {
-    "undici": "^7.16.0"
-  },
   "homepage": "https://github.com/julienandreu/zod-codegen",
   "license": "Apache-2.0",
   "name": "zod-codegen",
@@ -75,7 +72,7 @@
     "url": "git+ssh://git@github.com/julienandreu/zod-codegen.git"
   },
   "engines": {
-    "node": ">=24.11.1"
+    "node": ">=18.0.0"
   },
   "overrides": {
     "npm": {
@@ -88,8 +85,8 @@
   },
   "scripts": {
     "audit:fix": "npm audit fix",
-    "build": "NODE_OPTIONS='--no-deprecation' sh -c 'rm -rf dist && tsc --project tsconfig.json && cp -r src/assets dist/src/ && chmod +x ./dist/src/cli.js'",
-    "build:native": "rm -rf dist && NODE_OPTIONS='--no-deprecation' npx tsgo --project tsconfig.json && cp -r src/assets dist/src/ && chmod +x ./dist/src/cli.js",
+    "build": "NODE_OPTIONS='--no-deprecation' sh -c 'rm -rf dist && tsc --project tsconfig.json && ts-node scripts/add-js-extensions.ts && mkdir -p dist/src/assets && cp -r src/assets/. dist/src/assets/ && chmod +x ./dist/src/cli.js'",
+    "build:native": "rm -rf dist && NODE_OPTIONS='--no-deprecation' npx tsgo --project tsconfig.json && ts-node scripts/add-js-extensions.ts && cp -r src/assets dist/src/ && chmod +x ./dist/src/cli.js",
     "build:watch": "tsc --project tsconfig.json --watch",
     "dev": "npm run build && node ./dist/src/cli.js --input ./samples/swagger-petstore.yaml --output ./examples/petstore && npm run format && npm run lint",
     "lint": "eslint src --fix",
@@ -110,5 +107,5 @@
     "release": "semantic-release",
     "release:dry": "semantic-release --dry-run"
   },
-  "version": "1.5.0"
+  "version": "1.6.1"
 }

package/scripts/add-js-extensions.ts

@@ -0,0 +1,79 @@
+import {readdirSync, readFileSync, statSync, writeFileSync} from 'node:fs';
+import {extname, join} from 'node:path';
+
+/**
+ * Recursively finds all .js files in a directory
+ */
+function findJsFiles(dir: string): string[] {
+  const files: string[] = [];
+  const entries = readdirSync(dir);
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      files.push(...findJsFiles(fullPath));
+    } else if (extname(entry) === '.js') {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Adds .js extensions to relative imports in a JavaScript file
+ */
+function addJsExtensions(content: string): string {
+  // Match relative imports: './something' or '../something' but not './something.js' or node: imports
+  // Handles both single and double quotes
+  // Also handles type imports: import type { ... } from './something'
+  const importRegex = /from\s+(['"])(\.\.?\/[^'"]+?)(['"])/g;
+
+  return content.replace(importRegex, (match, quote: string, importPath: string, endQuote: string) => {
+    // Skip if already has an extension
+    if (importPath.endsWith('.js') || importPath.endsWith('.json')) {
+      return match;
+    }
+
+    // Add .js extension
+    return `from ${quote}${importPath}.js${endQuote}`;
+  });
+}
+
+/**
+ * Main function to process all JavaScript files in dist/src
+ */
+function main(): void {
+  const distDir = join(process.cwd(), 'dist', 'src');
+
+  try {
+    const jsFiles = findJsFiles(distDir);
+
+    if (jsFiles.length === 0) {
+      console.warn('No .js files found in dist/src');
+      process.exit(0);
+    }
+
+    let processedCount = 0;
+
+    for (const filePath of jsFiles) {
+      const content = readFileSync(filePath, 'utf-8');
+      const updatedContent = addJsExtensions(content);
+
+      if (content !== updatedContent) {
+        writeFileSync(filePath, updatedContent, 'utf-8');
+        processedCount++;
+      }
+    }
+
+    console.log(`✅ Added .js extensions to ${String(processedCount)} file(s)`);
+    process.exit(0);
+  } catch (error) {
+    console.error('❌ Error processing files:', error);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/update-manifest.ts

@@ -1,5 +1,6 @@
-import {readFileSync, writeFileSync} from 'fs';
-import {resolve} from 'path';
+import {readFileSync, writeFileSync} from 'node:fs';
+import {dirname, resolve} from 'node:path';
+import {fileURLToPath} from 'node:url';
 import {z} from 'zod';
 
 interface PackageJson {
@@ -30,6 +31,7 @@ export function isPackageJson(input: unknown): input is PackageJson {
   return success;
 }
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
 const sourcePath = resolve(__dirname, '..', 'package.json');
 
 const data: unknown = JSON.parse(readFileSync(sourcePath, 'utf8'));

package/src/assets/manifest.json

@@ -1,5 +1,5 @@
 {
   "name": "zod-codegen",
-  "version": "1.0.1",
+  "version": "1.5.0",
   "description": "A powerful TypeScript code generator that creates Zod schemas and type-safe clients from OpenAPI specifications"
 }

package/src/cli.ts

@@ -2,16 +2,16 @@
 
 import yargs from 'yargs';
 import {hideBin} from 'yargs/helpers';
-import {Generator, type GeneratorOptions, type NamingConvention} from './generator.js';
+import {Generator, type GeneratorOptions, type NamingConvention} from './generator';
 import {readFileSync} from 'node:fs';
 import {fileURLToPath} from 'node:url';
 import {dirname, join} from 'node:path';
 
 import loudRejection from 'loud-rejection';
-import {handleErrors} from './utils/error-handler.js';
-import {handleSignals} from './utils/signal-handler.js';
+import {handleErrors} from './utils/error-handler';
+import {handleSignals} from './utils/signal-handler';
 import debug from 'debug';
-import {Reporter} from './utils/reporter.js';
+import {Reporter} from './utils/reporter';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Read package.json from the project root
@@ -47,14 +47,14 @@ const packageData = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) as {
 };
 
 const {name, description, version} = packageData;
-const reporter = new Reporter(process.stdout);
+const reporter = new Reporter(process.stdout, process.stderr);
 const startTime = process.hrtime.bigint();
 
 debug(`${name}:${String(process.pid)}`);
 
 loudRejection();
-handleSignals(process, startTime);
-handleErrors(process, startTime);
+handleSignals(process, startTime, reporter);
+handleErrors(process, startTime, reporter);
 
 const argv = yargs(hideBin(process.argv))
   .scriptName(name)

package/src/generator.ts

@@ -1,14 +1,41 @@
-import type {Reporter} from './utils/reporter.js';
-import type {OpenApiSpecType} from './types/openapi.js';
-import type {GeneratorOptions} from './types/generator-options.js';
-import {OpenApiFileParserService, SyncFileReaderService} from './services/file-reader.service.js';
-import {TypeScriptCodeGeneratorService} from './services/code-generator.service.js';
-import {SyncFileWriterService} from './services/file-writer.service.js';
+import type {Reporter} from './utils/reporter';
+import type {OpenApiSpecType} from './types/openapi';
+import type {GeneratorOptions} from './types/generator-options';
+import {OpenApiFileParserService, SyncFileReaderService} from './services/file-reader.service';
+import {TypeScriptCodeGeneratorService} from './services/code-generator.service';
+import {SyncFileWriterService} from './services/file-writer.service';
 
 // Re-export types for library users
-export type {GeneratorOptions} from './types/generator-options.js';
-export type {NamingConvention, OperationDetails, OperationNameTransformer} from './utils/naming-convention.js';
+export type {GeneratorOptions} from './types/generator-options';
+export type {NamingConvention, OperationDetails, OperationNameTransformer} from './utils/naming-convention';
 
+/**
+ * Main generator class for creating TypeScript code from OpenAPI specifications.
+ *
+ * This class orchestrates the code generation process:
+ * 1. Reads the OpenAPI specification file (local or remote)
+ * 2. Parses and validates the specification
+ * 3. Generates TypeScript code with Zod schemas and type-safe API client
+ * 4. Writes the generated code to the output directory
+ *
+ * @example
+ * ```typescript
+ * import {Generator} from 'zod-codegen';
+ * import {Reporter} from './utils/reporter';
+ *
+ * const reporter = new Reporter(process.stdout, process.stderr);
+ * const generator = new Generator(
+ *   'my-app',
+ *   '1.0.0',
+ *   reporter,
+ *   './openapi.yaml',
+ *   './generated',
+ *   {namingConvention: 'camelCase'}
+ * );
+ *
+ * const exitCode = await generator.run();
+ * ```
+ */
 export class Generator {
   private readonly fileReader = new SyncFileReaderService();
   private readonly fileParser = new OpenApiFileParserService();
@@ -16,6 +43,16 @@ export class Generator {
   private readonly fileWriter: SyncFileWriterService;
   private readonly outputPath: string;
 
+  /**
+   * Creates a new Generator instance.
+   *
+   * @param _name - The name of the application/library (used in generated file headers)
+   * @param _version - The version of the application/library (used in generated file headers)
+   * @param reporter - Reporter instance for logging messages and errors
+   * @param inputPath - Path or URL to the OpenAPI specification file
+   * @param _outputDir - Directory where generated files will be written
+   * @param options - Optional configuration for code generation
+   */
   constructor(
     private readonly _name: string,
     private readonly _version: string,
@@ -29,6 +66,11 @@ export class Generator {
     this.codeGenerator = new TypeScriptCodeGeneratorService(options);
   }
 
+  /**
+   * Executes the code generation process.
+   *
+   * @returns Promise that resolves to an exit code (0 for success, 1 for failure)
+   */
   async run(): Promise<number> {
     try {
       const rawSource = await this.readFile();
@@ -46,7 +88,7 @@ export class Generator {
         this.reporter.error('❌ An unknown error occurred');
       }
 
-      return Promise.resolve(1);
+      return 1;
     }
   }
 

package/src/interfaces/code-generator.ts

@@ -1,4 +1,4 @@
-import type {OpenApiSpecType} from '../types/openapi.js';
+import type {OpenApiSpecType} from '../types/openapi';
 
 export interface CodeGenerator {
   generate(spec: OpenApiSpecType): string;

package/src/services/code-generator.service.ts

@@ -1,18 +1,18 @@
 import jp from 'jsonpath';
 import * as ts from 'typescript';
 import {z} from 'zod';
-import type {CodeGenerator, SchemaBuilder} from '../interfaces/code-generator.js';
-import type {MethodSchemaType, OpenApiSpecType, ReferenceType} from '../types/openapi.js';
-import type {GeneratorOptions} from '../types/generator-options.js';
-import {MethodSchema, Reference, SchemaProperties} from '../types/openapi.js';
-import {TypeScriptImportBuilderService} from './import-builder.service.js';
-import {TypeScriptTypeBuilderService} from './type-builder.service.js';
+import type {CodeGenerator, SchemaBuilder} from '../interfaces/code-generator';
+import type {MethodSchemaType, OpenApiSpecType, ReferenceType} from '../types/openapi';
+import type {GeneratorOptions} from '../types/generator-options';
+import {MethodSchema, Reference, SchemaProperties} from '../types/openapi';
+import {TypeScriptImportBuilderService} from './import-builder.service';
+import {TypeScriptTypeBuilderService} from './type-builder.service';
 import {
   type NamingConvention,
   type OperationDetails,
   type OperationNameTransformer,
   transformNamingConvention,
-} from '../utils/naming-convention.js';
+} from '../utils/naming-convention';
 
 export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuilder {
   private readonly typeBuilder = new TypeScriptTypeBuilderService();
@@ -161,6 +161,7 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
         this.typeBuilder.createProperty('#baseUrl', 'string', true),
         this.buildConstructor(openapi),
         this.buildGetBaseRequestOptionsMethod(),
+        this.buildHandleResponseMethod(),
         this.buildHttpRequestMethod(),
         ...methods,
       ],
@@ -290,6 +291,29 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
     );
   }
 
+  private buildHandleResponseMethod(): ts.MethodDeclaration {
+    return ts.factory.createMethodDeclaration(
+      [ts.factory.createToken(ts.SyntaxKind.ProtectedKeyword), ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)],
+      undefined,
+      ts.factory.createIdentifier('handleResponse'),
+      undefined,
+      [this.typeBuilder.createGenericType('T')],
+      [
+        this.typeBuilder.createParameter('response', 'Response'),
+        this.typeBuilder.createParameter('method', 'string'),
+        this.typeBuilder.createParameter('path', 'string'),
+        this.typeBuilder.createParameter(
+          'options',
+          '{params?: Record<string, string | number | boolean>; data?: unknown; contentType?: string; headers?: Record<string, string>}',
+        ),
+      ],
+      ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Response'), undefined),
+      ]),
+      ts.factory.createBlock([ts.factory.createReturnStatement(ts.factory.createIdentifier('response'))], true),
+    );
+  }
+
   private buildHttpRequestMethod(): ts.MethodDeclaration {
     return ts.factory.createMethodDeclaration(
       [ts.factory.createToken(ts.SyntaxKind.ProtectedKeyword), ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)],
@@ -812,7 +836,7 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
             ts.factory.createVariableDeclarationList(
               [
                 ts.factory.createVariableDeclaration(
-                  ts.factory.createIdentifier('response'),
+                  ts.factory.createIdentifier('rawResponse'),
                   undefined,
                   undefined,
                   ts.factory.createAwaitExpression(
@@ -853,6 +877,35 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
               ts.NodeFlags.Const,
             ),
           ),
+          // Handle response through hook (allows subclasses to intercept and modify response)
+          ts.factory.createVariableStatement(
+            undefined,
+            ts.factory.createVariableDeclarationList(
+              [
+                ts.factory.createVariableDeclaration(
+                  ts.factory.createIdentifier('response'),
+                  undefined,
+                  undefined,
+                  ts.factory.createAwaitExpression(
+                    ts.factory.createCallExpression(
+                      ts.factory.createPropertyAccessExpression(
+                        ts.factory.createThis(),
+                        ts.factory.createIdentifier('handleResponse'),
+                      ),
+                      [ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('T'), undefined)],
+                      [
+                        ts.factory.createIdentifier('rawResponse'),
+                        ts.factory.createIdentifier('method'),
+                        ts.factory.createIdentifier('path'),
+                        ts.factory.createIdentifier('options'),
+                      ],
+                    ),
+                  ),
+                ),
+              ],
+              ts.NodeFlags.Const,
+            ),
+          ),
           // Check response status
           ts.factory.createIfStatement(
             ts.factory.createPrefixUnaryExpression(
@@ -907,6 +960,28 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
     openapi: OpenApiSpecType,
     schemas: Record<string, ts.VariableStatement>,
   ): ts.MethodDeclaration[] {
+    // Track operation IDs to detect duplicates
+    const operationIdMap = new Map<string, {method: string; path: string}[]>();
+
+    // First pass: collect all operation IDs and their methods/paths
+    Object.entries(openapi.paths).forEach(([path, pathItem]) => {
+      Object.entries(pathItem)
+        .filter(([method]) => ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'].includes(method))
+        .forEach(([method, methodSchema]) => {
+          const safeMethodSchema = MethodSchema.parse(methodSchema);
+          if (safeMethodSchema.operationId) {
+            const operationId = safeMethodSchema.operationId;
+            const existing = operationIdMap.get(operationId);
+            if (existing) {
+              existing.push({method, path});
+            } else {
+              operationIdMap.set(operationId, [{method, path}]);
+            }
+          }
+        });
+    });
+
+    // Second pass: build methods, appending method name for HEAD/OPTIONS or when duplicates exist
     return Object.entries(openapi.paths).reduce<ts.MethodDeclaration[]>((endpoints, [path, pathItem]) => {
       const methods = Object.entries(pathItem)
         .filter(([method]) => ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'].includes(method))
@@ -917,6 +992,26 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
             return null;
           }
 
+          const operationId = safeMethodSchema.operationId;
+          const methodLower = method.toLowerCase();
+
+          // Check if this operationId is used by multiple methods
+          const operations = operationIdMap.get(operationId);
+          const hasDuplicates = operations !== undefined && operations.length > 1;
+
+          // For HEAD/OPTIONS or when duplicates exist, we need to ensure uniqueness
+          // We'll handle this in transformOperationName by appending the method
+          // But we need to mark it here so transformOperationName knows to append
+          if (hasDuplicates || methodLower === 'head' || methodLower === 'options') {
+            // Temporarily modify the operationId to include method for uniqueness
+            // This will be handled in transformOperationName
+            const modifiedSchema = {
+              ...safeMethodSchema,
+              operationId: `${operationId}_${methodLower}`,
+            };
+            return this.buildEndpointMethod(method, path, modifiedSchema, schemas);
+          }
+
           return this.buildEndpointMethod(method, path, safeMethodSchema, schemas);
         })
         .filter((method): method is ts.MethodDeclaration => method !== null);
@@ -928,6 +1023,7 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
   /**
    * Transforms operation ID according to the configured naming convention or transformer
    * Ensures the result is a valid TypeScript identifier
+   * For HEAD and OPTIONS methods, appends the method name to ensure uniqueness when same operationId is used
    */
   private transformOperationName(operationId: string, method: string, path: string, schema: MethodSchemaType): string {
     let transformed: string;
@@ -951,6 +1047,16 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
       transformed = operationId;
     }
 
+    // For HEAD and OPTIONS methods, append method name to ensure uniqueness
+    // This prevents duplicate method names when GET and HEAD share the same operationId
+    const methodLower = method.toLowerCase();
+    if (methodLower === 'head' || methodLower === 'options') {
+      // Only append if not already present to avoid double-appending
+      if (!transformed.toLowerCase().endsWith(`_${methodLower}`)) {
+        transformed = `${transformed}_${methodLower}`;
+      }
+    }
+
     // Sanitize to ensure valid TypeScript identifier (handles edge cases from custom transformers)
     return this.typeBuilder.sanitizeIdentifier(transformed);
   }

package/src/services/file-reader.service.ts

@@ -1,8 +1,8 @@
 import {readFileSync} from 'node:fs';
 import {load} from 'js-yaml';
-import type {OpenApiFileParser, OpenApiFileReader} from '../interfaces/file-reader.js';
-import type {OpenApiSpecType} from '../types/openapi.js';
-import {OpenApiSpec} from '../types/openapi.js';
+import type {OpenApiFileParser, OpenApiFileReader} from '../interfaces/file-reader';
+import type {OpenApiSpecType} from '../types/openapi';
+import {OpenApiSpec} from '../types/openapi';
 
 export class SyncFileReaderService implements OpenApiFileReader {
   async readFile(path: string): Promise<string> {

package/src/services/file-writer.service.ts

@@ -1,6 +1,6 @@
 import {existsSync, mkdirSync, writeFileSync} from 'node:fs';
 import {dirname, resolve} from 'node:path';
-import type {FileWriter} from '../interfaces/code-generator.js';
+import type {FileWriter} from '../interfaces/code-generator';
 
 export class SyncFileWriterService implements FileWriter {
   constructor(

package/src/services/import-builder.service.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import {z} from 'zod';
-import type {ImportBuilder} from '../interfaces/code-generator.js';
+import type {ImportBuilder} from '../interfaces/code-generator';
 
 const IsTypeImport = z.boolean();
 const ImportedElement = z.record(z.string(), IsTypeImport);
@@ -33,7 +33,7 @@ export class TypeScriptImportBuilderService implements ImportBuilder {
     const namedImports =
       namedImportList.length > 0
         ? ts.factory.createNamedImports(
-            namedImportList.map(([name, isTypeImport = false]) => {
+            namedImportList.map(([name, isTypeImport]) => {
               return ts.factory.createImportSpecifier(isTypeImport, undefined, ts.factory.createIdentifier(name));
             }),
           )

package/src/services/type-builder.service.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import type {TypeBuilder} from '../interfaces/code-generator.js';
+import type {TypeBuilder} from '../interfaces/code-generator';
 
 export class TypeScriptTypeBuilderService implements TypeBuilder {
   buildType(type: string): ts.TypeNode {

package/src/types/generator-options.ts

@@ -1,4 +1,4 @@
-import type {NamingConvention, OperationNameTransformer} from '../utils/naming-convention.js';
+import type {NamingConvention, OperationNameTransformer} from '../utils/naming-convention';
 
 /**
  * Configuration options for the Generator class.

package/src/utils/error-handler.ts

@@ -1,13 +1,14 @@
-import {getExecutionTime} from './execution-time.js';
+import {getExecutionTime} from './execution-time';
+import type {Reporter} from './reporter';
 
-export const errorReceived = (process: NodeJS.Process, startTime: bigint) => (): void => {
-  console.log(`Done after ${String(getExecutionTime(startTime))}s`);
+export const errorReceived = (process: NodeJS.Process, startTime: bigint, reporter: Reporter) => (): void => {
+  reporter.log(`Done after ${String(getExecutionTime(startTime))}s`);
   process.exit(1);
 };
 
-export const handleErrors = (process: NodeJS.Process, startTime: bigint): void => {
+export const handleErrors = (process: NodeJS.Process, startTime: bigint, reporter: Reporter): void => {
   const catchErrors: string[] = ['unhandledRejection', 'uncaughtException'];
   catchErrors.forEach((event) => {
-    process.on(event, errorReceived(process, startTime));
+    process.on(event, errorReceived(process, startTime, reporter));
   });
 };

package/src/utils/reporter.ts

@@ -1,16 +1,19 @@
 import {format} from 'node:util';
 
 export class Reporter {
-  constructor(private readonly _stdout: NodeJS.WriteStream) {
+  constructor(
+    private readonly stdout: NodeJS.WriteStream,
+    private readonly stderr: NodeJS.WriteStream = stdout,
+  ) {
     this.log = this.log.bind(this);
     this.error = this.error.bind(this);
   }
 
   log(...args: readonly unknown[]): void {
-    this._stdout.write(format(...args) + '\n');
+    this.stdout.write(format(...args) + '\n');
   }
 
   error(...args: readonly unknown[]): void {
-    this._stdout.write(format(...args) + '\n');
+    this.stderr.write(format(...args) + '\n');
   }
 }

package/src/utils/signal-handler.ts

@@ -1,14 +1,16 @@
-import {getExecutionTime} from './execution-time.js';
+import {getExecutionTime} from './execution-time';
+import type {Reporter} from './reporter';
 
-export const signalReceived = (process: NodeJS.Process, startTime: bigint, event: NodeJS.Signals) => (): void => {
-  console.log(`Done after ${String(getExecutionTime(startTime))}s`);
-  process.kill(process.pid, event);
-  process.exit(1);
-};
+export const signalReceived =
+  (process: NodeJS.Process, startTime: bigint, event: NodeJS.Signals, reporter: Reporter) => (): void => {
+    reporter.log(`Done after ${String(getExecutionTime(startTime))}s`);
+    process.kill(process.pid, event);
+    process.exit(1);
+  };
 
-export const handleSignals = (process: NodeJS.Process, startTime: bigint): void => {
+export const handleSignals = (process: NodeJS.Process, startTime: bigint, reporter: Reporter): void => {
   const catchSignals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
   catchSignals.forEach((event) => {
-    process.once(event, signalReceived(process, startTime, event));
+    process.once(event, signalReceived(process, startTime, event, reporter));
   });
 };