codify-plugin-lib 1.0.81 → 1.0.83

package/dist/plan/change-set.js

@@ -1,5 +1,4 @@
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { areArraysEqual } from '../utils/utils.js';
 // Change set will coerce undefined values to null because undefined is not valid JSON
 export class ChangeSet {
     operation;
@@ -139,14 +138,6 @@ export class ChangeSet {
         return orderOfOperations[Math.max(indexPrev, indexNext)];
     }
     static isSame(desired, current, setting) {
-        switch (setting?.type) {
-            case 'array': {
-                const arrayParameter = setting;
-                return areArraysEqual(arrayParameter, desired, current);
-            }
-            default: {
-                return (setting?.isEqual ?? ((a, b) => a === b))(desired, current);
-            }
-        }
+        return (setting?.isEqual ?? ((a, b) => a === b))(desired, current);
     }
 }

package/dist/plan/plan.js

@@ -148,13 +148,26 @@ export class Plan {
                 && settings.parameterSettings[k].definition.getSettings().type === 'array'
                 && 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) {
             const desiredArray = desired[k];
             const matcher = settings.parameterSettings[k]
                 .definition
                 .getSettings()
-                .isElementEqual;
-            return v.filter((cv) => desiredArray.find((dv) => (matcher ?? ((a, b) => a === b))(dv, cv)));
+                .isElementEqual ?? ((a, b) => a === b);
+            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;
+                }
+                desiredCopy.splice(counter, 1);
+                const [element] = currentCopy.splice(idx, 1);
+                result.push(element);
+            }
+            return result;
         }
     }
     // TODO: This needs to be revisited. I don't think this is valid anymore.

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

@@ -21,6 +21,5 @@ export declare class ParsedResourceSettings<T extends StringIndexedObject> imple
     get statefulParameterOrder(): Map<keyof T, number>;
     private validateSettings;
     private validateParameterEqualsFn;
-    private resolveEqualsFn;
     private getFromCacheOrCreate;
 }

package/dist/resource/parsed-resource-settings.js

