feat!: add import command (#40)

* Add command + parsing + validation

* Add import step and generate imported configs

* Added check to prevent complicated resources from being imported (resources with complex required statements)

* Added rendering for question prompts to default renderer

* Changed uninstallation text to destroy. Switched to the new getResourceInfo API. Improved import copy. Improved import error messages

BREAKING CHANGE: Changed `uninstall` command to `destroy`

Author: kevinwang5658

.eslintrc.json

@@ -9,9 +9,16 @@
       "warn",
       "always"
     ],
-    "perfectionist/sort-classes": [
-      "off"
-    ],
+    "perfectionist/sort-classes": "off",
+    "perfectionist/sort-interfaces": "off",
+    "perfectionist/sort-enums": "off",
+    "perfectionist/sort-objects": "off",
+    "perfectionist/sort-object-types": "off",
+    "unicorn/no-array-reduce": "off",
+    "unicorn/no-array-for-each": "off",
+    "unicorn/prefer-object-from-entries": "off",
+    "unicorn/prefer-type-error": "off",
+    "no-await-in-loop": "off",
     "quotes": [
       "error",
       "single"

package.json

@@ -11,16 +11,17 @@
     "ajv": "^8.12.0",
     "ajv-formats": "^3.0.1",
     "chalk": "^5.3.0",
-    "codify-schemas": "1.0.44",
+    "codify-schemas": "1.0.52",
     "debug": "^4.3.4",
     "ink": "^4.4.1",
+    "ink-form": "^2.0.1",
+    "js-yaml": "^4.1.0",
+    "js-yaml-source-map": "^0.2.2",
+    "json-source-map": "^0.6.1",
     "parse-json": "^8.1.0",
     "react": "^18.3.1",
     "semver": "^7.5.4",
-    "supports-color": "^9.4.0",
-    "json-source-map": "^0.6.1",
-    "js-yaml": "^4.1.0",
-    "js-yaml-source-map": "^0.2.2"
+    "supports-color": "^9.4.0"
   },
   "description": "Codify is a set up as code tool for developers",
   "devDependencies": {
@@ -30,12 +31,12 @@
     "@types/chai-as-promised": "^7.1.7",
     "@types/chalk": "^2.2.0",
     "@types/debug": "^4.1.12",
+    "@types/js-yaml": "^4.0.9",
     "@types/mocha": "^9.0.0",
     "@types/mock-fs": "^4.13.3",
     "@types/node": "^18",
     "@types/react": "^18.3.1",
     "@types/semver": "^7.5.4",
-    "@types/js-yaml": "^4.0.9",
     "@types/strip-ansi": "^5.2.1",
     "chai": "^4",
     "chai-as-promised": "^7.1.1",

src/commands/uninstall.ts src/commands/destroy.tssrc/commands/uninstall.ts renamed to src/commands/destroy.ts

@@ -2,34 +2,32 @@ import path from 'node:path';
 
 import { BaseCommand } from '../common/base-command.js';
 import { ApplyOrchestrator } from '../orchestrators/apply.js';
-import { UninstallOrchestrator } from '../orchestrators/uninstall.js';
-
-export default class Uninstall extends BaseCommand {
-  static description = 'Uninstall a given resource based on id.'
+import { DestroyOrchestrator } from '../orchestrators/destroy.js';
 
+export default class Destroy extends BaseCommand {
+  static strict = false;
+  static description = 'Destroy or uninstall a resource (or many resources).'
   static examples = [
-    '<%= config.bin %> <%= command.id %>',
+    '<%= config.bin %> <%= command.id %> homebrew nvm',
   ]
-
-  static strict = false;
-
+  
   public async run(): Promise<void> {
-    const { flags, raw } = await this.parse(Uninstall)
+    const { flags, raw } = await this.parse(Destroy)
 
     const args = raw
       .filter((r) => r.type === 'arg')
       .map((r) => r.input);
 
     if (args.length === 0) {
-      throw new Error('A resource id must be specified for uninstall. Ex: "codify uninstall homebrew"')
+      throw new Error('At least one resource <type> must be specified. Ex: "codify destroy homebrew"')
     }
 
     if (flags.path) {
       this.log(`Applying Codify from: ${flags.path}`);
     }
 
     const resolvedPath = path.resolve(flags.path ?? '.');
-    const planResult = await UninstallOrchestrator.getUninstallPlan(args, resolvedPath, flags.secure);
+    const planResult = await DestroyOrchestrator.getDestroyPlan(args, resolvedPath, flags.secure);
 
     this.reporter.displayPlan(planResult.plan);
 

src/commands/import.ts

@@ -0,0 +1,46 @@
+import { Flags } from '@oclif/core';
+import path from 'node:path';
+
+import { BaseCommand } from '../common/base-command.js';
+import { ImportOrchestrator } from '../orchestrators/import.js';
+
+export default class Import extends BaseCommand {
+  static strict = false;
+  static override description = 'Generate codify configs from existing installations'
+  static override examples = [
+    '<%= config.bin %> <%= command.id %> homebrew nvm',
+  ]
+
+  static flags = {
+    // flag with a value (-p, --path=VALUE)
+    path: Flags.string({ char: 'p', description: 'path to project' }),
+  }
+
+
+  public async run(): Promise<void> {
+    const { raw, flags } = await this.parse(Import)
+
+    if (flags.path) {
+      this.log(`Applying Codify from: ${flags.path}`);
+    }
+
+    const resolvedPath = path.resolve(flags.path ?? '.');
+
+    const args = raw
+      .filter((r) => r.type === 'arg')
+      .map((r) => r.input);
+
+    if (args.length === 0) {
+      throw new Error('At least one resource <type> must be specified. Ex: "codify import homebrew"')
+    }
+
+    const { pluginManager } = await ImportOrchestrator.initializeAndValidate(args, resolvedPath, flags.secure)
+    const requiredParameters = await ImportOrchestrator.getRequiredParameters(args, pluginManager);
+    const userSuppliedProperties = await this.reporter.askRequiredPropertiesForImport(requiredParameters);
+
+    const importResult = await ImportOrchestrator.getImportedConfigs(pluginManager, args, userSuppliedProperties)
+    this.reporter.displayImportResult(importResult);
+
+    process.exit(0)
+  }
+}

src/events/context.ts

@@ -20,7 +20,8 @@ export enum Event {
 export enum ProcessName {
   APPLY = 'apply',
   PLAN = 'plan',
-  UNINSTALL = 'uninstall',
+  DESTROY = 'destroy',
+  IMPORT = 'import',
 }
 
 export enum SubProcessName {
@@ -29,6 +30,8 @@ export enum SubProcessName {
   INITIALIZE_PLUGINS = 'initialize_plugins',
   PARSE = 'parse',
   VALIDATE = 'validate',
+  GET_REQUIRED_PARAMETERS = 'get_required_parameters',
+  IMPORT_RESOURCE = 'import_resource',
 }
 
 export const ctx = new class {

src/orchestrators/uninstall.ts src/orchestrators/destroy.tssrc/orchestrators/uninstall.ts renamed to src/orchestrators/destroy.ts

@@ -9,25 +9,25 @@ import { DependencyMap, PluginManager } from '../plugins/plugin-manager.js';
 import { getTypeAndNameFromId } from '../utils/index.js';
 import { PlanOrchestratorResponse } from './plan.js';
 
-export class UninstallOrchestrator {
-  static async getUninstallPlan(
+export class DestroyOrchestrator {
+  static async getDestroyPlan(
     ids: string[], path: null | string, secureMode: boolean): Promise<PlanOrchestratorResponse> {
     if (ids.length === 0) {
-      throw new InternalError('getUninstallPlan called with no ids passed in');
+      throw new InternalError('getDestroyPlan called with no ids passed in');
     }
 
-    ctx.processStarted(ProcessName.PLAN)
+    ctx.processStarted(ProcessName.DESTROY)
 
-    const project = await UninstallOrchestrator.parse(path, ids)
+    const project = await DestroyOrchestrator.parse(path, ids)
 
     const { dependencyMap, pluginManager } = await CommonOrchestrator.initializePlugins(project, secureMode);
-    await UninstallOrchestrator.validate(project, pluginManager, dependencyMap)
+    await DestroyOrchestrator.validate(project, pluginManager, dependencyMap)
 
     const uninstallProject = project.toUninstallProject()
     uninstallProject.resolveResourceDependencies(dependencyMap);
     uninstallProject.calculateEvaluationOrder();
 
-    const plan = await UninstallOrchestrator.plan(uninstallProject, pluginManager)
+    const plan = await DestroyOrchestrator.plan(uninstallProject, pluginManager)
     return {
       plan,
       pluginManager,

src/orchestrators/import.ts

@@ -0,0 +1,143 @@
+import { ResourceConfig , ResourceConfig as SchemaResourceConfig } from 'codify-schemas';
+
+import { InternalError } from '../common/errors.js';
+import { CommonOrchestrator } from '../common/orchestrator.js';
+import { Project } from '../entities/project.js';
+import { ProcessName, SubProcessName, ctx } from '../events/context.js';
+import { CodifyParser } from '../parser/index.js';
+import { DependencyMap, PluginManager } from '../plugins/plugin-manager.js';
+
+export type RequiredProperties = Map<string, RequiredProperty[]>;
+export type UserSuppliedProperties = Map<string, Record<string, unknown>>;
+export type ImportResult = { result: ResourceConfig[], errors: string[] }
+
+export interface RequiredProperty {
+  propertyName: string;
+  propertyType: string;
+  plugin: string;
+}
+
+export class ImportOrchestrator {
+  static async initializeAndValidate(
+    typeIds: string[],
+    path: string,
+    secureMode: boolean
+  ): Promise<{
+    project: Project;
+    pluginManager: PluginManager;
+  }> {
+    if (typeIds.length === 0) {
+      throw new InternalError('importAndGenerateConfigs called with no typeIds passed in');
+    }
+
+    ctx.processStarted(ProcessName.IMPORT)
+
+    const project = await ImportOrchestrator.parse(path)
+
+    const { dependencyMap, pluginManager } = await CommonOrchestrator.initializePlugins(project, secureMode);
+    await ImportOrchestrator.validate(typeIds, project, pluginManager, dependencyMap)
+
+    return { project, pluginManager };
+  }
+
+  static async getRequiredParameters(
+    typeIds: string[],
+    pluginManager: PluginManager
+  ): Promise<RequiredProperties> {
+    ctx.subprocessStarted(SubProcessName.GET_REQUIRED_PARAMETERS);
+
+    const allRequiredProperties = new Map<string, RequiredProperty[]>();
+    for (const type of typeIds) {
+      const resourceInfo = await pluginManager.getResourceInfo(type);
+
+      const { schema } = resourceInfo;
+      if (!schema) {
+        continue;
+      }
+
+      const requiredPropertyNames = resourceInfo.import?.requiredParameters;
+      if (!requiredPropertyNames || requiredPropertyNames.length === 0) {
+        continue;
+      }
+
+      requiredPropertyNames
+        .forEach((name) => {
+          if (!allRequiredProperties.has(type)) {
+            allRequiredProperties.set(type, []);
+          }
+
+          const propertyInfo = (schema.properties as any)[name];
+
+          allRequiredProperties.get(type)!.push({
+            propertyName: name,
+            propertyType: propertyInfo.type ?? null,
+            plugin: resourceInfo.plugin
+          })
+        });
+    }
+
+    ctx.subprocessFinished(SubProcessName.GET_REQUIRED_PARAMETERS);
+
+    return allRequiredProperties;
+  }
+
+  static async getImportedConfigs(
+    pluginManager: PluginManager,
+    typeIds: string[],
+    userSuppliedProperties: UserSuppliedProperties
+  ): Promise<ImportResult> {
+    const importedConfigs = [];
+    const errors = [];
+
+    for (const type of typeIds) {
+      ctx.subprocessStarted(SubProcessName.IMPORT_RESOURCE, type);
+      try {
+        const config: SchemaResourceConfig = {
+          type,
+          ...userSuppliedProperties.get(type),
+        };
+
+        const response = await pluginManager.importResource(config);
+
+        if (response.result !== null && response.result.length > 0) {
+          importedConfigs.push(...response.result);
+        } else {
+          errors.push(`Unable to import resource '${type}', resource not found`);
+        }
+      } catch (error: any) {
+        errors.push(error.message ?? error);
+      }
+
+      ctx.subprocessFinished(SubProcessName.IMPORT_RESOURCE, type);
+    }
+
+    ctx.processFinished(ProcessName.IMPORT)
+
+    return {
+      result: importedConfigs,
+      errors,
+    }
+  }
+
+  private static async parse(path: string): Promise<Project> {
+    ctx.subprocessStarted(SubProcessName.PARSE);
+    const project = await CodifyParser.parse(path);
+    ctx.subprocessFinished(SubProcessName.PARSE);
+
+    return project
+  }
+
+  private static async validate(typeIds: string[], project: Project, pluginManager: PluginManager, dependencyMap: DependencyMap): Promise<void> {
+    ctx.subprocessStarted(SubProcessName.VALIDATE)
+
+    project.validateTypeIds(dependencyMap);
+
+    const unsupportedTypeIds = typeIds.filter((type) => !dependencyMap.has(type));
+    if (unsupportedTypeIds.length > 0) {
+      throw new Error(`The following resources cannot be imported. No plugins found that support the following types:
+${JSON.stringify(unsupportedTypeIds)}`);
+    }
+
+    ctx.subprocessFinished(SubProcessName.VALIDATE)
+  }
+}