feat: Added support for new import prompts in debug and plain reporters. Fixed build errors and bugs

Author: kevinwang5658

src/orchestrators/import.ts

@@ -14,8 +14,6 @@ import { groupBy, sleep } from '../utils/index.js';
 import { wildCardMatch } from '../utils/wild-card-match.js';
 import { InitializationResult, InitializeOrchestrator } from './initialize.js';
 
-export type RequiredParameters = Map<string, RequiredParameter[]>;
-export type UserSuppliedParameters = Map<string, Record<string, unknown>>;
 export type ImportResult = { result: ResourceConfig[], errors: string[] }
 
 export interface ImportArgs {

src/plugins/plugin-manager.ts

@@ -10,7 +10,6 @@ import { Plan, ResourcePlan } from '../entities/plan.js';
 import { Project } from '../entities/project.js';
 import { ResourceInfo } from '../entities/resource-info.js';
 import { SubProcessName, ctx } from '../events/context.js';
-import { RequiredParameter, RequiredParameters } from '../orchestrators/import.js';
 import { groupBy } from '../utils/index.js';
 import { Plugin } from './plugin.js';
 import { PluginResolver } from './resolver.js';

src/ui/components/default-component.tsx

@@ -67,9 +67,9 @@ export function DefaultComponent(props: {
     {
       renderStatus === RenderStatus.PROMPT_OPTIONS && (
         <Box flexDirection="column">
-          <Text>{(renderData as any).message}</Text>
+          <Text>{(renderData as { message: string, options: string[] }).message}</Text>
           <Select onChange={(value) => emitter.emit(RenderEvent.PROMPT_RESULT, value)} options={
-            (renderData as any).options.map((option) => ({
+            (renderData as { message: string, options: string[] }).options.map((option) => ({
               label: option, value: option
             }))
           }/>

src/ui/reporters/debug-reporter.ts

@@ -1,21 +1,16 @@
-import chalk from 'chalk';
-import { SudoRequestData, SudoRequestResponseData } from 'codify-schemas';
 import createDebug, { Debugger } from 'debug';
-import readline from 'node:readline';
 
-import { Plan } from '../../entities/plan.js';
 import { Event, ctx } from '../../events/context.js';
-import { ImportResult, RequiredParameters, UserSuppliedParameters } from '../../orchestrators/import.js';
-import { SudoUtils } from '../../utils/sudo.js';
-import { Reporter } from './reporter.js';
+import { PlainReporter } from './plain-reporter.js';
 
 const debug = createDebug('codify');
 
-export class DebugReporter implements Reporter {
-  private readonly rl = readline.createInterface(process.stdin, process.stdout);
+export class DebugReporter extends PlainReporter{
   private debuggerCache = new Map<string, Debugger>();
 
   constructor() {
+    super(false);
+
     ctx.on(Event.PLUGIN_STDOUT, (name, args) => this.getDebug(name)(args));
     ctx.on(Event.PLUGIN_STDERR, (name, args) => this.getDebug(name)(args));
     ctx.on(Event.STDOUT, (args) => debug(args));
@@ -27,68 +22,6 @@ export class DebugReporter implements Reporter {
     ctx.on(Event.SUB_PROCESS_FINISH, (name) => debug(name))
   }
 
-  async promptUserForParameterValues(requiredParameters: RequiredParameters): Promise<UserSuppliedParameters> {
-    if (requiredParameters.size > 0 || [...requiredParameters.values()].reduce(
-      (total, arr) => arr.length + total, 0
-    )) {
-      console.log('Some required information is needed for the import');
-    }
-
-    const parameterInput = new Map<string, Record<string, unknown>>();
-
-    for (const [type, requiredParameter] of requiredParameters.entries()) {
-      if (requiredParameter.length > 0) {
-        console.log(`Resource: "${type}" requires additional information:`)
-      }
-
-      for (const parameter of requiredParameter) {
-        const response = await new Promise((resolve) => {
-          this.rl.question(`${parameter.name} [${parameter.type}]: `, (answer) => resolve(answer));
-        });
-
-        if (!parameterInput.has(type)) {
-          parameterInput.set(type, {});
-        }
-
-        parameterInput.get(type)![parameter.name] = response;
-      }
-    }
-
-    return parameterInput;
-  }
-
-  displayImportResult(importResult: ImportResult) {
-    console.log();
-    console.log(JSON.stringify(importResult.result.map((r) => r.raw), null, 2));
-
-    if (importResult.errors.length > 0) {
-      console.log('The following configs failed to import:')
-      console.log(JSON.stringify(importResult.errors, null, 2));
-    }
-  }
-
-  async promptSudo(pluginName: string, data: SudoRequestData, secureMode: boolean): Promise<SudoRequestResponseData> {
-    console.log(chalk.blue(`Plugin: "${pluginName}" requires root access to run command: "${data.command}"`));
-    return SudoUtils.runCommand(data.command, data.options, secureMode, pluginName);
-  }
-
-  async promptConfirmation(message: string): Promise<boolean> {
-    const response = await new Promise((resolve) => {
-      this.rl.question(`${message} (only 'yes' is accepted)`, (answer) => resolve(answer));
-    });
-
-    return response === 'yes';
-  }
-
-  displayPlan(plan: Plan): void {
-    console.log(JSON.stringify(plan.raw, null, 2));
-  }
-
-  displayApplyComplete(message: string[]): void {
-    console.log('🎉 Finished applying 🎉');
-    console.log('Open a new terminal or source \'.zshrc\' for the new changes to be reflected')
-  }
-
   private getDebug(name: string): Debugger {
     if (!this.debuggerCache.has(name)) {
       this.debuggerCache.set(name, createDebug(`plugin:${name}`));

src/ui/reporters/plain-reporter.ts

@@ -3,53 +3,88 @@ import { SudoRequestData, SudoRequestResponseData } from 'codify-schemas';
 import readline from 'node:readline';
 
 import { Plan } from '../../entities/plan.js';
+import { ResourceConfig } from '../../entities/resource-config.js';
+import { ResourceInfo } from '../../entities/resource-info.js';
 import { Event, ctx } from '../../events/context.js';
-import { ImportResult, RequiredParameters, UserSuppliedParameters } from '../../orchestrators/import.js';
+import { ImportResult } from '../../orchestrators/import.js';
+import { FileModificationResult } from '../../utils/file-modification-calculator.js';
 import { SudoUtils } from '../../utils/sudo.js';
 import { prettyFormatPlan } from '../plan-pretty-printer.js';
-import { Reporter } from './reporter.js';
+import { PromptType, Reporter } from './reporter.js';
 
 export class PlainReporter implements Reporter {
   private readonly rl = readline.createInterface(process.stdin, process.stdout);
 
-  constructor() {
-    ctx.on(Event.OUTPUT, (...args) => console.log(...args))
-    ctx.on(Event.PROCESS_START, (name) => console.log(name))
-    ctx.on(Event.PROCESS_FINISH, (name) => console.log(name))
-    ctx.on(Event.SUB_PROCESS_START, (name) => console.log(name))
-    ctx.on(Event.SUB_PROCESS_FINISH, (name) => console.log(name))
+  constructor(attachListeners = true) {
+    if (attachListeners) {
+      ctx.on(Event.OUTPUT, (...args) => console.log(...args))
+      ctx.on(Event.PROCESS_START, (name) => console.log(name))
+      ctx.on(Event.PROCESS_FINISH, (name) => console.log(name))
+      ctx.on(Event.SUB_PROCESS_START, (name) => console.log(name))
+      ctx.on(Event.SUB_PROCESS_FINISH, (name) => console.log(name))
+    }
   }
 
-  async promptUserForParameterValues(
-    requiredParameters: RequiredParameters
-  ): Promise<UserSuppliedParameters> {
-    if (requiredParameters.size > 0 || [...requiredParameters.values()].reduce(
-      (total, arr) => arr.length + total, 0
-    )) {
-      console.log('Some required information is needed for the import');
+  async promptOptions(message: string, options: string[]): Promise<number> {
+    console.log(message);
+    console.log('')
+
+    const response = await new Promise((resolve) => {
+      this.rl.question(`${options.map((o, idx) => `[${idx}] ${o} ` ).join(' ')}\n`, (answer) => resolve(answer));
+    });
+
+    const parsedNumber = Number.parseInt(response as string, 10);
+    if (!Number.isInteger(parsedNumber) || parsedNumber < 0 || parsedNumber > options.length - 1) {
+      throw new Error(`Invalid response ${response}`)
+    }
+
+    return Number.parseInt(response as string, 10);
+  }
+
+  displayFileModifications(diffs: { file: string; modification: FileModificationResult; }[]): void {
+    console.log(chalk.bold('File modifications\n'))
+
+    for (const diff of diffs) {
+      console.log(chalk.bold(diff.file))
+      console.log('')
+      console.log(diff.modification.diff)
+      console.log('')
     }
+  }
 
-    const parameterInput = new Map<string, Record<string, unknown>>();
+  displayMessage(message: string): void {
+    console.log(message);
+  }
 
-    for (const [type, requiredParameter] of requiredParameters.entries()) {
-      if (requiredParameter.length > 0) {
-        console.log(`Resource: "${type}" requires additional information:`)
+  async promptUserForValues(
+    resourceInfoList: ResourceInfo[],
+    promptType: PromptType
+  ): Promise<ResourceConfig[]> {
+    const requiredParameters = resourceInfoList.flatMap((r) => r.getRequiredParameters())
+    if (requiredParameters.length > 0) {
+      console.log('Some required information is needed for the import');
+    }
+
+    const result: ResourceConfig[] = [];
+    for (const resourceInfo of resourceInfoList) {
+      if (resourceInfo.getRequiredParameters().length > 0) {
+        console.log(`Resource: "${resourceInfo.type}" requires additional information:`)
       }
 
+      const requiredParameter = resourceInfo.getRequiredParameters()
+      const configJson: Record<string, unknown> = { type: resourceInfo.type }
       for (const parameter of requiredParameter) {
         const response = await new Promise((resolve) => {
           this.rl.question(`${parameter.name} [${parameter.type}]: `, (answer) => resolve(answer));
         });
 
-        if (!parameterInput.has(type)) {
-          parameterInput.set(type, {});
-        }
-
-        parameterInput.get(type)![parameter.name] = response;
+        configJson[parameter.name] = response;
       }
+
+      result.push(new ResourceConfig(configJson as any))
     }
 
-    return parameterInput;
+    return result;
   }
 
   displayImportResult(importResult: ImportResult) {

src/ui/reporters/reporter.ts

@@ -6,6 +6,8 @@ import { DefaultReporter } from './default-reporter.js';
 import { ResourceInfo } from '../../entities/resource-info.js';
 import { ResourceConfig } from '../../entities/resource-config.js';
 import { FileModificationResult } from '../../utils/file-modification-calculator.js';
+import { PlainReporter } from './plain-reporter.js';
+import { DebugReporter } from './debug-reporter.js';
 
 export enum RenderEvent {
   LOG = 'log',
@@ -68,12 +70,12 @@ export const ReporterFactory = {
   create(type: ReporterType): Reporter {
     switch (type) {
       case ReporterType.DEBUG: {
-        return new DefaultReporter();
+        return new DebugReporter();
       }
 
-      // case ReporterType.PLAIN: {
-      //   return new PlainReporter();
-      // }
+      case ReporterType.PLAIN: {
+        return new PlainReporter();
+      }
 
       case ReporterType.JSON: {
         return new DefaultReporter();

src/utils/index.ts

@@ -51,7 +51,7 @@ export function deepEqual(obj1: unknown, obj2: unknown): boolean {
 
   // Iterate through the keys and compare their values recursively.
   for (const key of keys1) {
-    if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
+    if (!keys2.includes(key) || !deepEqual((obj1 as Record<string, unknown>)[key], (obj2 as Record<string, unknown>)[key])) {
       return false;
     }
   }