@@ -1,5 +1,4 @@
-import { areArraysEqual } from '../utils/utils.js';
-import { ParameterEqualsDefaults } from './resource-settings.js';
+import { resolveEqualsFn } from './resource-settings.js';
 export class ParsedResourceSettings {
     cache = new Map();
     id;
@@ -35,7 +34,7 @@ export class ParsedResourceSettings {
             const settings = Object.entries(this.settings.parameterSettings ?? {})
                 .map(([k, v]) => [k, v])
                 .map(([k, v]) => {
-                v.isEqual = this.resolveEqualsFn(v, k);
+                v.isEqual = resolveEqualsFn(v, k);
                 return [k, v];
             });
             return Object.fromEntries(settings);
@@ -106,15 +105,6 @@ export class ParsedResourceSettings {
         }
         // The rest of the types have defaults set already
     }
-    resolveEqualsFn(parameter, key) {
-        if (parameter.type === 'array') {
-            return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter);
-        }
-        if (parameter.type === 'stateful') {
-            return this.resolveEqualsFn(parameter.definition.getSettings(), key);
-        }
-        return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type] ?? (((a, b) => a === b));
-    }
     getFromCacheOrCreate(key, create) {
         if (this.cache.has(key)) {
             return this.cache.get(key);

package/dist/resource/resource-controller.js

@@ -73,7 +73,7 @@ export class ResourceController {
         await this.applyTransformParameters(desiredConfig);
         // Parse data from the user supplied config
         const parsedConfig = new ConfigParser(desiredConfig, stateConfig, this.parsedSettings.statefulParameters);
-        const { coreParameters, desiredParameters, stateParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
+        const { coreParameters, desiredParameters, stateParameters, allParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
         // Refresh resource parameters. This refreshes the parameters that configure the resource itself
         const currentParametersArray = await this.refreshNonStatefulParameters(allNonStatefulParameters);
         // Short circuit here. If the resource is non-existent, there's no point checking stateful parameters
@@ -93,7 +93,7 @@ export class ResourceController {
         }
         // Refresh stateful parameters. These parameters have state external to the resource. allowMultiple
         // does not work together with stateful parameters
-        const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters);
+        const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, allParameters);
         return Plan.calculate({
             desiredParameters,
             currentParametersArray: [{ ...currentParametersArray[0], ...statefulCurrentParameters }],
@@ -220,7 +220,7 @@ ${JSON.stringify(refresh, null, 2)}
     }
     // Refresh stateful parameters
     // This refreshes parameters that are stateful (they can be added, deleted separately from the resource)
-    async refreshStatefulParameters(statefulParametersConfig) {
+    async refreshStatefulParameters(statefulParametersConfig, allParameters) {
         const result = {};
         const sortedEntries = Object.entries(statefulParametersConfig)
             .sort(([key1], [key2]) => this.parsedSettings.statefulParameterOrder.get(key1) - this.parsedSettings.statefulParameterOrder.get(key2));
@@ -229,7 +229,7 @@ ${JSON.stringify(refresh, null, 2)}
             if (!statefulParameter) {
                 throw new Error(`Stateful parameter ${key} was not found`);
             }
-            result[key] = await statefulParameter.refresh(desiredValue ?? null);
+            result[key] = await statefulParameter.refresh(desiredValue ?? null, allParameters);
         }
         return result;
     }

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

@@ -146,4 +146,4 @@ export interface StatefulParameterSetting extends DefaultParameterSetting {
      */
     order?: number;
 }
-export declare const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown, b: unknown) => boolean>>;
+export declare function resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => boolean;

package/dist/resource/resource-settings.js

@@ -1,9 +1,18 @@
 import path from 'node:path';
-import { untildify } from '../utils/utils.js';
-export const ParameterEqualsDefaults = {
+import { areArraysEqual, untildify } from '../utils/utils.js';
+const ParameterEqualsDefaults = {
     'boolean': (a, b) => Boolean(a) === Boolean(b),
     'directory': (a, b) => path.resolve(untildify(String(a))) === path.resolve(untildify(String(b))),
     'number': (a, b) => Number(a) === Number(b),
     'string': (a, b) => String(a) === String(b),
     'version': (desired, current) => String(current).includes(String(desired))
 };
+export function resolveEqualsFn(parameter, key) {
+    if (parameter.type === 'array') {
+        return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter);
+    }
+    if (parameter.type === 'stateful') {
+        return resolveEqualsFn(parameter.definition.getSettings(), key);
+    }
+    return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type] ?? (((a, b) => a === b));
+}

package/dist/resource/stateful-parameter.d.ts

@@ -25,10 +25,11 @@ export declare abstract class StatefulParameter<T extends StringIndexedObject, V
      * Return the value of the stateful parameter or null if not found.
      *
      * @param desired The desired value of the user.
+     * @param config The desired config
      *
      * @return The value of the stateful parameter currently on the system or null if not found
      */
-    abstract refresh(desired: V | null): Promise<V | null>;
+    abstract refresh(desired: V | null, config: Partial<T>): Promise<V | null>;
     /**
      * Create the stateful parameter on the system. This method is similar {@link Resource.create} except that its only
      * applicable to the stateful parameter. For resource `CREATE` operations, this method will be called after the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.81",
+  "version": "1.0.83",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -22,7 +22,7 @@
     "@oclif/prettier-config": "^0.2.1",
     "@oclif/test": "^3",
     "@types/npmcli__promise-spawn": "^6.0.3",
-    "@types/node": "^18",
+    "@types/node": "^20",
     "@types/semver": "^7.5.4",
     "@types/sinon": "^17.0.3",
     "@types/uuid": "^10.0.0",

package/src/plan/change-set.test.ts

@@ -1,6 +1,7 @@
 import { ChangeSet } from './change-set.js';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
 import { describe, expect, it } from 'vitest';
+import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
 
 describe('Change set tests', () => {
   it ('Correctly diffs two resource configs (modify)', () => {
@@ -31,7 +32,7 @@ describe('Change set tests', () => {
       propA: 'after',
     }
 
-    const cs = ChangeSet.calculateModification(after, before,);
+    const cs = ChangeSet.calculateModification(after, before);
     expect(cs.parameterChanges.length).to.eq(2);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.ADD);
@@ -104,7 +105,14 @@ describe('Change set tests', () => {
       propA: ['b', 'a', 'c'],
     }
 
-    const cs = ChangeSet.calculateModification(after, before, { propA: { type: 'array' } });
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      }
+    }).parameterSettings
+
+    const cs = ChangeSet.calculateModification(after, before, parameterSettings);
     expect(cs.parameterChanges.length).to.eq(1);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
     expect(cs.operation).to.eq(ResourceOperation.NOOP)
@@ -119,7 +127,14 @@ describe('Change set tests', () => {
       propA: ['b', 'a'],
     }
 
-    const cs = ChangeSet.calculateModification(after, before, { propA: { type: 'array' } });
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      }
+    }).parameterSettings
+
+    const cs = ChangeSet.calculateModification(after, before, parameterSettings);
     expect(cs.parameterChanges.length).to.eq(1);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs.operation).to.eq(ResourceOperation.RECREATE)
@@ -135,7 +150,14 @@ describe('Change set tests', () => {
       propB: 'before'
     }
 
-    const cs = ChangeSet.calculateModification(after, before, { propA: { canModify: true } });
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { canModify: true }
+      }
+    }).parameterSettings
+
+    const cs = ChangeSet.calculateModification(after, before, parameterSettings);
     expect(cs.parameterChanges.length).to.eq(2);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
@@ -152,10 +174,15 @@ describe('Change set tests', () => {
       propB: 'before'
     }
 
-    const cs = ChangeSet.calculateModification<any>(after, before, {
-      propA: { canModify: true },
-      propB: { canModify: true }
-    });
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { canModify: true },
+        propB: { canModify: true }
+      },
+    }).parameterSettings
+
+    const cs = ChangeSet.calculateModification<any>(after, before, parameterSettings);
     expect(cs.parameterChanges.length).to.eq(2);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
@@ -167,7 +194,15 @@ describe('Change set tests', () => {
     const arrA = ['a', 'b', 'd'];
     const arrB = ['a', 'b', 'd'];
 
-    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      },
+    }).parameterSettings
+
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
 
     expect(result.operation).to.eq(ResourceOperation.NOOP);
   })
@@ -176,7 +211,14 @@ describe('Change set tests', () => {
     const arrA = ['a', 'b'];
     const arrB = ['a', 'b', 'd'];
 
-    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      },
+    }).parameterSettings
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
 
     expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
   })
@@ -185,7 +227,14 @@ describe('Change set tests', () => {
     const arrA = ['b', 'a', 'd'];
     const arrB = ['a', 'b', 'd'];
 
-    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: { type: 'array' }
+      },
+    }).parameterSettings
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
 
     expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
   })
@@ -194,12 +243,18 @@ describe('Change set tests', () => {
     const arrA = [{ key1: 'a' }, { key1: 'a' }, { key1: 'a' }];
     const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
 
-    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, {
-      propA: {
-        type: 'array',
-        isElementEqual: (a, b) => a.key1 === b.key1
-      }
-    })
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: {
+          type: 'array',
+          isElementEqual: (a, b) => a.key1 === b.key1
+        }
+      },
+    }).parameterSettings
+
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
 
     expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
   })
@@ -208,12 +263,17 @@ describe('Change set tests', () => {
     const arrA = [{ key1: 'b' }, { key1: 'a' }, { key1: 'a' }];
     const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
 
-    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, {
-      propA: {
-        type: 'array',
-        isElementEqual: (a, b) => a.key1 === b.key1
-      }
-    })
+    const parameterSettings = new ParsedResourceSettings({
+      id: 'type',
+      parameterSettings: {
+        propA: {
+          type: 'array',
+          isElementEqual: (a, b) => a.key1 === b.key1
+        }
+      },
+    }).parameterSettings
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, parameterSettings)
 
     expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
   })

package/src/plan/change-set.ts

@@ -1,7 +1,6 @@
 import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
 
-import { ArrayParameterSetting, ParameterSetting, StatefulParameterSetting } from '../resource/resource-settings.js';
-import { areArraysEqual } from '../utils/utils.js';
+import { ParameterSetting } from '../resource/resource-settings.js';
 
 /**
  * A parameter change describes a parameter level change to a resource.
@@ -215,15 +214,6 @@ export class ChangeSet<T extends StringIndexedObject> {
     current: unknown,
     setting?: ParameterSetting,
   ): boolean {
-    switch (setting?.type) {
-      case 'array': {
-        const arrayParameter = setting as ArrayParameterSetting;
-        return areArraysEqual(arrayParameter, desired, current)
-      }
-
-      default: {
-        return (setting?.isEqual ?? ((a, b) => a === b))(desired, current)
-      }
-    }
+    return (setting?.isEqual ?? ((a, b) => a === b))(desired, current)
   }
 }

package/src/plan/plan.ts

@@ -253,16 +253,31 @@ export class Plan<T extends StringIndexedObject> {
         && 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: string, v: unknown[]): unknown[] {
       const desiredArray = desired![k] as unknown[];
       const matcher = ((settings.parameterSettings![k] as StatefulParameterSetting)
         .definition
         .getSettings() as ArrayParameterSetting)
-        .isElementEqual;
+        .isElementEqual ?? ((a, b) => a === b);
 
-      return v.filter((cv) =>
-        desiredArray.find((dv) => (matcher ?? ((a: any, b: any) => a === b))(dv, cv))
-      )
+      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;
+        }
+
+        desiredCopy.splice(counter, 1)
+        const [element] = currentCopy.splice(idx, 1)
+        result.push(element)
+      }
+
+      return result;
     }
   }
 

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

@@ -1,14 +1,6 @@
 import { StringIndexedObject } from 'codify-schemas';
 
-import { areArraysEqual } from '../utils/utils.js';
-import {
-  ArrayParameterSetting,
-  ParameterEqualsDefaults,
-  ParameterSetting,
-  ParameterSettingType,
-  ResourceSettings,
-  StatefulParameterSetting
-} from './resource-settings.js';
+import { ParameterSetting, resolveEqualsFn, ResourceSettings, StatefulParameterSetting } from './resource-settings.js';
 import { StatefulParameter as StatefulParameterImpl } from './stateful-parameter.js'
 
 export class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
@@ -54,7 +46,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
       const settings = Object.entries(this.settings.parameterSettings ?? {})
         .map(([k, v]) => [k, v!] as const)
         .map(([k, v]) => {
-          v.isEqual = this.resolveEqualsFn(v, k);
+          v.isEqual = resolveEqualsFn(v, k);
 
           return [k, v];
         })
@@ -154,18 +146,6 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
     // The rest of the types have defaults set already
   }
 
-  private resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => boolean {
-    if (parameter.type === 'array') {
-      return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter as ArrayParameterSetting)
-    }
-
-    if (parameter.type === 'stateful') {
-      return this.resolveEqualsFn((parameter as StatefulParameterSetting).definition.getSettings(), key)
-    }
-
-    return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type as ParameterSettingType] ?? (((a, b) => a === b));
-  }
-
   private getFromCacheOrCreate<T2>(key: string, create: () => T2): T2 {
     if (this.cache.has(key)) {
       return this.cache.get(key) as T2

package/src/resource/resource-controller.ts

@@ -112,6 +112,7 @@ export class ResourceController<T extends StringIndexedObject> {
       coreParameters,
       desiredParameters,
       stateParameters,
+      allParameters,
       allNonStatefulParameters,
       allStatefulParameters,
     } = parsedConfig;
@@ -138,7 +139,7 @@ export class ResourceController<T extends StringIndexedObject> {
 
     // Refresh stateful parameters. These parameters have state external to the resource. allowMultiple
     // does not work together with stateful parameters
-    const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters);
+    const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, allParameters);
 
     return Plan.calculate({
       desiredParameters,
@@ -298,7 +299,7 @@ ${JSON.stringify(refresh, null, 2)}
 
   // Refresh stateful parameters
   // This refreshes parameters that are stateful (they can be added, deleted separately from the resource)
-  private async refreshStatefulParameters(statefulParametersConfig: Partial<T>): Promise<Partial<T>> {
+  private async refreshStatefulParameters(statefulParametersConfig: Partial<T>, allParameters: Partial<T>): Promise<Partial<T>> {
     const result: Partial<T> = {}
     const sortedEntries = Object.entries(statefulParametersConfig)
       .sort(
@@ -311,7 +312,7 @@ ${JSON.stringify(refresh, null, 2)}
         throw new Error(`Stateful parameter ${key} was not found`);
       }
 
-      (result as Record<string, unknown>)[key] = await statefulParameter.refresh(desiredValue ?? null)
+      (result as Record<string, unknown>)[key] = await statefulParameter.refresh(desiredValue ?? null, allParameters)
     }
 
     return result;

package/src/resource/resource-settings.ts

@@ -1,7 +1,7 @@
 import { StringIndexedObject } from 'codify-schemas';
 import path from 'node:path';
 
-import { untildify } from '../utils/utils.js';
+import { areArraysEqual, untildify } from '../utils/utils.js';
 import { StatefulParameter } from './stateful-parameter.js';
 
 /**
@@ -183,10 +183,23 @@ export interface StatefulParameterSetting extends DefaultParameterSetting {
   order?: number,
 }
 
-export const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown, b: unknown) => boolean>> = {
+const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown, b: unknown) => boolean>> = {
   'boolean': (a: unknown, b: unknown) => Boolean(a) === Boolean(b),
   'directory': (a: unknown, b: unknown) => path.resolve(untildify(String(a))) === path.resolve(untildify(String(b))),
   'number': (a: unknown, b: unknown) => Number(a) === Number(b),
   'string': (a: unknown, b: unknown) => String(a) === String(b),
   'version': (desired: unknown, current: unknown) => String(current).includes(String(desired))
 }
+
+
+export function resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => boolean {
+  if (parameter.type === 'array') {
+    return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter as ArrayParameterSetting)
+  }
+
+  if (parameter.type === 'stateful') {
+    return resolveEqualsFn((parameter as StatefulParameterSetting).definition.getSettings(), key)
+  }
+
+  return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type as ParameterSettingType] ?? (((a, b) => a === b));
+}

package/src/resource/stateful-parameter.test.ts

@@ -1,8 +1,15 @@
 import { describe, expect, it } from 'vitest';
 import { spy } from 'sinon';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { TestArrayStatefulParameter, TestConfig, testPlan, TestStatefulParameter } from '../utils/test-utils.test.js';
-import { ArrayParameterSetting, ParameterSetting } from './resource-settings.js';
+import {
+  TestArrayStatefulParameter,
+  TestConfig,
+  testPlan,
+  TestResource,
+  TestStatefulParameter
+} from '../utils/test-utils.test.js';
+import { ArrayParameterSetting, ParameterSetting, ResourceSettings } from './resource-settings.js';
+import { ResourceController } from './resource-controller.js';
 
 describe('Stateful parameter tests', () => {
   it('addItem is called the correct number of times', async () => {
@@ -49,7 +56,7 @@ describe('Stateful parameter tests', () => {
     expect(plan.changeSet.operation).to.eq(ResourceOperation.MODIFY);
     expect(plan.changeSet.parameterChanges[0]).toMatchObject({
       name: 'propZ',
-      previousValue: ['a', 'c'], // In stateless mode the previous value gets filtered to prevent deletes
+      previousValue: ['c', 'a'], // In stateless mode the previous value gets filtered to prevent deletes
       newValue: ['a', 'c', 'd', 'e', 'f'],
       operation: ParameterOperation.MODIFY,
     })
@@ -108,4 +115,44 @@ describe('Stateful parameter tests', () => {
 
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
+
+  it('isElementEquals test', async () => {
+    const testParameter = spy(new class extends TestArrayStatefulParameter {
+      getSettings(): ArrayParameterSetting {
+        return {
+          type: 'array',
+          isElementEqual: (desired, current) => current.includes(desired),
+        }
+      }
+
+      async refresh(): Promise<any> {
+        return [
+          '20.15.0',
+          '20.15.1'
+        ]
+      }
+    });
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'type',
+          parameterSettings: { nodeVersions: { type: 'stateful', definition: testParameter } }
+        }
+      }
+
+      async refresh(): Promise<Partial<any> | null> {
+        return {};
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({
+      nodeVersions: ['20.15'],
+    } as any)
+
+    console.log(JSON.stringify(plan, null, 2))
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
 })

package/src/resource/stateful-parameter.ts

@@ -31,10 +31,11 @@ export abstract class StatefulParameter<T extends StringIndexedObject, V extends
    * Return the value of the stateful parameter or null if not found.
    *
    * @param desired The desired value of the user.
+   * @param config The desired config
    *
    * @return The value of the stateful parameter currently on the system or null if not found
    */
-  abstract refresh(desired: V | null): Promise<V | null>;
+  abstract refresh(desired: V | null, config: Partial<T>): Promise<V | null>;
 
   /**
    * Create the stateful parameter on the system. This method is similar {@link Resource.create} except that its only