codify-plugin-lib 1.0.99 → 1.0.101

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;
@@ -151,7 +157,78 @@ describe('Stateful parameter tests', () => {
       nodeVersions: ['20.15'],
     } as any)
 
-    console.log(JSON.stringify(plan, null, 2))
+    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);
   })

package/src/stateful-parameter/stateful-parameter-controller.ts

@@ -0,0 +1,112 @@
+import { StringIndexedObject } from 'codify-schemas';
+
+import { Plan } from '../plan/plan.js';
+import { ParsedArrayParameterSetting, ParsedParameterSetting, } from '../resource/parsed-resource-settings.js';
+import {
+  ArrayParameterSetting,
+  ParameterSetting,
+  resolveEqualsFn,
+  resolveFnFromEqualsFnOrString
+} from '../resource/resource-settings.js';
+import { ArrayStatefulParameter, StatefulParameter } from './stateful-parameter.js';
+
+/**
+ * This class is analogous to what {@link ResourceController} is for {@link Resource}
+ * It's a bit messy because this class supports both {@link StatefulParameter} and {@link ArrayStatefulParameter}
+ */
+export class StatefulParameterController<T extends StringIndexedObject, V extends T[keyof T]> {
+  readonly sp: ArrayStatefulParameter<T, V> | StatefulParameter<T, V>
+  readonly settings: ParameterSetting;
+  readonly parsedSettings: ParsedParameterSetting
+
+  private readonly isArrayStatefulParameter: boolean;
+
+  constructor(
+    statefulParameter: ArrayStatefulParameter<T, V> | StatefulParameter<T, V>
+  ) {
+    this.sp = statefulParameter;
+    this.settings = statefulParameter.getSettings();
+    this.isArrayStatefulParameter = this.calculateIsArrayStatefulParameter();
+
+    this.parsedSettings = (this.isArrayStatefulParameter || this.settings.type === 'array') ? {
+      ...this.settings,
+      isEqual: resolveEqualsFn(this.settings),
+      isElementEqual: resolveFnFromEqualsFnOrString((this.settings as ArrayParameterSetting).isElementEqual)
+        ?? ((a: unknown, b: unknown) => a === b)
+    } as ParsedParameterSetting : {
+      ...this.settings,
+      isEqual: resolveEqualsFn(this.settings),
+    };
+  }
+
+  async refresh(desired: V | null, config: Partial<T>): Promise<V | null> {
+    return await this.sp.refresh(desired as any, config) as V | null;
+  }
+
+  async add(valueToAdd: V, plan: Plan<T>): Promise<void> {
+    if (!this.isArrayStatefulParameter) {
+      const sp = this.sp as StatefulParameter<T, V>;
+      return sp.add(valueToAdd, plan);
+    }
+
+    const sp = this.sp as ArrayStatefulParameter<any, any>;
+    const valuesToAdd = valueToAdd as Array<any>;
+    for (const value of valuesToAdd) {
+      await sp.addItem(value, plan);
+    }
+  }
+
+  async modify(newValue: V, previousValue: V, plan: Plan<T>): Promise<void> {
+    if (!this.isArrayStatefulParameter) {
+      const sp = this.sp as StatefulParameter<T, V>;
+      return sp.modify(newValue, previousValue, plan);
+    }
+
+    const sp = this.sp as ArrayStatefulParameter<any, any>;
+    const settings = this.parsedSettings as ParsedArrayParameterSetting;
+    const newValues = newValue as Array<unknown>[];
+    const previousValues = previousValue as Array<unknown>[];
+
+    // TODO: I don't think this works with duplicate elements. Solve at another time
+    const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
+      if (settings.isElementEqual) {
+        return settings.isElementEqual!(n, p);
+      }
+
+      return n === p;
+    }));
+
+    const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
+      if (settings.isElementEqual) {
+        return settings.isElementEqual!(n, p);
+      }
+
+      return n === p;
+    }));
+
+    for (const value of valuesToAdd) {
+      await sp.addItem(value, plan)
+    }
+
+    for (const value of valuesToRemove) {
+      await sp.removeItem(value, plan)
+    }
+  }
+
+  async remove(valueToRemove: V, plan: Plan<T>): Promise<void> {
+    if (!this.isArrayStatefulParameter) {
+      const sp = this.sp as StatefulParameter<T, V>;
+      return sp.remove(valueToRemove, plan);
+    }
+
+    const sp = this.sp as ArrayStatefulParameter<any, any>;
+    const valuesToRemove = valueToRemove as Array<any>;
+    for (const value of valuesToRemove) {
+      await sp.removeItem(value as V, plan);
+    }
+  }
+
+  private calculateIsArrayStatefulParameter() {
+    return Object.hasOwn(this.sp, 'addItem') && Object.hasOwn(this.sp, 'removeItem');
+  }
+}

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

