codify-plugin-lib 1.0.79 → 1.0.81

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

@@ -30,7 +30,7 @@ export declare class ChangeSet<T extends StringIndexedObject> {
     static empty<T extends StringIndexedObject>(): ChangeSet<T>;
     static create<T extends StringIndexedObject>(desired: Partial<T>): ChangeSet<T>;
     static destroy<T extends StringIndexedObject>(current: Partial<T>): ChangeSet<T>;
-    static calculateModification<T extends StringIndexedObject>(desired: Partial<T>, current: Partial<T>, parameterSettings?: Partial<Record<keyof T, ParameterSetting>>): Promise<ChangeSet<T>>;
+    static calculateModification<T extends StringIndexedObject>(desired: Partial<T>, current: Partial<T>, parameterSettings?: Partial<Record<keyof T, ParameterSetting>>): ChangeSet<T>;
     /**
      * Calculates the differences between the desired and current parameters,
      * and returns a list of parameter changes that describe what needs to be added,

package/dist/plan/change-set.js

@@ -45,8 +45,8 @@ export class ChangeSet {
         }));
         return new ChangeSet(ResourceOperation.DESTROY, parameterChanges);
     }
-    static async calculateModification(desired, current, parameterSettings = {}) {
-        const pc = await ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
+    static calculateModification(desired, current, parameterSettings = {}) {
+        const pc = ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
         const statefulParameterKeys = new Set(Object.entries(parameterSettings)
             .filter(([, v]) => v?.type === 'stateful')
             .map(([k]) => k));
@@ -77,7 +77,7 @@ export class ChangeSet {
      * @param {Partial<Record<keyof T, ParameterSetting>>} [parameterOptions] - Optional settings used when comparing parameters.
      * @return {ParameterChange<T>[]} A list of changes required to transition from the current state to the desired state.
      */
-    static async calculateParameterChanges(desiredParameters, currentParameters, parameterOptions) {
+    static calculateParameterChanges(desiredParameters, currentParameters, parameterOptions) {
         const parameterChangeSet = new Array();
         // Filter out null and undefined values or else the diff below will not work
         const desired = Object.fromEntries(Object.entries(desiredParameters).filter(([, v]) => v !== null && v !== undefined));
@@ -93,7 +93,7 @@ export class ChangeSet {
                 delete current[k];
                 continue;
             }
-            if (!await ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
+            if (!ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
                 parameterChangeSet.push({
                     name: k,
                     previousValue: v ?? null,
@@ -138,12 +138,8 @@ export class ChangeSet {
         const indexNext = orderOfOperations.indexOf(next);
         return orderOfOperations[Math.max(indexPrev, indexNext)];
     }
-    static async isSame(desired, current, setting) {
+    static isSame(desired, current, setting) {
         switch (setting?.type) {
-            case 'stateful': {
-                const statefulSetting = setting.definition.getSettings();
-                return ChangeSet.isSame(desired, current, statefulSetting);
-            }
             case 'array': {
                 const arrayParameter = setting;
                 return areArraysEqual(arrayParameter, desired, current);

package/dist/plan/plan.d.ts

@@ -41,7 +41,7 @@ export declare class Plan<T extends StringIndexedObject> {
         coreParameters: ResourceConfig;
         settings: ParsedResourceSettings<T>;
         statefulMode: boolean;
-    }): Promise<Plan<T>>;
+    }): Plan<T>;
     /**
      *  Only keep relevant params for the plan. We don't want to change settings that were not already
      *  defined.

package/dist/plan/plan.js

@@ -70,7 +70,7 @@ export class Plan {
     getResourceType() {
         return this.coreParameters.type;
     }
-    static async calculate(params) {
+    static calculate(params) {
         const { desiredParameters, currentParametersArray, stateParameters, coreParameters, settings, statefulMode } = params;
         const currentParameters = Plan.matchCurrentParameters({
             desiredParameters,
@@ -99,7 +99,7 @@ export class Plan {
             return new Plan(uuidV4(), ChangeSet.destroy(filteredCurrentParameters), coreParameters);
         }
         // NO-OP, MODIFY or RE-CREATE
-        const changeSet = await ChangeSet.calculateModification(desiredParameters, filteredCurrentParameters, settings.parameterSettings);
+        const changeSet = ChangeSet.calculateModification(desiredParameters, filteredCurrentParameters, settings.parameterSettings);
         return new Plan(uuidV4(), changeSet, coreParameters);
     }
     /**

package/dist/resource/resource-settings.d.ts

@@ -97,7 +97,7 @@ export interface DefaultParameterSetting {
      *
      * @return Return true if equal
      */
-    isEqual?: (desired: any, current: any) => Promise<boolean> | boolean;
+    isEqual?: (desired: any, current: any) => boolean;
     /**
      * Chose if the resource can be modified instead of re-created when there is a change to this parameter.
      * Defaults to false (re-create).
@@ -123,7 +123,7 @@ export interface ArrayParameterSetting extends DefaultParameterSetting {
      *
      * @return Return true if desired is equivalent to current.
      */
-    isElementEqual?: (desired: any, current: any) => Promise<boolean> | boolean;
+    isElementEqual?: (desired: any, current: any) => boolean;
 }
 /**
  * Stateful parameter type specific settings. A stateful parameter is a sub-resource that can hold its own

package/package.json

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

package/src/plan/change-set.ts

@@ -85,12 +85,12 @@ export class ChangeSet<T extends StringIndexedObject> {
     return new ChangeSet(ResourceOperation.DESTROY, parameterChanges);
   }
 
-  static async calculateModification<T extends StringIndexedObject>(
+  static calculateModification<T extends StringIndexedObject>(
     desired: Partial<T>,
     current: Partial<T>,
     parameterSettings: Partial<Record<keyof T, ParameterSetting>> = {},
-  ): Promise<ChangeSet<T>> {
-    const pc = await ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
+  ): ChangeSet<T> {
+    const pc = ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
 
     const statefulParameterKeys = new Set(
       Object.entries(parameterSettings)
@@ -126,11 +126,11 @@ export class ChangeSet<T extends StringIndexedObject> {
    * @param {Partial<Record<keyof T, ParameterSetting>>} [parameterOptions] - Optional settings used when comparing parameters.
    * @return {ParameterChange<T>[]} A list of changes required to transition from the current state to the desired state.
    */
-  private static async calculateParameterChanges<T extends StringIndexedObject>(
+  private static calculateParameterChanges<T extends StringIndexedObject>(
     desiredParameters: Partial<T>,
     currentParameters: Partial<T>,
     parameterOptions?: Partial<Record<keyof T, ParameterSetting>>,
-  ): Promise<ParameterChange<T>[]> {
+  ): ParameterChange<T>[] {
     const parameterChangeSet = new Array<ParameterChange<T>>();
 
     // Filter out null and undefined values or else the diff below will not work
@@ -155,7 +155,7 @@ export class ChangeSet<T extends StringIndexedObject> {
         continue;
       }
 
-      if (!await ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
+      if (!ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
         parameterChangeSet.push({
           name: k,
           previousValue: v ?? null,
@@ -210,18 +210,12 @@ export class ChangeSet<T extends StringIndexedObject> {
     return orderOfOperations[Math.max(indexPrev, indexNext)];
   }
 
-  private static async isSame(
+  private static isSame(
     desired: unknown,
     current: unknown,
     setting?: ParameterSetting,
-  ): Promise<boolean> {
+  ): boolean {
     switch (setting?.type) {
-      case 'stateful': {
-        const statefulSetting = (setting as StatefulParameterSetting).definition.getSettings()
-
-        return ChangeSet.isSame(desired, current, statefulSetting as ParameterSetting);
-      }
-
       case 'array': {
         const arrayParameter = setting as ArrayParameterSetting;
         return areArraysEqual(arrayParameter, desired, current)

package/src/plan/plan.ts

@@ -105,14 +105,14 @@ export class Plan<T extends StringIndexedObject> {
     return this.coreParameters.type
   }
 
-  static async calculate<T extends StringIndexedObject>(params: {
+  static calculate<T extends StringIndexedObject>(params: {
     desiredParameters: Partial<T> | null,
     currentParametersArray: Partial<T>[] | null,
     stateParameters: Partial<T> | null,
     coreParameters: ResourceConfig,
     settings: ParsedResourceSettings<T>,
     statefulMode: boolean,
-  }): Promise<Plan<T>> {
+  }): Plan<T> {
     const {
       desiredParameters,
       currentParametersArray,
@@ -166,7 +166,7 @@ export class Plan<T extends StringIndexedObject> {
     }
 
     // NO-OP, MODIFY or RE-CREATE
-    const changeSet = await ChangeSet.calculateModification(
+    const changeSet = ChangeSet.calculateModification(
       desiredParameters!,
       filteredCurrentParameters!,
       settings.parameterSettings,

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

@@ -154,7 +154,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
     // The rest of the types have defaults set already
   }
 
-  private resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => Promise<boolean> | boolean {
+  private resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => boolean {
     if (parameter.type === 'array') {
       return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter as ArrayParameterSetting)
     }

package/src/resource/resource-settings.ts

@@ -127,7 +127,7 @@ export interface DefaultParameterSetting {
    *
    * @return Return true if equal
    */
-  isEqual?: (desired: any, current: any) => Promise<boolean> | boolean;
+  isEqual?: (desired: any, current: any) => boolean;
 
   /**
    * Chose if the resource can be modified instead of re-created when there is a change to this parameter.
@@ -156,7 +156,7 @@ export interface ArrayParameterSetting extends DefaultParameterSetting {
    *
    * @return Return true if desired is equivalent to current.
    */
-  isElementEqual?: (desired: any, current: any) => Promise<boolean> | boolean;
+  isElementEqual?: (desired: any, current: any) => boolean
 }
 
 /**

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

@@ -1,8 +1,8 @@
 import { describe, expect, it } from 'vitest';
 import { spy } from 'sinon';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { TestArrayStatefulParameter, TestConfig, testPlan } from '../utils/test-utils.test.js';
-import { ArrayParameterSetting } from './resource-settings.js';
+import { TestArrayStatefulParameter, TestConfig, testPlan, TestStatefulParameter } from '../utils/test-utils.test.js';
+import { ArrayParameterSetting, ParameterSetting } from './resource-settings.js';
 
 describe('Stateful parameter tests', () => {
   it('addItem is called the correct number of times', async () => {
@@ -90,4 +90,22 @@ describe('Stateful parameter tests', () => {
     expect(testParameter.addItem.calledOnce).to.be.true;
     expect(testParameter.removeItem.called).to.be.false;
   })
+
+  it('isEqual works with type defaults', () => {
+    const testParameter = spy(new class extends TestStatefulParameter {
+      getSettings(): ParameterSetting {
+        return {
+          type: 'version',
+        }
+      }
+    });
+
+    const plan = testPlan<TestConfig>({
+      desired: { propZ: '20' },
+      current: [{ propZ: '20.17.0' }],
+      settings: { id: 'type', parameterSettings: { propZ: { type: 'stateful', definition: testParameter } } }
+    });
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
 })