Fixed bugs with the plan process. Fixed invalid validations and refactored logic across plugin, project and ipc-bridge

Author: kevinwang5658

codify-core/bin/run.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
-import { execute, handle } from '@oclif/core'
+import { flush, handle, run } from '@oclif/core'
 
-await execute({ dir: import.meta.url })
-  .catch(handle)
+await run(process.argv.slice(2), import.meta.url)
+  .catch(async (error) => handle(error))
+  .finally(async () => flush())

codify-core/package.json

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

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

@@ -4,13 +4,18 @@ import { PluginCollection } from '../../plugins/plugin-collection.js';
 export const PlanOrchestrator = {
   async run(rootDirectory: string): Promise<string> {
     const project = await ConfigCompiler.parseProject(rootDirectory);
+    if (project.isEmpty()) {
+      console.log('Empty project. Taking no action');
+      return '';
+    }
 
     const pluginCollection = new PluginCollection();
     const dependencyMap = await pluginCollection.initialize(project);
     project.validateWithResourceMap(dependencyMap);
     project.resolveResourceDependencies(dependencyMap);
 
-    await pluginCollection.validate(project);
+    const validationResults = await pluginCollection.validate(project);
+    project.handlePluginResourceValidationResults(validationResults);
     project.calculateEvaluationOrder();
 
     const plan = await pluginCollection.getPlan(project);

codify-core/src/entities/project.ts

@@ -1,3 +1,5 @@
+import { ValidateResponseData } from 'codify-schemas';
+
 import { DependencyMap } from '../plugins/plugin-collection.js';
 import { DependencyGraphResolver } from '../utils/dependency-graph-resolver.js';
 import { ProjectConfig } from './project-config.js';
@@ -14,10 +16,16 @@ export class Project {
     this.resourceConfigs = resourceConfigs;
   }
 
+  isEmpty(): boolean {
+    return this.resourceConfigs.length === 0;
+  }
+
   validateWithResourceMap(resourceMap: Map<string, string[]>) {
-    const invalidConfigs = this.resourceConfigs.filter((c) => resourceMap.get(c.type));
+    const invalidConfigs = this.resourceConfigs.filter((c) => !resourceMap.get(c.type));
     if (invalidConfigs.length > 0) {
-      throw new Error(`Unknown types specified: ${JSON.stringify(invalidConfigs, null, 2)}`);
+      const invalidTypes = invalidConfigs.map((c) => c.type)
+
+      throw new Error(`Unknown type specified: ${invalidTypes.join(',\n')}`);
     }
   }
 
@@ -30,6 +38,19 @@ export class Project {
     })
   }
 