@@ -1,7 +1,7 @@
 import { StringIndexedObject } from 'codify-schemas';
 
 import { Plan } from '../plan/plan.js';
-import { ArrayParameterSetting, ParameterSetting } from './resource-settings.js';
+import { ArrayParameterSetting, ParameterSetting } from '../resource/resource-settings.js';
 
 /**
  * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
@@ -101,83 +101,25 @@ export abstract class StatefulParameter<T extends StringIndexedObject, V extends
  * - Homebrew formulas are arrays
  * - Pyenv python versions are arrays
  */
-export abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any>{
+export abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> {
 
   /**
-   * Parameter level settings. Type must be 'array'.
+   * Parameter settings for the stateful parameter. Stateful parameters share the same parameter settings as
+   * regular parameters except that they cannot be of type 'stateful'. See {@link ParameterSetting} for more
+   * information on available settings. Type must be 'array'.
+   *
+   * @return The parameter settings
    */
   getSettings(): ArrayParameterSetting {
     return { type: 'array' }
   }
 
-  /**
-   * It is not recommended to override the `add` method. A addItem helper method is available to operate on
-   * individual elements of the desired array. See {@link StatefulParameter.add} for more info.
-   *
-   * @param valuesToAdd The array of values to add
-   * @param plan The overall plan
-   *
-   */
-  async add(valuesToAdd: V[], plan: Plan<T>): Promise<void> {
-    for (const value of valuesToAdd) {
-      await this.addItem(value, plan);
-    }
-  }
-
-  /**
-   * It is not recommended to override the `modify` method. `addItem` and `removeItem` will be called accordingly based
-   * on the modifications. See {@link StatefulParameter.modify} for more info.
-   *
-   * @param newValues The new array value
-   * @param previousValues The previous array value
-   * @param plan The overall plan
-   */
-  async modify(newValues: V[], previousValues: V[], plan: Plan<T>): Promise<void> {
-
-    // TODO: I don't think this works with duplicate elements. Solve at another time
-    const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
-      if (this.getSettings()?.isElementEqual) {
-        return this.getSettings().isElementEqual!(n, p);
-      }
-
-      return n === p;
-    }));
-
-    const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
-      if (this.getSettings().isElementEqual) {
-        return this.getSettings().isElementEqual!(n, p);
-      }
-
-      return n === p;
-    }));
-
-    for (const value of valuesToAdd) {
-      await this.addItem(value, plan)
-    }
-
-    for (const value of valuesToRemove) {
-      await this.removeItem(value, plan)
-    }
-  }
-
-  /**
-   * It is not recommended to override the `remove` method. A removeItem helper method is available to operate on
-   * individual elements of the desired array. See {@link StatefulParameter.remove} for more info.
-   *
-   * @param valuesToAdd The array of values to add
-   * @param plan The overall plan
-   *
-   */
-  async remove(valuesToRemove: V[], plan: Plan<T>): Promise<void> {
-    for (const value of valuesToRemove) {
-      await this.removeItem(value as V, plan);
-    }
-  }
-
   /**
    * See {@link StatefulParameter.refresh} for more info.
    *
    * @param desired The desired value to refresh
+   * @param config The desired config
+   *
    * @return The current value on the system or null if not found.
    */
   abstract refresh(desired: V[] | null, config: Partial<T>): Promise<V[] | null>;

package/src/utils/test-utils.test.ts

@@ -3,7 +3,7 @@ import { ResourceSettings } from '../resource/resource-settings.js';
 import { Plan } from '../plan/plan.js';
 import { Resource } from '../resource/resource.js';
 import { CreatePlan, DestroyPlan } from '../plan/plan-types.js';
-import { ArrayStatefulParameter, StatefulParameter } from '../resource/stateful-parameter.js';
+import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
 import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
 
 export function testPlan<T extends StringIndexedObject>(params: {

package/src/utils/utils.ts

@@ -3,8 +3,6 @@ import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
 import { SpawnOptions } from 'node:child_process';
 import os from 'node:os';
 
-import { ArrayParameterSetting } from '../resource/resource-settings.js';
-
 export enum SpawnStatus {
   SUCCESS = 'success',
   ERROR = 'error',
@@ -111,7 +109,11 @@ export function untildify(pathWithTilde: string) {
   return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
 }
 
-export function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown) {
+export function areArraysEqual(
+  isElementEqual: ((desired: unknown, current: unknown) => boolean) | undefined,
+  desired: unknown,
+  current: unknown
+): boolean {
   if (!Array.isArray(desired) || !Array.isArray(current)) {
     throw new Error(`A non-array value:
           
@@ -133,7 +135,10 @@ Was provided even though type array was specified.
   // 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 = currentCopy.findIndex((e2) => (
+      isElementEqual
+      ?? ((a, b) => a === b))(desiredCopy[counter], e2
+    ))
 
     if (idx === -1) {
       return false;