codify-plugin-lib 1.0.51 → 1.0.53

package/dist/entities/plan.js

@@ -58,39 +58,40 @@ export class Plan {
             Object.entries(defaultValues)
                 .forEach(([key, defaultValue]) => {
                 const configValueExists = data
-                    ?.parameters
-                    .find((p) => p.name === key) !== undefined;
-                if (!configValueExists) {
-                    switch (data?.operation) {
-                        case ResourceOperation.CREATE: {
-                            data?.parameters.push({
-                                name: key,
-                                operation: ParameterOperation.ADD,
-                                previousValue: null,
-                                newValue: defaultValue,
-                            });
-                            break;
-                        }
-                        case ResourceOperation.DESTROY: {
-                            data?.parameters.push({
-                                name: key,
-                                operation: ParameterOperation.REMOVE,
-                                previousValue: defaultValue,
-                                newValue: null,
-                            });
-                            break;
-                        }
-                        case ResourceOperation.MODIFY:
-                        case ResourceOperation.RECREATE:
-                        case ResourceOperation.NOOP: {
-                            data?.parameters.push({
-                                name: key,
-                                operation: ParameterOperation.NOOP,
-                                previousValue: defaultValue,
-                                newValue: defaultValue,
-                            });
-                            break;
-                        }
+                    .parameters
+                    .some((p) => p.name === key);
+                if (configValueExists) {
+                    return;
+                }
+                switch (data.operation) {
+                    case ResourceOperation.CREATE: {
+                        data.parameters.push({
+                            name: key,
+                            operation: ParameterOperation.ADD,
+                            previousValue: null,
+                            newValue: defaultValue,
+                        });
+                        break;
+                    }
+                    case ResourceOperation.DESTROY: {
+                        data.parameters.push({
+                            name: key,
+                            operation: ParameterOperation.REMOVE,
+                            previousValue: defaultValue,
+                            newValue: null,
+                        });
+                        break;
+                    }
+                    case ResourceOperation.MODIFY:
+                    case ResourceOperation.RECREATE:
+                    case ResourceOperation.NOOP: {
+                        data.parameters.push({
+                            name: key,
+                            operation: ParameterOperation.NOOP,
+                            previousValue: defaultValue,
+                            newValue: defaultValue,
+                        });
+                        break;
                     }
                 }
             });

package/dist/entities/plugin.js

@@ -66,10 +66,10 @@ export class Plugin {
             return this.planStorage.get(planId);
         }
         if (!planRequest?.resourceType || !this.resources.has(planRequest.resourceType)) {
-            throw new Error('Malformed plan. Resource type must be supplied');
+            throw new Error('Malformed plan. Resource type must be supplied or resource type was not found');
         }
         const resource = this.resources.get(planRequest.resourceType);
-        return Plan.fromResponse(data.plan, resource?.defaultValues);
+        return Plan.fromResponse(data.plan, resource.defaultValues);
     }
     async crossValidateResources(configs) { }
 }

package/dist/entities/resource-options.js

@@ -46,8 +46,8 @@ export class ResourceOptionsParser {
             return {};
         }
         return Object.fromEntries([...this.resourceParameters.entries()]
-            .filter(([, rp]) => rp.defaultValue !== undefined)
-            .map(([name, rp]) => [name, rp.defaultValue]));
+            .filter(([, rp]) => rp.default !== undefined)
+            .map(([name, rp]) => [name, rp.default]));
     }
     get statefulParameterOrder() {
         const entries = Object.entries(this.options.parameterOptions ?? {})

package/dist/entities/resource-types.d.ts

@@ -3,7 +3,7 @@ export type ErrorMessage = string;
 export interface ResourceParameterOptions {
     planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
     isEqual?: (desired: any, current: any) => boolean;
-    defaultValue?: unknown;
+    default?: unknown;
 }
 export interface ResourceDefinition {
     [x: string]: {

package/dist/entities/resource.js

@@ -55,9 +55,9 @@ export class Resource {
             parameterOptions: this.parameterOptions,
         };
         const parsedConfig = new ConfigParser(desiredConfig, this.statefulParameters, this.transformParameters);
-        const { parameters: desiredParameters, resourceMetadata, resourceParameters, statefulParameters } = parsedConfig;
+        const { parameters: desiredParameters, resourceMetadata, resourceParameters, statefulParameters, transformParameters, } = parsedConfig;
         this.addDefaultValues(resourceParameters);
-        await this.applyTransformParameters(resourceParameters);
+        await this.applyTransformParameters(transformParameters, resourceParameters);
         const currentParameters = await this.refreshResourceParameters(resourceParameters);
         if (currentParameters == null) {
             return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
@@ -151,8 +151,8 @@ Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
 Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         }
     }
-    async applyTransformParameters(desired) {
-        const orderedEntries = [...this.transformParameters.entries()]
+    async applyTransformParameters(transformParameters, desired) {
+        const orderedEntries = [...Object.entries(transformParameters)]
             .sort(([keyA], [keyB]) => this.transformParameterOrder.get(keyA) - this.transformParameterOrder.get(keyB));
         for (const [key, tp] of orderedEntries) {
             if (desired[key] !== null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.51",
+  "version": "1.0.53",
   "description": "",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/entities/plan.test.ts

@@ -141,9 +141,7 @@ function createResource(): Resource<any> {
       super({
         type: 'type',
         parameterOptions: {
-          propA: {
-            defaultValue: 'defaultA'
-          }
+          propA: { default: 'defaultA' }
         }
       });
     }

package/src/entities/plan.ts

@@ -97,43 +97,46 @@ export class Plan<T extends StringIndexedObject> {
    function addDefaultValues(): void {
       Object.entries(defaultValues)
         .forEach(([key, defaultValue]) => {
-          const configValueExists = data
-            ?.parameters
-            .find((p) => p.name === key) !== undefined;
-
-          if (!configValueExists) {
-            switch (data?.operation) {
-              case ResourceOperation.CREATE: {
-                data?.parameters.push({
-                  name: key,
-                  operation: ParameterOperation.ADD,
-                  previousValue: null,
-                  newValue: defaultValue,
-                });
-                break;
-              }
-
-              case ResourceOperation.DESTROY: {
-                data?.parameters.push({
-                  name: key,
-                  operation: ParameterOperation.REMOVE,
-                  previousValue: defaultValue,
-                  newValue: null,
-                });
-                break;
-              }
-
-              case ResourceOperation.MODIFY:
-              case ResourceOperation.RECREATE:
-              case ResourceOperation.NOOP: {
-                data?.parameters.push({
-                  name: key,
-                  operation: ParameterOperation.NOOP,
-                  previousValue: defaultValue,
-                  newValue: defaultValue,
-                });
-                break;
-              }
+          const configValueExists = data!
+            .parameters
+            .some((p) => p.name === key);
+
+          // Only set default values if the value does not exist in the config
+          if (configValueExists) {
+            return;
+          }
+
+          switch (data!.operation) {
+            case ResourceOperation.CREATE: {
+              data!.parameters.push({
+                name: key,
+                operation: ParameterOperation.ADD,
+                previousValue: null,
+                newValue: defaultValue,
+              });
+              break;
+            }
+
+            case ResourceOperation.DESTROY: {
+              data!.parameters.push({
+                name: key,
+                operation: ParameterOperation.REMOVE,
+                previousValue: defaultValue,
+                newValue: null,
+              });
+              break;
+            }
+
+            case ResourceOperation.MODIFY:
+            case ResourceOperation.RECREATE:
+            case ResourceOperation.NOOP: {
+              data!.parameters.push({
+                name: key,
+                operation: ParameterOperation.NOOP,
+                previousValue: defaultValue,
+                newValue: defaultValue,
+              });
+              break;
             }
           }
         });

package/src/entities/plugin.ts

@@ -95,11 +95,11 @@ export class Plugin {
     }
 
     if (!planRequest?.resourceType || !this.resources.has(planRequest.resourceType)) {
-      throw new Error('Malformed plan. Resource type must be supplied');
+      throw new Error('Malformed plan. Resource type must be supplied or resource type was not found');
     }
 
-    const resource = this.resources.get(planRequest.resourceType);
-    return Plan.fromResponse(data.plan, resource?.defaultValues!);
+    const resource = this.resources.get(planRequest.resourceType)!;
+    return Plan.fromResponse(data.plan, resource.defaultValues);
   }
 
   protected async crossValidateResources(configs: ResourceConfig[]): Promise<void> {}

package/src/entities/resource-options.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { ResourceOptions, ResourceOptionsParser } from './resource-options.js';
+import { TestConfig } from './resource.test.js';
+
+describe('Resource options parser tests', () => {
+  it('Parses default values from options', () => {
+    const option: ResourceOptions<TestConfig> = {
+      type: 'typeId',
+      parameterOptions: {
+        propA: { default: 'propA' },
+        propB: { default: 'propB' },
+        propC: { isEqual: () => true },
+        propD: { },
+      }
+    }
+
+    const result = new ResourceOptionsParser(option);
+    expect(result.defaultValues).to.deep.eq({
+      propA: 'propA',
+      propB: 'propB'
+    })
+  })
+})

package/src/entities/resource-options.ts

@@ -113,8 +113,8 @@ export class ResourceOptionsParser<T extends StringIndexedObject> {
 
     return Object.fromEntries(
       [...this.resourceParameters.entries()]
-        .filter(([, rp]) => rp.defaultValue !== undefined)
-        .map(([name, rp]) => [name, rp.defaultValue])
+        .filter(([, rp]) => rp.default !== undefined)
+        .map(([name, rp]) => [name, rp.default])
     ) as Partial<Record<keyof T, unknown>>;
   }
 

package/src/entities/resource-parameters.test.ts

@@ -407,6 +407,43 @@ describe('Resource parameters tests', () => {
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
 
+  it('Does not call transform parameters unless they are specified in the user config', async () => {
+    const transformParameter = spy(new class extends TransformParameter<TestConfig> {
+      async transform(value: any): Promise<Partial<TestConfig>> {
+        return {
+          propA: 'propA',
+          propB: 10,
+        }
+      }
+    })
+
+    const resource = spy(new class extends TestResource {
+      constructor() {
+        super({
+          type: 'resourceType',
+          parameterOptions: {
+            propC: { transformParameter }
+          },
+        });
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'propA',
+          propB: 10,
+        }
+      }
+    });
+
+    const plan = await resource.plan({ type: 'resourceType', propA: 'propA', propB: 10 } as any);
+
+    expect(transformParameter.transform.called).to.be.false;
+    expect(resource.refresh.getCall(0).firstArg.has('propA')).to.be.true;
+    expect(resource.refresh.getCall(0).firstArg.has('propB')).to.be.true;
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
+
   it('Plans transform parameters in the order specified', async () => {
     const transformParameterA = spy(new class extends TransformParameter<TestConfig> {
       async transform(value: any): Promise<Partial<TestConfig>> {

package/src/entities/resource-types.ts

@@ -19,7 +19,7 @@ export interface ResourceParameterOptions {
   /**
    * Default value for the parameter. If a value is not provided in the config, the library will use this value.
    */
-  defaultValue?: unknown,
+  default?: unknown,
 }
 
 /**

package/src/entities/resource.test.ts

@@ -296,7 +296,7 @@ describe('Resource tests', () => {
         super({
           type: 'type',
           parameterOptions: {
-            propA: { defaultValue: 'propADefault' }
+            propA: { default: 'propADefault' }
           }
         });
       }
@@ -325,7 +325,7 @@ describe('Resource tests', () => {
         super({
           type: 'type',
           parameterOptions: {
-            propA: { defaultValue: 'propADefault' }
+            propA: { default: 'propADefault' }
           }
         });
       }
@@ -346,4 +346,21 @@ describe('Resource tests', () => {
     expect(plan.desiredConfig.propA).to.eq('propA');
     expect(plan.changeSet.operation).to.eq(ResourceOperation.RECREATE);
   });
+
+  it('Sets the default value properly on the resource', () => {
+    const resource = new class extends TestResource {
+      constructor() {
+        super({
+          type: 'type',
+          parameterOptions: {
+            propA: { default: 'propADefault' }
+          }
+        });
+      }
+    }
+
+    expect(resource.defaultValues).to.deep.eq({
+      propA: 'propADefault',
+    })
+  })
 });

package/src/entities/resource.ts

@@ -89,11 +89,12 @@ export abstract class Resource<T extends StringIndexedObject> {
       parameters: desiredParameters,
       resourceMetadata,
       resourceParameters,
-      statefulParameters
+      statefulParameters,
+      transformParameters,
     } = parsedConfig;
 
     this.addDefaultValues(resourceParameters);
-    await this.applyTransformParameters(resourceParameters);
+    await this.applyTransformParameters(transformParameters, resourceParameters);
 
     // Refresh resource parameters. This refreshes the parameters that configure the resource itself
     const currentParameters = await this.refreshResourceParameters(resourceParameters);
@@ -223,8 +224,8 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     }
   }
 
-  private async applyTransformParameters(desired: Partial<T>): Promise<void> {
-    const orderedEntries = [...this.transformParameters.entries()]
+  private async applyTransformParameters(transformParameters: Partial<T>, desired: Partial<T>): Promise<void> {
+    const orderedEntries = [...Object.entries(transformParameters)]
       .sort(([keyA], [keyB]) => this.transformParameterOrder.get(keyA)! - this.transformParameterOrder.get(keyB)!)
 
     for (const [key, tp] of orderedEntries) {