refactor(cli): prepare for core package

packages/cli/package.json

@@ -8,8 +8,8 @@
     "bundle-require": "^4.0.1",
     "chalk": "^5.3.0",
     "yargs": "^17.7.2",
-    "zod": "^3.22.1",
     "@quality-metrics/models": "^0.0.1",
-    "@quality-metrics/utils": "^0.0.1"
+    "@quality-metrics/utils": "^0.0.1",
+    "zod": "^3.22.1"
   }
 }

packages/cli/src/lib/cli.spec.ts

@@ -1,10 +1,11 @@
 import { join } from 'path';
 import { describe, expect, it } from 'vitest';
 import { yargsCli } from './cli';
-import { getDirname } from './implementation/utils';
 import { middlewares } from './middlewares';
 import { options as defaultOptions } from './options';
-import { CommandBase } from './implementation/model';
+import { CollectOptions } from '@quality-metrics/utils';
+import { GlobalOptions } from './model';
+import { getDirname } from './implementation/helper.mock';
 
 const __dirname = getDirname(import.meta.url);
 const withDirName = (path: string) => join(__dirname, path);
@@ -16,10 +17,10 @@ const demandCommand: [number, string] = [0, 'no command required'];
 describe('CLI arguments parsing', () => {
   it('options should provide correct defaults', async () => {
     const args: string[] = [];
-    const parsedArgv: CommandBase = yargsCli(args, {
+    const parsedArgv = yargsCli(args, {
       options,
       demandCommand,
-    }).argv;
+    }).argv as unknown as GlobalOptions;
     expect(parsedArgv.configPath).toContain('code-pushup.config.js');
     expect(parsedArgv.verbose).toBe(false);
     expect(parsedArgv.interactive).toBe(true);
@@ -33,21 +34,21 @@ describe('CLI arguments parsing', () => {
       validConfigPath,
     ];
 
-    const parsedArgv: CommandBase = yargsCli(args, {
+    const parsedArgv = yargsCli(args, {
       options,
       demandCommand,
-    }).argv;
+    }).argv as unknown as GlobalOptions & CollectOptions;
     expect(parsedArgv.configPath).toContain(validConfigPath);
     expect(parsedArgv.verbose).toBe(true);
     expect(parsedArgv.interactive).toBe(false);
   });
 
   it('middleware should use config correctly', async () => {
     const args: string[] = ['--configPath', validConfigPath];
-    const parsedArgv: CommandBase = await yargsCli(args, {
+    const parsedArgv = (await yargsCli(args, {
       demandCommand,
       middlewares,
-    }).argv;
+    }).argv) as unknown as GlobalOptions & CollectOptions;
     expect(parsedArgv.configPath).toContain(validConfigPath);
     expect(parsedArgv.persist.outputPath).toContain('cli-config-out.json');
   });

packages/cli/src/lib/cli.ts

@@ -1,4 +1,4 @@
-import { CoreConfig } from '@quality-metrics/models';
+import { CoreConfig, GlobalOptions } from '@quality-metrics/models';
 import chalk from 'chalk';
 import yargs, {
   Argv,
@@ -30,7 +30,7 @@ export function yargsCli(
       applyBeforeValidation?: boolean;
     }[];
   },
-): Argv<CoreConfig> {
+): Argv<CoreConfig & GlobalOptions> {
   const { usageMessage, scriptName } = cfg;
   let { commands, options, middlewares /*demandCommand*/ } = cfg;
   // demandCommand = Array.isArray(demandCommand) ? demandCommand: [1, 'Minimum 1 command!']; @TODO implement when commands are present
@@ -81,5 +81,5 @@ export function yargsCli(
   });
 
   // return CLI object
-  return cli as unknown as Argv<CoreConfig>;
+  return cli as unknown as Argv<CoreConfig & GlobalOptions>;
 }

packages/cli/src/lib/collect/command-object.spec.ts

@@ -4,10 +4,11 @@ import { CollectOptions } from '@quality-metrics/utils';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { yargsCli } from '../cli';
-import { getDirname, logErrorBeforeThrow } from '../implementation/utils';
+import { logErrorBeforeThrow } from '../implementation/utils';
 import { middlewares } from '../middlewares';
 import { yargsGlobalOptionsDefinition } from '../implementation/global-options';
 import { yargsCollectCommandObject } from './command-object';
+import { getDirname } from '../implementation/helper.mock';
 
 const command = {
   ...yargsCollectCommandObject(),

packages/cli/src/lib/collect/command-object.ts

@@ -1,43 +1,10 @@
-import { pluginOutputSchema, Report } from '@quality-metrics/models';
-import {
-  collect,
-  CollectOptions,
-  CollectOutputError,
-  persistReport,
-  logPersistedResults,
-} from '@quality-metrics/utils';
 import { CommandModule } from 'yargs';
-import * as packageJson from '../../../package.json';
+import { collectAndPersistReports } from '../implementation/collect-and-persist';
 
 export function yargsCollectCommandObject() {
-  const handler = async (
-    config: CollectOptions & { format: string },
-  ): Promise<void> => {
-    const collectReport = await collect(config);
-    const report: Report = {
-      ...collectReport,
-      packageName: packageJson.name,
-      version: packageJson.version,
-    };
-
-    const persistResults = await persistReport(report, config);
-
-    logPersistedResults(persistResults);
-
-    // validate report
-    report.plugins.forEach(plugin => {
-      try {
-        // Running checks after persisting helps while debugging as you can check the invalid output after the error
-        pluginOutputSchema.parse(plugin);
-      } catch (e) {
-        throw new CollectOutputError(plugin.slug, e as Error);
-      }
-    });
-  };
-
   return {
     command: 'collect',
     describe: 'Run Plugins and collect results',
-    handler: handler as unknown as CommandModule['handler'],
+    handler: collectAndPersistReports as unknown as CommandModule['handler'],
   } satisfies CommandModule;
 }

packages/cli/src/lib/implementation/collect-and-persist.ts

@@ -0,0 +1,35 @@
+import {
+  collect,
+  CollectOptions,
+  CollectOutputError,
+  logPersistedResults,
+  persistReport,
+} from '@quality-metrics/utils';
+import { pluginOutputSchema, Report } from '@quality-metrics/models';
+import * as packageJson from '../../../package.json';
+
+// @TODO [73] move into core
+export async function collectAndPersistReports(
+  config: CollectOptions,
+): Promise<void> {
+  const collectReport = await collect(config);
+  const report: Report = {
+    ...collectReport,
+    packageName: packageJson.name,
+    version: packageJson.version,
+  };
+
+  const persistResults = await persistReport(report, config);
+
+  logPersistedResults(persistResults);
+
+  // validate report
+  report.plugins.forEach(plugin => {
+    try {
+      // Running checks after persisting helps while debugging as you can check the invalid output after the error
+      pluginOutputSchema.parse(plugin);
+    } catch (e) {
+      throw new CollectOutputError(plugin.slug, e as Error);
+    }
+  });
+}

packages/cli/src/lib/implementation/config-middleware.spec.ts

@@ -1,7 +1,7 @@
 import { join } from 'path';
 import { expect } from 'vitest';
 import { configMiddleware, ConfigParseError } from './config-middleware';
-import { getDirname } from './utils';
+import { getDirname } from './helper.mock';
 
 const __dirname = getDirname(import.meta.url);
 

packages/cli/src/lib/implementation/config-middleware.ts

@@ -1,37 +1,18 @@
-import { bundleRequire } from 'bundle-require';
-import { stat } from 'fs/promises';
 import { GlobalOptions, globalOptionsSchema } from '../model';
-import { CommandBase, commandBaseSchema } from './model';
+import { readCodePushupConfig } from './read-code-pushup-config';
 
 export class ConfigParseError extends Error {
   constructor(configPath: string) {
     super(`Config file ${configPath} does not exist`);
   }
 }
 
-export async function configMiddleware<T = unknown>(
-  processArgs: T,
-): Promise<CommandBase> {
-  const globalCfg: GlobalOptions = globalOptionsSchema.parse(processArgs);
-  const { configPath } = globalCfg;
-  try {
-    const stats = await stat(configPath);
-    if (!stats.isFile) {
-      throw new ConfigParseError(configPath);
-    }
-  } catch (err) {
-    throw new ConfigParseError(configPath);
-  }
-
-  const { mod } = await bundleRequire({
-    filepath: globalCfg.configPath,
-    format: 'esm',
-  });
-  const exportedConfig = mod.default || mod;
-
-  return commandBaseSchema.parse({
-    ...globalCfg,
-    ...exportedConfig,
+export async function configMiddleware<T = unknown>(processArgs: T) {
+  const globalOptions: GlobalOptions = globalOptionsSchema.parse(processArgs);
+  const importedRc = await readCodePushupConfig(globalOptions.configPath);
+  return {
+    ...importedRc,
     ...processArgs,
-  });
+    ...globalOptions,
+  };
 }

packages/cli/src/lib/implementation/helper.mock.ts

@@ -0,0 +1,5 @@
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+export const getDirname = (import_meta_url: string) =>
+  dirname(fileURLToPath(import_meta_url));

packages/cli/src/lib/implementation/load-file.ts

@@ -0,0 +1,15 @@
+import { bundleRequire, Options } from 'bundle-require';
+
+// @TODO [73] move into utils
+export async function importModule<T = unknown>(
+  options: Options,
+  parse?: (d: unknown) => T,
+) {
+  parse = parse || (v => v as T);
+  options = {
+    format: 'esm',
+    ...options,
+  };
+  const { mod } = await bundleRequire(options);
+  return parse(mod.default || mod);
+}

packages/cli/src/lib/implementation/read-code-pushup-config.ts

@@ -0,0 +1,23 @@
+import { CoreConfig, coreConfigSchema } from '@quality-metrics/models';
+import { stat } from 'fs/promises';
+import { importModule } from './load-file';
+import { ConfigParseError } from './config-middleware';
+
+// @TODO [73] move into core
+export async function readCodePushupConfig(filepath: string) {
+  try {
+    const stats = await stat(filepath);
+    if (!stats.isFile) {
+      throw new ConfigParseError(filepath);
+    }
+  } catch (err) {
+    throw new ConfigParseError(filepath);
+  }
+
+  return importModule<CoreConfig>(
+    {
+      filepath,
+    },
+    coreConfigSchema.parse,
+  );
+}

packages/cli/src/lib/implementation/utils.ts

@@ -1,10 +1,4 @@
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-export const getDirname = (import_meta_url: string) =>
-  dirname(fileURLToPath(import_meta_url));
-
-// log error and flush stdout so that Yargs doesn't supress it
+// log error and flush stdout so that Yargs doesn't suppress it
 // related issue: https://github.com/yargs/yargs/issues/2118
 export function logErrorBeforeThrow<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any

packages/cli/src/lib/middlewares.ts

@@ -1,7 +1,6 @@
-import { MiddlewareFunction } from 'yargs';
 import { configMiddleware } from './implementation/config-middleware';
+import { MiddlewareFunction } from 'yargs';
 
-export const middlewares: {
-  middlewareFunction: MiddlewareFunction;
-  applyBeforeValidation?: boolean;
-}[] = [{ middlewareFunction: configMiddleware }];
+export const middlewares = [
+  { middlewareFunction: configMiddleware as unknown as MiddlewareFunction },
+];

packages/models/src/lib/plugin-config.spec.ts

@@ -79,7 +79,6 @@ describe('pluginConfigSchema', () => {
 
   it('should throw if a group has duplicate audit refs', () => {
     const auditSlug = 'no-any';
-    // @TODO use pluginConfigSchema instead of auditGroupSchema
     const cfg = mockGroupConfig({ auditSlug: [auditSlug, auditSlug] });
 
     expect(() => auditGroupSchema.parse(cfg)).toThrow(

packages/utils/src/lib/collect/implementation/execute-plugin.ts

@@ -26,7 +26,7 @@ export class PluginOutputError extends Error {
  * Execute a plugin.
  *
  * @public
- * @param cfg - {@link ProcessConfig} object with runner and meta
+ * @param pluginConfig - {@link ProcessConfig} object with runner and meta
  * @param observer - process {@link ProcessObserver}
  * @returns {Promise<AuditOutput[]>} - audit outputs from plugin runner
  * @throws {PluginOutputError} - if plugin runner output is invalid
@@ -45,11 +45,12 @@ export class PluginOutputError extends Error {
  *  }
  */
 export async function executePlugin(
-  cfg: PluginConfig,
+  pluginConfig: PluginConfig,
   observer?: ProcessObserver,
 ): Promise<PluginOutput> {
-  const { slug, title, description, docsUrl } = cfg;
-  const { args, command } = cfg.runner;
+  const { slug, title, description, docsUrl, version, packageName } =
+    pluginConfig;
+  const { args, command } = pluginConfig.runner;
 
   const { duration, date } = await executeProcess({
     command,
@@ -58,13 +59,18 @@ export async function executePlugin(
   });
 
   try {
-    const processOutputPath = join(process.cwd(), cfg.runner.outputPath);
+    const processOutputPath = join(
+      process.cwd(),
+      pluginConfig.runner.outputPath,
+    );
     // read process output from file system and parse it
     const audits = auditOutputsSchema.parse(
       JSON.parse((await readFile(processOutputPath)).toString()),
     );
 
     return {
+      version,
+      packageName,
       slug,
       title,
       description,

packages/utils/src/lib/collect/implementation/execute-process.spec.ts

@@ -40,7 +40,7 @@ describe('executeProcess', () => {
     expect(observer?.complete).toHaveBeenCalledTimes(1);
   });
 
-  it('should work with async script `node custom-script.js` that throws an error', async () => {
+  it('should work with async script `node custom-script.js --arg` that throws an error', async () => {
     const cfg = mockProcessConfig(
       getAsyncProcessRunnerConfig({ interval: 10, runs: 1, throwError: true }),
     );