Add plugin entity + plugin initialization

kevinwang5658 · kevinwang5658 · commit 52bbf7b3687d · 2023-10-29T16:03:52.000-04:00
diff --git a/codify-core/src/commands/plan/orchestrator.ts b/codify-core/src/commands/plan/orchestrator.ts
@@ -1,9 +1,13 @@
 import { ConfigCompiler } from '../../config-compiler';
+import { PluginsManager } from '../../plugins/manager';
 
 export const PlanOrchestrator = {
   async run(rootDirectory: string): Promise<void> {
-    const loadedProject = await ConfigCompiler.compileProject(rootDirectory);
+    const project = await ConfigCompiler.parseProject(rootDirectory);
+
+    const pluginsManager = new PluginsManager();
+    await pluginsManager.initializePlugins(project);
+
 
-    console.log(JSON.stringify(loadedProject, null, 2));
   },
 };
diff --git a/codify-core/src/config-compiler/index.ts b/codify-core/src/config-compiler/index.ts
@@ -1,8 +1,9 @@
 import { InternalError } from '../utils/errors';
+import { ConfigBlockType } from './language-definition';
 import { ConfigLoader } from './loader';
-import { LoadedProject } from './loader/entities/project';
 import { FileParser } from './parser';
-import { ConfigBlockType, ParsedModule, ParsedProject } from './parser/entities';
+import { ParsedModule, ParsedProject } from './parser/entities';
+import { ProjectConfig } from './parser/entities/project';
 import { JsonFileParser } from './parser/json/file-parser';
 
 
@@ -12,30 +13,30 @@ export class ConfigCompiler {
     'json': new JsonFileParser(),
   }
 
