codify-plugin-lib 1.0.100 → 1.0.102

package/src/plan/change-set.ts

@@ -1,6 +1,6 @@
 import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
 
-import { ParameterSetting } from '../resource/resource-settings.js';
+import { ParsedParameterSetting } from '../resource/parsed-resource-settings.js';
 
 /**
  * A parameter change describes a parameter level change to a resource.
@@ -87,7 +87,7 @@ export class ChangeSet<T extends StringIndexedObject> {
   static calculateModification<T extends StringIndexedObject>(
     desired: Partial<T>,
     current: Partial<T>,
-    parameterSettings: Partial<Record<keyof T, ParameterSetting>> = {},
+    parameterSettings: Partial<Record<keyof T, ParsedParameterSetting>> = {},
   ): ChangeSet<T> {
     const pc = ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
 
@@ -128,7 +128,7 @@ export class ChangeSet<T extends StringIndexedObject> {
   private static calculateParameterChanges<T extends StringIndexedObject>(
     desiredParameters: Partial<T>,
     currentParameters: Partial<T>,
-    parameterOptions?: Partial<Record<keyof T, ParameterSetting>>,
+    parameterOptions?: Partial<Record<keyof T, ParsedParameterSetting>>,
   ): ParameterChange<T>[] {
     const parameterChangeSet = new Array<ParameterChange<T>>();
 
@@ -204,8 +204,8 @@ export class ChangeSet<T extends StringIndexedObject> {
   private static isSame(
     desired: unknown,
     current: unknown,
-    setting?: ParameterSetting,
+    setting?: ParsedParameterSetting,
   ): boolean {
-    return (setting?.isEqual ?? ((a, b) => a === b))(desired, current)
+    return (setting?.isEqual ?? ((a: unknown, b: unknown) => a === b))(desired, current)
   }
 }

package/src/plan/plan.test.ts

@@ -183,7 +183,12 @@ describe('Plan entity tests', () => {
         return {
           id: 'type',
           parameterSettings: {
-            propZ: { type: 'array', canModify: true, isElementEqual: (a, b) => b.includes(a), filterInStatelessMode: false }
+            propZ: {
+              type: 'array',
+              canModify: true,
+              isElementEqual: (a, b) => b.includes(a),
+              filterInStatelessMode: false
+            }
           }
         }
       }

package/src/plan/plan.ts

@@ -8,8 +8,12 @@ import {
 } from 'codify-schemas';
 import { v4 as uuidV4 } from 'uuid';
 
-import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
-import { ArrayParameterSetting, ResourceSettings, StatefulParameterSetting } from '../resource/resource-settings.js';
+import {
+  ParsedArrayParameterSetting,
+  ParsedResourceSettings,
+  ParsedStatefulParameterSetting
+} from '../resource/parsed-resource-settings.js';
+import { ArrayParameterSetting, ResourceSettings } from '../resource/resource-settings.js';
 import { ChangeSet } from './change-set.js';
 
 /**
@@ -248,26 +252,27 @@ export class Plan<T extends StringIndexedObject> {
     }
 
     function isArrayParameterWithFiltering(k: string, v: T[keyof T]): boolean {
-      return (((settings.parameterSettings?.[k]?.type === 'stateful'
-          && (settings.parameterSettings[k] as StatefulParameterSetting).definition.getSettings().type === 'array')
-          && (((settings.parameterSettings[k] as StatefulParameterSetting).definition.getSettings() as ArrayParameterSetting).filterInStatelessMode ?? true)
-        ) || (
-          settings.parameterSettings?.[k]?.type === 'array'
-          && ((settings.parameterSettings?.[k] as ArrayParameterSetting).filterInStatelessMode ?? true)
-        ))
-        && Array.isArray(v)
+      if (settings.parameterSettings?.[k]?.type === 'stateful') {
+        const statefulSetting = settings.parameterSettings[k] as ParsedStatefulParameterSetting;
+        return statefulSetting.nestedSettings.type === 'array' &&
+          ((statefulSetting.nestedSettings as ArrayParameterSetting).filterInStatelessMode ?? true)
+          && Array.isArray(v);
+      }
+
+      return settings.parameterSettings?.[k]?.type === 'array'
+        && ((settings.parameterSettings?.[k] as ArrayParameterSetting).filterInStatelessMode ?? true)
+        && 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]!.type === 'stateful'
-        ? ((settings.parameterSettings![k] as StatefulParameterSetting)
-          .definition
-          .getSettings() as ArrayParameterSetting)
-          .isElementEqual ?? ((a, b) => a === b)
-        : (settings.parameterSettings![k] as ArrayParameterSetting)
-          .isElementEqual ?? ((a, b) => a === b)
+        ? ((settings.parameterSettings![k] as ParsedStatefulParameterSetting)
+          .nestedSettings as ParsedArrayParameterSetting)
+          .isElementEqual
+        : (settings.parameterSettings![k] as ParsedArrayParameterSetting)
+          .isElementEqual
 
       const desiredCopy = [...desiredArray];
       const currentCopy = [...v];

package/src/resource/config-parser.ts

@@ -1,17 +1,17 @@
 import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
 
+import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 import { splitUserConfig } from '../utils/utils.js';
-import { StatefulParameter } from './stateful-parameter.js';
 
 export class ConfigParser<T extends StringIndexedObject> {
   private readonly desiredConfig: Partial<T> & ResourceConfig | null;
   private readonly stateConfig: Partial<T> & ResourceConfig | null;
-  private statefulParametersMap: Map<keyof T, StatefulParameter<T, T[keyof T]>>;
+  private statefulParametersMap: Map<keyof T, StatefulParameterController<T, T[keyof T]>>;
 
   constructor(
     desiredConfig: Partial<T> & ResourceConfig | null,
     stateConfig: Partial<T> & ResourceConfig | null,
-    statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>,
+    statefulParameters: Map<keyof T, StatefulParameterController<T, T[keyof T]>>,
   ) {
     this.desiredConfig = desiredConfig;
     this.stateConfig = stateConfig

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

@@ -1,14 +1,36 @@
 import { JSONSchemaType } from 'ajv';
 import { StringIndexedObject } from 'codify-schemas';
 
+import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 import {
+  ArrayParameterSetting,
+  DefaultParameterSetting,
   ParameterSetting,
   resolveEqualsFn,
+  resolveFnFromEqualsFnOrString,
   resolveParameterTransformFn,
   ResourceSettings,
   StatefulParameterSetting
 } from './resource-settings.js';
-import { StatefulParameter as StatefulParameterImpl } from './stateful-parameter.js'
+
+export interface ParsedStatefulParameterSetting extends DefaultParameterSetting {
+  type: 'stateful',
+  controller: StatefulParameterController<any, unknown>
+  order?: number,
+  nestedSettings: ParsedParameterSetting;
+}
+
+export type ParsedArrayParameterSetting = {
+  isElementEqual: (a: unknown, b: unknown) => boolean;
+  isEqual: (a: unknown, b: unknown) => boolean;
+} & ArrayParameterSetting
+
+export type ParsedParameterSetting =
+  {
+  isEqual: (desired: unknown, current: unknown) => boolean;
+  } & (DefaultParameterSetting
+  | ParsedArrayParameterSetting
+  | ParsedStatefulParameterSetting)
 
 export class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
   private cache = new Map<string, unknown>();
@@ -36,24 +58,49 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
     return this.id;
   }
 
-  get statefulParameters(): Map<keyof T, StatefulParameterImpl<T, T[keyof T]>> {
+  get statefulParameters(): Map<keyof T, StatefulParameterController<T, T[keyof T]>> {
     return this.getFromCacheOrCreate('statefulParameters', () => {
 
       const statefulParameters = Object.entries(this.settings.parameterSettings ?? {})
         .filter(([, p]) => p?.type === 'stateful')
-        .map(([k, v]) => [k, (v as StatefulParameterSetting).definition] as const)
+        .map(([k, v]) => [
+          k,
+          new StatefulParameterController((v as StatefulParameterSetting).definition)
+        ] as const)
 
-      return new Map(statefulParameters) as Map<keyof T, StatefulParameterImpl<T, T[keyof T]>>;
+      return new Map(statefulParameters) as Map<keyof T, StatefulParameterController<T, T[keyof T]>>;
     })
   }
 
-  get parameterSettings(): Record<keyof T, ParameterSetting> {
+  get parameterSettings(): Record<keyof T, ParsedParameterSetting> {
     return this.getFromCacheOrCreate('parameterSetting', () => {
 
       const settings = Object.entries(this.settings.parameterSettings ?? {})
         .map(([k, v]) => [k, v!] as const)
         .map(([k, v]) => {
-          v.isEqual = resolveEqualsFn(v, k);
+          v.isEqual = resolveEqualsFn(v);
+
+          if (v.type === 'stateful') {
+            const spController = this.statefulParameters.get(k);
+            const parsed = {
+              ...v,
+              controller: spController,
+              nestedSettings: spController?.parsedSettings,
+              definition: undefined,
+            };
+
+            return [k, parsed as ParsedStatefulParameterSetting];
+          }
+
+          if (v.type === 'array') {
+            const parsed = {
+              ...v,
+              isElementEqual: resolveFnFromEqualsFnOrString((v as ArrayParameterSetting).isElementEqual)
+                ?? ((a: unknown, b: unknown) => a === b),
+            }
+
+            return [k, parsed as ParsedArrayParameterSetting];
+          }
 
           return [k, v];
         })

package/src/resource/resource-controller.ts

@@ -63,7 +63,8 @@ export class ResourceController<T extends StringIndexedObject> {
     this.addDefaultValues(parameters);
 
     if (this.schemaValidator) {
-      const isValid = this.schemaValidator(parameters);
+      // Schema validator uses pre transformation parameters
+      const isValid = this.schemaValidator(desiredConfig);
 
       if (!isValid) {
         return {

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

@@ -629,4 +629,105 @@ describe('Resource parameter tests', () => {
       }
     };
   })
+
+  it('Accepts a string isEqual method which selects from one of the defaults', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          parameterSettings: {
+            propA: { type: 'string', isEqual: 'version' }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: '10.0.0'
+        }
+      }
+    };
+
+    const controller = new ResourceController(resource);
+
+    const result = await controller.plan({ type: 'resourceType', propA: '10.0' });
+    expect(result.changeSet).toMatchObject({
+      operation: ResourceOperation.NOOP,
+    })
+  });
+
+  it('Object equals method (works when equal)', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          parameterSettings: {
+            propD: { type: 'object' }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          propD: {
+            testA: 'a',
+            testB: 'b',
+            testC: 10,
+          }
+        }
+      }
+    };
+
+    const controller = new ResourceController(resource);
+
+    const result = await controller.plan({
+      type: 'resourceType',
+      propD: {
+        testC: 10,
+        testA: 'a',
+        testB: 'b',
+      }
+    });
+
+    expect(result.changeSet).toMatchObject({
+      operation: ResourceOperation.NOOP,
+    })
+  });
+
+  it('Object equals method (works when not equal)', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          parameterSettings: {
+            propD: { type: 'object' }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          propD: {
+            testA: 'a',
+            testB: 'b',
+          }
+        }
+      }
+    };
+
+    const controller = new ResourceController(resource);
+
+    const result = await controller.plan({
+      type: 'resourceType',
+      propD: {
+        testC: 10,
+        testA: 'a',
+        testB: 'b',
+      }
+    });
+
+    expect(result.changeSet).toMatchObject({
+      operation: ResourceOperation.RECREATE,
+    })
+  });
 })

package/src/resource/resource-settings.ts

@@ -1,8 +1,9 @@
 import { StringIndexedObject } from 'codify-schemas';
+import isObjectsEqual from 'lodash.isequal'
 import path from 'node:path';
 
+import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
 import { areArraysEqual, untildify } from '../utils/utils.js';
-import { StatefulParameter } from './stateful-parameter.js';
 
 /**
  * The configuration and settings for a resource.
@@ -130,6 +131,7 @@ export type ParameterSettingType =
   | 'boolean'
   | 'directory'
   | 'number'
+  | 'object'
   | 'setting'
   | 'stateful'
   | 'string'
@@ -181,7 +183,7 @@ export interface DefaultParameterSetting {
    *
    * @return Return true if equal
    */
