Re-named previous entities. Modified plugin resolver to pull from s3

Author: kevinwang5658

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

@@ -9,7 +9,7 @@ export class PluginData {
   // Plugin names should be globally unique
   name!: string;
   directory!: string;
-  resourceDefinitions!: Map<ResourceName, ResourceDefinition>;
+  resourceDefinitions?: Map<ResourceName, ResourceDefinition>;
 
   constructor(props: RemoveMethods<PluginData>) {
     Object.assign(this, props);

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

@@ -4,28 +4,28 @@ import { PluginData } from './plugin-data.js';
 
 export class Plugin {
 
-  ipcBridge: PluginIpcBridge;
+  ipcBridge?: PluginIpcBridge;
 
   // Separate out data so that the validation logic is testable.
   data: PluginData;
 
-  constructor(data: PluginData, ipcBridge: PluginIpcBridge) {
-    this.ipcBridge = ipcBridge;
+  constructor(data: PluginData) {
     this.data = data;
   }
 
-  static async create(directory: string, name: string, ipcBridge?: PluginIpcBridge): Promise<Plugin> {
-    ipcBridge = ipcBridge ?? await PluginIpcBridge.create(directory, name);
-    const resourceDefinitions = await ipcBridge.sendMessageForResult({ cmd: 'getResourceDefinitions' });
+  async initialize(ipcBridge?: PluginIpcBridge): Promise<unknown> {
+    ipcBridge = ipcBridge ?? await PluginIpcBridge.create(this.data.directory);
+    const resourceList = await ipcBridge.sendMessageForResult({ cmd: 'initialize' });
 
-    return new Plugin(PluginData.create(directory, name, resourceDefinitions), ipcBridge);
+    this.data.resourceDefinitions = resourceList as any;
+    return resourceList;
   }
 
   async generateResourcePlan(applyable: Applyable): Promise<unknown> {
-    return this.ipcBridge.sendMessageForResult({ cmd: 'generateResourcePlan', data: applyable.toJson() });
+    return this.ipcBridge!.sendMessageForResult({ cmd: 'generateResourcePlan', data: applyable.toJson() });
   }
 
   destroy() {
-    this.ipcBridge.killPlugin();
+    this.ipcBridge!.killPlugin();
   }
 }

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

@@ -1,6 +1,4 @@
 import { ChildProcess, fork } from 'node:child_process';
-
-import { config } from '../project-configs/index.js';
 import { validateTypeRecordStringUnknown } from '../utils/validator.js';
 import { PluginMessage } from './entities/message.js';
 
@@ -16,9 +14,9 @@ export class PluginIpcBridge {
     this.process = process;
   }
 
-  static async create(directory: string, name: string): Promise<PluginIpcBridge> {
-    const process = await fork(
-      directory + '/' + name + config.defaultPluginEntryPoint,
+  static async create(jsFileDir: string): Promise<PluginIpcBridge> {
+    const process = fork(
+      jsFileDir,
       [],
       { execArgv: ['-r', 'ts-node/register'], silent: true },
     );

…fy-core/src/plugins/plugin-collection.ts codify-core/src/plugins/plugin-manager.tscodify-core/src/plugins/plugin-collection.ts renamed to codify-core/src/plugins/plugin-manager.ts codify-core/src/plugins/plugin-collection.ts renamed to codify-core/src/plugins/plugin-manager.ts

@@ -7,19 +7,19 @@ import { PluginResolver } from './resolver.js';
 type PluginName = string;
 
 const DEFAULT_PLUGINS = {
-  'default:homebrew': 'latest',
+  'default': 'latest',
   // 'default:node': 'latest',
 }
 
-export class PluginCollection {
+export class PluginManager {
 
   private plugins: Map<PluginName, Plugin>
 
   constructor(plugins: Map<PluginName, Plugin>) {
     this.plugins = plugins;
   }
 
-  static async create(project: ParsedProject): Promise<PluginCollection> {
+  static async initialize(project: ParsedProject): Promise<PluginManager> {
     const pluginDefinitions: Record<string, string> = {
       ...DEFAULT_PLUGINS,
       ...project.projectConfig.plugins,
@@ -29,7 +29,11 @@ export class PluginCollection {
       PluginResolver.resolve(name, version)
     ));
 
-    return new PluginCollection(new Map(plugins.map((plugin) => [plugin.data.name, plugin])))
+    const definitions = await Promise.all(
+      plugins.map((p) => p.initialize())
+    );
+
+    return new PluginManager(new Map(plugins.map((plugin) => [plugin.data.name, plugin])))
   }
 
   getResourceDefinitions(): Map<string, ResourceDefinition> {

codify-core/src/plugins/resolver.ts

@@ -1,31 +1,50 @@
+import * as fsSync from 'node:fs';
 import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import { finished } from 'node:stream/promises';
 
 import { Plugin } from './entities/plugin.js';
 
-const DEFAULT_PLUGIN_REGEX = /(?<=default:).*$/g
+const DEFAULT_PLUGIN_URL = 'https://codify-plugin-library.s3.amazonaws.com/codify-core/index.js';
+const DEFAULT_PLUGIN_REGEX = /(?<=default).*$/g
+const PLUGIN_CACHE_DIR = '/Library/Caches/codify/plugins'
 
 export class PluginResolver {
 
-  static async resolve(name: string, version: string): Promise<Plugin> {
+  static async resolve(name: string, version?: string): Promise<Plugin> {
+    await PluginResolver.checkAndCreateCacheDirIfNotExists()
 
+    // TODO: Add plugin versioning in the future
     if (DEFAULT_PLUGIN_REGEX.test(name)) {
-      return this.resolveDefaultPlugin(name, version)
+      return this.resolveDefaultPlugin()
     }
 
     throw new Error(`Unable to resolve plugin of name: ${name} and version: ${version}`)
   }
 
-  // TODO: update this method to resolve default plugins from github in the future.
-  private static async resolveDefaultPlugin(name: string, _version: string): Promise<Plugin> {
-    const pluginName = name.match(DEFAULT_PLUGIN_REGEX)![0]
+  private static async resolveDefaultPlugin(): Promise<Plugin> {
 
-    const defaultPluginDir = '/Users/kevinwang/Projects/codify/plugins';
-    const pluginDirFiles = await fs.readdir(defaultPluginDir);
-    if (!pluginDirFiles.includes(pluginName)) {
-      throw new Error(`Unable to find default plugin: ${name}`)
+    const { body } = await fetch(DEFAULT_PLUGIN_URL)
+    if (!body) {
+      throw new Error('Un-able to fetch default plugin. Body was null');
     }
 
-    return Plugin.create(defaultPluginDir, pluginName);
+    const fileUrl = path.join(PLUGIN_CACHE_DIR, 'default.js');
+    const ws = fsSync.createWriteStream(fileUrl)
+
+    // Different type definitions here for readable stream (NodeJS vs DOM). Small hack to fix that
+    await finished(Readable.fromWeb(body as never).pipe(ws));
+
+    return new Plugin({
+      directory: fileUrl,
+      name: 'default',
+    })
   }
 
+  private static async checkAndCreateCacheDirIfNotExists() {
+    if (!(await fs.stat(PLUGIN_CACHE_DIR))) {
+      await fs.mkdir(PLUGIN_CACHE_DIR);
+    }
+  }
 }

codify-core/test/integration/resolver.test.ts

@@ -0,0 +1,20 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import { PluginResolver } from '../../src/plugins/resolver.js';
+import mock from 'mock-fs';
+import * as fs from 'fs';
+
+describe('Plugin resolver integration test', () => {
+  beforeEach(() => {
+    mock({
+      '/Library/Caches/codify/plugins': {}
+    })
+
+  })
+
+  it('resolves the default plugin', async () => {
+    const plugin = await PluginResolver.resolve('default')
+
+    expect(fs.existsSync('/Library/Caches/codify/plugins/default.js')).to.be.true;
+  })
+})

codify-core/tsconfig.test.json

@@ -5,6 +5,7 @@
   },
   "include": [
     "src/**/*.test.ts",
-    "test/**/*.test.ts"
+    "test/**/*.test.ts",
+    "test/**/*.integration-test.ts"
   ]
 }