feat: Refactored resolver to be completely separate from the parser

Author: kevinwang5658

package-lock.json

@@ -11,6 +11,7 @@ import { CODIFY_FILE_REGEX, CodifyParser } from '../parser/index.js';
 import { PluginManager, ResourceDefinitionMap } from '../plugins/plugin-manager.js';
 import { Reporter } from '../ui/reporters/reporter.js';
 import { FileUtils } from '../utils/file.js';
+import { CodifyResolver } from '../resolver/index.js';
 
 export interface InitializeArgs {
   path?: string;
@@ -60,11 +61,18 @@ export class PluginInitOrchestrator {
       return CodifyParser.parseJson(args.codifyConfigs);
     }
 
-    const codifyPath = await PluginInitOrchestrator.resolveCodify(args, reporter);
+    ctx.subprocessStarted(SubProcessName.RESOLVE);
+
+    const codifyFile = await CodifyResolver.resolveFile(args.path ?? process.cwd(), {
+      allowTemplates: args.allowTemplates,
+      reporter,
+    });
+
+    ctx.subprocessFinished(SubProcessName.RESOLVE);
     ctx.subprocessStarted(SubProcessName.PARSE);
 
-    const project = codifyPath
-      ? await CodifyParser.parse(codifyPath)
+    const project = codifyFile
+      ? await CodifyParser.parse(codifyFile)
       : Project.empty()
 
     ctx.subprocessFinished(SubProcessName.PARSE);

src/common/initialize-plugins.ts

@@ -14,4 +14,6 @@ export const config = {
   supabaseUrl: 'https://kdctbvqvqjfquplxhqrm.supabase.co',
 
   isBeta: VERSION.includes('beta'),
+
+  fileRegex: /^(.*)?codify(.*)?(.json|.yaml|.json5|.jsonc)$/,
 }

src/config.ts

@@ -35,6 +35,7 @@ export enum SubProcessName {
   APPLYING_RESOURCE = 'apply_resource',
   GENERATE_PLAN = 'generate_plan',
   INITIALIZE_PLUGINS = 'initialize_plugins',
+  RESOLVE = 'resolve',
   PARSE = 'parse',
   CREATE_ROOT_FILE = 'create_root_file',
   VALIDATE = 'validate',

src/events/context.ts

@@ -5,16 +5,14 @@ import { ConfigBlock } from '../entities/config.js';
 import { Project } from '../entities/project.js';
 import { ConfigFactory } from './config-factory.js';
 import { FileType, InMemoryFile, ParsedConfig } from './entities.js';
-import { MultipleFilesError, NoCodifyFileError } from './errors.js';
 import { JsonParser } from './json/json-parser.js';
 import { Json5Parser } from './json5/json-parser.js';
 import { JsoncParser } from './jsonc/json-parser.js';
 import { RemoteParser } from './remote/remote-parser.js';
-import { CodifyResolver, ResolverResult, ResolverType } from './resolvers.js';
+import { ResolverType } from './resolvers.js';
 import { SourceMapCache } from './source-maps.js';
 import { YamlParser } from './yaml/yaml-parser.js';
 
-export const CODIFY_FILE_REGEX = /^(.*)?codify(.*)?(.json|.yaml|.json5|.jsonc)$/;
 
 export interface ParserArgs {
   allowEmptyProject?: boolean;
@@ -57,12 +55,10 @@ class Parser {
    * @param location
    * @param args
    */
-  async parse(location: string, args?: ParserArgs, isLoggedIn = false): Promise<Project> {
+  async parse(file: InMemoryFile, args?: ParserArgs): Promise<Project> {
     const sourceMaps = new SourceMapCache()
 
-    const { configs, file } = await this.resolveFiles(location, args, isLoggedIn)
-      .then((result) => this.validateResolver(result))
-      .then((files) => this.parseContents(files, sourceMaps))
+    const { configs } = await Promise.resolve(this.parseContents(file, sourceMaps))
       .then((config) => this.createConfigBlocks(config, sourceMaps))
 
     return Project.create(configs, file.path, sourceMaps);
@@ -79,35 +75,6 @@ class Parser {
     return Project.create(configBlocks.configs, undefined, sourceMaps);
   }
 
-  private async resolveFiles(location: string, args?: ParserArgs, isLoggedIn = false): Promise<ResolverResult> {
-    if (args?.resolverType) {
-      return CodifyResolver.runResolver(location, args.resolverType);
-    }
-
-   if (args?.path) {
-      return CodifyResolver.resolveLocal(args?.path)
-    }
-
-   return CodifyResolver.run(location, [
-      ResolverType.LOCAL,
-      (isLoggedIn) ? ResolverType.REMOTE_DOCUMENT_ID : null,
-      (isLoggedIn) ? ResolverType.REMOTE_DOCUMENT : null,
-      (args?.allowTemplates) ? ResolverType.TEMPLATE : null,
-    ]);
-  }
-
-  private async validateResolver(result: ResolverResult): Promise<InMemoryFile> {
-    if (result.files.length === 0) {
-      throw new NoCodifyFileError(result);
-    }
-
-   if (result.files.length > 1) {
-      throw new MultipleFilesError(result);
-    }
-
-    return result.files[0];
-  }
-
   private parseContents(file: InMemoryFile, sourceMaps: SourceMapCache): ParseResult {
     const parser = this.languageSpecificParsers[file.fileType];
     if (!parser) {

src/parser/index.ts

@@ -0,0 +1,88 @@
+import { LoginHelper } from '../connect/login-helper.js';
+import { InMemoryFile } from '../parser/entities.js';
+import { Reporter } from '../ui/reporters/reporter.js';
+import { MultipleFilesError, NoCodifyFileError } from './errors.js';
+import { CodifyResolverRunner, ResolverResult } from './runners.js';
+
+export enum ResolverType {
+  LOCAL = 'LOCAL',
+  REMOTE_DOCUMENT_ID = 'REMOTE_DOCUMENT_ID',
+  REMOTE_DOCUMENT = 'REMOTE_DOCUMENT',
+  TEMPLATE = 'TEMPLATE',
+  REMOTE_DEFAULT_DOCUMENT = 'REMOTE_DEFAULT_DOCUMENT',
+}
+
+interface ResolverArgs {
+  resolverType?: ResolverType;
+  path?: string;
+  allowTemplates?: boolean;
+  reporter?: Reporter;
+}
+
+/**
+ * Resolver for resolving and getting the contents of files based on a location. It operated in a fall through manner,
+ * where it tries different resolvers until it finds a match (starting with the LOCAL resolver).
+ */
+export class CodifyResolver {
+  
+  /**
+   * Order:
+   * 1. If a path is provided, parse it and look for the location within the path
+   * 3. If it is a path (relative or absolute) then search for that directory or file
+   * 4. If the path is an uuid (try to match it with a UUID) on the user's account (if they are logged in)
+   * 5. Attempt to search for the name on the user's account (if they are logged in)
+   * 6. Attempt to resolve to a public template (if allowTemplate is enabled)
+   * Error out and tell the user that the following file could not be found
+   *
+   *
+   * @param location
+   * @param args
+   */
+  static async resolveFile(location: string, args?: ResolverArgs): Promise<InMemoryFile> {
+    return CodifyResolver.run(location, args)
+      .then((result) => this.narrow(result))
+  }
+  
+  private static async run(location: string, args?: ResolverArgs): Promise<ResolverResult> {
+    if (args?.resolverType) {
+      return CodifyResolverRunner.runResolver(location, args.resolverType);
+    }
+
+    if (args?.path) {
+      return CodifyResolverRunner.resolveLocal(args?.path)
+    }
+    
+    const isLoggedIn = LoginHelper.get()?.isLoggedIn;
+
+    return CodifyResolverRunner.run(location, [
+      ResolverType.LOCAL,
+      (isLoggedIn) ? ResolverType.REMOTE_DOCUMENT_ID : null,
+      (isLoggedIn) ? ResolverType.REMOTE_DOCUMENT : null,
+      (args?.allowTemplates) ? ResolverType.TEMPLATE : null,
+      (isLoggedIn) ? ResolverType.REMOTE_DEFAULT_DOCUMENT : null,
+    ]);
+  }
+
+  private static async narrow(result: ResolverResult, args?: ResolverArgs): Promise<InMemoryFile> {
+    if (result.files.length === 0) {
+      throw new NoCodifyFileError(result);
+    }
+
+    if (result.files.length > 1) {
+      if (!args?.reporter) {
+        throw new MultipleFilesError(result);
+      }
+      
+      const reporter = args?.reporter;
+      const index = await reporter.promptOptions(
+        'Multiple matching Codify files found',
+        result.files.map((file) => result.location + file.path),
+      );
+
+      return result.files[index];
+    }
+
+    return result.files[0];
+  }
+
+}