codify-plugin-lib 1.0.87 → 1.0.89

package/dist/messages/handlers.js

@@ -1,31 +1,36 @@
 import { Ajv } from 'ajv';
 import addFormats from 'ajv-formats';
-import { ApplyRequestDataSchema, ApplyResponseDataSchema, InitializeRequestDataSchema, InitializeResponseDataSchema, IpcMessageSchema, MessageStatus, PlanRequestDataSchema, PlanResponseDataSchema, ResourceSchema, ValidateRequestDataSchema, ValidateResponseDataSchema } from 'codify-schemas';
+import { ApplyRequestDataSchema, ApplyResponseDataSchema, GetResourceInfoRequestDataSchema, GetResourceInfoResponseDataSchema, InitializeRequestDataSchema, InitializeResponseDataSchema, IpcMessageSchema, MessageStatus, PlanRequestDataSchema, PlanResponseDataSchema, ResourceSchema, ValidateRequestDataSchema, ValidateResponseDataSchema } from 'codify-schemas';
 import { SudoError } from '../errors.js';
 const SupportedRequests = {
-    'apply': {
-        async handler(plugin, data) {
-            await plugin.apply(data);
-            return null;
-        },
-        requestValidator: ApplyRequestDataSchema,
-        responseValidator: ApplyResponseDataSchema
-    },
     'initialize': {
         handler: async (plugin) => plugin.initialize(),
         requestValidator: InitializeRequestDataSchema,
         responseValidator: InitializeResponseDataSchema
     },
+    'validate': {
+        handler: async (plugin, data) => plugin.validate(data),
+        requestValidator: ValidateRequestDataSchema,
+        responseValidator: ValidateResponseDataSchema
+    },
+    'getResourceInfo': {
+        handler: async (plugin, data) => plugin.getResourceInfo(data),
+        requestValidator: GetResourceInfoRequestDataSchema,
+        responseValidator: GetResourceInfoResponseDataSchema
+    },
     'plan': {
         handler: async (plugin, data) => plugin.plan(data),
         requestValidator: PlanRequestDataSchema,
         responseValidator: PlanResponseDataSchema
     },
-    'validate': {
-        handler: async (plugin, data) => plugin.validate(data),
-        requestValidator: ValidateRequestDataSchema,
-        responseValidator: ValidateResponseDataSchema
-    }
+    'apply': {
+        async handler(plugin, data) {
+            await plugin.apply(data);
+            return null;
+        },
+        requestValidator: ApplyRequestDataSchema,
+        responseValidator: ApplyResponseDataSchema
+    },
 };
 export class MessageHandler {
     ajv;

package/dist/plugin/plugin.d.ts

@@ -1,4 +1,4 @@
-import { ApplyRequestData, InitializeResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
+import { ApplyRequestData, GetResourceInfoRequestData, GetResourceInfoResponseData, InitializeResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
 import { Plan } from '../plan/plan.js';
 import { Resource } from '../resource/resource.js';
 import { ResourceController } from '../resource/resource-controller.js';
@@ -9,6 +9,7 @@ export declare class Plugin {
     constructor(name: string, resourceControllers: Map<string, ResourceController<ResourceConfig>>);
     static create(name: string, resources: Resource<any>[]): Plugin;
     initialize(): Promise<InitializeResponseData>;
+    getResourceInfo(data: GetResourceInfoRequestData): Promise<GetResourceInfoResponseData>;
     validate(data: ValidateRequestData): Promise<ValidateResponseData>;
     plan(data: PlanRequestData): Promise<PlanResponseData>;
     apply(data: ApplyRequestData): Promise<void>;

package/dist/plugin/plugin.js

@@ -27,6 +27,18 @@ export class Plugin {
             }))
         };
     }
