Added initialization code

Author: kevinwang5658

codify-core/package.json

@@ -8,7 +8,7 @@
     "@oclif/plugin-help": "^5",
     "@oclif/plugin-plugins": "^3.8.4",
     "semver": "^7.5.4",
-    "codify-schemas": "1.0.25",
+    "codify-schemas": "1.0.28",
     "ajv": "^8.12.0"
   },
   "description": "Codify is a set up as code tool for developers",

codify-core/src/commands/plan/orchestrator.ts

@@ -1,12 +1,16 @@
 import { ConfigCompiler } from '../../config-compiler/index.js';
+import { PluginCollection } from '../../plugins/plugin-collection.js';
 
 export const PlanOrchestrator = {
   async run(rootDirectory: string): Promise<string> {
     const parsedProject = await ConfigCompiler.parseProject(rootDirectory);
 
-    // const pluginCollection = await PluginCollection.create(parsedProject);
-    // const definitions = await pluginCollection.getResourceDefinitions();
-    //
+    const pluginCollection = new PluginCollection();
+    const resourceMap = await pluginCollection.initialize(parsedProject);
+
+    parsedProject.validateWithResourceMap(resourceMap);
+
+
     // const compiledProject = await ConfigCompiler.compileProject(parsedProject, definitions);
     // console.log(compiledProject);
     // const plan = await pluginCollection.getPlan(compiledProject);

codify-core/src/config-compiler/parser/entities/index.ts

@@ -1,6 +1,7 @@
 import { ConfigClass } from '../../language-definition.js';
 
 export interface ConfigBlock {
+  type: string;
   configClass: ConfigClass;
 
   validateConfig(config: unknown): never | void;

codify-core/src/config-compiler/parser/entities/parsed-project.ts

@@ -14,4 +14,11 @@ export class ParsedProject {
   getModuleTree(): ParsedModule {
     return this.coreModule;
   }
+
+  validateWithResourceMap(resourceMap: Map<string, string[]>) {
+    const invalidConfigs = this.coreModule.configBlocks.filter((c) => resourceMap.get(c.type));
+    if (invalidConfigs.length > 0) {
+      throw new Error(`Unknown types specified: ${JSON.stringify(invalidConfigs, null, 2)}`);
+    }
+  }
 }

codify-core/src/plugins/entities/plugin.ts

@@ -1,24 +1,36 @@
 import { Applyable } from '../../config-compiler/output-generator/entities/index.js';
 import { PluginIpcBridge } from '../ipc-bridge.js';
-import { PluginData } from './plugin-data.js';
+import { InitializeResponseData, InitializeResponseDataSchema } from 'codify-schemas';
+import { ajv } from '../../utils/ajv.js';
+
+const initializeResponseValidator = ajv.compile(InitializeResponseDataSchema);
 
 export class Plugin {
 
   ipcBridge?: PluginIpcBridge;
 
-  // Separate out data so that the validation logic is testable.
-  data: PluginData;
+  name: string;
+  path: string;
+  resourceDependenciesMap = new Map<string, string[]>()
 
-  constructor(data: PluginData) {
-    this.data = data;
+  constructor(name: string, path: string) {
+    this.name = name;
+    this.path = path;
   }
 
-  async initialize(ipcBridge?: PluginIpcBridge): Promise<unknown> {
-    ipcBridge = ipcBridge ?? await PluginIpcBridge.create(this.data.directory);
-    const resourceList = await ipcBridge.sendMessageForResult({ cmd: 'initialize' });
+  async initialize(ipcBridge?: PluginIpcBridge): Promise<InitializeResponseData> {
+    ipcBridge = ipcBridge ?? await PluginIpcBridge.create(this.path);
+    const initializeResponse = await ipcBridge.sendMessageForResult({ cmd: 'initialize' });
+
+    if (!this.validateInitializeResponse(initializeResponse)) {
+      throw new Error();
+    }
+
+    initializeResponse.resourceDefinitions.forEach((d) => {
+      this.resourceDependenciesMap.set(d.type, d.dependencies)
+    });
 
-    this.data.resourceDefinitions = resourceList as any;
-    return resourceList;
+    return initializeResponse;
   }
 
   async generateResourcePlan(applyable: Applyable): Promise<unknown> {
@@ -28,4 +40,12 @@ export class Plugin {
   destroy() {
     this.ipcBridge!.killPlugin();
   }
+
+  private validateInitializeResponse(response: unknown): response is InitializeResponseData {
+    if (initializeResponseValidator(response)) {
+      throw new Error(`Invalid initialize response from plugin: ${this.name}. Error: ${initializeResponseValidator.errors}`)
+    }
+
+    return true;
+  }
 }

codify-core/src/plugins/ipc-bridge.ts

@@ -1,6 +1,9 @@
 import { ChildProcess, fork } from 'node:child_process';
-import { validateTypeRecordStringUnknown } from '../utils/validator.js';
 import { PluginMessage } from './entities/message.js';
+import { IpcMessage, IpcMessageSchema } from 'codify-schemas';
+import { ajv } from '../utils/ajv.js';
+
+const ipcMessageValidator = ajv.compile(IpcMessageSchema);
 
 type Resolve = (value: unknown) => void;
 type Reject = (reason?: Error) => void;
@@ -65,7 +68,7 @@ class SendMessageForResultHandler {
   messageListener = (incomingMessage: unknown) => {
     console.log(incomingMessage);
 
-    if (!validateTypeRecordStringUnknown(incomingMessage)) {
+    if (!this.validateIpcMessage(incomingMessage)) {
       return this.reject(new Error(`Bad message from plugin. ${JSON.stringify(incomingMessage, null, 2)}`))
     }
 
@@ -97,5 +100,9 @@ class SendMessageForResultHandler {
   private setResultTimeout = () => setTimeout(() => {
     this.reject(new Error(`Plugin did not respond in 10s to call: ${this.messageToSend.cmd}`))
   }, 10_000);
+
+  private validateIpcMessage(response: unknown): response is IpcMessage {
+    return ipcMessageValidator(response);
+  }
 }
 

codify-core/src/plugins/plugin-collection.ts

@@ -0,0 +1,96 @@
+import { CompiledProject } from '../config-compiler/output-generator/entities/compiled-project.js';
+import { ParsedProject } from '../config-compiler/parser/entities/parsed-project.js';
+import { Plugin } from './entities/plugin.js';
+import { PluginResolver } from './resolver.js';
+
+type PluginName = string;
+
+const DEFAULT_PLUGINS = {
+  'default': 'latest',
+  // 'default:node': 'latest',
+}
+
+export class PluginCollection {
+
+  private plugins = new Map<PluginName, Plugin>()
+  private resourceToPluginMapping = new Map<string, string>()
+  private pluginToResourceMapping = new Map<string, string[]>()
+
+  async initialize(project: ParsedProject): Promise<Map<string, string[]>> {
+    const plugins = await this.resolvePlugins(project);
+
+    plugins.forEach((plugin) => {
+      this.plugins.set(plugin.name, plugin)
+    })
+
+    const dependencyMap = await this.initializePlugins(plugins);
+    return dependencyMap;
+  }
+
+  async getPlan(project: CompiledProject): Promise<Array<string>> {
+    const result = new Array<string>();
+    for (const applyable of project.getApplySequence()) {
+      const plugin = this.plugins.get(applyable.pluginName);
+      if (!plugin) {
+        continue;
+      }
+
+      console.log('a');
+
+      // eslint-disable-next-line no-await-in-loop
+      result.push(await plugin.generateResourcePlan(applyable) as string);
+    }
+
+    return result;
+  }
+
+  async destroy(): Promise<void> {
+    for (const plugin of this.plugins.values()) {
+      plugin.destroy();
+    }
+  }
+
+  private async resolvePlugins(project: ParsedProject): Promise<Plugin[]> {
+    const pluginDefinitions: Record<string, string> = {
+      ...DEFAULT_PLUGINS,
+      ...project.projectConfig.plugins,
+    };
+
+    return await Promise.all(Object.entries(pluginDefinitions).map(([name, version]) =>
+      PluginResolver.resolve(name, version)
+    ));
+  }
+
+  private async initializePlugins(plugins: Plugin[]): Promise<Map<string, string[]>> {
+    const responses = await Promise.all(
+      plugins.map(async (p) => [p.name, (await p.initialize()).resourceDefinitions] as const)
+    );
+
+    const resourceMap = new Map<string, string[]>;
+
+    for (const [pluginName, definitions] of responses) {
+      for (const definition of definitions) {
+        // Build resource to plugin mapping
+        if (this.resourceToPluginMapping.has(definition.type)) {
+          throw new Error(`Duplicated types between plugin ${this.resourceToPluginMapping.get(definition.type)} and ${pluginName}`)
+        }
+        this.resourceToPluginMapping.set(definition.type, pluginName);
+
+        // Build plugin to resource mapping
+        if (!this.pluginToResourceMapping.has(pluginName)) {
+          this.pluginToResourceMapping.set(pluginName, []);
+        }
+        this.pluginToResourceMapping.get(pluginName)!.push(definition.type);
+
+        // Build resource dependency map
+        if (resourceMap.has(definition.type)) {
+          throw new Error(`Duplicated types between plugins ${this.resourceToPluginMapping.get(definition.type)} and ${pluginName}`);
+        }
+        resourceMap.set(definition.type, definition.dependencies)
+      }
+    }
+
+    return resourceMap;
+  }
+
+}