codify-plugin-lib 1.0.52 → 1.0.54

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.d.ts

@@ -29,6 +29,7 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     private _applyModify;
     private _applyDestroy;
     private validateRefreshResults;
+    private applyDefaultValueToRefreshResults;
     private applyTransformParameters;
     private addDefaultValues;
     private refreshResourceParameters;

package/dist/entities/resource.js

@@ -142,8 +142,10 @@ export class Resource {
         if (!refresh) {
             return;
         }
-        const desiredKeys = new Set(desiredMap.keys());
-        const refreshKeys = new Set(Object.keys(refresh));
+        const desiredKeys = new Set([...desiredMap.keys()]
+            .filter((key) => this.defaultValues[key] === undefined));
+        const refreshKeys = new Set([...Object.keys(refresh)]
+            .filter((key) => this.defaultValues[key] === undefined));
         if (!setsEqual(desiredKeys, refreshKeys)) {
             throw new Error(`Resource ${this.typeId}
 refresh() must return back exactly the keys that were provided
@@ -151,12 +153,22 @@ Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
 Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         }
     }
+    applyDefaultValueToRefreshResults(refresh) {
+        if (!refresh) {
+            return;
+        }
+        for (const [key, defaultValue] of Object.entries(this.defaultValues)) {
+            if (refresh[key] === undefined) {
+                refresh[key] = defaultValue;
+            }
+        }
+    }
     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) {
+        for (const [key] of orderedEntries) {
             if (desired[key] !== null) {
-                const transformedValue = await tp.transform(desired[key]);
+                const transformedValue = await this.transformParameters.get(key).transform(desired[key]);
                 if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
                     throw new Error(`Transform parameter ${key} is attempting to override existing value ${desired[key]}`);
                 }
@@ -179,6 +191,7 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         const entriesToRefresh = new Map(Object.entries(resourceParameters));
         const currentParameters = await this.refresh(entriesToRefresh);
         this.validateRefreshResults(currentParameters, entriesToRefresh);
+        this.applyDefaultValueToRefreshResults(currentParameters);
         return currentParameters;
     }
     async refreshStatefulParameters(statefulParametersConfig, isStatefulMode) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.52",
+  "version": "1.0.54",
   "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-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' }
           }
         });
       }
@@ -316,7 +316,28 @@ describe('Resource tests', () => {
     expect(plan.currentConfig.propA).to.eq('propAAfter');
     expect(plan.desiredConfig.propA).to.eq('propADefault');
     expect(plan.changeSet.operation).to.eq(ResourceOperation.RECREATE);
+  })
+
+  it('Allows default values to be added to both desired and current', async () => {
+    const resource = new class extends TestResource {
+      constructor() {
+        super({
+          type: 'type',
+          parameterOptions: {
+            propE: { default: 'propEDefault' }
+          }
+        });
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return {};
+      }
+    }
 
+    const plan = await resource.plan({ type: 'resource'})
+    expect(plan.currentConfig.propE).to.eq('propEDefault');
+    expect(plan.desiredConfig.propE).to.eq('propEDefault');
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
 
   it('Allows default values to be added (ignore default value if already present)', async () => {
@@ -325,7 +346,7 @@ describe('Resource tests', () => {
         super({
           type: 'type',
           parameterOptions: {
-            propA: { defaultValue: 'propADefault' }
+            propA: { default: 'propADefault' }
           }
         });
       }
@@ -346,4 +367,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

@@ -211,8 +211,15 @@ export abstract class Resource<T extends StringIndexedObject> {
       return;
     }
 
-    const desiredKeys = new Set<keyof T>(desiredMap.keys());
-    const refreshKeys = new Set(Object.keys(refresh)) as Set<keyof T>;
+    const desiredKeys = new Set<keyof T>(
+      [...desiredMap.keys()]
+        .filter((key) => this.defaultValues[key] === undefined)
+    );
+
+    const refreshKeys = new Set(
+      [...Object.keys(refresh)]
+        .filter((key) => this.defaultValues[key] === undefined)
+    ) as Set<keyof T>;
 
     if (!setsEqual(desiredKeys, refreshKeys)) {
       throw new Error(
@@ -224,13 +231,26 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     }
   }
 
+  private applyDefaultValueToRefreshResults(refresh: Partial<T> | null) {
+    if (!refresh) {
+      return;
+    }
+
+    for (const [key, defaultValue] of Object.entries(this.defaultValues)) {
+      if (refresh[key] === undefined) {
+        // @ts-ignore
+        refresh[key] = defaultValue;
+      }
+    }
+  }
+
   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) {
+    for (const [key] of orderedEntries) {
       if (desired[key] !== null) {
-        const transformedValue = await tp.transform(desired[key]);
+        const transformedValue = await this.transformParameters.get(key)!.transform(desired[key]);
 
         if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
           throw new Error(`Transform parameter ${key as string} is attempting to override existing value ${desired[key]}`);
@@ -261,6 +281,8 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     const currentParameters = await this.refresh(entriesToRefresh);
 
     this.validateRefreshResults(currentParameters, entriesToRefresh);
+    this.applyDefaultValueToRefreshResults(currentParameters);
+
     return currentParameters;
   }