codify-plugin-lib 1.0.182-beta70 → 1.0.182-beta72

package/dist/plan/plan.js

@@ -187,7 +187,6 @@ export class Plan {
      *  or wants to set. If a parameter is not specified then it's not managed by Codify.
      */
     static filterCurrentParams(params) {
-        console.log('Filter current params', params.desired, params.current, params.state, params.settings, params.isStateful);
         const { desired, current, state, settings, isStateful } = params;
         if (!current) {
             return null;
@@ -196,19 +195,23 @@ export class Plan {
         if (!filteredCurrent) {
             return null;
         }
-        console.log('Before exit', isStateful, desired);
         // For stateful mode, we're done after filtering by the keys of desired + state. Stateless mode
         // requires additional filtering for stateful parameter arrays and objects.
-        // We also want to filter parameters when in delete mode. We don't want to delete parameters that
-        // are not specified in the original config.
         if (isStateful && desired) {
             return filteredCurrent;
         }
-        console.log('Post exit', isStateful, desired);
+        // We also want to filter parameters when in delete mode. We don't want to delete parameters that
+        // are not specified in the original config.
+        if (isStateful && !desired) {
+            const arrayStatefulParameters = Object.fromEntries(Object.entries(filteredCurrent)
+                .filter(([k, v]) => isArrayParameterWithFiltering(k, v))
+                .map(([k, v]) => [k, filterArrayParameterForDeletes(k, v)]));
+            return { ...filteredCurrent, ...arrayStatefulParameters };
+        }
         // TODO: Add object handling here in addition to arrays in the future
         const arrayStatefulParameters = Object.fromEntries(Object.entries(filteredCurrent)
             .filter(([k, v]) => isArrayParameterWithFiltering(k, v))
-            .map(([k, v]) => [k, filterArrayStatefulParameter(k, v)]));
+            .map(([k, v]) => [k, filterArrayParameterForStatelessMode(k, v)]));
         console.log('Result', { ...filteredCurrent, ...arrayStatefulParameters });
         return { ...filteredCurrent, ...arrayStatefulParameters };
         function filterCurrent() {
@@ -250,7 +253,8 @@ export class Plan {
                 && Array.isArray(v);
         }
         // For stateless mode, we must filter the current array so that the diff algorithm will not detect any deletes
-        function filterArrayStatefulParameter(k, v) {
+        function filterArrayParameterForStatelessMode(k, v) {
+            console.log('Attempting to filter stateless (key, value)', k, v);
             const desiredArray = desired[k];
             const matcher = settings.parameterSettings[k].type === 'stateful'
                 ? settings.parameterSettings[k]
@@ -278,6 +282,35 @@ export class Plan {
                 ? filterParameter(desiredCopy, currentCopy)
                 : defaultFilterMethod(desiredCopy, currentCopy);
         }
+        function filterArrayParameterForDeletes(k, v) {
+            console.log('Attempting to filter deletes (key, value)', k, v);
+            const stateArray = state[k];
+            const matcher = settings.parameterSettings[k].type === 'stateful'
+                ? settings.parameterSettings[k]
+                    .nestedSettings
+                    .isElementEqual
+                : settings.parameterSettings[k]
+                    .isElementEqual;
+            const stateCopy = [...stateArray];
+            const currentCopy = [...v];
+            const defaultFilterMethod = ((state, current) => {
+                const result = [];
+                for (let counter = state.length - 1; counter >= 0; counter--) {
+                    const idx = currentCopy.findIndex((e2) => matcher(state[counter], e2));
+                    if (idx === -1) {
+                        continue;
+                    }
+                    state.splice(counter, 1);
+                    const [element] = current.splice(idx, 1);
+                    result.push(element);
+                }
+                return result;
+            });
+            const filterParameter = getFilterParameter(k);
+            return typeof filterParameter === 'function'
+                ? filterParameter(stateCopy, currentCopy)
+                : defaultFilterMethod(stateCopy, currentCopy);
+        }
     }
     // TODO: This needs to be revisited. I don't think this is valid anymore.
     //   1. For all scenarios, there shouldn't be an apply without a plan beforehand

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.182-beta70",
+  "version": "1.0.182-beta72",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/plan/plan.test.ts

@@ -180,6 +180,52 @@ describe('Plan entity tests', () => {
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
 
+  it('Filters array parameters in delete mode (when desired is null)', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'type',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propZ: { type: 'array', isElementEqual: (a, b) => b.includes(a) }
+          }
+        }
+      }
+
+      async refresh(): Promise<Partial<any> | null> {
+        return {
+          propZ: [
+            '20.15.0',
+            '20.15.1'
+          ]
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan(
+      { type: 'type' },
+      null,
+      { propZ: ['20.15.0'], } as any,
+      true
+    )
+
+    console.log(JSON.stringify(plan, null, 2));
+    expect(plan).toMatchObject({
+      id: expect.any(String),
+      changeSet: expect.objectContaining({
+        operation: ResourceOperation.DESTROY,
+        parameterChanges: [
+          expect.objectContaining({ operation: 'remove', name: 'propZ', previousValue: ['20.15.0'], newValue: null }),
+        ],
+      }),
+      coreParameters: expect.objectContaining({
+        type: 'type',
+      }),
+      isStateful: true,
+    })
+  })
+
   it('Doesn\'t filters array parameters if filtering is disabled', async () => {
     const resource = new class extends TestResource {
       getSettings(): ResourceSettings<any> {

package/src/plan/plan.ts

@@ -307,8 +307,6 @@ export class Plan<T extends StringIndexedObject> {
     settings: ResourceSettings<T>,
     isStateful: boolean,
   }): Partial<T> | null {
-    console.log('Filter current params', params.desired, params.current, params.state, params.settings, params.isStateful)
-
     const {
       desired,
       current,
@@ -326,23 +324,29 @@ export class Plan<T extends StringIndexedObject> {
       return null
     }
 
-    console.log('Before exit', isStateful, desired);
-
     // For stateful mode, we're done after filtering by the keys of desired + state. Stateless mode
     // requires additional filtering for stateful parameter arrays and objects.
-    // We also want to filter parameters when in delete mode. We don't want to delete parameters that
-    // are not specified in the original config.
     if (isStateful && desired) {
       return filteredCurrent;
     }
 
-    console.log('Post exit', isStateful, desired);
+    // We also want to filter parameters when in delete mode. We don't want to delete parameters that
+    // are not specified in the original config.
+    if (isStateful && !desired) {
+      const arrayStatefulParameters = Object.fromEntries(
+        Object.entries(filteredCurrent)
+          .filter(([k, v]) => isArrayParameterWithFiltering(k, v))
+          .map(([k, v]) => [k, filterArrayParameterForDeletes(k, v)])
+      )
+
+      return { ...filteredCurrent, ...arrayStatefulParameters }
+    }
 
     // TODO: Add object handling here in addition to arrays in the future
     const arrayStatefulParameters = Object.fromEntries(
       Object.entries(filteredCurrent)
         .filter(([k, v]) => isArrayParameterWithFiltering(k, v))
-        .map(([k, v]) => [k, filterArrayStatefulParameter(k, v)])
+        .map(([k, v]) => [k, filterArrayParameterForStatelessMode(k, v)])
     )
 
     console.log('Result', { ...filteredCurrent, ...arrayStatefulParameters });
@@ -388,7 +392,7 @@ export class Plan<T extends StringIndexedObject> {
 
     function isArrayParameterWithFiltering(k: string, v: T[keyof T]): boolean {
       const filterParameter = getFilterParameter(k);
-      
+
       if (settings.parameterSettings?.[k]?.type === 'stateful') {
         const statefulSetting = settings.parameterSettings[k] as ParsedStatefulParameterSetting;
         return statefulSetting.nestedSettings.type === 'array' &&
@@ -402,7 +406,9 @@ export class Plan<T extends StringIndexedObject> {
     }
 
     // For stateless mode, we must filter the current array so that the diff algorithm will not detect any deletes
-    function filterArrayStatefulParameter(k: string, v: unknown[]): unknown[] {
+    function filterArrayParameterForStatelessMode(k: string, v: unknown[]): unknown[] {
+      console.log('Attempting to filter stateless (key, value)', k, v);
+
       const desiredArray = desired![k] as unknown[];
       const matcher = settings.parameterSettings![k]!.type === 'stateful'
         ? ((settings.parameterSettings![k] as ParsedStatefulParameterSetting)
@@ -437,6 +443,45 @@ export class Plan<T extends StringIndexedObject> {
         ? filterParameter(desiredCopy, currentCopy)
         : defaultFilterMethod(desiredCopy, currentCopy);
     }
+
+    function filterArrayParameterForDeletes(k: string, v: unknown[]): unknown[] {
+      console.log('Attempting to filter deletes (key, value)', k, v);
+
+      const stateArray = state![k] as unknown[];
+      const matcher = settings.parameterSettings![k]!.type === 'stateful'
+        ? ((settings.parameterSettings![k] as ParsedStatefulParameterSetting)
+          .nestedSettings as ParsedArrayParameterSetting)
+          .isElementEqual
+        : (settings.parameterSettings![k] as ParsedArrayParameterSetting)
+          .isElementEqual
+
+      const stateCopy = [...stateArray];
+      const currentCopy = [...v];
+
+      const defaultFilterMethod = ((state: any[], current: any[]) => {
+        const result = [];
+
+        for (let counter = state.length - 1; counter >= 0; counter--) {
+          const idx = currentCopy.findIndex((e2) => matcher(state[counter], e2))
+
+          if (idx === -1) {
+            continue;
+          }
+
+          state.splice(counter, 1)
+          const [element] = current.splice(idx, 1)
+          result.push(element)
+        }
+
+        return result;
+      })
+
+
+      const filterParameter = getFilterParameter(k);
+      return typeof filterParameter === 'function'
+        ? filterParameter(stateCopy, currentCopy)
+        : defaultFilterMethod(stateCopy, currentCopy);
+    }
   }
 
   // TODO: This needs to be revisited. I don't think this is valid anymore.