Refactored plugin class design

Author: kevinwang5658

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

@@ -11,6 +11,6 @@ export const PlanOrchestrator = {
     const resourceDefinitions = await pluginCollection.getAllResourceDefinitions();
     console.log(resourceDefinitions);
 
-    await pluginCollection.killPlugins();
+    await pluginCollection.destroy();
   },
 };

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

@@ -0,0 +1,46 @@
+import { ResourceDefinition } from '../../entities/resource-definition';
+import { RemoveMethods } from '../../utils/types';
+import { validateTypeArray, validateTypeRecordStringUnknown } from '../../utils/validator';
+
+type ResourceName = string;
+
+export class PluginData {
+
+  // Plugin names should be globally unique
+  name!: string;
+  directory!: string;
+  resourceDefinitions!: Map<ResourceName, ResourceDefinition>;
+
+  constructor(props: RemoveMethods<PluginData>) {
+    Object.assign(this, props);
+  }
+
+  static create(name: string, directory: string, resourceDefinitions: unknown): PluginData {
+    if (this.validate(resourceDefinitions)) {
+      const entries = resourceDefinitions.map((u) => {
+        const resourceDefinition = ResourceDefinition.fromJson(u);
+
+        // Append the plugin name to all resources to prevent conflicts across plugins
+        return [`${this.name}_${resourceDefinition.name}`, resourceDefinition] as const;
+      })
+
+      return new PluginData({ directory, name, resourceDefinitions: new Map(entries) });
+    }
+
+    throw new Error('Unable to parse plugin definition')
+  }
+
+
+  private static validate(resourceDefinitions: unknown): resourceDefinitions is Array<Record<string, unknown>> {
+    if (!validateTypeArray(resourceDefinitions)) {
+      throw new Error('Resource definitions is not of type array')
+    }
+
+    if (!resourceDefinitions.every((u) => validateTypeRecordStringUnknown(u))) {
+      throw new Error('Type definitions is not of Record<string, unknown>')
+    }
+
+    return true;
+  }
+
+}

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

@@ -1,50 +1,30 @@
 import type { ChildProcess } from 'node:child_process';
 
