feat: Refactored the initialization process to return a resource definition. We can put info in here in the future if needed. Right now return if a resource has any sensitive parameters

Author: kevinwang5658

package-lock.json

@@ -17,7 +17,7 @@
     "ajv": "^8.12.0",
     "ajv-formats": "^3.0.1",
     "chalk": "^5.3.0",
-    "codify-schemas": "^1.0.77",
+    "codify-schemas": "^1.0.81",
     "cors": "^2.8.5",
     "debug": "^4.3.4",
     "detect-indent": "^7.0.1",

package.json

@@ -1,16 +1,15 @@
 import * as fs from 'node:fs/promises'
-import * as os from 'node:os'
 import * as path from 'node:path'
+import { validate } from 'uuid';
 
+import { DashboardApiClient } from '../api/dashboard/index.js';
+import { LoginHelper } from '../connect/login-helper.js';
 import { Project } from '../entities/project.js';
 import { SubProcessName, ctx } from '../events/context.js';
 import { CODIFY_FILE_REGEX, CodifyParser } from '../parser/index.js';
-import { DependencyMap, PluginManager } from '../plugins/plugin-manager.js';
+import { PluginManager, ResourceDefinitionMap } from '../plugins/plugin-manager.js';
 import { Reporter } from '../ui/reporters/reporter.js';
-import { LoginHelper } from '../connect/login-helper.js';
 import { FileUtils } from '../utils/file.js';
-import { validate } from 'uuid';
-import { DashboardApiClient } from '../api/dashboard/index.js';
 
 export interface InitializeArgs {
   path?: string;
@@ -21,7 +20,7 @@ export interface InitializeArgs {
 }
 
 export interface InitializationResult {
-  typeIdsToDependenciesMap: DependencyMap
+  resourceDefinitions: ResourceDefinitionMap
   pluginManager: PluginManager,
   project: Project,
 }
@@ -42,10 +41,10 @@ export class PluginInitOrchestrator {
 
     ctx.subprocessStarted(SubProcessName.INITIALIZE_PLUGINS)
     const pluginManager = new PluginManager();
-    const typeIdsToDependenciesMap = await pluginManager.initialize(project, args.secure, args.verbosityLevel);
+    const resourceDefinitions = await pluginManager.initialize(project, args.secure, args.verbosityLevel);
     ctx.subprocessFinished(SubProcessName.INITIALIZE_PLUGINS)
 
-    return { typeIdsToDependenciesMap, pluginManager, project };
+    return { resourceDefinitions, pluginManager, project };
   }
 
   private static async parse(

src/common/initialize-plugins.ts

@@ -4,7 +4,7 @@ import { validate } from 'uuid'
 import { PluginValidationError, PluginValidationErrorParams, TypeNotFoundError } from '../common/errors.js';
 import { ctx } from '../events/context.js';
 import { SourceMapCache } from '../parser/source-maps.js';
-import { DependencyMap } from '../plugins/plugin-manager.js';
+import { ResourceDefinitionMap } from '../plugins/plugin-manager.js';
 import { DependencyGraphResolver } from '../utils/dependency-graph-resolver.js';
 import { groupBy } from '../utils/index.js';
 import { ConfigBlock, ConfigType } from './config.js';
@@ -155,16 +155,16 @@ ${JSON.stringify(projectConfigs, null, 2)}`);
     }
   }
 
-  validateTypeIds(resourceMap: Map<string, string[]>) {
-    const invalidConfigs = this.resourceConfigs.filter((c) => !resourceMap.get(c.type));
+  validateTypeIds(resourceDefinitions: ResourceDefinitionMap) {
+    const invalidConfigs = this.resourceConfigs.filter((c) => !resourceDefinitions.has(c.type));
 
     if (invalidConfigs.length > 0) {
       throw new TypeNotFoundError(invalidConfigs, this.sourceMaps);
     }
   }
 
-  resolveDependenciesAndCalculateEvalOrder(dependencyMap?: DependencyMap) {
-    this.resolveResourceDependencies(dependencyMap);
+  resolveDependenciesAndCalculateEvalOrder(resourceDefinitions?: ResourceDefinitionMap) {
+    this.resolveResourceDependencies(resourceDefinitions);
     this.calculateEvaluationOrder();
   }
 
@@ -189,7 +189,7 @@ ${JSON.stringify(projectConfigs, null, 2)}`);
     ) ?? null;
   }
 
