fix: object equals, schema validation order, custom filterInStatelessMode, fixed stateful parameters (#12)

* WIP added object equals and changed equals type to ((a, b) => boolean) | ParameterType

* Refactored and revamped how stateful parameters work and their parameters. Added stateful parameter controller and enforced that the parsed-setting has all default values set (isEqual, isElementEqual, etc...). Fixed tests.

* Moved schema validation to happen before transformations. Now the schema directly reflects the user's input

* Added the ability to define a custom filterInStatelessMode function

* Fixed bugs with arraystatefulparameters not being detected

* fix: Fixed inputTransformations in stateful parameters

Author: kevinwang5658

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.100",
+  "version": "1.0.107",
   "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.json

@@ -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) {

src/index.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)
   }
 }

src/plan/change-set.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';
 
 /**
@@ -247,45 +251,72 @@ export class Plan<T extends StringIndexedObject> {
       ) as Partial<T>;
     }
 
+    function getFilterParameter(k: string): ((desired: any[], current: any[]) => any[]) | boolean | undefined {
+      if (settings.parameterSettings?.[k]?.type === 'stateful') {
+        const statefulSetting = settings.parameterSettings[k] as ParsedStatefulParameterSetting;
+
+        if (statefulSetting.nestedSettings.type === 'array') {
+          return (statefulSetting.nestedSettings as ArrayParameterSetting).filterInStatelessMode
+        }
+      }
+
+      if (settings.parameterSettings?.[k]?.type === 'array') {
+        return (settings.parameterSettings?.[k] as ArrayParameterSetting).filterInStatelessMode;
+      }
+
+      return undefined;
+    }
+
     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)
+      const filterParameter = getFilterParameter(k);
+      
+      if (settings.parameterSettings?.[k]?.type === 'stateful') {
+        const statefulSetting = settings.parameterSettings[k] as ParsedStatefulParameterSetting;
+        return statefulSetting.nestedSettings.type === 'array' &&
+          (filterParameter ?? true)
+          && Array.isArray(v);
+      }
+
+      return settings.parameterSettings?.[k]?.type === 'array'
+        && (filterParameter ?? 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];
-      const result = [];
 
-      for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
-        const idx = currentCopy.findIndex((e2) => matcher(desiredCopy[counter], e2))
+      const defaultFilterMethod = ((desired: any[], current: any[]) => {
+        const result = [];
+
+        for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
+          const idx = currentCopy.findIndex((e2) => matcher(desiredCopy[counter], e2))
 
-        if (idx === -1) {
-          continue;
+          if (idx === -1) {
+            continue;
+          }
+
+          desiredCopy.splice(counter, 1)
+          const [element] = currentCopy.splice(idx, 1)
+          result.push(element)
         }
 
-        desiredCopy.splice(counter, 1)
-        const [element] = currentCopy.splice(idx, 1)
-        result.push(element)
-      }
+        return result;
+      })
 
-      return result;
+      const filterParameter = getFilterParameter(k);
+      return typeof filterParameter === 'function'
+        ? filterParameter(desiredCopy, currentCopy)
+        : defaultFilterMethod(desiredCopy, currentCopy);
     }
   }
 

src/plan/plan.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

src/resource/config-parser.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];
         })
@@ -86,15 +133,15 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
     });
   }
 
-  get inputTransformations(): Partial<Record<keyof T, (a: unknown) => unknown>> {
+  get inputTransformations(): Partial<Record<keyof T, (a: unknown, parameter: ParameterSetting) => unknown>> {
     return this.getFromCacheOrCreate('inputTransformations', () => {
       if (!this.settings.parameterSettings) {
         return {};
       }
 
       return Object.fromEntries(
         Object.entries(this.settings.parameterSettings)
-          .filter(([, v]) => resolveParameterTransformFn(v!) !== undefined)
+          .filter(([_, v]) => resolveParameterTransformFn(v!) !== undefined)
           .map(([k, v]) => [k, resolveParameterTransformFn(v!)] as const)
       ) as Record<keyof T, (a: unknown) => unknown>;
     });