codify-plugin-lib 1.0.86 → 1.0.88

package/dist/plugin/plugin.js

@@ -1,6 +1,5 @@
 import { Plan } from '../plan/plan.js';
 import { ResourceController } from '../resource/resource-controller.js';
-import { splitUserConfig } from '../utils/utils.js';
 export class Plugin {
     name;
     resourceControllers;
@@ -34,10 +33,9 @@ export class Plugin {
             if (!this.resourceControllers.has(config.type)) {
                 throw new Error(`Resource type not found: ${config.type}`);
             }
-            const { parameters, coreParameters } = splitUserConfig(config);
             const validation = await this.resourceControllers
                 .get(config.type)
-                .validate(parameters, coreParameters);
+                .validate(config);
             validationResults.push(validation);
         }
         await this.crossValidateResources(data.configs);

package/dist/resource/resource-controller.d.ts

@@ -14,7 +14,7 @@ export declare class ResourceController<T extends StringIndexedObject> {
     protected schemaValidator?: ValidateFunction;
     constructor(resource: Resource<T>);
     initialize(): Promise<void>;
-    validate(parameters: Partial<T>, resourceMetaData: ResourceConfig): Promise<ValidateResponseData['resourceValidations'][0]>;
+    validate(desiredConfig: Partial<T> & ResourceConfig): Promise<ValidateResponseData['resourceValidations'][0]>;
     plan(desiredConfig: Partial<T> & ResourceConfig | null, stateConfig?: Partial<T> & ResourceConfig | null, statefulMode?: boolean): Promise<Plan<T>>;
     apply(plan: Plan<T>): Promise<void>;
     private applyCreate;

package/dist/resource/resource-controller.js

@@ -31,14 +31,18 @@ export class ResourceController {
     async initialize() {
         return this.resource.initialize();
     }
-    async validate(parameters, resourceMetaData) {
+    async validate(desiredConfig) {
+        const configToValidate = { ...desiredConfig };
+        await this.applyTransformParameters(configToValidate);
+        const { parameters, coreParameters } = splitUserConfig(configToValidate);
+        this.addDefaultValues(parameters);
         if (this.schemaValidator) {
             const isValid = this.schemaValidator(parameters);
             if (!isValid) {
                 return {
                     isValid: false,
-                    resourceName: resourceMetaData.name,
-                    resourceType: resourceMetaData.type,
+                    resourceName: coreParameters.name,
+                    resourceType: coreParameters.type,
                     schemaValidationErrors: this.schemaValidator?.errors ?? [],
                 };
             }
@@ -56,15 +60,15 @@ export class ResourceController {
             return {
                 customValidationErrorMessage,
                 isValid: false,
-                resourceName: resourceMetaData.name,
-                resourceType: resourceMetaData.type,
+                resourceName: coreParameters.name,
+                resourceType: coreParameters.type,
                 schemaValidationErrors: this.schemaValidator?.errors ?? [],
             };
         }
         return {
             isValid: true,
-            resourceName: resourceMetaData.name,
-            resourceType: resourceMetaData.type,
+            resourceName: coreParameters.name,
+            resourceType: coreParameters.type,
             schemaValidationErrors: [],
         };
     }
@@ -72,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;
@@ -184,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.86",
+  "version": "1.0.88",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/resource/resource-controller.ts

@@ -57,10 +57,10 @@ export class ResourceController<T extends StringIndexedObject> {
     desiredConfig: Partial<T> & ResourceConfig,
   ): Promise<ValidateResponseData['resourceValidations'][0]> {
     const configToValidate = { ...desiredConfig };
-    const { parameters, coreParameters } = splitUserConfig(configToValidate);
+    await this.applyTransformParameters(configToValidate);
 
+    const { parameters, coreParameters } = splitUserConfig(configToValidate);
     this.addDefaultValues(parameters);
-    await this.applyTransformParameters(configToValidate);
 
     if (this.schemaValidator) {
       const isValid = this.schemaValidator(parameters);
@@ -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;
+  })
 })