-  private resolveResourceDependencies(dependencyMap?: DependencyMap) {
+  private resolveResourceDependencies(resourceDefinitions?: ResourceDefinitionMap) {
     const resourceMap = new Map(this.resourceConfigs.map((r) => [r.id, r] as const));
 
     for (const r of this.resourceConfigs) {
@@ -198,7 +198,7 @@ ${JSON.stringify(projectConfigs, null, 2)}`);
       r.addDependenciesBasedOnParameters((id) => resourceMap.has(id));
 
       // Plugin dependencies are soft dependencies. They only activate if the dependent resource is present.
-      r.addDependencies(dependencyMap?.get(r.type)
+      r.addDependencies(resourceDefinitions?.get(r.type)?.dependencies
         ?.filter((type) => [...resourceMap.values()].some((r) => r.type === type))
         ?.flatMap((type) => [...resourceMap.values()].filter((r) => r.type === type).map((r) => r.id)) ?? []
       );

src/entities/project.ts

@@ -4,7 +4,7 @@ import { Project } from '../entities/project.js';
 import { ResourceConfig } from '../entities/resource-config.js';
 import { ResourceInfo } from '../entities/resource-info.js';
 import { ProcessName, SubProcessName, ctx } from '../events/context.js';
-import { DependencyMap, PluginManager } from '../plugins/plugin-manager.js';
+import { PluginManager, ResourceDefinitionMap } from '../plugins/plugin-manager.js';
 import { PromptType, Reporter } from '../ui/reporters/reporter.js';
 import { wildCardMatch } from '../utils/wild-card-match.js';
 
@@ -68,11 +68,11 @@ Open a new terminal or source '.zshrc' for the new changes to be reflected`);
     reporter: Reporter,
     initializeResult: InitializationResult
   ): Promise<{ plan: Plan, destroyProject: Project }> {
-    const { project, pluginManager, typeIdsToDependenciesMap } = initializeResult;
+    const { project, pluginManager, resourceDefinitions } = initializeResult;
 
     // TODO: In the future if a user supplies resourceId.name (naming a specific resource) destroy that resource instead of stripping the name out.
-    const matchedTypes = this.matchTypeIds(typeIds.map((id) => id.split('.').at(0) ?? ''), [...typeIdsToDependenciesMap.keys()])
-    await DestroyOrchestrator.validateTypeIds(matchedTypes, project, pluginManager, typeIdsToDependenciesMap);
+    const matchedTypes = this.matchTypeIds(typeIds.map((id) => id.split('.').at(0) ?? ''), [...resourceDefinitions.keys()])
+    await DestroyOrchestrator.validateTypeIds(matchedTypes, project, pluginManager, resourceDefinitions);
 
     const resourceInfoList = (await pluginManager.getMultipleResourceInfo(matchedTypes));
     const resourcesToDestroy = await DestroyOrchestrator.getDestroyParameters(reporter, project, resourceInfoList);
@@ -83,7 +83,7 @@ Open a new terminal or source '.zshrc' for the new changes to be reflected`);
       project.codifyFiles
     ).toDestroyProject();
 
-    destroyProject.resolveDependenciesAndCalculateEvalOrder(typeIdsToDependenciesMap);
+    destroyProject.resolveDependenciesAndCalculateEvalOrder(resourceDefinitions);
     const plan = await ctx.subprocess(ProcessName.PLAN, () =>
       pluginManager.plan(destroyProject)
     )
@@ -96,16 +96,16 @@ Open a new terminal or source '.zshrc' for the new changes to be reflected`);
     reporter: Reporter,
     initializeResult: InitializationResult
   ): Promise<{ plan: Plan, destroyProject: Project }> {
-    const { pluginManager, project, typeIdsToDependenciesMap } = initializeResult;
+    const { pluginManager, project, resourceDefinitions } = initializeResult;
 
     await ctx.subprocess(SubProcessName.VALIDATE, async () => {
-      project.validateTypeIds(typeIdsToDependenciesMap);
+      project.validateTypeIds(resourceDefinitions);
       const validationResults = await pluginManager.validate(project);
       project.handlePluginResourceValidationResults(validationResults);
     })
 
     const destroyProject = project.toDestroyProject();
-    destroyProject.resolveDependenciesAndCalculateEvalOrder(typeIdsToDependenciesMap);
+    destroyProject.resolveDependenciesAndCalculateEvalOrder(resourceDefinitions);
 
     const plan = await ctx.subprocess(ProcessName.PLAN, () =>
       pluginManager.plan(destroyProject)
@@ -147,10 +147,10 @@ ${JSON.stringify(unsupportedTypeIds)}`);
     return result;
   }
 
-  private static async validateTypeIds(typeIds: string[], project: Project, pluginManager: PluginManager, dependencyMap: DependencyMap): Promise<void> {
-    project.validateTypeIds(dependencyMap);
+  private static async validateTypeIds(typeIds: string[], project: Project, pluginManager: PluginManager, resourceDefinitions: ResourceDefinitionMap): Promise<void> {
+    project.validateTypeIds(resourceDefinitions);
 
-    const unsupportedTypeIds = typeIds.filter((type) => !dependencyMap.has(type));
+    const unsupportedTypeIds = typeIds.filter((type) => !resourceDefinitions.has(type));
     if (unsupportedTypeIds.length > 0) {
       throw new Error(`The following resources cannot be destroyed. No plugins found that support the following types:
 ${JSON.stringify(unsupportedTypeIds)}`);

src/orchestrators/destroy.ts

@@ -13,7 +13,7 @@ import { FileModificationCalculator } from '../generators/file-modification-calc
 import { ModificationType } from '../generators/index.js';
 import { FileUpdater } from '../generators/writer.js';
 import { CodifyParser } from '../parser/index.js';
-import { DependencyMap, PluginManager } from '../plugins/plugin-manager.js';
+import { PluginManager, ResourceDefinitionMap } from '../plugins/plugin-manager.js';
 import { prettyFormatFileDiff } from '../ui/file-diff-pretty-printer.js';
 import { PromptType, Reporter } from '../ui/reporters/reporter.js';
 import { FileUtils } from '../utils/file.js';
@@ -56,10 +56,10 @@ export class ImportOrchestrator {
   }
 
   static async autoImportAll(reporter: Reporter, initializeResult: InitializationResult, args: ImportArgs) {
-    const { project, pluginManager, typeIdsToDependenciesMap } = initializeResult;
+    const { project, pluginManager, resourceDefinitions } = initializeResult;
 
     ctx.subprocessStarted(SubProcessName.IMPORT_RESOURCE)
-    const importResults = await Promise.all([...typeIdsToDependenciesMap.keys()].map(async (typeId) => {
+    const importResults = await Promise.all([...resourceDefinitions.keys()].map(async (typeId) => {
       try {
         return await pluginManager.importResource({
           core: { type: typeId },
@@ -98,10 +98,10 @@ export class ImportOrchestrator {
 
   /** Import new resources. Type ids supplied. This will ask for any required parameters */
   static async runNewImport(typeIds: string[], reporter: Reporter, initializeResult: InitializationResult, args: ImportArgs): Promise<void> {
-    const { project, pluginManager, typeIdsToDependenciesMap } = initializeResult;
+    const { project, pluginManager, resourceDefinitions } = initializeResult;
 
-    const matchedTypes = this.matchTypeIds(typeIds, [...typeIdsToDependenciesMap.keys()])
-    await ImportOrchestrator.validate(matchedTypes, project, pluginManager, typeIdsToDependenciesMap);
+    const matchedTypes = this.matchTypeIds(typeIds, [...resourceDefinitions.keys()])
+    await ImportOrchestrator.validate(matchedTypes, project, pluginManager, resourceDefinitions);
 
     const resourceInfoList = (await pluginManager.getMultipleResourceInfo(matchedTypes))
       .filter((info) => info.canImport)
@@ -364,10 +364,10 @@ ${JSON.stringify(unsupportedTypeIds)}`);
     return result;
   }
 