-  isEqual?: (desired: any, current: any) => boolean;
+  isEqual?: ((desired: any, current: any) => boolean) | ParameterSettingType;
 
   /**
    * Chose if the resource can be modified instead of re-created when there is a change to this parameter.
@@ -210,7 +212,7 @@ export interface ArrayParameterSetting extends DefaultParameterSetting {
    *
    * @return Return true if desired is equivalent to current.
    */
-  isElementEqual?: (desired: any, current: any) => boolean
+  isElementEqual?: ((desired: any, current: any) => boolean) | ParameterSettingType;
 
   /**
    * Filter the contents of the refreshed array by the desired. This way items currently on the system but not
@@ -249,7 +251,7 @@ export interface StatefulParameterSetting extends DefaultParameterSetting {
    * as a resource and taps, formulas and casks are represented as a stateful parameter. A formula can be installed,
    * modified and removed (has state) but it is still tied to the overall lifecycle of homebrew.
    */
-  definition: StatefulParameter<any, unknown>,
+  definition: ArrayStatefulParameter<any, unknown> | StatefulParameter<any, unknown>,
 
   /**
    * The order multiple stateful parameters should be applied in. The order is applied in ascending order (1, 2, 3...).
@@ -263,19 +265,42 @@ const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown,
   '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)),
-  'setting': (a: unknown, b: unknown) => true,
+  'setting': () => true,
+  'object': isObjectsEqual,
 }
 
-export function resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => boolean {
+export function resolveEqualsFn(parameter: ParameterSetting): (desired: unknown, current: unknown) => boolean {
+  const isEqual = resolveFnFromEqualsFnOrString(parameter.isEqual);
+
   if (parameter.type === 'array') {
-    return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter as ArrayParameterSetting)
+    const arrayParameter = parameter as ArrayParameterSetting;
+    const isElementEqual = resolveFnFromEqualsFnOrString(arrayParameter.isElementEqual);
+
+    return isEqual ?? areArraysEqual.bind(areArraysEqual, isElementEqual)
   }
 
   if (parameter.type === 'stateful') {
-    return resolveEqualsFn((parameter as StatefulParameterSetting).definition.getSettings(), key)
+    return resolveEqualsFn((parameter as StatefulParameterSetting).definition.getSettings())
+  }
+
+  return isEqual ?? ParameterEqualsDefaults[parameter.type as ParameterSettingType] ?? (((a, b) => a === b));
+}
+
+// This resolves the fn if it is a string.
+// A string can be specified to use a default equals method
+export function resolveFnFromEqualsFnOrString(
+  fnOrString: ((a: unknown, b: unknown) => boolean) | ParameterSettingType | undefined,
+): ((a: unknown, b: unknown) => boolean) | undefined {
+
+  if (fnOrString && typeof fnOrString === 'string') {
+    if (!ParameterEqualsDefaults[fnOrString]) {
+      throw new Error(`isEqual of type ${fnOrString} was not found`)
+    }
+
+    return ParameterEqualsDefaults[fnOrString]!
   }
 
-  return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type as ParameterSettingType] ?? (((a, b) => a === b));
+  return fnOrString as ((a: unknown, b: unknown) => boolean) | undefined;
 }
 
 const ParameterTransformationDefaults: Partial<Record<ParameterSettingType, (input: any) => Promise<any> | any>> = {

package/src/{resource/stateful-parameter.test.ts → stateful-parameter/stateful-parameter-controller.test.ts}

@@ -8,8 +8,9 @@ import {
   TestResource,
   TestStatefulParameter
 } from '../utils/test-utils.test.js';
-import { ArrayParameterSetting, ParameterSetting, ResourceSettings } from './resource-settings.js';
-import { ResourceController } from './resource-controller.js';
+import { ArrayParameterSetting, ParameterSetting, ResourceSettings } from '../resource/resource-settings.js';
+import { ResourceController } from '../resource/resource-controller.js';
+import { StatefulParameterController } from './stateful-parameter-controller.js';
 
 describe('Stateful parameter tests', () => {
   it('addItem is called the correct number of times', async () => {
@@ -20,11 +21,12 @@ describe('Stateful parameter tests', () => {
     expect(plan.changeSet.operation).to.eq(ResourceOperation.CREATE);
     expect(plan.changeSet.parameterChanges.length).to.eq(1);
 
-    const testParameter = spy(new TestArrayStatefulParameter());
-    await testParameter.add((plan.desiredConfig! as any).propZ, plan);
+    const parameter = spy(new TestArrayStatefulParameter());
+    const controller = new StatefulParameterController(parameter);
+    await controller.add((plan.desiredConfig! as any).propZ, plan);
 
-    expect(testParameter.addItem.callCount).to.eq(3);
-    expect(testParameter.removeItem.called).to.be.false;
+    expect(parameter.addItem.callCount).to.eq(3);
+    expect(parameter.removeItem.called).to.be.false;
   })
 
   it('applyRemoveItem is called the correct number of times', async () => {
@@ -38,11 +40,12 @@ describe('Stateful parameter tests', () => {
     expect(plan.changeSet.operation).to.eq(ResourceOperation.DESTROY);
     expect(plan.changeSet.parameterChanges.length).to.eq(1);
 
-    const testParameter = spy(new TestArrayStatefulParameter());
-    await testParameter.remove((plan.currentConfig as any).propZ, plan);
+    const parameter = spy(new TestArrayStatefulParameter());
+    const controller = new StatefulParameterController(parameter);
+    await controller.remove((plan.currentConfig as any).propZ, plan);
 
-    expect(testParameter.addItem.called).to.be.false;
-    expect(testParameter.removeItem.callCount).to.eq(3);
+    expect(parameter.addItem.called).to.be.false;
+    expect(parameter.removeItem.callCount).to.eq(3);
   })
 
   it('In stateless mode only applyAddItem is called only for modifies', async () => {
@@ -61,8 +64,10 @@ describe('Stateful parameter tests', () => {
       operation: ParameterOperation.MODIFY,
     })
 
+
     const testParameter = spy(parameter);
-    await testParameter.modify((plan.desiredConfig as any).propZ, (plan.currentConfig as any).propZ, plan);
+    const controller = new StatefulParameterController(testParameter);
+    await controller.modify((plan.desiredConfig as any).propZ, (plan.currentConfig as any).propZ, plan);
 
     expect(testParameter.addItem.calledThrice).to.be.true;
     expect(testParameter.removeItem.called).to.be.false;
@@ -92,7 +97,8 @@ describe('Stateful parameter tests', () => {
       operation: ParameterOperation.MODIFY,
     })
 
-    await testParameter.modify((plan.desiredConfig as any).propZ, (plan.currentConfig as any).propZ, plan);
+    const controller = new StatefulParameterController(testParameter);
+    await controller.modify((plan.desiredConfig as any).propZ, (plan.currentConfig as any).propZ, plan);
 
     expect(testParameter.addItem.calledOnce).to.be.true;
     expect(testParameter.removeItem.called).to.be.false;
@@ -153,4 +159,77 @@ describe('Stateful parameter tests', () => {
 
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
+
+  it('Accepts a string equals value', async () => {
+    const testParameter = spy(new class extends TestStatefulParameter {
+      getSettings(): ParameterSetting {
+        return {
+          type: 'string',
+          isEqual: 'version'
+        }
+      }
+
+      async refresh(): Promise<any> {
+        return '20.15.0';
+      }
+    });
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'type',
+          parameterSettings: { propA: { type: 'stateful', definition: testParameter } }
+        }
+      }
+
+      async refresh(): Promise<Partial<any> | null> {
+        return {};
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({
+      propA: '20.15',
+    } as any)
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
+
+  it('Accepts a string isElementEquals value', async () => {
+    const testParameter = spy(new class extends TestStatefulParameter {
+      getSettings(): ParameterSetting {
+        return {
+          type: 'array',
+          isElementEqual: 'version'
+        }
+      }
+
+      async refresh(): Promise<any> {
+        return [
+          '20.15.0',
+          '20.18.0'
+        ]
+      }
+    });
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'type',
+          parameterSettings: { propA: { type: 'stateful', definition: testParameter } }
+        }
+      }
+
+      async refresh(): Promise<Partial<any> | null> {
+        return {};
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({
+      propA: ['20.15', '20.18'],
+    } as any)
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
 })