codify-plugin-lib 1.0.79 → 1.0.80

package/dist/plan/plan.js

@@ -1,5 +1,6 @@
 import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
 import { v4 as uuidV4 } from 'uuid';
+import { asyncFilter, asyncIncludes, asyncMap } from '../utils/utils.js';
 import { ChangeSet } from './change-set.js';
 /**
  * A plan represents a set of actions that after taken will turn the current resource into the desired one.
@@ -79,7 +80,7 @@ export class Plan {
             settings,
             statefulMode
         });
-        const filteredCurrentParameters = Plan.filterCurrentParams({
+        const filteredCurrentParameters = await Plan.filterCurrentParams({
             desiredParameters,
             currentParameters,
             stateParameters,
@@ -110,7 +111,7 @@ export class Plan {
      *  2. In stateful mode, filter current by state and desired. We only know about the settings the user has previously set
      *  or wants to set. If a parameter is not specified then it's not managed by Codify.
      */
-    static filterCurrentParams(params) {
+    static async filterCurrentParams(params) {
         const { desiredParameters: desired, currentParameters: current, stateParameters: state, settings, statefulMode } = params;
         if (!current) {
             return null;
@@ -125,9 +126,8 @@ export class Plan {
             return filteredCurrent;
         }
         // TODO: Add object handling here in addition to arrays in the future
-        const arrayStatefulParameters = Object.fromEntries(Object.entries(filteredCurrent)
-            .filter(([k, v]) => isArrayStatefulParameter(k, v))
-            .map(([k, v]) => [k, filterArrayStatefulParameter(k, v)]));
+        const arrayStatefulParameters = Object.fromEntries(await asyncMap(Object.entries(filteredCurrent)
+            .filter(([k, v]) => isArrayStatefulParameter(k, v)), async ([k, v]) => [k, await filterArrayStatefulParameter(k, v)]));
         return { ...filteredCurrent, ...arrayStatefulParameters };
         function filterCurrent() {
             if (!current) {
@@ -148,13 +148,14 @@ export class Plan {
                 && settings.parameterSettings[k].definition.getSettings().type === 'array'
                 && Array.isArray(v);
         }
-        function filterArrayStatefulParameter(k, v) {
+        async 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)));
+            const eq = matcher ?? ((a, b) => a === b);
+            return asyncFilter(v, async (cv) => asyncIncludes(desiredArray, async (dv) => eq(dv, cv)));
         }
     }
     // TODO: This needs to be revisited. I don't think this is valid anymore.

package/dist/utils/utils.d.ts

@@ -37,5 +37,10 @@ export declare function splitUserConfig<T extends StringIndexedObject>(config: R
 };
 export declare function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean;
 export declare function untildify(pathWithTilde: string): string;
-export declare function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown): boolean;
+export declare function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown): Promise<boolean>;
+export declare function asyncFilter<T>(arr: T[], filter: (a: T) => Promise<boolean> | boolean): Promise<T[]>;
+export declare function asyncMap<T, R>(arr: T[], map: (a: T) => Promise<R> | R): Promise<R[]>;
+export declare function asyncFindIndex<T>(arr: T[], eq: (a: T) => Promise<boolean> | boolean): Promise<number>;
+export declare function asyncFind<T>(arr: T[], eq: (a: T) => Promise<boolean> | boolean): Promise<T | undefined>;
+export declare function asyncIncludes<T>(arr: T[], eq: (a: T) => Promise<boolean> | boolean): Promise<boolean>;
 export {};

package/dist/utils/utils.js

@@ -72,7 +72,7 @@ const homeDirectory = os.homedir();
 export function untildify(pathWithTilde) {
     return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
 }