-  private static async validate(typeIds: string[], project: Project, pluginManager: PluginManager, dependencyMap: DependencyMap): Promise<void> {
-    project.validateTypeIds(dependencyMap);
+  private static async validate(typeIds: string[], project: Project, pluginManager: PluginManager, resourceDefinitions: ResourceDefinitionMap): Promise<void> {
+    project.validateTypeIds(resourceDefinitions);
 
-    const unsupportedTypeIds = typeIds.filter((type) => !dependencyMap.has(type));
+    const unsupportedTypeIds = typeIds.filter((type) => !resourceDefinitions.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)}`);

src/orchestrators/import.ts

@@ -22,10 +22,10 @@ export const InitializeOrchestrator = {
     await reporter.displayProgress();
 
 
-    const { pluginManager, typeIdsToDependenciesMap } = await PluginInitOrchestrator.run(args, reporter);
+    const { pluginManager, resourceDefinitions } = await PluginInitOrchestrator.run(args, reporter);
 
     ctx.subprocessStarted(SubProcessName.IMPORT_RESOURCE)
-    const importResults = await Promise.all([...typeIdsToDependenciesMap.keys()].map(async (typeId) => {
+    const importResults = await Promise.all([...resourceDefinitions.keys()].map(async (typeId) => {
       try {
         return await pluginManager.importResource({
           core: { type: typeId },

src/orchestrators/init.ts

@@ -27,12 +27,12 @@ export class PlanOrchestrator {
     const initializationResult = await PluginInitOrchestrator.run({
       ...args,
     }, reporter);
-    const { typeIdsToDependenciesMap, pluginManager, project } = initializationResult;
+    const { resourceDefinitions, pluginManager, project } = initializationResult;
 
     await createStartupShellScriptsIfNotExists();
 
     await ValidateOrchestrator.run({ existing: initializationResult }, reporter);
-    project.resolveDependenciesAndCalculateEvalOrder(typeIdsToDependenciesMap);
+    project.resolveDependenciesAndCalculateEvalOrder(resourceDefinitions);
     project.addXCodeToolsConfig(); // We have to add xcode-tools config always since almost every resource depends on it
 
     const plan = await PlanOrchestrator.plan(project, pluginManager);

src/orchestrators/plan.ts

@@ -16,7 +16,7 @@ export const ValidateOrchestrator = {
   ): Promise<void> {
     const {
       project,
-      typeIdsToDependenciesMap: dependencyMap,
+      resourceDefinitions,
       pluginManager,
     } = args.existing ?? await PluginInitOrchestrator.run(args, reporter)
 
@@ -26,7 +26,7 @@ export const ValidateOrchestrator = {
       ctx.processStarted(SubProcessName.VALIDATE)
     }
 
-    project.validateTypeIds(dependencyMap);
+    project.validateTypeIds(resourceDefinitions);
     const validationResults = await pluginManager.validate(project);
     project.handlePluginResourceValidationResults(validationResults);
 

src/orchestrators/validate.ts

@@ -1,5 +1,5 @@
-import { 
-  ImportResponseData,
+import {
+  ImportResponseData, ResourceDefinition,
   ResourceJson,
   ValidateResponseData,
 } from 'codify-schemas';
@@ -16,7 +16,7 @@ import { PluginResolver } from './resolver.js';
 
 type PluginName = string;
 type ResourceTypeId = string;
-export type DependencyMap = Map<ResourceTypeId, ResourceTypeId[]>;
+export type ResourceDefinitionMap = Map<ResourceTypeId, ResourceDefinition>;
 
 const DEFAULT_PLUGINS = {
   'default': 'latest',
@@ -28,17 +28,15 @@ export class PluginManager {
   private resourceToPluginMapping = new Map<string, string>()
   private pluginToResourceMapping = new Map<string, string[]>()
 
-  async initialize(project: Project | null, secureMode = false, verbosityLevel = 0): Promise<DependencyMap> {
+  async initialize(project: Project | null, secureMode = false, verbosityLevel = 0): Promise<ResourceDefinitionMap> {
     const plugins = await this.resolvePlugins(project);
 
     for (const plugin of plugins) {
       this.plugins.set(plugin.name, plugin)
     }
 
     this.registerKillListeners(plugins)
-
-    const dependencyMap = await this.initializePlugins(plugins, secureMode, verbosityLevel);
-    return dependencyMap;
+    return this.initializePlugins(plugins, secureMode, verbosityLevel);
   }
 
   async validate(project: Project): Promise<ValidateResponseData[]> {
@@ -158,15 +156,15 @@ export class PluginManager {
     return PluginResolver.resolveAll(pluginDefinitions);
   }
 
-  private async initializePlugins(plugins: Plugin[], secureMode: boolean, verbosityLevel: number): Promise<Map<string, string[]>> {
+  private async initializePlugins(plugins: Plugin[], secureMode: boolean, verbosityLevel: number): Promise<Map<string, ResourceDefinition>> {
     const responses = await Promise.all(
       plugins.map(async (p) => {
         const initializeResult = await p.initialize(secureMode, verbosityLevel);
         return [p.name, initializeResult.resourceDefinitions] as const
       })
     );
 
-    const resourceMap = new Map<string, string[]>;
+    const resourceMap = new Map<string, ResourceDefinition>();
 
     for (const [pluginName, definitions] of responses) {
       for (const definition of definitions) {
@@ -189,7 +187,7 @@ export class PluginManager {
           throw new Error(`Duplicated types between plugins ${this.resourceToPluginMapping.get(definition.type)} and ${pluginName}`);
         }
 
-        resourceMap.set(definition.type, definition.dependencies)
+        resourceMap.set(definition.type, definition)
       }
     }