codify-plugin-lib 1.0.103 → 1.0.105

package/dist/plan/plan.js

@@ -143,15 +143,28 @@ export class Plan {
             return Object.fromEntries(Object.entries(current)
                 .filter(([k]) => keys.has(k)));
         }
+        function getFilterParameter(k) {
+            if (settings.parameterSettings?.[k]?.type === 'stateful') {
+                const statefulSetting = settings.parameterSettings[k];
+                if (statefulSetting.nestedSettings.type === 'array') {
+                    return statefulSetting.nestedSettings.filterInStatelessMode;
+                }
+            }
+            if (settings.parameterSettings?.[k]?.type === 'array') {
+                return (settings.parameterSettings?.[k]).filterInStatelessMode;
+            }
+            return undefined;
+        }
         function isArrayParameterWithFiltering(k, v) {
+            const filterParameter = getFilterParameter(k);
             if (settings.parameterSettings?.[k]?.type === 'stateful') {
                 const statefulSetting = settings.parameterSettings[k];
                 return statefulSetting.nestedSettings.type === 'array' &&
-                    (statefulSetting.nestedSettings.filterInStatelessMode ?? true)
+                    (filterParameter ?? true)
                     && Array.isArray(v);
             }
             return settings.parameterSettings?.[k]?.type === 'array'
-                && ((settings.parameterSettings?.[k]).filterInStatelessMode ?? true)
+                && (filterParameter ?? true)
                 && Array.isArray(v);
         }
         // For stateless mode, we must filter the current array so that the diff algorithm will not detect any deletes
@@ -165,17 +178,23 @@ export class Plan {
                     .isElementEqual;
             const desiredCopy = [...desiredArray];
             const currentCopy = [...v];
-            const result = [];
-            for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
-                const idx = currentCopy.findIndex((e2) => matcher(desiredCopy[counter], e2));
-                if (idx === -1) {
-                    continue;
+            const defaultFilterMethod = ((desired, current) => {
+                const result = [];
+                for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
+                    const idx = currentCopy.findIndex((e2) => matcher(desiredCopy[counter], e2));
+                    if (idx === -1) {
+                        continue;
+                    }
+                    desiredCopy.splice(counter, 1);
+                    const [element] = currentCopy.splice(idx, 1);
+                    result.push(element);
                 }
-                desiredCopy.splice(counter, 1);
-                const [element] = currentCopy.splice(idx, 1);
-                result.push(element);
-            }
-            return result;
+                return result;
+            });
+            const filterParameter = getFilterParameter(k);
+            return typeof filterParameter === 'function'
+                ? filterParameter(desiredCopy, currentCopy)
+                : defaultFilterMethod(desiredCopy, currentCopy);
         }
     }
     // TODO: This needs to be revisited. I don't think this is valid anymore.

package/dist/resource/resource-settings.d.ts