-  static async compileProject(directory: string): Promise<ParsedProject> {
-    const loadedProject = await ConfigCompiler.load(directory);
-    return ConfigCompiler.parse(loadedProject);
-  }
-
-  private static load(directory: string): Promise<LoadedProject> {
-    return new ConfigLoader().loadProject(directory);
-  }
+  static async parseProject(directory: string): Promise<ParsedProject> {
+    const loadedProject = await (new ConfigLoader().loadProject(directory));
 
-  private static async parse(loadedProject: LoadedProject): Promise<ParsedProject> {
-    const configBlocks = await Promise.all(loadedProject.coreModule.files.map((file) => {
+    const configBlocksResult = await Promise.all(loadedProject.coreModule.files.map((file) => {
       const parser = ConfigCompiler.supportedParsers[file.fileType];
       if (!parser) {
         throw new InternalError(`Unsupported file format loaded into parser: ${file.fileName}`);
       }
 
       return parser.parse(file);
     }));
+    const configBlocks = configBlocksResult.flat(1);
+
+    const parsedProjectConfigs = configBlocks.filter((u) => u.configType === ConfigBlockType.PROJECT);
+    if (parsedProjectConfigs.length !== 1) {
+      throw new Error('One one project config can be specified');
+    }
 
+    const projectConfig = parsedProjectConfigs[0] as ProjectConfig;
     return new ParsedProject({
       coreModule: new ParsedModule({
         configBlocks: configBlocks.flat(1),
       }),
-      projectConfig: configBlocks.flat(1).find((u) => u.configType === ConfigBlockType.PROJECT)!,
+      projectConfig,
     })
   }
 }
diff --git a/codify-core/src/config-compiler/language-definition.ts b/codify-core/src/config-compiler/language-definition.ts
@@ -0,0 +1,14 @@
+export enum ConfigBlockType {
+  PLUGIN = 'plugin',
+  PROJECT = 'project',
+  RESOURCE = 'resource',
+}
+
+export enum ResourceParameterType {
+  ARRAY = 'array',
+  BOOLEAN = 'boolean',
+  NULL = 'null',
+  NUMBER = 'number',
+  OBJECT = 'object',
+  STRING = 'string',
+}
diff --git a/codify-core/src/config-compiler/parser/entities/index.ts b/codify-core/src/config-compiler/parser/entities/index.ts
@@ -1,12 +1,7 @@
 import { RemoveMethods } from '../../../utils/types';
+import { ConfigBlockType } from '../../language-definition';
 import { ProjectConfig } from './project';
 
-export enum ConfigBlockType {
-  PLUGIN = 'plugin',
-  PROJECT = 'project',
-  RESOURCE = 'resource',
-}
-
 export interface ConfigBlock {
   configType: ConfigBlockType;
 
diff --git a/codify-core/src/config-compiler/parser/entities/plugin.ts b/codify-core/src/config-compiler/parser/entities/plugin.ts
@@ -1,5 +1,6 @@
 import { RemoveMethods } from '../../../utils/types'
-import { ConfigBlock, ConfigBlockType } from './index';
+import { ConfigBlockType } from '../../language-definition';
+import { ConfigBlock } from './index';
 
 export class PluginConfig implements ConfigBlock {
   configType = ConfigBlockType.PLUGIN;
diff --git a/codify-core/src/config-compiler/parser/entities/project.ts b/codify-core/src/config-compiler/parser/entities/project.ts
@@ -9,7 +9,8 @@ import {
   validateTypeString,
   validateUrl
 } from '../../../utils/validator';
-import { ConfigBlock, ConfigBlockType } from './index';
+import { ConfigBlockType } from '../../language-definition';
+import { ConfigBlock } from './index';
 
 /** Project JSON supported format
  * {
diff --git a/codify-core/src/config-compiler/parser/entities/resource.ts b/codify-core/src/config-compiler/parser/entities/resource.ts
@@ -1,6 +1,7 @@
 import { RemoveMethods } from '../../../utils/types';
 import { validateNameString, validateStringEq, validateTypeRecordStringUnknown, } from '../../../utils/validator';
-import { ConfigBlock, ConfigBlockType } from './index';
+import { ConfigBlockType } from '../../language-definition';
+import { ConfigBlock } from './index';
 
 /** Resource JSON supported format
  * {
diff --git a/codify-core/src/config-compiler/parser/json/config-block-factory.ts b/codify-core/src/config-compiler/parser/json/config-block-factory.ts
@@ -1,5 +1,6 @@
 import { InvalidResourceError, SyntaxError } from '../../../utils/errors';
-import { ConfigBlock, ConfigBlockType } from '../entities';
+import { ConfigBlockType } from '../../language-definition';
+import { ConfigBlock } from '../entities';
 import { PluginConfig } from '../entities/plugin';
 import { ProjectConfig } from '../entities/project';
 import { ResourceConfig } from '../entities/resource';
diff --git a/codify-core/src/entities/resource-definition.ts b/codify-core/src/entities/resource-definition.ts
@@ -1,12 +1,64 @@
 import { RemoveMethods } from '../utils/types';
-import { ResourceParameter } from './resource-parameter';
+import { validateAllowedObjectKeys, validateNameString, validateTypeRecordStringUnknown, } from '../utils/validator';
+import { ResourceParameterDefinition } from './resource-parameter';
+
+type Name = string;
+
+/**
+ * Example json def:
+ * {
+ *   "name": "plugin_name_resource_one"
+ *   "parameters: {
+ *     "parameter1": {
+ *       "type": "number",
+ *       "minNumberValue": 0,
+ *     }
+ *     "parameter2": "string",
+ *   }
+ * }
+ */
 
 export class ResourceDefinition {
-  typeId!: string;
-  parameters!: ResourceParameter[];
+  name!: string;
+  parameters!: Map<Name, ResourceParameterDefinition>;
 
   constructor(props: RemoveMethods<ResourceDefinition>) {
     Object.assign(this, props);
   }
 
+  static fromJson(json: unknown): ResourceDefinition {
+    if (this.validateDefinition(json)) {
+      const entries = Object.entries(json.parameters).map(([name, value]) => {
+        const resourceParameterDefinition = ResourceParameterDefinition.fromJson(name, value);
+
+        return [name, resourceParameterDefinition] as const;
+      })
+
+      const parametersMap = new Map(entries);
+      return new ResourceDefinition({ name: json.name, parameters: parametersMap })
+    }
+
+    throw new Error('Unable to parse resource definition');
+  }
+
+  private static validateDefinition(json: unknown): json is { name: string; parameters: Record<string, unknown> } {
+    if (!validateTypeRecordStringUnknown(json)) {
+      return false;
+    }
+
+    if (!validateAllowedObjectKeys(json, ['name', 'parameters'])) {
+      return false;
+    }
+
+    if (!validateNameString(json.name)) {
+      return false;
+    }
+
+    if (!validateTypeRecordStringUnknown(json.parameters)) {
+      return false;
+    }
+
+    return true;
+  }
+
 }
diff --git a/codify-core/src/entities/resource-node.ts b/codify-core/src/entities/resource-node.ts
@@ -1,12 +1,12 @@
 import { RemoveMethods } from '../utils/types';
 import { Node } from './node';
-import { ResourceParameter } from './resource-parameter';
+import { ResourceParameterDefinition } from './resource-parameter';
 
 export class ResourceNode implements Node {
   type!: string;
   name!: string;
   metadata?: Record<string, unknown>;
-  parameters!: ResourceParameter[];
+  parameters!: ResourceParameterDefinition[];
   dependencies!: Node[];
 
   constructor(props: RemoveMethods<ResourceNode>) {
diff --git a/codify-core/src/entities/resource-parameter.ts b/codify-core/src/entities/resource-parameter.ts
@@ -1,3 +1,73 @@
-export interface ResourceParameter {
-  name: string;
+import { ResourceParameterType } from '../config-compiler/language-definition';
+import { RemoveMethods } from '../utils/types';
+import {
+  validateAllowedObjectKeys,
+  validateTypeNumber,
+  validateTypeRecordStringString,
+  validateTypeResourceParameterType
+} from '../utils/validator';
+
+type ResourceParameter = [] | boolean | null | number | object | string
+
+/**
+ * Resource parameter defintiion can be either a resource parameter type or an object with additional definitions.
+ * Ex.
+ * "version": "number"
+ * OR
+ * "version": {
+ *   "type": "number",
+ *   "minNumberValue": 10
+ * }
+ */
+
+export class ResourceParameterDefinition {
+  name!: string;
+  type!: ResourceParameterType
+  allowedValues?: ResourceParameter | ResourceParameter[];
+  minNumberValue?: number;
+  maxNumberValue?: number;
+
+  constructor(props: RemoveMethods<ResourceParameterDefinition>) {
+    Object.assign(this, props);
+  }
+
+  static fromJson(name: string, value: unknown): ResourceParameterDefinition {
+    if (this.validateTypeOnlyDefinition(value)) {
+      return new ResourceParameterDefinition({ name, type: value });
+    }
+
+    if (this.validateObjectDefinition(value)) {
+      return new ResourceParameterDefinition({ ...value, name });
+    }
+
+    throw new Error('Unable to parse resource definition');
+  }
+
+  private static validateTypeOnlyDefinition(value: unknown): value is ResourceParameterType {
+    return validateTypeResourceParameterType(value);
+  }
+
+  private static validateObjectDefinition(value: unknown): value is RemoveMethods<ResourceParameterDefinition> {
+    if (!validateTypeRecordStringString(value)) {
+      return false;
+    }
+
+    if (!validateAllowedObjectKeys(value, ['name', 'type', 'allowedValues', 'minNumberValue', 'maxNumberValue'])) {
+      return false;
+    }
+
+    if (!validateTypeResourceParameterType(value.type)) {
+      return false;
+    }
+
+    if (value.minNumberValue && !validateTypeNumber(value.minNumberValue)) {
+      return false;
+    }
+
+    if (value.maxNumberValue && validateTypeNumber(value.maxNumberValue)) {
+      return false;
+    }
+
+    return true;
+  }
 }
diff --git a/codify-core/src/plugins/entities/plugin.ts b/codify-core/src/plugins/entities/plugin.ts
@@ -0,0 +1,45 @@
+import type { ChildProcess } from 'node:child_process';
+
+import { ResourceDefinition } from '../../entities/resource-definition';
+import { validateTypeArray, validateTypeRecordStringUnknown } from '../../utils/validator';
+
+type ResourceName = string;
+
+export class Plugin {
+  name: string;
+  directory: string;
+
+  process: ChildProcess;
+  resourceDefinitions?: Map<ResourceName, ResourceDefinition>;
+
+  constructor(name: string, directory: string, process: ChildProcess) {
+    this.name = name;
+    this.directory = directory;
+    this.process = process;
+  }
+
+  setResourceDefinitions(definitions: unknown): void {
+    if (this.validate(definitions)) {
+      const entries = definitions.map((u) => {
+        const resourceDefinition = ResourceDefinition.fromJson(u);
+        return [resourceDefinition.name, resourceDefinition] as const;
+      })
+
+      this.resourceDefinitions = new Map(entries);
+    }
+
+    throw new Error('Unable to parse resource definition');
+  }
+
+  private validate(definitions: unknown): definitions is Array<Record<string, unknown>> {
+    if (!validateTypeArray(definitions)) {
+      return false;
+    }
+
+    if (!definitions.every((u) => validateTypeRecordStringUnknown(u))) {
+      return false;
+    }
+
+    return true;
+  }
+}
diff --git a/codify-core/src/plugins/ipc-bridge.ts b/codify-core/src/plugins/ipc-bridge.ts
@@ -1,7 +1,36 @@
-export const PluginIpcBridge = new class {
-  
-  async sendMessage(_msg: unknown): Promise<void> {
+import * as ChildProcess from 'node:child_process';
 
+import { config } from '../project-configs';
+import { Plugin } from './entities/plugin';
+
+export class PluginIpcBridge {
+
+  static async initializePlugin(directory: string, name: string): Promise<Plugin> {
+    const childProcess = ChildProcess.fork(location + config.defaultPluginEntryPoint);
+    const plugin = new Plugin(directory, name, childProcess);
+    await this.initializeResourceDefinitions(plugin);
+
+    return plugin;
+  }
+
+  static async initializeResourceDefinitions(plugin: Plugin): Promise<void> {
+    const resourceDefinitions = await this.sendMessageForResult(plugin, 'getResourceDefinitions');
+    plugin.setResourceDefinitions(resourceDefinitions);
+  }
+
+  private static async sendMessageForResult(plugin: Plugin, rpcFunctionName: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      setTimeout(() => reject(new Error(`Plugin did respond in 10s to call: ${rpcFunctionName}`)), 10_000);
+      plugin.process.on(this.getResultFunctionName(rpcFunctionName), (message) => {
+        resolve(message);
+      });
+
+      plugin.process.send(rpcFunctionName);
+    });
+  }
+
+  private static getResultFunctionName(rpcFunctionName: string): string {
+    return rpcFunctionName + 'Result';
   }
 
-};
+}
diff --git a/codify-core/src/plugins/manager.ts b/codify-core/src/plugins/manager.ts
diff --git a/codify-core/src/plugins/resolver.ts b/codify-core/src/plugins/resolver.ts
diff --git a/codify-core/src/project-configs/index.ts b/codify-core/src/project-configs/index.ts
diff --git a/codify-core/src/utils/validator.ts b/codify-core/src/utils/validator.ts
