feat: Added wild card matching for import

Author: kevinwang5658

src/orchestrators/destroy.ts

@@ -23,7 +23,7 @@ export class DestroyOrchestrator {
 
     ctx.processStarted(ProcessName.DESTROY)
 
-    const { dependencyMap, pluginManager, project } = await InitializeOrchestrator.run({
+    const { typeIdsToDependenciesMap, pluginManager, project } = await InitializeOrchestrator.run({
       ...args,
       allowEmptyProject: true,
       transformProject(project) {
@@ -42,10 +42,10 @@ export class DestroyOrchestrator {
       }
     }, reporter);
 
-    await DestroyOrchestrator.validate(project, pluginManager, dependencyMap)
+    await DestroyOrchestrator.validate(project, pluginManager, typeIdsToDependenciesMap)
 
     const uninstallProject = project.toDestroyProject()
-    uninstallProject.resolveDependenciesAndCalculateEvalOrder(dependencyMap);
+    uninstallProject.resolveDependenciesAndCalculateEvalOrder(typeIdsToDependenciesMap);
 
     const plan = await ctx.subprocess(ProcessName.PLAN, () =>
       pluginManager.plan(uninstallProject)

src/orchestrators/import.ts

@@ -10,6 +10,7 @@ import { PromptType, Reporter } from '../ui/reporters/reporter.js';
 import { FileUtils } from '../utils/file.js';
 import { FileModificationCalculator, ModificationType } from '../utils/file-modification-calculator.js';
 import { sleep } from '../utils/index.js';
+import { wildCardMatch } from '../utils/wild-card-match.js';
 import { InitializeOrchestrator } from './initialize.js';
 
 export type RequiredParameters = Map<string, RequiredParameter[]>;
@@ -51,16 +52,18 @@ export class ImportOrchestrator {
 
     ctx.processStarted(ProcessName.IMPORT)
 
-    const { dependencyMap, pluginManager, project } = await InitializeOrchestrator.run(
+    const { typeIdsToDependenciesMap, pluginManager, project } = await InitializeOrchestrator.run(
       { ...args, allowEmptyProject: true },
       reporter
     );
-    await ImportOrchestrator.validate(typeIds, project, pluginManager, dependencyMap)
-    const resourceInfoList = await pluginManager.getMultipleResourceInfo(typeIds);
 
+    const matchedTypes = this.matchTypeIds(typeIds, [...typeIdsToDependenciesMap.keys()])
+    await ImportOrchestrator.validate(matchedTypes, project, pluginManager, typeIdsToDependenciesMap);
+
+    const resourceInfoList = await pluginManager.getMultipleResourceInfo(matchedTypes);
+    // Figure out which resources we need to prompt the user for additional info (based on the resource info)
     const [noPrompt, askPrompt] = resourceInfoList.reduce((result, info) => {
       info.getRequiredParameters().length === 0 ? result[0].push(info) : result[1].push(info);
-      
       return result;
     }, [<ResourceInfo[]>[], <ResourceInfo[]>[]])
 
@@ -115,6 +118,39 @@ export class ImportOrchestrator {
     }
   }
 
+  private static matchTypeIds(typeIds: string[], validTypeIds: string[]): string[] {
+    const result: string[] = [];
+    const unsupportedTypeIds: string[] = [];
+     
+    for (const typeId of typeIds) {
+      if (!typeId.includes('*') && !typeId.includes('?')) {
+        const matched = validTypeIds.includes(typeId);
+        if (!matched) {
+          unsupportedTypeIds.push(typeId);
+          continue;
+        }
+        
+        result.push(typeId)
+        continue;
+      }
+      
+      const matched = validTypeIds.filter((valid) => wildCardMatch(valid, typeId))
+      if (matched.length === 0) {
+        unsupportedTypeIds.push(typeId);
+        continue;
+      }
+      
+      result.push(...matched);
+    }
+    
+    if (unsupportedTypeIds.length > 0) {
+      throw new Error(`The following resources cannot be imported. No plugins found that support the following types:
+${JSON.stringify(unsupportedTypeIds)}`);
+    }
+
+    return result;
+  }
+
   private static async validate(typeIds: string[], project: Project, pluginManager: PluginManager, dependencyMap: DependencyMap): Promise<void> {
     ctx.subprocessStarted(SubProcessName.VALIDATE)
 
@@ -237,3 +273,4 @@ ${JSON.stringify(unsupportedTypeIds)}`);
     })
   }
 }
+

src/orchestrators/initialize.ts

@@ -16,7 +16,7 @@ export interface InitializeArgs {
 }
 
 export interface InitializationResult {
-  dependencyMap: DependencyMap
+  typeIdsToDependenciesMap: DependencyMap
   pluginManager: PluginManager,
   project: Project,
 }
@@ -37,10 +37,10 @@ export class InitializeOrchestrator {
 
     ctx.subprocessStarted(SubProcessName.INITIALIZE_PLUGINS)
     const pluginManager = new PluginManager();
-    const dependencyMap = await pluginManager.initialize(project, args.secure);
+    const typeIdsToDependenciesMap = await pluginManager.initialize(project, args.secure);
     ctx.subprocessFinished(SubProcessName.INITIALIZE_PLUGINS)
 
-    return { dependencyMap, pluginManager, project };
+    return { typeIdsToDependenciesMap, pluginManager, project };
   }
 
   private static async parse(

src/orchestrators/plan.ts

@@ -21,14 +21,14 @@ export class PlanOrchestrator {
   static async run(args: PlanArgs, reporter: Reporter): Promise<PlanOrchestratorResponse> {
     ctx.processStarted(ProcessName.PLAN)
 
-    const { dependencyMap, pluginManager, project } = await InitializeOrchestrator.run({
+    const { typeIdsToDependenciesMap, pluginManager, project } = await InitializeOrchestrator.run({
       ...args,
     }, reporter);
 
     await createStartupShellScriptsIfNotExists();
 
-    await PlanOrchestrator.validate(project, pluginManager, dependencyMap)
-    project.resolveDependenciesAndCalculateEvalOrder(dependencyMap);
+    await PlanOrchestrator.validate(project, pluginManager, typeIdsToDependenciesMap)
+    project.resolveDependenciesAndCalculateEvalOrder(typeIdsToDependenciesMap);
     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/plugins/plugin-manager.ts

@@ -54,25 +54,11 @@ export class PluginManager {
     );
   }
 
-  async getResourceInfo(type: string): Promise<GetResourceInfoResponseData> {
-    const pluginName = this.resourceToPluginMapping.get(type);
-    if (!pluginName) {
-      throw new Error(`Unable to find plugin for resource: ${type}`);
-    }
-
-    const plugin = this.plugins.get(pluginName)
-    if (!plugin) {
-      throw new Error(`Unable to find plugin for resource ${type}`);
-    }
-
-    return plugin.getResourceInfo(type);
-  }
-
   async getMultipleResourceInfo(typeIds: string[]): Promise<ResourceInfo[]> {
-    return Promise.all(typeIds.map((type) => this.getResourceInfoV2(type)))
+    return Promise.all(typeIds.map((type) => this.getResourceInfo(type)))
   }
 
-  async getResourceInfoV2(type: string): Promise<ResourceInfo> {
+  async getResourceInfo(type: string): Promise<ResourceInfo> {
     const pluginName = this.resourceToPluginMapping.get(type);
     if (!pluginName) {
       throw new Error(`Unable to find plugin for resource: ${type}`);
@@ -143,41 +129,6 @@ export class PluginManager {
     }
   }
 
-  async getRequiredParameters(
-    typeIds: string[],
-  ): Promise<RequiredParameters> {
-    const allRequiredParameters = new Map<string, RequiredParameter[]>();
-    for (const type of typeIds) {
-      const resourceInfo = await this.getResourceInfo(type);
-
-      const { schema } = resourceInfo;
-      if (!schema) {
-        continue;
-      }
-
-      const requiredParameterNames = resourceInfo.import?.requiredParameters;
-      if (!requiredParameterNames || requiredParameterNames.length === 0) {
-        continue;
-      }
-
-      requiredParameterNames
-        .forEach((name) => {
-          if (!allRequiredParameters.has(type)) {
-            allRequiredParameters.set(type, []);
-          }
-
-          const schemaInfo = (schema.properties as any)[name];
-
-          allRequiredParameters.get(type)!.push({
-            name,
-            type: schemaInfo.type ?? null
-          })
-        });
-    }
-
-    return allRequiredParameters;
-  }
-
   private async resolvePlugins(project: Project | null): Promise<Plugin[]> {
     const pluginDefinitions: Record<string, string> = {
       ...DEFAULT_PLUGINS,

src/utils/wild-card-match.ts

@@ -0,0 +1,54 @@
+// JavaScript program for wild card matching using single traversal. From: https://www.geeksforgeeks.org/wildcard-pattern-matching/
+// O(n) time and O(1) space complexity
+export function wildCardMatch(txt: string, pat: string) {
+  const n = txt.length;
+  const m = pat.length;
+  let i = 0, j = 0, startIndex = -1, match = 0;
+
+  while (i < n) {
+
+    // Characters match or '?' in pattern matches
+    // any character.
+    if (j < m && (pat[j] === '?' || pat[j] === txt[i])) {
+      i++;
+      j++;
+    }
+
+    else if (j < m && pat[j] === '*') {
+
+      // Wildcard character '*', mark the current
+      // position in the pattern and the text as a
+      // proper match.
+      startIndex = j;
+      match = i;
+      j++;
+    }
+
+    else if (startIndex !== -1) {
+
+      // No match, but a previous wildcard was found.
+      // Backtrack to the last '*' character position
+      // and try for a different match.
+      j = startIndex + 1;
+      match++;
+      i = match;
+    }
+
+    else {
+
+      // If none of the above cases comply, the
+      // pattern does not match.
+      return false;
+    }
+  }
+
+  // Consume any remaining '*' characters in the given
+  // pattern.
+  while (j < m && pat[j] === '*') {
+    j++;
+  }
+
+  // If we have reached the end of both the pattern and
+  // the text, the pattern matches the text.
+  return j === m;
+}

test/orchestrator/initialize/initialize.test.ts

@@ -64,7 +64,7 @@ describe('Parser integration tests', () => {
     const cwdSpy = vi.spyOn(process, 'cwd');
     cwdSpy.mockReturnValue(folder);
 
-    const { project, pluginManager, dependencyMap } = await InitializeOrchestrator.run({}, reporter);
+    const { project, pluginManager, typeIdsToDependenciesMap } = await InitializeOrchestrator.run({}, reporter);
 
     console.log(project);
     expect(project).toMatchObject({
@@ -106,7 +106,7 @@ describe('Parser integration tests', () => {
     const cwdSpy = vi.spyOn(process, 'cwd');
     cwdSpy.mockReturnValue(innerFolder);
 
-    const { project, pluginManager, dependencyMap } = await InitializeOrchestrator.run({}, reporter);
+    const { project, pluginManager, typeIdsToDependenciesMap } = await InitializeOrchestrator.run({}, reporter);
 
     console.log(project);
     expect(project).toMatchObject({