codify-plugin-lib 1.0.41 → 1.0.43

package/dist/entities/change-set.d.ts

@@ -12,13 +12,12 @@ export declare class ChangeSet<T extends StringIndexedObject> {
     constructor(operation: ResourceOperation, parameterChanges: Array<ParameterChange<T>>);
     get desiredParameters(): T;
     get currentParameters(): T;
-    static newCreate<T extends {}>(desiredConfig: T): ChangeSet<StringIndexedObject>;
     static calculateParameterChangeSet<T extends StringIndexedObject>(desired: T | null, current: T | null, options: {
         statefulMode: boolean;
         parameterConfigurations?: Record<keyof T, ParameterConfiguration>;
     }): ParameterChange<T>[];
     static combineResourceOperations(prev: ResourceOperation, next: ResourceOperation): ResourceOperation;
-    static isSame(a: unknown, b: unknown, isEqual?: (a: unknown, b: unknown) => boolean): boolean;
+    static isSame(desired: unknown, current: unknown, configuration?: ParameterConfiguration): boolean;
     private static calculateStatefulModeChangeSet;
     private static calculateStatelessModeChangeSet;
 }

package/dist/entities/change-set.js

@@ -20,19 +20,6 @@ export class ChangeSet {
             [pc.name]: pc.previousValue,
         }), {});
     }
