Added first step of semantic analysis + minor refactoring

Author: kevinwang5658

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

@@ -1,15 +1,15 @@
 import { ConfigCompiler } from '../../config-compiler';
+import { ConfigSemanticAnalyzer } from '../../config-compiler/semantic-analysis/config-semantic-analyzer';
 import { PluginCollection } from '../../plugins/plugin-collection';
 
 export const PlanOrchestrator = {
   async run(rootDirectory: string): Promise<void> {
     const project = await ConfigCompiler.parseProject(rootDirectory);
 
-    const pluginCollection = new PluginCollection();
-    await pluginCollection.initializePlugins(project);
-
+    const pluginCollection = await PluginCollection.create(project);
     const resourceDefinitions = await pluginCollection.getAllResourceDefinitions();
-    console.log(resourceDefinitions);
+
+    await ConfigSemanticAnalyzer.validate(project, resourceDefinitions);
 
     await pluginCollection.destroy();
   },

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

@@ -1,10 +1,12 @@
+import { ResourceDefinitions } from '../entities/resource-definition';
 import { InternalError } from '../utils/errors';
 import { ConfigBlockType } from './language-definition';
 import { ConfigLoader } from './loader';
 import { FileParser } from './parser';
 import { ParsedModule, ParsedProject } from './parser/entities';
 import { ProjectConfig } from './parser/entities/project';
 import { JsonFileParser } from './parser/json/file-parser';
+import { ConfigSemanticAnalyzer } from './semantic-analysis/config-semantic-analyzer';
 
 export class ConfigCompiler {
 
@@ -38,4 +40,8 @@ export class ConfigCompiler {
       projectConfig,
     })
   }
+
+  static async analyzeProject(parsedProject: ParsedProject, resourceDefinitions: ResourceDefinitions): Promise<void> {
+    ConfigSemanticAnalyzer.validate(parsedProject, resourceDefinitions);
+  }
 }

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

@@ -1,5 +1,5 @@
 import { RemoveMethods } from '../../../utils/types';
-import { validateNameString, validateStringEq, validateTypeRecordStringUnknown, } from '../../../utils/validator';
+import { validateNameString, validateTypeRecordStringUnknown, validateTypeString, } from '../../../utils/validator';
 import { ConfigBlockType } from '../../language-definition';
 import { ConfigBlock } from './index';
 