+    async getResourceInfo(data) {
+        if (!this.resourceControllers.has(data.type)) {
+            throw new Error(`Cannot get info for resource ${data.type}, resource doesn't exist`);
+        }
+        const resource = this.resourceControllers.get(data.type);
+        return {
+            plugin: this.name,
+            type: data.type,
+            dependencies: resource.dependencies,
+            schema: resource.settings.schema
+        };
+    }
     async validate(data) {
         const validationResults = [];
         for (const config of data.configs) {

package/dist/resource/resource-controller.js

@@ -76,6 +76,8 @@ export class ResourceController {
         this.validatePlanInputs(desiredConfig, stateConfig, statefulMode);
         this.addDefaultValues(desiredConfig);
         await this.applyTransformParameters(desiredConfig);
+        this.addDefaultValues(stateConfig);
+        await this.applyTransformParameters(stateConfig);
         // Parse data from the user supplied config
         const parsedConfig = new ConfigParser(desiredConfig, stateConfig, this.parsedSettings.statefulParameters);
         const { coreParameters, desiredParameters, stateParameters, allParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
@@ -188,30 +190,30 @@ ${JSON.stringify(refresh, null, 2)}
 `);
         }
     }
-    async applyTransformParameters(desired) {
-        if (!desired) {
+    async applyTransformParameters(config) {
+        if (!config) {
             return;
         }
         for (const [key, inputTransformation] of Object.entries(this.parsedSettings.inputTransformations)) {
-            if (desired[key] === undefined || !inputTransformation) {
+            if (config[key] === undefined || !inputTransformation) {
                 continue;
             }
-            desired[key] = await inputTransformation(desired[key]);
+            config[key] = await inputTransformation(config[key]);
         }
         if (this.settings.inputTransformation) {
-            const { parameters, coreParameters } = splitUserConfig(desired);
+            const { parameters, coreParameters } = splitUserConfig(config);
             const transformed = await this.settings.inputTransformation(parameters);
-            Object.keys(desired).forEach((k) => delete desired[k]);
-            Object.assign(desired, transformed, coreParameters);
+            Object.keys(config).forEach((k) => delete config[k]);
+            Object.assign(config, transformed, coreParameters);
         }
     }
-    addDefaultValues(desired) {
-        if (!desired) {
+    addDefaultValues(config) {
+        if (!config) {
             return;
         }
         for (const [key, defaultValue] of Object.entries(this.parsedSettings.defaultValues)) {
-            if (defaultValue !== undefined && (desired[key] === undefined || desired[key] === null)) {
-                desired[key] = defaultValue;
+            if (defaultValue !== undefined && (config[key] === undefined || config[key] === null)) {
+                config[key] = defaultValue;
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.87",
+  "version": "1.0.89",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -14,7 +14,7 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "codify-schemas": "1.0.45",
+    "codify-schemas": "1.0.47",
     "@npmcli/promise-spawn": "^7.0.1",
     "uuid": "^10.0.0"
   },

package/src/messages/handlers.ts

@@ -3,6 +3,8 @@ import addFormats from 'ajv-formats';
 import {
   ApplyRequestDataSchema,
   ApplyResponseDataSchema,
+  GetResourceInfoRequestDataSchema,
+  GetResourceInfoResponseDataSchema,
   InitializeRequestDataSchema,
   InitializeResponseDataSchema,
   IpcMessage,
@@ -19,29 +21,34 @@ import { SudoError } from '../errors.js';
 import { Plugin } from '../plugin/plugin.js';
 
 const SupportedRequests: Record<string, { handler: (plugin: Plugin, data: any) => Promise<unknown>; requestValidator: SchemaObject; responseValidator: SchemaObject }> = {
-  'apply': {
-    async handler(plugin: Plugin, data: any) {
-      await plugin.apply(data);
-      return null;
-    },
-    requestValidator: ApplyRequestDataSchema,
-    responseValidator: ApplyResponseDataSchema
-  },
   'initialize': {
     handler: async (plugin: Plugin) => plugin.initialize(),
     requestValidator: InitializeRequestDataSchema,
     responseValidator: InitializeResponseDataSchema
   },
+  'validate': {
+    handler: async (plugin: Plugin, data: any) => plugin.validate(data),
+    requestValidator: ValidateRequestDataSchema,
+    responseValidator: ValidateResponseDataSchema
+  },
+  'getResourceInfo': {
+    handler: async (plugin: Plugin, data: any) => plugin.getResourceInfo(data),
+    requestValidator: GetResourceInfoRequestDataSchema,
+    responseValidator: GetResourceInfoResponseDataSchema
+  },
   'plan': {
     handler: async (plugin: Plugin, data: any) => plugin.plan(data),
     requestValidator: PlanRequestDataSchema,
     responseValidator: PlanResponseDataSchema
   },
-  'validate': {
-    handler: async (plugin: Plugin, data: any) => plugin.validate(data),
-    requestValidator: ValidateRequestDataSchema,
-    responseValidator: ValidateResponseDataSchema
-  }
+  'apply': {
+    async handler(plugin: Plugin, data: any) {
+      await plugin.apply(data);
+      return null;
+    },
+    requestValidator: ApplyRequestDataSchema,
+    responseValidator: ApplyResponseDataSchema
+  },
 }
 
 export class MessageHandler {

package/src/plugin/plugin.ts

@@ -1,5 +1,7 @@
 import {
   ApplyRequestData,
+  GetResourceInfoRequestData,
+  GetResourceInfoResponseData,
   InitializeResponseData,
   PlanRequestData,
   PlanResponseData,
@@ -47,6 +49,21 @@ export class Plugin {
     }
   }
 
+  async getResourceInfo(data: GetResourceInfoRequestData): Promise<GetResourceInfoResponseData> {
+    if (!this.resourceControllers.has(data.type)) {
+      throw new Error(`Cannot get info for resource ${data.type}, resource doesn't exist`);
+    }
+
+    const resource = this.resourceControllers.get(data.type)!;
+
+    return {
+      plugin: this.name,
+      type: data.type,
+      dependencies: resource.dependencies,
+      schema: resource.settings.schema as Record<string, unknown> | undefined
+    }
+  }
+
   async validate(data: ValidateRequestData): Promise<ValidateResponseData> {
     const validationResults = [];
     for (const config of data.configs) {

package/src/resource/resource-controller.ts

@@ -112,6 +112,9 @@ export class ResourceController<T extends StringIndexedObject> {
     this.addDefaultValues(desiredConfig);
     await this.applyTransformParameters(desiredConfig);
 
+    this.addDefaultValues(stateConfig);
+    await this.applyTransformParameters(stateConfig);
+
     // Parse data from the user supplied config
     const parsedConfig = new ConfigParser(desiredConfig, stateConfig, this.parsedSettings.statefulParameters)
     const {
@@ -258,36 +261,36 @@ ${JSON.stringify(refresh, null, 2)}
     }
   }
 
-  private async applyTransformParameters(desired: Partial<T> & ResourceConfig | null): Promise<void> {
-    if (!desired) {
+  private async applyTransformParameters(config: Partial<T> & ResourceConfig | null): Promise<void> {
+    if (!config) {
       return;
     }
 
     for (const [key, inputTransformation] of Object.entries(this.parsedSettings.inputTransformations)) {
-      if (desired[key] === undefined || !inputTransformation) {
+      if (config[key] === undefined || !inputTransformation) {
         continue;
       }
 
-      (desired as Record<string, unknown>)[key] = await inputTransformation(desired[key]);
+      (config as Record<string, unknown>)[key] = await inputTransformation(config[key]);
     }
 
     if (this.settings.inputTransformation) {
-      const { parameters, coreParameters } = splitUserConfig(desired);
+      const { parameters, coreParameters } = splitUserConfig(config);
 
       const transformed = await this.settings.inputTransformation(parameters)
-      Object.keys(desired).forEach((k) => delete desired[k])
-      Object.assign(desired, transformed, coreParameters);
+      Object.keys(config).forEach((k) => delete config[k])
+      Object.assign(config, transformed, coreParameters);
     }
   }
 
-  private addDefaultValues(desired: Partial<T> | null): void {
-    if (!desired) {
+  private addDefaultValues(config: Partial<T> | null): void {
+    if (!config) {
       return;
     }
 
     for (const [key, defaultValue] of Object.entries(this.parsedSettings.defaultValues)) {
-      if (defaultValue !== undefined && (desired[key] === undefined || desired[key] === null)) {
-        (desired as Record<string, unknown>)[key] = defaultValue;
+      if (defaultValue !== undefined && (config[key] === undefined || config[key] === null)) {
+        (config as Record<string, unknown>)[key] = defaultValue;
       }
     }
   }

package/src/resource/resource-settings.test.ts

@@ -491,4 +491,37 @@ describe('Resource parameter tests', () => {
 
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
+
+  it('Supports transform parameters for state parameters', async () => {
+    const resource = spy(new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          inputTransformation: (desired) => ({
+            propA: 'propA',
+            propB: 10,
+          })
+        }
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'propA',
+          propB: 10,
+        }
+      }
+    });
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan(null, { type: 'resourceType', propC: 'abc' } as any, true);
+
+    expect(resource.refresh.called).to.be.true;
+    expect(resource.refresh.getCall(0).firstArg['propA']).to.exist;
+    expect(resource.refresh.getCall(0).firstArg['propB']).to.exist;
+    expect(resource.refresh.getCall(0).firstArg['propC']).to.not.exist;
+
+    expect(plan.currentConfig?.propA).to.eq('propA');
+    expect(plan.currentConfig?.propB).to.eq(10);
+    expect(plan.currentConfig?.propC).to.be.undefined;
+  })
 })