feat: Added filtering for array parameters in deletes

Author: kevinwang5658

package-lock.json

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

package.json

@@ -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> {

src/plan/plan.test.ts

@@ -326,15 +326,27 @@ export class Plan<T extends StringIndexedObject> {
 
     // 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.
-    if (isStateful) {
+    if (isStateful && desired) {
       return filteredCurrent;
     }
 
+    // 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)])
     )
 
     return { ...filteredCurrent, ...arrayStatefulParameters }
@@ -378,7 +390,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' &&
@@ -392,7 +404,7 @@ 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[] {
       const desiredArray = desired![k] as unknown[];
       const matcher = settings.parameterSettings![k]!.type === 'stateful'
         ? ((settings.parameterSettings![k] as ParsedStatefulParameterSetting)
@@ -427,6 +439,43 @@ export class Plan<T extends StringIndexedObject> {
         ? filterParameter(desiredCopy, currentCopy)
         : defaultFilterMethod(desiredCopy, currentCopy);
     }
+
+    function filterArrayParameterForDeletes(k: string, v: unknown[]): unknown[] {
+      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.

src/plan/plan.ts

@@ -66,7 +66,7 @@ describe('SequentialPty tests', () => {
   });
 
 
-  it('It can launch a command in interactive mode', async () => {
+  it('It can launch a command in interactive mode', { timeout: 30_000 }, async () => {
     const originalSend = process.send;
     process.send = (req: IpcMessageV2) => {
       expect(req).toMatchObject({