-    static newCreate(desiredConfig) {
-        const parameterChangeSet = Object.entries(desiredConfig)
-            .filter(([k,]) => k !== 'type' && k !== 'name')
-            .map(([k, v]) => {
-            return {
-                name: k,
-                operation: ParameterOperation.ADD,
-                previousValue: null,
-                newValue: v,
-            };
-        });
-        return new ChangeSet(ResourceOperation.CREATE, parameterChangeSet);
-    }
     static calculateParameterChangeSet(desired, current, options) {
         if (options.statefulMode) {
             return ChangeSet.calculateStatefulModeChangeSet(desired, current, options.parameterConfigurations);
@@ -53,16 +40,22 @@ export class ChangeSet {
         const indexNext = orderOfOperations.indexOf(next);
         return orderOfOperations[Math.max(indexPrev, indexNext)];
     }
-    static isSame(a, b, isEqual) {
-        if (isEqual) {
-            return isEqual(a, b);
+    static isSame(desired, current, configuration) {
+        if (configuration?.isEqual) {
+            return configuration.isEqual(desired, current);
         }
-        if (Array.isArray(a) && Array.isArray(b)) {
-            const sortedPrev = a.map((x) => x).sort();
-            const sortedNext = b.map((x) => x).sort();
-            return JSON.stringify(sortedPrev) === JSON.stringify(sortedNext);
+        if (Array.isArray(desired) && Array.isArray(current)) {
+            const sortedDesired = desired.map((x) => x).sort();
+            const sortedCurrent = current.map((x) => x).sort();
+            if (sortedDesired.length !== sortedCurrent.length) {
+                return false;
+            }
+            if (configuration?.isElementEqual) {
+                return sortedDesired.every((value, index) => configuration.isElementEqual(value, sortedCurrent[index]));
+            }
+            return JSON.stringify(sortedDesired) === JSON.stringify(sortedCurrent);
         }
-        return a === b;
+        return desired === current;
     }
     static calculateStatefulModeChangeSet(desired, current, parameterConfigurations) {
         const parameterChangeSet = new Array();
@@ -79,7 +72,7 @@ export class ChangeSet {
                 delete _current[k];
                 continue;
             }
-            if (!ChangeSet.isSame(_desired[k], _current[k], parameterConfigurations?.[k]?.isEqual)) {
+            if (!ChangeSet.isSame(_desired[k], _current[k], parameterConfigurations?.[k])) {
                 parameterChangeSet.push({
                     name: k,
                     previousValue: v,
@@ -126,7 +119,7 @@ export class ChangeSet {
                 });
                 continue;
             }
-            if (!ChangeSet.isSame(_desired[k], _current[k], parameterConfigurations?.[k]?.isEqual)) {
+            if (!ChangeSet.isSame(_desired[k], _current[k], parameterConfigurations?.[k])) {
                 parameterChangeSet.push({
                     name: k,
                     previousValue: _current[k],

package/dist/entities/plan-types.d.ts

@@ -2,6 +2,7 @@ import { ResourceOperation } from 'codify-schemas';
 export interface ParameterConfiguration {
     planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
     isEqual?: (desired: any, current: any) => boolean;
+    isElementEqual?: (desired: any, current: any) => boolean;
     isStatefulParameter?: boolean;
 }
 export interface PlanConfiguration<T> {

package/dist/entities/plan.d.ts

@@ -6,7 +6,7 @@ export declare class Plan<T extends StringIndexedObject> {
     changeSet: ChangeSet<T>;
     resourceMetadata: ResourceConfig;
     constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig);
-    static create<T extends StringIndexedObject>(desiredConfig: Partial<T> & ResourceConfig, currentConfig: Partial<T> & ResourceConfig | null, configuration: PlanConfiguration<T>): Plan<T>;
+    static create<T extends StringIndexedObject>(desiredParameters: Partial<T> | null, currentParameters: Partial<T> | null, resourceMetadata: ResourceConfig, configuration: PlanConfiguration<T>): Plan<T>;
     getResourceType(): string;
     static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan']): Plan<T>;
     get desiredConfig(): T;

package/dist/entities/plan.js

@@ -1,7 +1,6 @@
 import { ChangeSet } from './change-set.js';
 import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
 import { randomUUID } from 'crypto';
-import { splitUserConfig } from '../utils/utils.js';
 export class Plan {
     id;
     changeSet;
@@ -11,19 +10,17 @@ export class Plan {
         this.changeSet = changeSet;
         this.resourceMetadata = resourceMetadata;
     }
-    static create(desiredConfig, currentConfig, configuration) {
+    static create(desiredParameters, currentParameters, resourceMetadata, configuration) {
         const parameterConfigurations = configuration.parameterConfigurations ?? {};
         const statefulParameterNames = new Set([...Object.entries(parameterConfigurations)]
             .filter(([k, v]) => v.isStatefulParameter)
             .map(([k, v]) => k));
-        const { resourceMetadata, parameters: desiredParameters } = splitUserConfig(desiredConfig);
-        const { parameters: currentParameters } = currentConfig != null ? splitUserConfig(currentConfig) : { parameters: null };
         const parameterChangeSet = ChangeSet.calculateParameterChangeSet(desiredParameters, currentParameters, { statefulMode: configuration.statefulMode, parameterConfigurations });
         let resourceOperation;
-        if (!currentConfig && desiredConfig) {
+        if (!currentParameters && desiredParameters) {
             resourceOperation = ResourceOperation.CREATE;
         }
-        else if (currentConfig && !desiredConfig) {
+        else if (currentParameters && !desiredParameters) {
             resourceOperation = ResourceOperation.DESTROY;
         }
         else {

package/dist/entities/resource.js

@@ -33,18 +33,18 @@ export class Resource {
         const keysToRefresh = new Set(Object.keys(resourceParameters));
         const currentParameters = await this.refresh(keysToRefresh);
         if (currentParameters == null) {
-            return Plan.create(desiredConfig, null, planConfiguration);
+            return Plan.create(desiredParameters, null, resourceMetadata, planConfiguration);
         }
         this.validateRefreshResults(currentParameters, keysToRefresh);
         for (const statefulParameter of statefulParameters) {
             const desiredValue = desiredParameters[statefulParameter.name];
-            let currentValue = await statefulParameter.refresh(desiredValue ?? null) ?? undefined;
+            let currentValue = await statefulParameter.refresh() ?? undefined;
             if (Array.isArray(currentValue) && Array.isArray(desiredValue) && !planConfiguration.statefulMode) {
                 currentValue = currentValue.filter((p) => desiredValue?.includes(p));
             }
             currentParameters[statefulParameter.name] = currentValue;
         }
-        return Plan.create(desiredConfig, { ...currentParameters, ...resourceMetadata }, planConfiguration);
+        return Plan.create(desiredParameters, currentParameters, resourceMetadata, planConfiguration);
     }
     async apply(plan) {
         if (plan.getResourceType() !== this.typeId) {

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

@@ -2,23 +2,28 @@ import { Plan } from './plan.js';
 import { StringIndexedObject } from 'codify-schemas';
 export interface StatefulParameterConfiguration<T> {
     name: keyof T;
-    isEqual?: (a: any, b: any) => boolean;
+    isEqual?: (desired: any, current: any) => boolean;
+}
+export interface ArrayStatefulParameterConfiguration<T> extends StatefulParameterConfiguration<T> {
+    isEqual?: (desired: any[], current: any[]) => boolean;
+    isElementEqual?: (desired: any, current: any) => boolean;
 }
 export declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
     readonly name: keyof T;
     readonly configuration: StatefulParameterConfiguration<T>;
     protected constructor(configuration: StatefulParameterConfiguration<T>);
-    abstract refresh(previousValue: V | null): Promise<V | null>;
+    abstract refresh(): Promise<V | null>;
     abstract applyAdd(valueToAdd: V, plan: Plan<T>): Promise<void>;
     abstract applyModify(newValue: V, previousValue: V, allowDeletes: boolean, plan: Plan<T>): Promise<void>;
     abstract applyRemove(valueToRemove: V, plan: Plan<T>): Promise<void>;
 }
 export declare abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any> {
-    protected constructor(configuration: StatefulParameterConfiguration<T>);
+    configuration: ArrayStatefulParameterConfiguration<T>;
+    constructor(configuration: ArrayStatefulParameterConfiguration<T>);
     applyAdd(valuesToAdd: V[], plan: Plan<T>): Promise<void>;
     applyModify(newValues: V[], previousValues: V[], allowDeletes: boolean, plan: Plan<T>): Promise<void>;
     applyRemove(valuesToRemove: V[], plan: Plan<T>): Promise<void>;
-    abstract refresh(previousValue: V[] | null): Promise<V[] | null>;
+    abstract refresh(): Promise<V[] | null>;
     abstract applyAddItem(item: V, plan: Plan<T>): Promise<void>;
     abstract applyRemoveItem(item: V, plan: Plan<T>): Promise<void>;
 }

package/dist/entities/stateful-parameter.js

@@ -7,8 +7,10 @@ export class StatefulParameter {
     }
 }
 export class ArrayStatefulParameter extends StatefulParameter {
+    configuration;
     constructor(configuration) {
         super(configuration);
+        this.configuration = configuration;
     }
     async applyAdd(valuesToAdd, plan) {
         for (const value of valuesToAdd) {
@@ -16,8 +18,19 @@ export class ArrayStatefulParameter extends StatefulParameter {
         }
     }
     async applyModify(newValues, previousValues, allowDeletes, plan) {
-        const valuesToAdd = newValues.filter((n) => !previousValues.includes(n));
-        const valuesToRemove = previousValues.filter((n) => !newValues.includes(n));
+        const configuration = this.configuration;
+        const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
+            if ((configuration).isElementEqual) {
+                return configuration.isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
+            if ((configuration).isElementEqual) {
+                return configuration.isElementEqual(n, p);
+            }
+            return n === p;
+        }));
         for (const value of valuesToAdd) {
             await this.applyAddItem(value, plan);
         }

package/package.json

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

package/src/entities/change-set.ts

@@ -43,20 +43,20 @@ export class ChangeSet<T extends StringIndexedObject> {
   //   const operation = ChangeSet.combineResourceOperations(prev, );
   // }
 
-  static newCreate<T extends {}>(desiredConfig: T) {
-    const parameterChangeSet = Object.entries(desiredConfig)
-      .filter(([k,]) => k !== 'type' && k !== 'name')
-      .map(([k, v]) => {
-        return {
-          name: k,
-          operation: ParameterOperation.ADD,
-          previousValue: null,
-          newValue: v,
-        }
-      })
-
-    return new ChangeSet(ResourceOperation.CREATE, parameterChangeSet);
-  }
+  // static newCreate<T extends {}>(desiredConfig: T) {
+  //   const parameterChangeSet = Object.entries(desiredConfig)
+  //     .filter(([k,]) => k !== 'type' && k !== 'name')
+  //     .map(([k, v]) => {
+  //       return {
+  //         name: k,
+  //         operation: ParameterOperation.ADD,
+  //         previousValue: null,
+  //         newValue: v,
+  //       }
+  //     })
+  //
+  //   return new ChangeSet(ResourceOperation.CREATE, parameterChangeSet);
+  // }
 
   static calculateParameterChangeSet<T extends StringIndexedObject>(
     desired: T | null,
@@ -86,22 +86,32 @@ export class ChangeSet<T extends StringIndexedObject> {
   }
 
   static isSame(
-    a: unknown,
-    b: unknown,
-    isEqual?: (a: unknown, b: unknown) => boolean,
+    desired: unknown,
+    current: unknown,
+    configuration?: ParameterConfiguration,
   ): boolean {
-    if (isEqual) {
-      return isEqual(a, b);
+    if (configuration?.isEqual) {
+      return configuration.isEqual(desired, current);
     }
 
-    if (Array.isArray(a) && Array.isArray(b)) {
-      const sortedPrev = a.map((x) => x).sort();
-      const sortedNext = b.map((x) => x).sort();
+    if (Array.isArray(desired) && Array.isArray(current)) {
+      const sortedDesired = desired.map((x) => x).sort();
+      const sortedCurrent = current.map((x) => x).sort();
+
+      if (sortedDesired.length !== sortedCurrent.length) {
+        return false;
+      }
+
+      if (configuration?.isElementEqual) {
+        return sortedDesired.every((value, index) =>
+          configuration.isElementEqual!(value, sortedCurrent[index])
+        );
+      }
 
-      return JSON.stringify(sortedPrev) === JSON.stringify(sortedNext);
+      return JSON.stringify(sortedDesired) === JSON.stringify(sortedCurrent);
     }
 
-    return a === b;
+    return desired === current;
   }
 
   // Explanation: Stateful mode means that codify maintains a stateful to keep track of resources it has added. 
@@ -130,7 +140,7 @@ export class ChangeSet<T extends StringIndexedObject> {
         continue;
       }
 
-      if (!ChangeSet.isSame(_desired[k], _current[k], parameterConfigurations?.[k]?.isEqual)) {
+      if (!ChangeSet.isSame(_desired[k], _current[k], parameterConfigurations?.[k])) {
         parameterChangeSet.push({
           name: k,
           previousValue: v,
@@ -194,7 +204,7 @@ export class ChangeSet<T extends StringIndexedObject> {
         continue;
       }
 
-      if (!ChangeSet.isSame(_desired[k], _current[k], parameterConfigurations?.[k]?.isEqual)) {
+      if (!ChangeSet.isSame(_desired[k], _current[k], parameterConfigurations?.[k])) {
         parameterChangeSet.push({
           name: k,
           previousValue: _current[k],

package/src/entities/plan-types.ts

@@ -15,6 +15,8 @@ export interface ParameterConfiguration {
    */
   isEqual?: (desired: any, current: any) => boolean;
 
+  isElementEqual?: (desired: any, current: any) => boolean;
+
   isStatefulParameter?: boolean;
 }
 

package/src/entities/plan.ts

@@ -9,7 +9,6 @@ import {
 } from 'codify-schemas';
 import { randomUUID } from 'crypto';
 import { ParameterConfiguration, PlanConfiguration } from './plan-types.js';
-import { splitUserConfig } from '../utils/utils.js';
 
 export class Plan<T extends StringIndexedObject> {
   id: string;
@@ -23,8 +22,9 @@ export class Plan<T extends StringIndexedObject> {
   }
 
   static create<T extends StringIndexedObject>(
-    desiredConfig: Partial<T> & ResourceConfig,
-    currentConfig: Partial<T> & ResourceConfig | null,
+    desiredParameters: Partial<T> | null,
+    currentParameters: Partial<T> | null,
+    resourceMetadata: ResourceConfig,
     configuration: PlanConfiguration<T>
   ): Plan<T> {
     const parameterConfigurations = configuration.parameterConfigurations ?? {} as Record<keyof T, ParameterConfiguration>;
@@ -34,9 +34,6 @@ export class Plan<T extends StringIndexedObject> {
         .map(([k, v]) => k)
     );
 
-    const { resourceMetadata, parameters: desiredParameters } = splitUserConfig(desiredConfig);
-    const { parameters: currentParameters } = currentConfig != null ? splitUserConfig(currentConfig) : { parameters: null };
-
 
     // TODO: After adding in state files, need to calculate deletes here
     //  Where current config exists and state config exists but desired config doesn't
@@ -51,9 +48,9 @@ export class Plan<T extends StringIndexedObject> {
     );
 
     let resourceOperation: ResourceOperation;
-    if (!currentConfig && desiredConfig) {
+    if (!currentParameters && desiredParameters) {
       resourceOperation = ResourceOperation.CREATE;
-    } else if (currentConfig && !desiredConfig) {
+    } else if (currentParameters && !desiredParameters) {
       resourceOperation = ResourceOperation.DESTROY;
     } else {
       resourceOperation = parameterChangeSet

package/src/entities/resource-parameters.test.ts

@@ -50,8 +50,9 @@ describe('Resource parameters tests', () => {
     const resourceSpy = spy(resource);
     const result = await resourceSpy.apply(
       Plan.create<TestConfig>(
-        { type: 'resource', propA: 'a', propB: 0, propC: 'b' },
+        { propA: 'a', propB: 0, propC: 'b' },
         null,
+        { type: 'resource' },
         { statefulMode: false },
       )
     );

package/src/entities/resource.test.ts

@@ -136,6 +136,7 @@ describe('Resource tests', () => {
     const result = await resourceSpy.apply(
       Plan.create<TestConfig>(
         { type: 'resource', propA: 'a', propB: 0 },
+        null,
         { type: 'resource' },
         { statefulMode: false },
       )
@@ -154,8 +155,9 @@ describe('Resource tests', () => {
     const resourceSpy = spy(resource);
     const result = await resourceSpy.apply(
       Plan.create<TestConfig>(
+        null,
+        { propA: 'a', propB: 0 },
         { type: 'resource' },
-        { type: 'resource', propA: 'a', propB: 0 },
         { statefulMode: true },
       )
     )
@@ -173,8 +175,9 @@ describe('Resource tests', () => {
     const resourceSpy = spy(resource);
     const result = await resourceSpy.apply(
       Plan.create<TestConfig>(
-        { type: 'resource', propA: 'a', propB: 0 },
-        { type: 'resource', propA: 'b', propB: -1 },
+        { propA: 'a', propB: 0 },
+        { propA: 'b', propB: -1 },
+        { type: 'resource' },
         { statefulMode: true },
       )
     );

package/src/entities/resource.ts

@@ -66,7 +66,7 @@ export abstract class Resource<T extends StringIndexedObject> {
 
     // Short circuit here. If resource is non-existent, then there's no point checking stateful parameters
     if (currentParameters == null) {
-      return Plan.create(desiredConfig, null, planConfiguration);
+      return Plan.create(desiredParameters, null, resourceMetadata, planConfiguration);
     }
 
     this.validateRefreshResults(currentParameters, keysToRefresh);
@@ -76,7 +76,7 @@ export abstract class Resource<T extends StringIndexedObject> {
     for(const statefulParameter of statefulParameters) {
       const desiredValue = desiredParameters[statefulParameter.name];
 
-      let currentValue = await statefulParameter.refresh(desiredValue ?? null) ?? undefined;
+      let currentValue = await statefulParameter.refresh() ?? undefined;
 
       // In stateless mode, filter the refreshed parameters by the desired to ensure that no deletes happen
       if (Array.isArray(currentValue) && Array.isArray(desiredValue) && !planConfiguration.statefulMode) {
@@ -87,8 +87,9 @@ export abstract class Resource<T extends StringIndexedObject> {
     }
 
     return Plan.create(
-      desiredConfig,
-      { ...currentParameters, ...resourceMetadata } as Partial<T> & ResourceConfig,
+      desiredParameters,
+      currentParameters as Partial<T>,
+      resourceMetadata,
       planConfiguration,
     )
   }

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

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest';
+import { ArrayStatefulParameter, ArrayStatefulParameterConfiguration, } from './stateful-parameter.js';
+import { Plan } from './plan.js';
+import { spy } from 'sinon';
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+
+interface TestConfig {
+  propA: string[];
+  [x: string]: unknown;
+}
+
+class TestArrayParameter extends ArrayStatefulParameter<TestConfig, string> {
+  constructor(configuration?: ArrayStatefulParameterConfiguration<TestConfig>) {
+    super(configuration ?? {
+      name: 'propA'
+    })
+  }
+
+  async applyAddItem(item: string, plan: Plan<TestConfig>): Promise<void> {}
+  async applyRemoveItem(item: string, plan: Plan<TestConfig>): Promise<void> {}
+
+  async refresh(): Promise<string[] | null> {
+    return null;
+  }
+}
+
+
+describe('Stateful parameter tests', () => {
+  it('applyAddItem is called the correct number of times', async () => {
+    const plan = Plan.create<TestConfig>(
+      { propA: ['a', 'b', 'c'] },
+      null,
+      { type: 'typeA' },
+      { statefulMode: false }
+    );
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.CREATE);
+    expect(plan.changeSet.parameterChanges.length).to.eq(1);
+
+    const testParameter = spy(new TestArrayParameter());
+    await testParameter.applyAdd(plan.desiredConfig.propA, plan);
+
+    expect(testParameter.applyAddItem.callCount).to.eq(3);
+    expect(testParameter.applyRemoveItem.called).to.be.false;
+  })
+
+  it('applyRemoveItem is called the correct number of times', async () => {
+    const plan = Plan.create<TestConfig>(
+      null,
+      { propA: ['a', 'b', 'c'] },
+      { type: 'typeA' },
+      { statefulMode: true }
+    );
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.DESTROY);
+    expect(plan.changeSet.parameterChanges.length).to.eq(1);
+
+    const testParameter = spy(new TestArrayParameter());
+    await testParameter.applyRemove(plan.currentConfig.propA, plan);
+
+    expect(testParameter.applyAddItem.called).to.be.false;
+    expect(testParameter.applyRemoveItem.callCount).to.eq(3);
+  })
+
+  it('In stateless mode only applyAddItem is called only for modifies', async () => {
+    const plan = Plan.create<TestConfig>(
+      { propA: ['a', 'c', 'd', 'e', 'f'] }, // b to remove, d, e, f to add
+      { propA: ['a', 'b', 'c'] },
+      { type: 'typeA' },
+      { statefulMode: true, parameterConfigurations: { propA: { isStatefulParameter: true }} }
+    );
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.MODIFY);
+    expect(plan.changeSet.parameterChanges[0]).toMatchObject({
+      name: 'propA',
+      previousValue: ['a', 'b', 'c'],
+      newValue: ['a', 'c', 'd', 'e', 'f'],
+      operation: ParameterOperation.MODIFY,
+    })
+
+    const testParameter = spy(new TestArrayParameter());
+    await testParameter.applyModify(plan.desiredConfig.propA, plan.currentConfig.propA, false, plan);
+
+    expect(testParameter.applyAddItem.calledThrice).to.be.true;
+    expect(testParameter.applyRemoveItem.called).to.be.false;
+  })
+
+  it('isElementEqual is called for modifies', async () => {
+    const plan = Plan.create<TestConfig>(
+      { propA: ['9.12', '9.13'] }, // b to remove, d, e, f to add
+      { propA: ['9.12.9'] },
+      { type: 'typeA' },
+      { statefulMode: false, parameterConfigurations: { propA: { isStatefulParameter: true }} }
+    );
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.MODIFY);
+    expect(plan.changeSet.parameterChanges[0]).toMatchObject({
+      name: 'propA',
+      previousValue: ['9.12.9'],
+      newValue: ['9.12', '9.13'],
+      operation: ParameterOperation.MODIFY,
+    })
+
+    const testParameter = spy(new class extends TestArrayParameter {
+      constructor() {
+        super({
+          name: 'propA',
+          isElementEqual: (desired, current) => current.includes(desired),
+        });
+      }
+    });
+
+    await testParameter.applyModify(plan.desiredConfig.propA, plan.currentConfig.propA, false, plan);
+
+    expect(testParameter.applyAddItem.calledOnce).to.be.true;
+    expect(testParameter.applyRemoveItem.called).to.be.false;
+  })
+})

package/src/entities/stateful-parameter.ts

@@ -3,9 +3,15 @@ import { StringIndexedObject } from 'codify-schemas';
 
 export interface StatefulParameterConfiguration<T> {
   name: keyof T;
-  isEqual?: (a: any, b: any) => boolean;
+  isEqual?: (desired: any, current: any) => boolean;
 }
 
+export interface ArrayStatefulParameterConfiguration<T> extends StatefulParameterConfiguration<T> {
+  isEqual?: (desired: any[], current: any[]) => boolean;
+  isElementEqual?: (desired: any, current: any) => boolean;
+}
+
+
 export abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
   readonly name: keyof T;
   readonly configuration: StatefulParameterConfiguration<T>;
@@ -15,7 +21,7 @@ export abstract class StatefulParameter<T extends StringIndexedObject, V extends
     this.configuration = configuration
   }
 
-  abstract refresh(previousValue: V | null): Promise<V | null>;
+  abstract refresh(): Promise<V | null>;
 
   // TODO: Add an additional parameter here for what has actually changed.
   abstract applyAdd(valueToAdd: V, plan: Plan<T>): Promise<void>;
@@ -24,8 +30,11 @@ export abstract class StatefulParameter<T extends StringIndexedObject, V extends
 }
 
 export abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any>{
-  protected constructor(configuration: StatefulParameterConfiguration<T>) {
+  configuration: ArrayStatefulParameterConfiguration<T>;
+
+  constructor(configuration: ArrayStatefulParameterConfiguration<T>) {
     super(configuration);
+    this.configuration = configuration;
   }
 
   async applyAdd(valuesToAdd: V[], plan: Plan<T>): Promise<void> {
@@ -35,8 +44,21 @@ export abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> e
   }
 
   async applyModify(newValues: V[], previousValues: V[], allowDeletes: boolean, plan: Plan<T>): Promise<void> {
-    const valuesToAdd = newValues.filter((n) => !previousValues.includes(n));
-    const valuesToRemove = previousValues.filter((n) => !newValues.includes(n));
+    const configuration = this.configuration as ArrayStatefulParameterConfiguration<T>;
+
+    const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
+      if ((configuration).isElementEqual) {
+        return configuration.isElementEqual(n, p);
+      }
+      return n === p;
+    }));
+
+    const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
+      if ((configuration).isElementEqual) {
+        return configuration.isElementEqual(n, p);
+      }
+      return n === p;
+    }));
 
     for (const value of valuesToAdd) {
       await this.applyAddItem(value, plan)
@@ -55,7 +77,7 @@ export abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> e
     }
   }
 
-  abstract refresh(previousValue: V[] | null): Promise<V[] | null>;
+  abstract refresh(): Promise<V[] | null>;
   abstract applyAddItem(item: V, plan: Plan<T>): Promise<void>;
   abstract applyRemoveItem(item: V, plan: Plan<T>): Promise<void>;
 }