@@ -191,7 +191,7 @@ export interface ArrayParameterSetting extends DefaultParameterSetting {
      *
      * Defaults to true.
      */
-    filterInStatelessMode?: boolean;
+    filterInStatelessMode?: ((desired: any[], current: any[]) => any[]) | boolean;
 }
 /**
  * Stateful parameter type specific settings. A stateful parameter is a sub-resource that can hold its own

package/package.json

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

package/src/plan/plan.ts

@@ -251,16 +251,34 @@ export class Plan<T extends StringIndexedObject> {
       ) as Partial<T>;
     }
 
+    function getFilterParameter(k: string): ((desired: any[], current: any[]) => any[]) | boolean | undefined {
+      if (settings.parameterSettings?.[k]?.type === 'stateful') {
+        const statefulSetting = settings.parameterSettings[k] as ParsedStatefulParameterSetting;
+
+        if (statefulSetting.nestedSettings.type === 'array') {
+          return (statefulSetting.nestedSettings as ArrayParameterSetting).filterInStatelessMode
+        }
+      }
+
+      if (settings.parameterSettings?.[k]?.type === 'array') {
+        return (settings.parameterSettings?.[k] as ArrayParameterSetting).filterInStatelessMode;
+      }
+
+      return undefined;
+    }
+
     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' &&
-          ((statefulSetting.nestedSettings as ArrayParameterSetting).filterInStatelessMode ?? true)
+          (filterParameter ?? true)
           && Array.isArray(v);
       }
 
       return settings.parameterSettings?.[k]?.type === 'array'
-        && ((settings.parameterSettings?.[k] as ArrayParameterSetting).filterInStatelessMode ?? true)
+        && (filterParameter ?? true)
         && Array.isArray(v);
     }
 
@@ -276,21 +294,29 @@ export class Plan<T extends StringIndexedObject> {
 
       const desiredCopy = [...desiredArray];
       const currentCopy = [...v];
-      const result = [];
 
-      for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
-        const idx = currentCopy.findIndex((e2) => matcher(desiredCopy[counter], e2))
+      const defaultFilterMethod = ((desired: any[], current: any[]) => {
+        const result = [];
+
+        for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
+          const idx = currentCopy.findIndex((e2) => matcher(desiredCopy[counter], e2))
 
-        if (idx === -1) {
-          continue;
+          if (idx === -1) {
+            continue;
+          }
+
+          desiredCopy.splice(counter, 1)
+          const [element] = currentCopy.splice(idx, 1)
+          result.push(element)
         }
 
-        desiredCopy.splice(counter, 1)
-        const [element] = currentCopy.splice(idx, 1)
-        result.push(element)
-      }
+        return result;
+      })
 
-      return result;
+      const filterParameter = getFilterParameter(k);
+      return typeof filterParameter === 'function'
+        ? filterParameter(desiredCopy, currentCopy)
+        : defaultFilterMethod(desiredCopy, currentCopy);
     }
   }
 

package/src/resource/resource-controller.test.ts

@@ -2,12 +2,14 @@ import { Resource } from './resource.js';
 import { ResourceOperation } from 'codify-schemas';
 import { spy } from 'sinon';
 import { describe, expect, it } from 'vitest'
-import { ResourceSettings } from './resource-settings.js';
+import { ArrayParameterSetting, ParameterSetting, ResourceSettings } from './resource-settings.js';
 import { CreatePlan, DestroyPlan, ModifyPlan } from '../plan/plan-types.js';
 import { ParameterChange } from '../plan/change-set.js';
 import { ResourceController } from './resource-controller.js';
 import { TestConfig, testPlan, TestResource, TestStatefulParameter } from '../utils/test-utils.test.js';
 import { untildify } from '../utils/utils.js';
+import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
+import { Plan } from '../plan/plan.js';
 
 describe('Resource tests', () => {
 
@@ -391,4 +393,116 @@ describe('Resource tests', () => {
       }
     }
   })
+
+  it('Can use multiple stateful parameters (create)', async () => {
+    const parameter1 = new class extends StatefulParameter<any, any> {
+      getSettings(): ParameterSetting {
+        return {
+          type: 'version'
+        }
+      }
+      override async refresh(desired: any, config: Partial<any>): Promise<any> {
+        return null;
+      }
+      override async add(valueToAdd: any, plan: Plan<any>): Promise<void> {}
+      override async modify(newValue: any, previousValue: any, plan: Plan<any>): Promise<void> {}
+      override async remove(valueToRemove: any, plan: Plan<any>): Promise<void> {}
+    }
+
+    const parameter2 = new class extends ArrayStatefulParameter<any, any> {
+      override getSettings(): ArrayParameterSetting {
+        return {
+          type: 'array',
+          isElementEqual: (desired, current) => current.includes(desired),
+        }
+      }
+
+      override async refresh(desired: any[] | null, config: Partial<any>): Promise<any[] | null> {
+        return null;
+      }
+      override async addItem(item: any, plan: Plan<any>): Promise<void> {}
+      override async removeItem(item: any, plan: Plan<any>): Promise<void> {}
+    }
+
+    const p1Spy = spy(parameter1);
+    const p2Spy = spy(parameter2);
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'nvm',
+          parameterSettings: {
+            global: { type: 'stateful', definition: parameter1, order: 2 },
+            nodeVersions: { type: 'stateful', definition: parameter2, order: 1 },
+          },
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({ type: 'nvm', global: '20.12', nodeVersions: ['18', '20'] })
+
+    expect(plan).toMatchObject({
+      changeSet: {
+        operation: ResourceOperation.CREATE,
+      }
+    })
+
+    console.log(JSON.stringify(plan, null, 2))
+
+    await controller.apply(plan)
+
+    expect(p1Spy.add.calledOnce).to.be.true;
+    expect(p2Spy.addItem.calledTwice).to.be.true;
+  });
+
+  it('Can use multiple stateful parameters (modify)', async () => {
+    const parameter1 = spy(new class extends TestStatefulParameter {
+      async refresh(desired: string | null): Promise<string | null> {
+        return '16';
+      }
+    })
+
+    const parameter2 = spy(new class extends ArrayStatefulParameter<any, any> {
+      async refresh(desired: any[] | null, config: Partial<any>): Promise<any[] | null> {
+        return ['20']
+      }
+      async addItem(item: any, plan: Plan<any>): Promise<void> {}
+      async removeItem(item: any, plan: Plan<any>): Promise<void> {}
+    })
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'nvm',
+          parameterSettings: {
+            global: { type: 'stateful', definition: parameter1, order: 2 },
+            nodeVersions: { type: 'stateful', definition: parameter2, order: 1 },
+          },
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {};
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({ type: 'nvm', global: '20.12', nodeVersions: ['18', '20'] })
+
+    expect(plan).toMatchObject({
+      changeSet: {
+        operation: ResourceOperation.MODIFY,
+      }
+    })
+
+    await controller.apply(plan)
+
+    expect(parameter1.modify.calledOnce).to.be.true;
+    expect(parameter2.addItem.calledOnce).to.be.true;
+  });
 });

package/src/resource/resource-settings.test.ts

@@ -239,6 +239,94 @@ describe('Resource parameter tests', () => {
     })
   })
 
+  it('Can accept a custom filter function to filter in stateless mode', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          parameterSettings: {
+            hosts: {
+              type: 'array',
+              isElementEqual: 'object',
+              filterInStatelessMode: (desired, current) => {
+                return current.filter((d) => desired.some((c) => d.Host === c.Host))
+              }
+            }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          hosts: [
+            {
+              Host: '*',
+              AddKeysToAgent: 'yes',
+              IdentityFile: 'id_ed25519'
+            },
+            {
+              Host: 'github.com',
+              AddKeysToAgent: 'yes',
+              UseKeychain: 'yes',
+              IgnoreUnknown: 'UseKeychain',
+              IdentityFile: '~/.ssh/id_ed25519',
+            }
+          ]
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({
+      type: 'type',
+      hosts: [
+        {
+          Host: 'new.com',
+          AddKeysToAgent: 'yes',
+          IdentityFile: '~/.ssh/id_ed25519'
+        },
+        {
+          Host: 'github.com',
+          AddKeysToAgent: 'yes',
+          UseKeychain: 'yes',
+        }
+      ]
+    });
+
+    expect(plan).toMatchObject({
+      'changeSet': {
+        'operation': 'recreate',
+        'parameterChanges': [
+          {
+            'name': 'hosts',
+            'previousValue': [
+              {
+                'Host': 'github.com',
+                'AddKeysToAgent': 'yes',
+                'UseKeychain': 'yes',
+                'IgnoreUnknown': 'UseKeychain',
+                'IdentityFile': '~/.ssh/id_ed25519'
+              }
+            ],
+            'newValue': [
+              {
+                'Host': 'new.com',
+                'AddKeysToAgent': 'yes',
+                'IdentityFile': '~/.ssh/id_ed25519'
+              },
+              {
+                'Host': 'github.com',
+                'AddKeysToAgent': 'yes',
+                'UseKeychain': 'yes'
+              }
+            ],
+            'operation': 'modify'
+          }
+        ]
+      },
+    })
+  })
+
   it('Uses isElementEqual for stateless mode filtering if available', async () => {
     const statefulParameter = new class extends TestArrayStatefulParameter {
       getSettings(): ArrayParameterSetting {

package/src/resource/resource-settings.ts

@@ -232,7 +232,7 @@ export interface ArrayParameterSetting extends DefaultParameterSetting {
    *
    * Defaults to true.
    */
-  filterInStatelessMode?: boolean,
+  filterInStatelessMode?: ((desired: any[], current: any[]) => any[]) | boolean,
 }
 
 /**