codify-plugin-lib 1.0.99 → 1.0.101

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 function areArraysEqual(isElementEqual, desired, current) {
     if (!Array.isArray(desired) || !Array.isArray(current)) {
         throw new Error(`A non-array value:
           
@@ -91,7 +91,8 @@ 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;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.99",
+  "version": "1.0.101",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -16,7 +16,8 @@
     "ajv-formats": "^2.1.1",
     "codify-schemas": "1.0.52",
     "@npmcli/promise-spawn": "^7.0.1",
-    "uuid": "^10.0.0"
+    "uuid": "^10.0.0",
+    "lodash.isequal": "^4.5.0"
   },
   "devDependencies": {
     "@oclif/prettier-config": "^0.2.1",
@@ -26,6 +27,7 @@
     "@types/semver": "^7.5.4",
     "@types/sinon": "^17.0.3",
     "@types/uuid": "^10.0.0",
+    "@types/lodash.isequal": "^4.5.8",
     "chai-as-promised": "^7.1.1",
     "vitest": "^1.4.0",
     "vitest-mock-extended": "^1.3.1",

package/src/index.ts

@@ -9,7 +9,7 @@ export * from './plugin/plugin.js'
 export * from './resource/parsed-resource-settings.js';
 export * from './resource/resource.js'
 export * from './resource/resource-settings.js'
-export * from './resource/stateful-parameter.js'
+export * from './stateful-parameter/stateful-parameter.js'
 export * from './utils/utils.js'
 
 export async function runPlugin(plugin: Plugin) {

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

@@ -147,6 +147,84 @@ describe('Plan entity tests', () => {
       operation: ResourceOperation.RECREATE
     })
   })
+
+  it('Filters array parameters in stateless mode (by default)', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'type',
+          parameterSettings: {
+            propZ: { type: 'array', isElementEqual: (a, b) => b.includes(a) }
+          }
+        }
+      }
+
+      async refresh(): Promise<Partial<any> | null> {
+        return {
+          propZ: [
+            '20.15.0',
+            '20.15.1'
+          ]
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({
+      propZ: ['20.15'],
+    } as any)
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
+
+  it('Doesn\'t filters array parameters if filtering is disabled', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'type',
+          parameterSettings: {
+            propZ: {
+              type: 'array',
+              canModify: true,
+              isElementEqual: (a, b) => b.includes(a),
+              filterInStatelessMode: false
+            }
+          }
+        }
+      }
+
+      async refresh(): Promise<Partial<any> | null> {
+        return {
+          propZ: [
+            '20.15.0',
+            '20.15.1'
+          ]
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({
+      propZ: ['20.15'],
+    } as any)
+
+    expect(plan.changeSet).toMatchObject({
+      operation: ResourceOperation.MODIFY,
+      parameterChanges: expect.arrayContaining([
+        expect.objectContaining({
+          name: 'propZ',
+          previousValue: expect.arrayContaining([
+            '20.15.0',
+            '20.15.1'
+          ]),
+          newValue: expect.arrayContaining([
+            '20.15'
+          ]),
+          operation: 'modify'
+        })
+      ])
+    })
+  })
 })
 
 function createTestResource() {

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';
 
 /**
@@ -220,7 +224,7 @@ 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))
+        .filter(([k, v]) => isArrayParameterWithFiltering(k, v))
         .map(([k, v]) => [k, filterArrayStatefulParameter(k, v)])
     )
 
@@ -247,19 +251,28 @@ export class Plan<T extends StringIndexedObject> {
       ) as Partial<T>;
     }
 
-    function isArrayStatefulParameter(k: string, v: T[keyof T]): boolean {
-      return settings.parameterSettings?.[k]?.type === 'stateful'
-        && (settings.parameterSettings[k] as StatefulParameterSetting).definition.getSettings().type === 'array'
-        && Array.isArray(v)
+    function isArrayParameterWithFiltering(k: string, v: T[keyof T]): boolean {
+      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] as StatefulParameterSetting)
-        .definition
-        .getSettings() as ArrayParameterSetting)
-        .isElementEqual ?? ((a, b) => a === b);
+      const matcher = settings.parameterSettings![k]!.type === 'stateful'
+        ? ((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];
         })
@@ -171,9 +218,9 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
       const { requiredParameters, refreshKeys, defaultRefreshValues } = this.settings.import;
 
       const requiredParametersNotInSchema = requiredParameters
-          ?.filter(
-            (p) => schema && !(schema.properties[p])
-          )
+        ?.filter(
+          (p) => schema && !(schema.properties[p])
+        )
       if (schema && requiredParametersNotInSchema && requiredParametersNotInSchema.length > 0) {
         throw new Error(`The following properties were declared in settings.import.requiredParameters but were not found in the schema:
 ${JSON.stringify(requiredParametersNotInSchema, null, 2)}`)

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.
@@ -65,11 +66,56 @@ export interface ResourceSettings<T extends StringIndexedObject> {
    */
   inputTransformation?: (desired: Partial<T>) => Promise<unknown> | unknown;
 
+  /**
+   * Customize the import behavior of the resource. By default, <code>codify import</code> will call `refresh()` with
+   * every parameter set to null and return the result of the refresh as the imported config. It looks for required parameters
+   * in the schema and will prompt the user for these values before performing the import.
+   *
+   * <b>Example:</b><br>
+   * Resource `alias` with parameters
+   *
+   * ```
+   * { alias <b>(*required)</b>: string; value: string;  }
+   * ```
+   *
+   * When the user calls `codify import alias`, they will first be prompted to enter the value for `alias`. Refresh
+   * is then called with `refresh({ alias: 'user-input', value: null })`. The result returned to the user will then be:
+   *
+   * ```
+   * { type: 'alias', alias: 'user-input', value: 'git push' }
+   * ```
+   */
   import?: {
+
+    /**
+     * Customize the required parameters needed to import this resource. By default, the `requiredParameters` are taken
+     * from the JSON schema. The `requiredParameters` parameter must be declared if a complex required is declared in
+     * the schema (contains `oneOf`, `anyOf`, `allOf`, `if`, `then`, `else`).
+     * <br>
+     * The user will be prompted for the required parameters before the import starts. This is done because for most resources
+     * the required parameters change the behaviour of the refresh (for example for the `alias` resource, the `alias` parmaeter
+     * chooses which alias the resource is managing).
+     *
+     * See {@link import} for more information on how importing works.
+     */
     requiredParameters?: Array<Partial<keyof T>>;
 
+    /**
+     * Customize which keys will be refreshed in the import. Typically, `refresh()` statements only refresh
+     * the parameters provided as the input. Use `refreshKeys` to control which parameter keys are passed in.
+     * <br>
+     * By default all parameters (except for {@link requiredParameters }) are passed in with the value `null`. The passed
+     * in value can be customized using {@link defaultRefreshValues}
+     *
+     * See {@link import} for more information on how importing works.
+     */
     refreshKeys?: Array<Partial<keyof T>>;
 
+    /**
+     * Customize the value that is passed into refresh when importing. This must only contain keys found in {@link refreshKeys}.
+     *
+     * See {@link import} for more information on how importing works.
+     */
     defaultRefreshValues?: Partial<T>
   }
 }
@@ -85,6 +131,7 @@ export type ParameterSettingType =
   | 'boolean'
   | 'directory'
   | 'number'
+  | 'object'
   | 'setting'
   | 'stateful'
   | 'string'
@@ -136,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.
@@ -165,7 +212,27 @@ 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
+   * in desired don't show up in the plan.
+   *
+   * <b>For example, for the nvm resource:</b>
+   * <ul>
+   *   <li>Desired (20.18.0, 18.9.0, 16.3.1)</li>
+   *   <li>Current (20.18.0, 22.1.3, 12.1.0)</li>
+   * </ul>
+   *
+   * Without filtering the plan will be:
+   * (~20.18.0, +18.9.0, +16.3.1, -22.1.3, -12.1.0)<br>
+   * With filtering the plan is: (~20.18.0, +18.9.0, +16.3.1)
+   *
+   * As you can see, filtering prevents items currently installed on the system from being removed.
+   *
+   * Defaults to true.
+   */
+  filterInStatelessMode?: boolean,
 }
 
 /**
@@ -184,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...).
@@ -198,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>> = {