codify-plugin-lib 1.0.53 → 1.0.54

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.53",
+  "version": "1.0.54",
   "description": "",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/entities/resource.test.ts

@@ -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 () => {

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;
   }