refactor(utils,core): move timings out of executeProcess function

Author: matejchalk

packages/core/src/index.ts

@@ -9,7 +9,7 @@ export {
 } from './lib/compare.js';
 export {
   getRunnerOutputsPath,
-  type ValidatedRunnerResult,
+  type RunnerResult,
 } from './lib/implementation/runner.js';
 
 export {
@@ -23,7 +23,6 @@ export {
   executePlugin,
   executePlugins,
 } from './lib/implementation/execute-plugin.js';
-export { AuditOutputsMissingAuditError } from './lib/implementation/runner.js';
 export {
   PersistDirError,
   PersistError,
@@ -34,6 +33,7 @@ export {
   ConfigPathError,
   readRcByPath,
 } from './lib/implementation/read-rc-file.js';
+export { AuditOutputsMissingAuditError } from './lib/implementation/runner.js';
 export { mergeDiffs } from './lib/merge-diffs.js';
 export type { GlobalOptions } from './lib/types.js';
 export { upload, type UploadOptions } from './lib/upload.js';

packages/core/src/lib/implementation/runner.ts

@@ -25,20 +25,16 @@ import { normalizeAuditOutputs } from '../normalize.js';
 export type RunnerResult = {
   date: string;
   duration: number;
-  audits: unknown;
-};
-
-export type ValidatedRunnerResult = Omit<RunnerResult, 'audits'> & {
   audits: AuditOutputs;
 };
 
 export async function executeRunnerConfig(
   config: RunnerConfig,
   args: RunnerArgs,
-): Promise<RunnerResult> {
+): Promise<unknown> {
   const { outputFile, outputTransform } = config;
 
-  const { duration, date } = await executeProcess({
+  await executeProcess({
     command: config.command,
     args: config.args,
     observer: {
@@ -60,30 +56,16 @@ export async function executeRunnerConfig(
   // transform unknownAuditOutputs to auditOutputs
   const audits = outputTransform ? await outputTransform(outputs) : outputs;
 
-  // create runner result
-  return {
-    duration,
-    date,
-    audits,
-  };
+  return audits;
 }
 
 export async function executeRunnerFunction(
   runner: RunnerFunction,
   args: RunnerArgs,
-): Promise<RunnerResult> {
-  const date = new Date().toISOString();
-  const start = performance.now();
-
+): Promise<unknown> {
   // execute plugin runner
   const audits = await runner(args);
-
-  // create runner result
-  return {
-    date,
-    duration: calcDuration(start),
-    audits,
-  };
+  return audits;
 }
 
 /**
@@ -102,13 +84,18 @@ export class AuditOutputsMissingAuditError extends Error {
 export async function executePluginRunner(
   pluginConfig: Pick<PluginConfig, 'audits' | 'runner'>,
   args: RunnerArgs,
-): Promise<Omit<RunnerResult, 'audits'> & { audits: AuditOutputs }> {
+): Promise<RunnerResult> {
   const { audits: pluginConfigAudits, runner } = pluginConfig;
-  const runnerResult: RunnerResult =
+
+  const date = new Date().toISOString();
+  const start = performance.now();
+
+  const unvalidatedAuditOutputs =
     typeof runner === 'object'
       ? await executeRunnerConfig(runner, args)
       : await executeRunnerFunction(runner, args);
-  const { audits: unvalidatedAuditOutputs, ...executionMeta } = runnerResult;
+
+  const duration = calcDuration(start);
 
   const result = auditOutputsSchema.safeParse(unvalidatedAuditOutputs);
   if (!result.success) {
@@ -118,7 +105,8 @@ export async function executePluginRunner(
   auditOutputsCorrelateWithPluginOutput(auditOutputs, pluginConfigAudits);
 
   return {
-    ...executionMeta,
+    date,
+    duration,
     audits: await normalizeAuditOutputs(auditOutputs),
   };
 }
@@ -150,7 +138,7 @@ export function getRunnerOutputsPath(pluginSlug: string, outputDir: string) {
 export async function writeRunnerResults(
   pluginSlug: string,
   outputDir: string,
-  runnerResult: ValidatedRunnerResult,
+  runnerResult: RunnerResult,
 ): Promise<void> {
   const cacheFilePath = getRunnerOutputsPath(pluginSlug, outputDir);
   await ensureDirectoryExists(path.dirname(cacheFilePath));
@@ -160,7 +148,7 @@ export async function writeRunnerResults(
 export async function readRunnerResults(
   pluginSlug: string,
   outputDir: string,
-): Promise<ValidatedRunnerResult | null> {
+): Promise<RunnerResult | null> {
   const auditOutputsPath = getRunnerOutputsPath(pluginSlug, outputDir);
   if (await fileExists(auditOutputsPath)) {
     const cachedResult = await readJsonFile<AuditOutputs>(auditOutputsPath);

packages/core/src/lib/implementation/runner.unit.test.ts

@@ -9,7 +9,6 @@ import {
   auditOutputsSchema,
 } from '@code-pushup/models';
 import {
-  ISO_STRING_REGEXP,
   MEMFS_VOLUME,
   MINIMAL_PLUGIN_CONFIG_MOCK,
   MINIMAL_RUNNER_CONFIG_MOCK,
@@ -18,7 +17,6 @@ import {
 } from '@code-pushup/test-utils';
 import * as utils from '@code-pushup/utils';
 import {
-  type RunnerResult,
   executePluginRunner,
   executeRunnerConfig,
   executeRunnerFunction,
@@ -52,17 +50,18 @@ describe('executeRunnerConfig', () => {
   });
 
   it('should execute valid runner config', async () => {
-    const runnerResult = await executeRunnerConfig(MINIMAL_RUNNER_CONFIG_MOCK, {
-      persist: DEFAULT_PERSIST_CONFIG,
-    });
+    const auditOutputs = (await executeRunnerConfig(
+      MINIMAL_RUNNER_CONFIG_MOCK,
+      {
+        persist: DEFAULT_PERSIST_CONFIG,
+      },
+    )) as AuditOutputs;
 
     // data sanity
-    expect((runnerResult.audits as AuditOutputs)[0]?.slug).toBe('node-version');
-    expect(runnerResult.date).toMatch(ISO_STRING_REGEXP);
-    expect(runnerResult.duration).toBeGreaterThanOrEqual(0);
+    expect(auditOutputs[0]?.slug).toBe('node-version');
 
     // schema validation
-    expect(() => auditOutputsSchema.parse(runnerResult.audits)).not.toThrow();
+    expect(() => auditOutputsSchema.parse(auditOutputs)).not.toThrow();
 
     // executed process configuration
     expect(utils.executeProcess).toHaveBeenCalledWith<[utils.ProcessConfig]>({
@@ -82,7 +81,7 @@ describe('executeRunnerConfig', () => {
   });
 
   it('should use outputTransform when provided', async () => {
-    const runnerResult = await executeRunnerConfig(
+    const auditOutputs = (await executeRunnerConfig(
       {
         command: 'node',
         args: ['-v'],
@@ -98,8 +97,7 @@ describe('executeRunnerConfig', () => {
           ]),
       },
       { persist: DEFAULT_PERSIST_CONFIG },
-    );
-    const auditOutputs = runnerResult.audits as AuditOutputs;
+    )) as AuditOutputs;
 
     expect(auditOutputs[0]?.slug).toBe('node-version');
     expect(auditOutputs[0]?.displayValue).toBe('16.0.0');
@@ -123,11 +121,10 @@ describe('executeRunnerConfig', () => {
 
 describe('executeRunnerFunction', () => {
   it('should execute a valid runner function', async () => {
-    const runnerResult: RunnerResult = await executeRunnerFunction(
+    const auditOutputs = (await executeRunnerFunction(
       MINIMAL_RUNNER_FUNCTION_MOCK,
       { persist: DEFAULT_PERSIST_CONFIG },
-    );
-    const auditOutputs = runnerResult.audits as AuditOutputs;
+    )) as AuditOutputs;
 
     expect(auditOutputs[0]?.slug).toBe('node-version');
     expect(auditOutputs[0]?.details?.issues).toEqual([

packages/utils/src/lib/execute-process.ts

@@ -9,22 +9,19 @@ import type { Readable, Writable } from 'node:stream';
 import { isVerbose } from './env.js';
 import { formatCommandLog } from './format-command-log.js';
 import { ui } from './logging.js';
-import { calcDuration } from './reports/utils.js';
 
 /**
  * Represents the process result.
  * @category Types
  * @public
+ * @property {number | null} code - The exit code of the process.
  * @property {string} stdout - The stdout of the process.
  * @property {string} stderr - The stderr of the process.
- * @property {number | null} code - The exit code of the process.
  */
 export type ProcessResult = {
+  code: number | null;
   stdout: string;
   stderr: string;
-  code: number | null;
-  date: string;
-  duration: number;
 };
 
 /**
@@ -148,8 +145,6 @@ export type ProcessObserver = {
 export function executeProcess(cfg: ProcessConfig): Promise<ProcessResult> {
   const { command, args, observer, ignoreExitCode = false, ...options } = cfg;
   const { onStdout, onStderr, onError, onComplete } = observer ?? {};
-  const date = new Date().toISOString();
-  const start = performance.now();
 
   if (isVerbose()) {
     ui().logger.log(
@@ -185,12 +180,11 @@ export function executeProcess(cfg: ProcessConfig): Promise<ProcessResult> {
     });
 
     spawnedProcess.on('close', code => {
-      const timings = { date, duration: calcDuration(start) };
       if (code === 0 || ignoreExitCode) {
         onComplete?.();
-        resolve({ code, stdout, stderr, ...timings });
+        resolve({ code, stdout, stderr });
       } else {
-        const errorMsg = new ProcessError({ code, stdout, stderr, ...timings });
+        const errorMsg = new ProcessError({ code, stdout, stderr });
         onError?.(errorMsg);
         reject(errorMsg);
       }