+  handlePluginResourceValidationResults(results: ValidateResponseData[]) {
+    const isValid = results.find((r) => !r.isValid);
+    if (!isValid) {
+      const errors = results
+        .filter((r) => (r.errors?.length ?? 0) > 0)
+        .flat(1)
+        .map((e) => JSON.stringify(e, null, 2))
+        .join('\n\n');
+
+      throw new Error(`Config definition errors: \n ${errors}`);
+    }
+  }
+
   calculateEvaluationOrder() {
     this.evaluationOrder = DependencyGraphResolver.calculateDependencyList(
       this.resourceConfigs,

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

@@ -2,15 +2,17 @@ import {
   InitializeResponseData,
   InitializeResponseDataSchema,
   PlanResponseData,
-  PlanResponseDataSchema
+  PlanResponseDataSchema,
+  ValidateResponseData,
+  ValidateResponseDataSchema
 } from 'codify-schemas';
 
-import { ConfigBlock } from '../../entities/index.js';
 import { ResourceConfig } from '../../entities/resource-config.js';
 import { ajv } from '../../utils/ajv.js';
 import { PluginIpcBridge } from '../ipc-bridge.js';
 
 const initializeResponseValidator = ajv.compile(InitializeResponseDataSchema);
+const validateResponseValidator = ajv.compile(ValidateResponseDataSchema);
 const planResponseValidator = ajv.compile(PlanResponseDataSchema);
 
 export class Plugin {
@@ -26,9 +28,10 @@ export class Plugin {
     this.path = path;
   }
 
-  async initialize(ipcBridge?: PluginIpcBridge): Promise<InitializeResponseData> {
-    ipcBridge = ipcBridge ?? await PluginIpcBridge.create(this.path);
-    const initializeResponse = await ipcBridge.sendMessageForResult({ cmd: 'initialize' });
+  async initialize(): Promise<InitializeResponseData> {
+    this.ipcBridge = await PluginIpcBridge.create(this.path);
+
+    const initializeResponse = await this.ipcBridge.sendMessageForResult({ cmd: 'initialize', data: {} });
 
     if (!this.validateInitializeResponse(initializeResponse)) {
       throw new Error(`Invalid initialize response from plugin: ${this.name}`);
@@ -41,9 +44,15 @@ export class Plugin {
     return initializeResponse;
   }
 
-  async validate(configs: ConfigBlock[]): Promise<string[]> {
-    const response = await this.ipcBridge!.sendMessageForResult({ cmd: 'validate', data: { configs } });
-    return response as string[];
+  async validate(configs: ResourceConfig[]): Promise<ValidateResponseData> {
+    const rawConfigs = configs.map((c) => c.raw);
+    const response = await this.ipcBridge!.sendMessageForResult({ cmd: 'validate', data: { configs: rawConfigs } });
+
+    if (!this.validateValidateResponse(response)) {
+      throw new Error(`Invalid validate response from plugin: ${this.name}`);
+    }
+
+    return response;
   }
 
   async plan(resource: ResourceConfig): Promise<PlanResponseData> {
@@ -61,15 +70,23 @@ export class Plugin {
   }
 
   private validateInitializeResponse(response: unknown): response is InitializeResponseData {
-    if (initializeResponseValidator(response)) {
+    if (!initializeResponseValidator(response)) {
       throw new Error(`Invalid initialize response from plugin: ${this.name}. Error: ${initializeResponseValidator.errors}`)
     }
 
     return true;
   }
 
+  private validateValidateResponse(response: unknown): response is ValidateResponseData {
+    if (!validateResponseValidator(response)) {
+      throw new Error(`Invalid validate response from plugin: ${this.name}. Error: ${initializeResponseValidator.errors}`)
+    }
+
+    return true;
+  }
+
   private validatePlanResponse(response: unknown): response is PlanResponseData {
-    if (planResponseValidator(response)) {
+    if (!planResponseValidator(response)) {
       throw new Error(`Invalid plan response from plugin: ${this.name}. Error: ${initializeResponseValidator.errors}`)
     }
 

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

@@ -1,14 +1,15 @@
-import { ChildProcess, fork } from 'node:child_process';
-import { PluginMessage } from './entities/message.js';
 import { IpcMessage, IpcMessageSchema } from 'codify-schemas';
+import { ChildProcess, fork } from 'node:child_process';
+
 import { ajv } from '../utils/ajv.js';
+import { PluginMessage } from './entities/message.js';
 
 const ipcMessageValidator = ajv.compile(IpcMessageSchema);
 
 type Resolve = (value: unknown) => void;
 type Reject = (reason?: Error) => void;
 
-const resultFunctionName = (cmd: string) => `${cmd}_Result`;
+const resultFunctionName = (cmd: string) => `${cmd}_Response`;
 
 export class PluginIpcBridge {
   process: ChildProcess;
@@ -66,7 +67,7 @@ class SendMessageForResultHandler {
   }
 
   messageListener = (incomingMessage: unknown) => {
-    console.log(incomingMessage);
+    console.log(JSON.stringify(incomingMessage, null, 2));
 
     if (!this.validateIpcMessage(incomingMessage)) {
       return this.reject(new Error(`Bad message from plugin. ${JSON.stringify(incomingMessage, null, 2)}`))

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

@@ -1,4 +1,4 @@
-import { PlanResponseData } from 'codify-schemas';
+import { PlanResponseData, ValidateResponseData } from 'codify-schemas';
 
 import { Project } from '../entities/project.js';
 import { groupBy } from '../utils/index.js';
@@ -30,23 +30,18 @@ export class PluginCollection {
     return dependencyMap;
   }
 
-  async validate(project: Project): Promise<void> {
+  async validate(project: Project): Promise<ValidateResponseData[]> {
     const { resourceConfigs } = project;
     const pluginGroupedResourceConfigs = groupBy(
         resourceConfigs,
         (item) => this.resourceToPluginMapping.get(item.type)!
     );
 
-    const result = await Promise.all(
+    return Promise.all(
         Object.entries(pluginGroupedResourceConfigs).map(([pluginName, configs]) =>
             this.plugins.get(pluginName)!.validate(configs)
         )
     );
-
-    const errorMessages = result.flat()
-    if (errorMessages.length > 0) {
-      throw new Error(`Config validation errors: ${JSON.stringify(errorMessages, null, 2)}`);
-    }
   }
 
   async getPlan(project: Project): Promise<PlanResponseData[]> {

codify-core/src/plugins/resolver.ts

@@ -16,12 +16,9 @@ export class PluginResolver {
 
     // TODO: Add plugin versioning in the future
     return this.resolvePlugin(name)
-
-    throw new Error(`Unable to resolve plugin of name: ${name} and version: ${version}`)
   }
 
   private static async resolvePlugin(name: string): Promise<Plugin> {
-
     const { body } = await fetch(DEFAULT_PLUGIN_URL)
     if (!body) {
       throw new Error(`Un-able to fetch plugin ${name}. Body was null`);

codify-core/src/utils/ajv.ts

@@ -1,6 +1,11 @@
 import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
 
-export const ajv = new Ajv2020.default({
+const ajv = new Ajv2020.default({
   allErrors: true,
   strict: true,
 });
+
+addFormats.default(ajv);
+
+export { ajv };

codify-core/src/utils/dependency-graph-resolver.ts

@@ -19,6 +19,10 @@ export class DependencyGraphResolver {
    * @return a dependency graph in the form of an adjacency list
    */
   static calculateDependencyList<T>(vals: T[], getId: (t: T) => string, getDependencyIds: (t: T) => string[]): T[] {
+    if (vals.length === 0) {
+      return [];
+    }
+
     const nodes = vals.map((r) => new Node(getId(r), r));
     const nodeMap = new Map(nodes.map((n) => [n.id, n] as const));
 
@@ -27,7 +31,7 @@ export class DependencyGraphResolver {
 
     const zeroIndegressNodes = nodes.filter((n) => n.indegree === 0);
     if (zeroIndegressNodes.length === 0) {
-      throw new Error('Cyclic dependency found in resource references')
+      throw new Error('Cyclic dependency found in configs. No resources is found that is not referenced');
     }
 
     const queue: Node<T>[] = [];