-import { ResourceDefinition } from '../../entities/resource-definition';
-import { validateTypeArray, validateTypeRecordStringUnknown } from '../../utils/validator';
-
-type ResourceName = string;
+import { PluginIpcBridge } from '../ipc-bridge';
+import { PluginData } from './plugin-data';
 
 export class Plugin {
 
-  // Plugin names should be globally unique
-  name: string;
-  directory: string;
-
   process: ChildProcess;
-  resourceDefinitions?: Map<ResourceName, ResourceDefinition>;
+  ipcBridge: PluginIpcBridge;
 
-  constructor(directory: string, name: string, process: ChildProcess) {
-    this.name = name;
-    this.directory = directory;
+  // Separate out data so that the validation logic is testable.
+  data: PluginData;
+
+  constructor(data: PluginData, process: ChildProcess, ipcBridge: PluginIpcBridge = new PluginIpcBridge()) {
     this.process = process;
+    this.ipcBridge = ipcBridge;
+    this.data = data;
   }
 
-  setResourceDefinitions(definitions: unknown): void {
-    if (this.validate(definitions)) {
-      const entries = definitions.map((u) => {
-        const resourceDefinition = ResourceDefinition.fromJson(u);
-
-        // Append the plugin name to all resources to prevent conflicts across plugins
-        return [`${this.name}_${resourceDefinition.name}`, resourceDefinition] as const;
-      })
+  static async create(directory: string, name: string, ipcBridge: PluginIpcBridge = new PluginIpcBridge()): Promise<Plugin> {
+    const process = await ipcBridge.createProcess(directory, name);
+    const resourceDefinitions = await ipcBridge.sendMessageForResult(process, { cmd: 'getResourceDefinitions' });
 
-      this.resourceDefinitions = new Map(entries);
-      return;
-    }
-
-    throw new Error('Unable to parse resource definition');
+    return new Plugin(PluginData.create(directory, name, resourceDefinitions), process);
   }
 
-  private validate(definitions: unknown): definitions is Array<Record<string, unknown>> {
-    if (!validateTypeArray(definitions)) {
-      throw new Error('Definitions is not of type array')
-    }
-
-    if (!definitions.every((u) => validateTypeRecordStringUnknown(u))) {
-      throw new Error('Type definitions is not of Record<string, unknown>')
-    }
-
-    return true;
+  destroy() {
+    this.ipcBridge.killPlugin(this.process);
   }
 }

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

@@ -1,80 +1,61 @@
-import * as ChildProcess from 'node:child_process';
+import { ChildProcess, fork } from 'node:child_process';
 
 import { config } from '../project-configs';
 import { validateTypeRecordStringUnknown } from '../utils/validator';
 import { PluginMessage } from './entities/message';
-import { Plugin } from './entities/plugin';
 
 export class PluginIpcBridge {
 
-  static async initializePlugin(directory: string, name: string): Promise<Plugin> {
-    const childProcess = ChildProcess.fork(
+  async createProcess(directory: string, name: string): Promise<ChildProcess> {
+    return fork(
       directory + '/' + name + config.defaultPluginEntryPoint,
       [],
       { execArgv: ['-r', 'ts-node/register'], silent: true },
     );
-    const plugin = new Plugin(directory, name, childProcess);
-
-    childProcess.stdout!.on('data', (data) => {
-      console.log(data.toString());
-    });
-
-    childProcess.stderr!.on('data', (data) => {
-      console.log(data.toString());
-    })
-
-    await this.initializeResourceDefinitions(plugin);
-
-    return plugin;
-  }
-
-  static async initializeResourceDefinitions(plugin: Plugin): Promise<void> {
-    const resourceDefinitions = await this.sendMessageForResult(plugin, { cmd: 'getResourceDefinitions' });
-    plugin.setResourceDefinitions(resourceDefinitions);
   }
 
-  static killPlugin(plugin: Plugin): void {
-    plugin.process.kill();
+  killPlugin(process: ChildProcess): void {
+    process.kill();
   }
 
-  private static async sendMessageForResult(plugin: Plugin, message: PluginMessage): Promise<unknown> {
+  async sendMessageForResult(process: ChildProcess, message: PluginMessage): Promise<unknown> {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
-        plugin.process.kill();
+        process.kill();
         reject(new Error(`Plugin did not respond in 10s to call: ${message.cmd}`))
       }, 10_000);
 
       const errorListener = (error: Buffer) => {
-        plugin.process.kill();
+        process.kill();
         reject(error.toString());
       }
 
       const messageListener = (incomingMessage: unknown) => {
         console.log(incomingMessage);
 
         if (!validateTypeRecordStringUnknown(incomingMessage)) {
-          return reject(new Error(`Bad message from plugin ${plugin.name}. ${JSON.stringify(incomingMessage, null, 2)}`))
+          return reject(new Error(`Bad message from plugin ${name}. ${JSON.stringify(incomingMessage, null, 2)}`))
         }
 
         if (incomingMessage.cmd === this.getResultFunctionName(message.cmd)) {
           clearTimeout(timer);
-          plugin.process.removeListener('message', messageListener);
-          plugin.process.removeListener('error', errorListener);
+          process.removeListener('message', messageListener);
+          process.removeListener('error', errorListener);
           resolve(incomingMessage.data);
         }
       };
 
-      plugin.process.on('message', messageListener);
-      plugin.process.stderr!.on('data', errorListener);
-      plugin.process.send(message);
+      process.on('message', messageListener);
+      process.stderr!.on('data', errorListener);
+      process.send(message);
     });
   }
 
-  private sendMessage(plugin: Plugin, message: PluginMessage): void {
-    plugin.process.send(message);
+  sendMessage(process: ChildProcess, message: PluginMessage): void {
+    process.send(message);
   }
 
-  private static getResultFunctionName(rpcFunctionName: string): string {
+  private getResultFunctionName(rpcFunctionName: string): string {
     return rpcFunctionName + 'Result';
   }
 

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

@@ -1,7 +1,6 @@
 import { ParsedProject } from '../config-compiler/parser/entities';
 import { ResourceDefinition } from '../entities/resource-definition';
 import { Plugin } from './entities/plugin';
-import { PluginIpcBridge } from './ipc-bridge';
 import { PluginResolver } from './resolver';
 
 type PluginName = string;
@@ -21,20 +20,19 @@ export class PluginCollection {
       ...project.projectConfig.plugins,
     };
 
-    const pluginResolver = new PluginResolver();
     const plugins = await Promise.all(Object.entries(pluginDefinitions).map(([name, version]) =>
-      pluginResolver.resolve(name, version)
+      PluginResolver.resolve(name, version)
     ));
 
-    for (const u of plugins) {
-      this.plugins.set(u.name, u);
+    for (const plugin of plugins) {
+      this.plugins.set(plugin.data.name, plugin);
     }
   }
 
   async getAllResourceDefinitions(): Promise<Map<string, ResourceDefinition>> {
     const result = new Map<string, ResourceDefinition>();
     for (const plugin of this.plugins.values()) {
-      const { resourceDefinitions } = plugin;
+      const { resourceDefinitions } = plugin.data;
       if (!resourceDefinitions) {
         continue;
       }
@@ -54,9 +52,9 @@ export class PluginCollection {
     return result;
   }
 
-  async killPlugins(): Promise<void> {
+  async destroy(): Promise<void> {
     for (const plugin of this.plugins.values()) {
-      PluginIpcBridge.killPlugin(plugin);
+      plugin.destroy();
     }
   }
 

codify-core/src/plugins/resolver.ts

@@ -1,13 +1,12 @@
 import * as fs from 'node:fs/promises';
 
 import { Plugin } from './entities/plugin';
-import { PluginIpcBridge } from './ipc-bridge';
 
 const DEFAULT_PLUGIN_REGEX = /(?<=default:).*$/g
 
 export class PluginResolver {
 
-  async resolve(name: string, version: string): Promise<Plugin> {
+  static async resolve(name: string, version: string): Promise<Plugin> {
 
     if (DEFAULT_PLUGIN_REGEX.test(name)) {
       return this.resolveDefaultPlugin(name, version)
@@ -17,7 +16,7 @@ export class PluginResolver {
   }
 
   // TODO: update this method to resolve default plugins from github in the future.
-  private async resolveDefaultPlugin(name: string, _version: string): Promise<Plugin> {
+  private static async resolveDefaultPlugin(name: string, _version: string): Promise<Plugin> {
     const pluginName = name.match(DEFAULT_PLUGIN_REGEX)![0]
 
     const defaultPluginDir = '../plugins';
@@ -26,7 +25,7 @@ export class PluginResolver {
       throw new Error(`Unable to find default plugin: ${name}`)
     }
 
-    return PluginIpcBridge.initializePlugin(defaultPluginDir, pluginName);
+    return Plugin.create(defaultPluginDir, pluginName);
   }
 
 }