@@ -28,10 +28,10 @@ export class ResourceConfig implements ConfigBlock {
 
   constructor(config: unknown) {
     if (this.validate(config)) {
-      const { name, type, ...params } = config;
+      const { name, type, ...parameters } = config;
       this.type = type;
       this.name = name;
-      this.parameters = params ?? {};
+      this.parameters = parameters ?? {};
 
       return;
     }
@@ -44,8 +44,8 @@ export class ResourceConfig implements ConfigBlock {
       throw new Error('Config is not an object');
     }
 
-    if (!validateStringEq(config.type, 'resource')) {
-      throw new Error('Config is not of type resource');
+    if (!validateTypeString(config.type)) {
+      throw new Error('Config type is not specified');
     }
 
     if (config.name && !validateNameString(config.name)) {

codify-core/src/config-compiler/parser/json/config-block-factory.ts

@@ -1,4 +1,4 @@
-import { InvalidResourceError, SyntaxError } from '../../../utils/errors';
+import { SyntaxError } from '../../../utils/errors';
 import { ConfigBlockType } from '../../language-definition';
 import { ConfigBlock } from '../entities';
 import { PluginConfig } from '../entities/plugin';
@@ -19,16 +19,6 @@ export const JsonConfigBlockFactory = {
     }
 
     switch (unknownNode.type) {
-      case ConfigBlockType.RESOURCE: {
-        const { name, type, ...parameters } = unknownNode;
-
-        return new ResourceConfig({
-          name: name?.toString(),
-          parameters,
-          type,
-        });
-      }
-
       case ConfigBlockType.PLUGIN: {
         return new PluginConfig({
           parameters: unknownNode,
@@ -40,11 +30,7 @@ export const JsonConfigBlockFactory = {
       }
 
       default: {
-        throw new InvalidResourceError({
-          fileName: errorInfo.fileName,
-          message: 'Unknown resource type',
-          resourceDefinition: JSON.stringify(unknownNode, null, 2),
-        })
+        return new ResourceConfig(unknownNode);
       }
     }
   },

codify-core/src/config-compiler/semantic-analysis/config-semantic-analyzer.ts

@@ -0,0 +1,43 @@
+import { ResourceDefinitions } from '../../entities/resource-definition';
+import { ConfigBlockType } from '../language-definition';
+import { ParsedProject } from '../parser/entities';
+import { ResourceConfig } from '../parser/entities/resource';
+
+export const ConfigSemanticAnalyzer = {
+
+  async validate(project: ParsedProject, resourceDefinitions: ResourceDefinitions): Promise<void> {
+    const resourceConfigs = project
+      .coreModule
+      .configBlocks
+      .filter((u) => u.configType === ConfigBlockType.RESOURCE) as ResourceConfig[];
+
+    this.validateResourceConfigs(resourceConfigs, resourceDefinitions);
+  },
+
+  // TODO: Move this logic to ResourceConfig entity when plugin initialization is moved to be the first step
+  validateResourceConfigs(blocks: ResourceConfig[], resourceDefinitions: ResourceDefinitions) {
+    for (const configBlock of blocks) {
+      const { parameters, type } = configBlock;
+      const definition = resourceDefinitions.get(type);
+      if (!definition) {
+        throw new Error(`Invalid resource type specified ${type}. Type is not found in any plugins`);
+      }
+
+      const { parameters: parameterDefinitions } = definition;
+      for (const [key, value] of Object.entries(parameters)) {
+
+        if (!parameterDefinitions.has(key)) {
+          throw new Error(`Invalid resource parameter: ${key}. Resource: ${type}`)
+        }
+
+        const parameter = parameterDefinitions.get(key)!;
+        // validate value here
+        if (parameter.allowedValues && !(parameter.allowedValues as Array<unknown>).includes(value)) {
+          throw new Error(`Invalid resource config ${type}. Allowed values are ${parameter.allowedValues} but ${value} was provided`)
+        }
+      }
+    }
+
+  }
+
+};

codify-core/src/entities/resource-definition.ts

@@ -1,8 +1,10 @@
+import { InternalError } from '../utils/errors';
 import { RemoveMethods } from '../utils/types';
 import { validateAllowedObjectKeys, validateNameString, validateTypeRecordStringUnknown, } from '../utils/validator';
 import { ResourceParameterDefinition } from './resource-parameter';
 
 type Name = string;
+export type ResourceDefinitions = Map<Name, ResourceDefinition>
 
 /**
  * Example json def:
@@ -17,7 +19,6 @@ type Name = string;
  *   }
  * }
  */
-
 export class ResourceDefinition {
   name!: string;
   parameters!: Map<Name, ResourceParameterDefinition>;
@@ -26,7 +27,7 @@ export class ResourceDefinition {
     Object.assign(this, props);
   }
 
-  static fromJson(json: unknown): ResourceDefinition {
+  static fromJson(pluginName: string, json: unknown): ResourceDefinition {
     if (this.validateDefinition(json)) {
       const entries = Object.entries(json.parameters).map(([name, value]) => {
         const resourceParameterDefinition = ResourceParameterDefinition.fromJson(name, value);
@@ -35,27 +36,27 @@ export class ResourceDefinition {
       })
 
       const parametersMap = new Map(entries);
-      return new ResourceDefinition({ name: json.name, parameters: parametersMap })
+      return new ResourceDefinition({ name: `${pluginName}_${json.name}`, parameters: parametersMap })
     }
 
-    throw new Error('Unable to parse resource definition');
+    throw new InternalError('Unable to parse resource definition');
   }
 
   private static validateDefinition(json: unknown): json is { name: string; parameters: Record<string, unknown> } {
     if (!validateTypeRecordStringUnknown(json)) {
-      return false;
+      throw new Error(`Unable to validate definition is type object ${json}`);
     }
 
     if (!validateAllowedObjectKeys(json, ['name', 'parameters'])) {
-      return false;
+      throw new Error(`Only keys name and parameters is allowed. ${json}`);
     }
 
     if (!validateNameString(json.name)) {
-      return false;
+      throw new Error(`Unable find definition name. ${json}`);
     }
 
     if (!validateTypeRecordStringUnknown(json.parameters)) {
-      return false;
+      throw new Error(`Unable to parse parameters. ${json}`);
     }
 
     return true;

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

@@ -15,13 +15,13 @@ export class PluginData {
     Object.assign(this, props);
   }
 
-  static create(name: string, directory: string, resourceDefinitions: unknown): PluginData {
+  static create(directory: string, name: string, resourceDefinitions: unknown): PluginData {
     if (this.validate(resourceDefinitions)) {
       const entries = resourceDefinitions.map((u) => {
-        const resourceDefinition = ResourceDefinition.fromJson(u);
+        const resourceDefinition = ResourceDefinition.fromJson(name, u);
 
         // Append the plugin name to all resources to prevent conflicts across plugins
-        return [`${this.name}_${resourceDefinition.name}`, resourceDefinition] as const;
+        return [resourceDefinition.name, resourceDefinition] as const;
       })
 
       return new PluginData({ directory, name, resourceDefinitions: new Map(entries) });

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

@@ -10,7 +10,6 @@ type Reject = (reason?: Error) => void;
 const resultFunctionName = (cmd: string) => `${cmd}Result`;
 
 export class PluginIpcBridge {
-
   process: ChildProcess;
 
   constructor(process: ChildProcess) {

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

@@ -12,9 +12,13 @@ const DEFAULT_PLUGINS = {
 
 export class PluginCollection {
 
-  private plugins: Map<PluginName, Plugin> = new Map();
+  private plugins: Map<PluginName, Plugin>
 
-  async initializePlugins(project: ParsedProject): Promise<void> {
+  constructor(plugins: Map<PluginName, Plugin>) {
+    this.plugins = plugins;
+  }
+
+  static async create(project: ParsedProject): Promise<PluginCollection> {
     const pluginDefinitions = {
       ...DEFAULT_PLUGINS,
       ...project.projectConfig.plugins,
@@ -24,12 +28,10 @@ export class PluginCollection {
       PluginResolver.resolve(name, version)
     ));
 
-    for (const plugin of plugins) {
-      this.plugins.set(plugin.data.name, plugin);
-    }
+    return new PluginCollection(new Map(plugins.map((plugin) => [plugin.data.name, plugin])))
   }
 
-  async getAllResourceDefinitions(): Promise<Map<string, ResourceDefinition>> {
+  getAllResourceDefinitions(): Map<string, ResourceDefinition> {
     const result = new Map<string, ResourceDefinition>();
     for (const plugin of this.plugins.values()) {
       const { resourceDefinitions } = plugin.data;

plugins/homebrew/resource-definitions/homebrew_installation.json

@@ -1,5 +1,5 @@
 {
-  "name": "homebrew_installation",
+  "name": "installation",
   "parameters": {
     "directory": "string"
   }