feat: Upgraded to latest schema which separates core and parameters

Author: kevinwang5658

package.json

@@ -12,7 +12,7 @@
     "ajv": "^8.12.0",
     "ajv-formats": "^3.0.1",
     "chalk": "^5.3.0",
-    "codify-schemas": "^1.0.60",
+    "codify-schemas": "^1.0.61",
     "debug": "^4.3.4",
     "ink": "^5",
     "ink-form": "^2.0.1",

src/entities/plan-request.ts

@@ -1,4 +1,4 @@
-import { ValidateResponseData } from 'codify-schemas';
+import { ValidateResponseData, PlanRequestData } from 'codify-schemas';
 
 import { PluginValidationError, PluginValidationErrorParams, TypeNotFoundError } from '../common/errors.js';
 import { ctx } from '../events/context.js';
@@ -7,7 +7,6 @@ import { DependencyMap } from '../plugins/plugin-manager.js';
 import { DependencyGraphResolver } from '../utils/dependency-graph-resolver.js';
 import { groupBy } from '../utils/index.js';
 import { ConfigBlock, ConfigType } from './config.js';
-import { PlanRequest } from './plan-request.js';
 import { ProjectConfig } from './project-config.js';
 import { ResourceConfig } from './resource-config.js';
 
@@ -19,7 +18,7 @@ export class Project {
   path: string;
 
   sourceMaps?: SourceMapCache;
-  planRequestsCache?: Map<string, PlanRequest>
+  planRequestsCache?: Map<string, PlanRequestData>
 
   isDestroyProject = false;
 
@@ -68,22 +67,32 @@ ${JSON.stringify(projectConfigs, null, 2)}`);
     return this;
   }
 
-  getPlanRequest(id: string): PlanRequest | undefined {
+  getPlanRequest(id: string): PlanRequestData | undefined {
     // One time build a cache for plan requests to make it more efficient
     if (!this.planRequestsCache) {
-      const { resourceConfigs } = this
-      const stateOnlyConfigs = this.stateConfigs?.filter((s) =>
+      const { resourceConfigs, stateConfigs } = this
+      const stateOnlyConfigs = stateConfigs?.filter((s) =>
         !resourceConfigs.some((r) => r.id === s.id)
       )
 
       const inputRequests = [
-        ...this.resourceConfigs.map((r) => [
-            r.id, new PlanRequest(
-              this.isStateful(), r, this.stateConfigs?.find((r) => r.id)
-            )
+        ...resourceConfigs.map((r) => [
+            r.id,
+            <PlanRequestData>{
+              isStateful: this.isStateful(),
+              core: r.toJson().core,
+              desired: r.toJson().parameters,
+              state: stateConfigs?.find((r) => r.id)?.parameters
+            }
           ] as const),
         ...(stateOnlyConfigs?.map((s) => [
-            s.id, new PlanRequest(this.isStateful(), undefined, s)
+            s.id,
+            <PlanRequestData>{
+              isStateful: this.isStateful(),
+              core: s.toJson().core,
+              desired: undefined,
+              state: s.toJson().parameters,
+            }
           ] as const) ?? [])
       ]
 

src/entities/project.ts

@@ -1,4 +1,5 @@
-import { ResourceConfig as SchemaResourceConfig } from 'codify-schemas';
+import { ResourceJson, ResourceConfig as SchemaResourceConfig } from 'codify-schemas';
+
 import { ConfigBlock, ConfigType } from './config.js';
 
 /** Resource JSON supported format
@@ -46,6 +47,16 @@ export class ResourceConfig implements ConfigBlock {
     return this.name ? `${this.type}.${this.name}` : this.type;
   }
 
+  toJson(): ResourceJson {
+    return {
+      core: {
+        type: this.type,
+        name: this.name,
+      },
+      parameters: this.parameters ?? {},
+    }
+  }
+
   isSame(type: string, name?: string): boolean {
     const externalId = name ? `${type}.${name}` : type;
     return externalId === this.id;

src/entities/resource-config.ts

@@ -1,17 +1,14 @@
 import { 
   GetResourceInfoResponseData,
   ImportResponseData,
-  ResourceOperation,
-  ResourceConfig as SchemaResourceConfig,
   ValidateResponseData,
 } from 'codify-schemas';
 
 import { InternalError } from '../common/errors.js';
 import { Plan, ResourcePlan } from '../entities/plan.js';
-import { PlanRequest } from '../entities/plan-request.js';
 import { Project } from '../entities/project.js';
+import { ResourceConfig } from '../entities/resource-config.js';
 import { SubProcessName, ctx } from '../events/context.js';
-import { prettyFormatResourcePlan } from '../ui/plan-pretty-printer.js';
 import { groupBy } from '../utils/index.js';
 import { Plugin } from './plugin.js';
 import { PluginResolver } from './resolver.js';
@@ -69,7 +66,7 @@ export class PluginManager {
     return plugin.getResourceInfo(type);
   }
 
-  async importResource(config: SchemaResourceConfig): Promise<ImportResponseData> {
+  async importResource(config: ResourceConfig): Promise<ImportResponseData> {
     const pluginName = this.resourceToPluginMapping.get(config.type);
     if (!pluginName) {
       throw new Error(`Unable to find plugin for resource: ${config.type}`);
@@ -80,7 +77,7 @@ export class PluginManager {
       throw new Error(`Unable to find plugin for resource ${config.type}`);
     }
 
-    return plugin.import(config);
+    return plugin.import(config.toJson());
   }
 
   async getPlan(project: Project): Promise<Plan> {
@@ -89,9 +86,9 @@ export class PluginManager {
       project.evaluationOrder!.map(async (id) => {
         const planRequest = project.getPlanRequest(id)!;
 
-        const pluginName = this.resourceToPluginMapping.get(planRequest.type);
+        const pluginName = this.resourceToPluginMapping.get(planRequest.core.type);
         if (!pluginName) {
-          throw new InternalError(`Unable to determine plugin for validated resource: ${planRequest.id}`);
+          throw new InternalError(`Unable to determine plugin for validated resource: ${planRequest.core.type}`);
         }
 
         const planResult = await this.plugins.get(pluginName)!.plan(planRequest);

src/plugins/plugin-manager.ts

@@ -5,15 +5,15 @@ import {
   ImportResponseDataSchema,
   InitializeResponseData,
   InitializeResponseDataSchema,
+  PlanRequestData,
   PlanResponseData,
   PlanResponseDataSchema,
-  ResourceConfig as SchemaResourceConfig,
+  ResourceJson,
   ValidateResponseData,
   ValidateResponseDataSchema,
 } from 'codify-schemas';
 
 import { ResourcePlan } from '../entities/plan.js';
-import { PlanRequest } from '../entities/plan-request.js';
 import { ResourceConfig } from '../entities/resource-config.js';
 import { ajv } from '../utils/ajv.js';
 import { PluginProcess } from './plugin-process.js';
@@ -55,8 +55,8 @@ export class Plugin {
   }
 
   async validate(configs: ResourceConfig[]): Promise<ValidateResponseData> {
-    const rawConfigs = configs.map((c) => c.raw);
-    const result = await this.process!.sendMessageForResult('validate', { configs: rawConfigs });
+    const jsonConfigs = configs.map((c) => c.toJson());
+    const result = await this.process!.sendMessageForResult('validate', { configs: jsonConfigs });
 
     if (!result.isSuccessful()) {
       throw new Error(`Initialize error for plugin: "${this.name}" \n\n` + result.data);
@@ -83,11 +83,11 @@ export class Plugin {
     return result.data;
   }
 
-  async import(config: SchemaResourceConfig): Promise<ImportResponseData> {
-    const result = await this.process!.sendMessageForResult('import', { config });
+  async import(config: ResourceJson): Promise<ImportResponseData> {
+    const result = await this.process!.sendMessageForResult('import', config);
 
     if (!result.isSuccessful()) {
-      throw new Error(`Unable import resource ${config.type} with plugin: "${this.name}" \n\n` + result.data);
+      throw new Error(`Unable import resource ${config.core.type} with plugin: "${this.name}" \n\n` + result.data);
     }
 
     if (!this.validateImportResponse(result.data)) {
@@ -97,18 +97,14 @@ export class Plugin {
     return result.data;
   }
 
-  async plan(request: PlanRequest): Promise<ResourcePlan> {
+  async plan(request: PlanRequestData): Promise<ResourcePlan> {
     const result = await this.process!.sendMessageForResult(
       'plan',
-      {
-        desired: request.desired,
-        state: request.state,
-        isStateful: request.isStateful
-      }
+      request
     );
 
     if (!result.isSuccessful()) {
-      throw new Error(`Plan error for plugin: "${this.name}", resource: "${request.type}" \n\n` + result.data);
+      throw new Error(`Plan error for plugin: "${this.name}", resource: "${request.core.type}" \n\n` + result.data);
     }
 
     if (!this.validatePlanResponse(result.data)) {