-export function areArraysEqual(parameter, desired, current) {
+export async function areArraysEqual(parameter, desired, current) {
     if (!Array.isArray(desired) || !Array.isArray(current)) {
         throw new Error(`A non-array value:
           
@@ -88,10 +88,11 @@ Was provided even though type array was specified.
     }
     const desiredCopy = [...desired];
     const currentCopy = [...current];
+    const eq = parameter.isElementEqual ?? ((a, b) => a === b);
     // Algorithm for to check equality between two un-ordered; un-hashable arrays using
     // an isElementEqual method. Time: O(n^2)
     for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
-        const idx = currentCopy.findIndex((e2) => (parameter.isElementEqual ?? ((a, b) => a === b))(desiredCopy[counter], e2));
+        const idx = await asyncFindIndex(currentCopy, (e2) => eq(desiredCopy[counter], e2));
         if (idx === -1) {
             return false;
         }
@@ -100,3 +101,43 @@ Was provided even though type array was specified.
     }
     return currentCopy.length === 0;
 }
+export async function asyncFilter(arr, filter) {
+    const result = [];
+    for (const element of arr) {
+        if (await filter(element)) {
+            result.push(element);
+        }
+    }
+    return result;
+}
+export async function asyncMap(arr, map) {
+    const result = [];
+    for (const element of arr) {
+        result.push(await map(element));
+    }
+    return result;
+}
+export async function asyncFindIndex(arr, eq) {
+    for (const [counter, element] of arr.entries()) {
+        if (await eq(element)) {
+            return counter;
+        }
+    }
+    return -1;
+}
+export async function asyncFind(arr, eq) {
+    for (const element of arr) {
+        if (await eq(element)) {
+            return element;
+        }
+    }
+    return undefined;
+}
+export async function asyncIncludes(arr, eq) {
+    for (const element of arr) {
+        if (await eq(element)) {
+            return true;
+        }
+    }
+    return false;
+}

package/package.json

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

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

@@ -2,8 +2,8 @@ import { ChangeSet } from './change-set.js';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
 import { describe, expect, it } from 'vitest';
 
-describe('Change set tests', () => {
-  it ('Correctly diffs two resource configs (modify)', () => {
+describe('Change set tests', async () => {
+  it ('Correctly diffs two resource configs (modify)', async () => {
     const after = {
       propA: 'before',
       propB: 'before'
@@ -14,14 +14,14 @@ describe('Change set tests', () => {
       propB: 'after'
     }
 
-    const cs = ChangeSet.calculateModification(after, before);
+    const cs = await 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.MODIFY);
     expect(cs.operation).to.eq(ResourceOperation.RECREATE)
   })
 
-  it ('Correctly diffs two resource configs (add)', () => {
+  it ('Correctly diffs two resource configs (add)', async () => {
     const after = {
       propA: 'before',
       propB: 'after'
@@ -31,7 +31,7 @@ describe('Change set tests', () => {
       propA: 'after',
     }
 
-    const cs = ChangeSet.calculateModification(after, before,);
+    const cs = await 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);
@@ -39,7 +39,7 @@ describe('Change set tests', () => {
 
   })
 
-  it ('Correctly diffs two resource configs (remove)', () => {
+  it ('Correctly diffs two resource configs (remove)', async () => {
     const after = {
       propA: 'after',
     }
@@ -49,14 +49,14 @@ describe('Change set tests', () => {
       propB: 'before'
     }
 
-    const cs = ChangeSet.calculateModification(after, before);
+    const cs = await 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.REMOVE);
     expect(cs.operation).to.eq(ResourceOperation.RECREATE)
   })
 
-  it ('Correctly diffs two resource configs (no-op)', () => {
+  it ('Correctly diffs two resource configs (no-op)', async () => {
     const after = {
       propA: 'prop',
     }
@@ -65,7 +65,7 @@ describe('Change set tests', () => {
       propA: 'prop',
     }
 
-    const cs = ChangeSet.calculateModification(after, before);
+    const cs = await ChangeSet.calculateModification(after, before);
     expect(cs.parameterChanges.length).to.eq(1);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
     expect(cs.operation).to.eq(ResourceOperation.NOOP)
@@ -95,7 +95,7 @@ describe('Change set tests', () => {
     expect(cs.operation).to.eq(ResourceOperation.DESTROY)
   })
 
-  it ('handles simple arrays', () => {
+  it ('handles simple arrays', async () => {
     const before = {
       propA: ['a', 'b', 'c'],
     }
@@ -104,13 +104,13 @@ describe('Change set tests', () => {
       propA: ['b', 'a', 'c'],
     }
 
-    const cs = ChangeSet.calculateModification(after, before, { propA: { type: 'array' } });
+    const cs = await ChangeSet.calculateModification(after, before, { propA: { type: 'array' } });
     expect(cs.parameterChanges.length).to.eq(1);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
     expect(cs.operation).to.eq(ResourceOperation.NOOP)
   })
 
-  it('handles simple arrays 2', () => {
+  it('handles simple arrays 2', async () => {
     const after = {
       propA: ['a', 'b', 'c'],
     }
@@ -119,13 +119,13 @@ describe('Change set tests', () => {
       propA: ['b', 'a'],
     }
 
-    const cs = ChangeSet.calculateModification(after, before, { propA: { type: 'array' } });
+    const cs = await ChangeSet.calculateModification(after, before, { propA: { type: 'array' } });
     expect(cs.parameterChanges.length).to.eq(1);
     expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
     expect(cs.operation).to.eq(ResourceOperation.RECREATE)
   })
 
-  it('determines the order of operations with canModify 1', () => {
+  it('determines the order of operations with canModify 1', async () => {
     const after = {
       propA: 'after',
     }
@@ -135,14 +135,14 @@ describe('Change set tests', () => {
       propB: 'before'
     }
 
-    const cs = ChangeSet.calculateModification(after, before, { propA: { canModify: true } });
+    const cs = await ChangeSet.calculateModification(after, before, { propA: { canModify: true } });
     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);
     expect(cs.operation).to.eq(ResourceOperation.RECREATE)
   })
 
-  it('determines the order of operations with canModify 2', () => {
+  it('determines the order of operations with canModify 2', async () => {
     const after = {
       propA: 'after',
     }
@@ -152,7 +152,7 @@ describe('Change set tests', () => {
       propB: 'before'
     }
 
-    const cs = ChangeSet.calculateModification<any>(after, before, {
+    const cs = await ChangeSet.calculateModification<any>(after, before, {
       propA: { canModify: true },
       propB: { canModify: true }
     });
@@ -163,38 +163,38 @@ describe('Change set tests', () => {
   })
 
 
-  it('correctly determines array equality', () => {
+  it('correctly determines array equality', async () => {
     const arrA = ['a', 'b', 'd'];
     const arrB = ['a', 'b', 'd'];
 
-    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+    const result = await ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
 
     expect(result.operation).to.eq(ResourceOperation.NOOP);
   })
 
-  it('correctly determines array equality 2', () => {
+  it('correctly determines array equality 2', async () => {
     const arrA = ['a', 'b'];
     const arrB = ['a', 'b', 'd'];
 
-    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+    const result = await ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
 
     expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
   })
 
-  it('correctly determines array equality 3', () => {
+  it('correctly determines array equality 3', async () => {
     const arrA = ['b', 'a', 'd'];
     const arrB = ['a', 'b', 'd'];
 
-    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+    const result = await ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
 
     expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
   })
 
-  it('correctly determines array equality 4', () => {
+  it('correctly determines array equality 4', async () => {
     const arrA = [{ key1: 'a' }, { key1: 'a' }, { key1: 'a' }];
     const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
 
-    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, {
+    const result = await ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, {
       propA: {
         type: 'array',
         isElementEqual: (a, b) => a.key1 === b.key1
@@ -204,11 +204,11 @@ describe('Change set tests', () => {
     expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
   })
 
-  it('correctly determines array equality 5', () => {
+  it('correctly determines array equality 5', async () => {
     const arrA = [{ key1: 'b' }, { key1: 'a' }, { key1: 'a' }];
     const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
 
-    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, {
+    const result = await ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, {
       propA: {
         type: 'array',
         isElementEqual: (a, b) => a.key1 === b.key1

package/src/plan/plan.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { Plan } from './plan.js';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { TestConfig, TestResource } from '../utils/test-utils.test.js';
+import { TestConfig, testPlan, TestResource } from '../utils/test-utils.test.js';
 import { ResourceController } from '../resource/resource-controller.js';
 import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
 import { ResourceSettings } from '../resource/resource-settings.js';
@@ -128,8 +128,8 @@ describe('Plan entity tests', () => {
     ).to.be.true;
   })
 
-  it('Returns the original resource names', () => {
-    const plan = Plan.calculate<TestConfig>({
+  it('Returns the original resource names', async () => {
+    const plan = await Plan.calculate<TestConfig>({
       desiredParameters: { propA: 'propA' },
       currentParametersArray: [{ propA: 'propA2' }],
       stateParameters: null,
@@ -147,7 +147,8 @@ describe('Plan entity tests', () => {
       operation: ResourceOperation.RECREATE
     })
   })
-})
+});
+
 
 function createTestResource() {
   return new class extends TestResource {

package/src/plan/plan.ts

@@ -10,6 +10,7 @@ import { v4 as uuidV4 } from 'uuid';
 
 import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
 import { ArrayParameterSetting, ResourceSettings, StatefulParameterSetting } from '../resource/resource-settings.js';
+import { asyncFilter, asyncIncludes, asyncMap } from '../utils/utils.js';
 import { ChangeSet } from './change-set.js';
 
 /**
@@ -130,7 +131,7 @@ export class Plan<T extends StringIndexedObject> {
       statefulMode
     });
 
-    const filteredCurrentParameters = Plan.filterCurrentParams<T>({
+    const filteredCurrentParameters = await Plan.filterCurrentParams<T>({
       desiredParameters,
       currentParameters,
       stateParameters,
@@ -187,13 +188,13 @@ export class Plan<T extends StringIndexedObject> {
    *  2. In stateful mode, filter current by state and desired. We only know about the settings the user has previously set
    *  or wants to set. If a parameter is not specified then it's not managed by Codify.
    */
-  private static filterCurrentParams<T extends StringIndexedObject>(params: {
+  private static async filterCurrentParams<T extends StringIndexedObject>(params: {
     desiredParameters: Partial<T> | null,
     currentParameters: Partial<T> | null,
     stateParameters: Partial<T> | null,
     settings: ResourceSettings<T>,
     statefulMode: boolean,
-  }): Partial<T> | null {
+  }): Promise<Partial<T> | null> {
     const {
       desiredParameters: desired,
       currentParameters: current,
@@ -219,10 +220,12 @@ export class Plan<T extends StringIndexedObject> {
 
     // TODO: Add object handling here in addition to arrays in the future
     const arrayStatefulParameters = Object.fromEntries(
-      Object.entries(filteredCurrent)
-        .filter(([k, v]) => isArrayStatefulParameter(k, v))
-        .map(([k, v]) => [k, filterArrayStatefulParameter(k, v)])
-    )
+      await asyncMap(
+        Object.entries(filteredCurrent)
+          .filter(([k, v]) => isArrayStatefulParameter(k, v)),
+        async ([k, v]) => [k, await filterArrayStatefulParameter(k, v)],
+      )
+    );
 
     return { ...filteredCurrent, ...arrayStatefulParameters }
 
@@ -253,15 +256,17 @@ export class Plan<T extends StringIndexedObject> {
         && Array.isArray(v)
     }
 
-    function filterArrayStatefulParameter(k: string, v: unknown[]): unknown[] {
+    async function filterArrayStatefulParameter(k: string, v: unknown[]): Promise<unknown[]> {
       const desiredArray = desired![k] as unknown[];
       const matcher = ((settings.parameterSettings![k] as StatefulParameterSetting)
         .definition
         .getSettings() as ArrayParameterSetting)
         .isElementEqual;
 
-      return v.filter((cv) =>
-        desiredArray.find((dv) => (matcher ?? ((a: any, b: any) => a === b))(dv, cv))
+      const eq = matcher ?? ((a: unknown, b: unknown) => a === b)
+
+      return asyncFilter(v, async (cv) =>
+        asyncIncludes(desiredArray, async (dv) => eq(dv, cv))
       )
     }
   }

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

@@ -99,7 +99,7 @@ describe('Resource tests', () => {
     const resourceSpy = spy(resource);
 
     await controllerSpy.apply(
-      testPlan({
+      await testPlan({
         desired: { propA: 'a', propB: 0 },
       })
     )
@@ -116,7 +116,7 @@ describe('Resource tests', () => {
     const resourceSpy = spy(resource);
 
     await controllerSpy.apply(
-      testPlan({
+      await testPlan({
         current: [{ propA: 'a', propB: 0 }],
         state: { propA: 'a', propB: 0 },
         statefulMode: true,
@@ -135,7 +135,7 @@ describe('Resource tests', () => {
     const resourceSpy = spy(resource);
 
     await controllerSpy.apply(
-      testPlan({
+      await testPlan({
         desired: { propA: 'a', propB: 0 },
         current: [{ propA: 'b', propB: -1 }],
         statefulMode: true

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

@@ -77,7 +77,7 @@ describe('Resource parameter tests', () => {
     const resourceSpy = spy(resource);
 
     await controller.apply(
-      testPlan<TestConfig>({
+      await testPlan<TestConfig>({
         desired: { propA: 'a', propB: 0, propC: 'c' }
       })
     );
@@ -491,4 +491,35 @@ describe('Resource parameter tests', () => {
 
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
+
+  it('Works with async equals methods', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          parameterSettings: {
+            propA: {
+              isEqual: async (desired, current) => {
+                console.log(desired, current)
+                await sleep(500);
+                return true;
+              }
+            }
+          }
+        }
+      }
+    };
+    const controller = new ResourceController(resource);
+
+    const plan = await controller.plan({ type: 'type', propA: 'abc' } as any);
+
+    console.log(JSON.stringify(plan, null, 2));
+
+    expect(plan.toResponse().operation).to.equal(ResourceOperation.NOOP);
+  })
 })
+
+function sleep(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+

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

@@ -1,12 +1,13 @@
 import { describe, expect, it } from 'vitest';
 import { spy } from 'sinon';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { TestArrayStatefulParameter, TestConfig, testPlan } from '../utils/test-utils.test.js';
-import { ArrayParameterSetting } from './resource-settings.js';
+import { TestArrayStatefulParameter, TestConfig, testPlan, TestResource } from '../utils/test-utils.test.js';
+import { ArrayParameterSetting, 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 () => {
-    const plan = testPlan<TestConfig>({
+    const plan = await testPlan<TestConfig>({
       desired: { propZ: ['a', 'b', 'c'] },
     });
 
@@ -21,7 +22,7 @@ describe('Stateful parameter tests', () => {
   })
 
   it('applyRemoveItem is called the correct number of times', async () => {
-    const plan = testPlan<TestConfig>({
+    const plan = await testPlan<TestConfig>({
       desired: null,
       current: [{ propZ: ['a', 'b', 'c'] }],
       state: { propZ: ['a', 'b', 'c'] },
@@ -40,7 +41,7 @@ describe('Stateful parameter tests', () => {
 
   it('In stateless mode only applyAddItem is called only for modifies', async () => {
     const parameter = new TestArrayStatefulParameter()
-    const plan = testPlan<TestConfig>({
+    const plan = await testPlan<TestConfig>({
       desired: { propZ: ['a', 'c', 'd', 'e', 'f'] }, // b to remove, d, e, f to add
       current: [{ propZ: ['a', 'b', 'c'] }],
       settings: { id: 'type', parameterSettings: { propZ: { type: 'stateful', definition: parameter } } },
@@ -71,7 +72,7 @@ describe('Stateful parameter tests', () => {
       }
     });
 
-    const plan = testPlan<TestConfig>({
+    const plan = await testPlan<TestConfig>({
       desired: { propZ: ['9.12', '9.13'] }, // b to remove, d, e, f to add
       current: [{ propZ: ['9.12.9'] }],
       settings: { id: 'type', parameterSettings: { propZ: { type: 'stateful', definition: testParameter } } }
@@ -90,4 +91,32 @@ describe('Stateful parameter tests', () => {
     expect(testParameter.addItem.calledOnce).to.be.true;
     expect(testParameter.removeItem.called).to.be.false;
   })
+
+  it('isElementEqual works being async', async () => {
+    const testParameter = spy(new class extends TestArrayStatefulParameter {
+      getSettings(): ArrayParameterSetting {
+        return {
+          type: 'array',
+          isElementEqual: async (desired, current) => {
+            console.log(desired, current)
+            await sleep(50);
+            return true;
+          }
+        }
+      }
+    });
+
+    const plan = await testPlan<TestConfig>({
+      desired: { propZ: ['9.12'] }, // b to remove, d, e, f to add
+      current: [{ propZ: ['23472934'] }], // purposely make these two values very different since isElementEqual always returns true
+      settings: { id: 'type', parameterSettings: { propZ: { type: 'stateful', definition: testParameter } } }
+    });
+
+    expect(plan.toResponse().operation).to.equal(ResourceOperation.NOOP);
+  })
 })
+
+function sleep(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+

package/src/utils/utils.ts

@@ -111,7 +111,7 @@ export function untildify(pathWithTilde: string) {
   return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
 }
 
-export function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown) {
+export async function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown) {
   if (!Array.isArray(desired) || !Array.isArray(current)) {
     throw new Error(`A non-array value:
           
@@ -130,10 +130,12 @@ Was provided even though type array was specified.
   const desiredCopy = [...desired];
   const currentCopy = [...current];
 
+  const eq = parameter.isElementEqual ?? ((a, b) => a === b);
+
   // Algorithm for to check equality between two un-ordered; un-hashable arrays using
   // an isElementEqual method. Time: O(n^2)
   for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
-    const idx = currentCopy.findIndex((e2) => (parameter.isElementEqual ?? ((a, b) => a === b))(desiredCopy[counter], e2))
+    const idx = await asyncFindIndex(currentCopy, (e2) => eq(desiredCopy[counter], e2))
 
     if (idx === -1) {
       return false;
@@ -145,3 +147,56 @@ Was provided even though type array was specified.
 
   return currentCopy.length === 0;
 }
+
+export async function asyncFilter<T>(arr: T[], filter: (a: T) => Promise<boolean> | boolean): Promise<T[]> {
+  const result = [];
+
+  for (const element of arr) {
+    if (await filter(element)) {
+      result.push(element);
+    }
+  }
+
+  return result;
+}
+
+export async function asyncMap<T, R>(arr: T[], map: (a: T) => Promise<R> | R): Promise<R[]> {
+  const result: R[] = [];
+
+  for (const element of arr) {
+    result.push(await map(element));
+  }
+
+  return result;
+}
+
+
+export async function asyncFindIndex<T>(arr: T[], eq: (a: T) => Promise<boolean> | boolean): Promise<number> {
+  for (const [counter, element] of arr.entries()) {
+    if (await eq(element)) {
+      return counter;
+    }
+  }
+
+  return -1;
+}
+
+export async function asyncFind<T>(arr: T[], eq: (a: T) => Promise<boolean> | boolean): Promise<T | undefined> {
+  for (const element of arr) {
+    if (await eq(element)) {
+      return element;
+    }
+  }
+
+  return undefined;
+}
+
+export async function asyncIncludes<T>(arr: T[], eq: (a: T) => Promise<boolean> | boolean): Promise<boolean> {
+  for (const element of arr) {
+    if (await eq(element)) {
+      return true
+    }
+  }
+
+  return false;
+}