feat: Refactored resolver layout and logic

Author: kevinwang5658

src/api/dashboard/index.ts

@@ -1,10 +1,10 @@
 import { config } from '../../config.js';
 import { LoginHelper } from '../../connect/login-helper.js';
-import { CloudDocument } from './types.js';
+import { RemoteDocument } from './types.js';
 import { UnauthorizedError } from '../../common/errors.js';
 
 export const DashboardApiClient = {
-  async getDocument(id: string): Promise<CloudDocument> {
+  async getDocument(id: string): Promise<RemoteDocument> {
     const login = LoginHelper.get()?.credentials;
     if (!login) {
       throw new Error('Not logged in');

src/api/dashboard/types.ts

@@ -1,6 +1,6 @@
 import { Config } from 'codify-schemas';
 
-export interface CloudDocument {
+export interface RemoteDocument {
   id: string;
   contents: Array<Config>
 }

src/common/initialize-plugins.ts

@@ -80,10 +80,10 @@ export class PluginInitOrchestrator {
    * Order:
    * 1. If path is specified, return that.
    * 2. If path is a dir with only one *codify.json|*codify.jsonc|*codify.json5|*codify.yaml, return that.
-   * 3. If path is a UUID, return file from Codify cloud.
+   * 3. If path is a UUID, return file from Codify remote.
    * 4. If multiple exists in the path (dir), then prompt the user to select one.
    * 5. If no path is provided, run steps 2 - 4 for the current dir.
-   * 6. If none exists, return default file from codify cloud.
+   * 6. If none exists, return default file from codify remote.
    * 7. If user is not logged in, return an error.
    *
    * Order:

src/orchestrators/import.ts

@@ -271,7 +271,7 @@ export class ImportOrchestrator {
     await sleep(100);
   }
 
-  // Special handling for codify cloud files. Import and refresh can automatically save file updates.
+  // Special handling for codify remote files. Import and refresh can automatically save file updates.
   static async handleCodifyRemoteFiles(reporter: Reporter, importResult: ImportResult) {
     try {
       if (!importResult.result.some((r) => r.type === 'remote-file')) {
@@ -330,7 +330,7 @@ export class ImportOrchestrator {
         await ApiClient.updateRemoteFile(file.parameters.remote as string, new Blob([content]), credentials);
       }
 
-      ctx.log('Successfully uploaded changes to Codify cloud');
+      ctx.log('Successfully uploaded changes to Codify remote');
     } catch {
       console.warn('Unable to process remote-files');
     }

src/parser/entities.ts

@@ -2,8 +2,11 @@ import { Config } from 'codify-schemas';
 import { SourceMapCache } from './source-maps.js';
 
 export interface InMemoryFile {
+  // The contents of the file
   contents: string;
+  // Path to the specific file
   path: string;
+  // The file type (json, yaml, json5, jsonc, remote)
   fileType: FileType;
 }
 
@@ -21,5 +24,5 @@ export enum FileType {
   YAML = 'yaml',
   JSON5 = 'json5',
   JSONC = 'jsonc',
-  REMOTE = 'remote',
+  REMOTE = 'remote', // Remote files are always JSONC for now.
 }

src/parser/errors.ts

@@ -1,8 +1,19 @@
+import { ResolverResult } from './resolvers.js';
+
 export class MultipleFilesError extends Error {
-  files: string[]
+  result: ResolverResult
 
-  constructor(files: string[]) {
-    super(`Multiple matching Codify files found:\n${files.join('\n')}`);
-    this.files = files;
+  constructor(result: ResolverResult) {
+    super(`Multiple matching Codify files found:\n${result.files.join('\n')}`);
+    this.result = result;
   }
 }
+
+export class NoCodifyFileError extends Error {
+  result: ResolverResult
+  
+  constructor(result: ResolverResult) {
+    super(`No Codify file found at ${result.location}`);
+    this.result = result;
+  }
+}

src/parser/index.ts

@@ -1,24 +1,18 @@
 import { Config } from 'codify-schemas';
-import * as fs from 'node:fs/promises';
-import path from 'node:path';
-import { validate } from 'uuid'
 
 import { InternalError } from '../common/errors.js';
 import { ConfigBlock } from '../entities/config.js';
 import { Project } from '../entities/project.js';
-import { FileUtils } from '../utils/file.js';
-import { CloudParser } from './cloud/cloud-parser.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 { CloudReader } from './reader/cloud-reader.js';
-import { FileReader } from './reader/file-reader.js';
+import { RemoteParser } from './remote/remote-parser.js';
+import { CodifyResolver, ResolverResult, ResolverType } from './resolvers.js';
 import { SourceMapCache } from './source-maps.js';
 import { YamlParser } from './yaml/yaml-parser.js';
-import { MultipleFilesError } from './errors.js';
-import { CodifyResolver, ResolverType } from './resolvers.js';
 
 export const CODIFY_FILE_REGEX = /^(.*)?codify(.*)?(.json|.yaml|.json5|.jsonc)$/;
 
@@ -28,11 +22,17 @@ export interface ParserArgs {
   path?: string;
   transformProject?: (project: Project) => Project | Promise<Project>;
   rawConfigs?: Config[]; // Raw configs are provided directly
+  resolverType?: ResolverType;
 }
 
-interface FilePointer {
-  location: string;
-  type: FileType;
+interface ParseResult {
+  configs: ParsedConfig[];
+  file: InMemoryFile;
+}
+
+interface ConfigResult {
+  configs: ConfigBlock[];
+  file: InMemoryFile;
 }
 
 class Parser {
@@ -41,7 +41,7 @@ class Parser {
     [FileType.YAML]: new YamlParser(),
     [FileType.JSON5]: new Json5Parser(),
     [FileType.JSONC]: new JsoncParser(),
-    [FileType.REMOTE]: new CloudParser(),
+    [FileType.REMOTE]: new RemoteParser(),
   }
 
   /**
@@ -57,16 +57,15 @@ class Parser {
    * @param location
    * @param args
    */
-  async parse(location: string, args?: ParserArgs): Promise<Project> {
+  async parse(location: string, args?: ParserArgs, isLoggedIn = false): Promise<Project> {
     const sourceMaps = new SourceMapCache()
 
-    const configs = this.resolveFiles(args)
-      .then((result) => this.throwIfMultipleFiles(result))
-      .then((path) => this.readFiles(codifyFiles))
+    const { configs, file } = await this.resolveFiles(location, args, isLoggedIn)
+      .then((result) => this.validateResolver(result))
       .then((files) => this.parseContents(files, sourceMaps))
       .then((config) => this.createConfigBlocks(config, sourceMaps))
 
-    return Project.create(configs, codifyFiles[0], sourceMaps);
+    return Project.create(configs, file.path, sourceMaps);
   }
 
   async parseJson(configs: Config[]): Promise<Project> {
@@ -77,83 +76,51 @@ class Parser {
       sourceMaps
     )
 
-    return Project.create(configBlocks, undefined, sourceMaps);
+    return Project.create(configBlocks.configs, undefined, sourceMaps);
   }
 
-  private async getFilePaths(dirOrFile: string): Promise<string[]> {
-    // A cloud file is represented as an uuid. Skip file checks if it's a cloud file;
-    if (validate(dirOrFile)) {
-      return [dirOrFile];
+  private async resolveFiles(location: string, args?: ParserArgs, isLoggedIn = false): Promise<ResolverResult> {
+    if (args?.resolverType) {
+      return CodifyResolver.runResolver(location, args.resolverType);
     }
 
-    const absolutePath = path.resolve(dirOrFile);
-    const isDirectory = (await fs.lstat(absolutePath)).isDirectory();
-
-    // A single file was passed in. We need to test if the file satisfies the codify file regex
-    if (!isDirectory) {
-      const fileName = path.basename(absolutePath);
-      if (!CODIFY_FILE_REGEX.test(fileName)) {
-        throw new Error(`Invalid file path provided ${absolutePath} ${fileName}. Expected the file to be *.codify.jsonc, *.codify.json5, *.codify.json, or *.codify.yaml `)
-      }
-
-      return [absolutePath];
+   if (args?.path) {
+      return CodifyResolver.resolveLocal(args?.path)
     }
 
-    const filesInDir = await fs.readdir(absolutePath);
-
-    return filesInDir
-      .filter((name) => CODIFY_FILE_REGEX.test(name))
-      .map((name) => path.join(absolutePath, name))
-  }
-
-  private async resolveFiles(location: string, args?: ParserArgs, isLoggedIn = false): Promise<string[]> {
-    return CodifyResolver.runUntilResolves(location, [
-      (args?.path) ? ResolverType.EXPLICIT_PATH : null,
-      ResolverType.FILE_OR_DIRECTORY,
+   return CodifyResolver.run(location, [
+      ResolverType.LOCAL,
       (isLoggedIn) ? ResolverType.REMOTE_DOCUMENT_ID : null,
-      (isLoggedIn) ? ResolverType.REMOTE_FILE : null,
-      ResolverType.TEMPLATE,
+      (isLoggedIn) ? ResolverType.REMOTE_DOCUMENT : null,
+      (args?.allowTemplates) ? ResolverType.TEMPLATE : null,
     ]);
-
   }
 
-  private async throwIfMultipleFiles(result: string[]): Promise<string> {
-    if (result.length > 1) {
-      throw new MultipleFilesError(result);
+  private async validateResolver(result: ResolverResult): Promise<InMemoryFile> {
+    if (result.files.length === 0) {
+      throw new NoCodifyFileError(result);
     }
 
-    return result[0];
-  }
-
-  private readFiles(filePaths: string[]): Promise<InMemoryFile[]> {
-    const cloudReader = new CloudReader();
-    const fileReader = new FileReader();
-
-    return Promise.all(filePaths.map(
-      async (p) => {
-        // If path is a uuid and doesn't exist as a file, it's a cloud file
-        if (validate(p) && !(await FileUtils.fileExists(p))) {
-          return cloudReader.read(p)
-        }
+   if (result.files.length > 1) {
+      throw new MultipleFilesError(result);
+    }
 
-        return fileReader.read(p)
-      }
-    ))
+    return result.files[0];
   }
 
-  private parseContents(files: InMemoryFile[], sourceMaps: SourceMapCache): ParsedConfig[] {
-    return files.flatMap((file) => {
-      const parser = this.languageSpecificParsers[file.fileType];
-      if (!parser) {
-        throw new InternalError(`Unable to find a language specific parser for type ${file.fileType} for file ${file.path}`)
-      }
+  private parseContents(file: InMemoryFile, sourceMaps: SourceMapCache): ParseResult {
+    const parser = this.languageSpecificParsers[file.fileType];
+    if (!parser) {
+      throw new InternalError(`Unable to find a language specific parser for type ${file.fileType} for file ${file.path}`)
+    }
 
-      return parser.parse(file, sourceMaps);
-    });
+    const configs = parser.parse(file, sourceMaps);
+    return { configs, file };
   }
 
-  private createConfigBlocks(parsedConfig: ParsedConfig[], sourceMaps: SourceMapCache): ConfigBlock[] {
-    return parsedConfig.map((config) => ConfigFactory.create(config, sourceMaps))
+  private createConfigBlocks(parseResult: ParseResult, sourceMaps: SourceMapCache): ConfigResult {
+    const configs = parseResult.configs.map((config) => ConfigFactory.create(config, sourceMaps));
+    return { configs, file: parseResult.file };
   }
 }
 

src/parser/reader/file-reader.ts src/parser/readers/file-reader.tssrc/parser/reader/file-reader.ts renamed to src/parser/readers/file-reader.ts

@@ -0,0 +1,16 @@
+import { DashboardApiClient } from '../../api/dashboard/index.js';
+import { FileType, InMemoryFile } from '../entities.js';
+import { Reader } from './index.js';
+
+export class RemoteDocumentIdReader implements Reader {
+  async read(filePath: string): Promise<InMemoryFile> {
+    const document = await DashboardApiClient.getDocument(filePath);
+
+    return {
+      contents: JSON.stringify(document.contents),
+      path: filePath,
+      fileType: FileType.REMOTE,
+    }
+  }
+
+}