codify-plugin-lib 1.0.76 → 1.0.78

package/src/plan/change-set.ts

@@ -0,0 +1,235 @@
+import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
+
+import { ArrayParameterSetting, ParameterSetting, StatefulParameterSetting } from '../resource/resource-settings.js';
+import { areArraysEqual } from '../utils/utils.js';
+
+/**
+ * A parameter change describes a parameter level change to a resource.
+ */
+export interface ParameterChange<T extends StringIndexedObject> {
+  /**
+   * The name of the parameter
+   */
+  name: keyof T & string;
+
+  /**
+   * The operation to be performed on the parameter.
+   */
+  operation: ParameterOperation;
+
+  /**
+   * The previous value of the resource (the current value on the system)
+   */
+  previousValue: any | null;
+
+  /**
+   * The new value of the resource (the desired value)
+   */
+  newValue: any | null;
+}
+
+// Change set will coerce undefined values to null because undefined is not valid JSON
+export class ChangeSet<T extends StringIndexedObject> {
+  operation: ResourceOperation
+  parameterChanges: Array<ParameterChange<T>>
+
+  constructor(
+    operation: ResourceOperation,
+    parameterChanges: Array<ParameterChange<T>>
+  ) {
+    this.operation = operation;
+    this.parameterChanges = parameterChanges;
+  }
+
+  get desiredParameters(): T {
+    return this.parameterChanges
+      .reduce((obj, pc) => ({
+        ...obj,
+        [pc.name]: pc.newValue,
+      }), {}) as T;
+  }
+
+  get currentParameters(): T {
+    return this.parameterChanges
+      .reduce((obj, pc) => ({
+        ...obj,
+        [pc.name]: pc.previousValue,
+      }), {}) as T;
+  }
+
+  static empty<T extends StringIndexedObject>(): ChangeSet<T> {
+    return new ChangeSet<T>(ResourceOperation.NOOP, []);
+  }
+
+  static create<T extends StringIndexedObject>(desired: Partial<T>): ChangeSet<T> {
+    const parameterChanges = Object.entries(desired)
+      .map(([k, v]) => ({
+        name: k,
+        operation: ParameterOperation.ADD,
+        previousValue: null,
+        newValue: v ?? null,
+      }))
+
+    return new ChangeSet(ResourceOperation.CREATE, parameterChanges);
+  }
+
+  static destroy<T extends StringIndexedObject>(current: Partial<T>): ChangeSet<T> {
+    const parameterChanges = Object.entries(current)
+      .map(([k, v]) => ({
+        name: k,
+        operation: ParameterOperation.REMOVE,
+        previousValue: v ?? null,
+        newValue: null,
+      }))
+
+    return new ChangeSet(ResourceOperation.DESTROY, parameterChanges);
+  }
+
+  static calculateModification<T extends StringIndexedObject>(
+    desired: Partial<T>,
+    current: Partial<T>,
+    parameterSettings: Partial<Record<keyof T, ParameterSetting>> = {},
+  ): ChangeSet<T> {
+    const pc = ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
+
+    const statefulParameterKeys = new Set(
+      Object.entries(parameterSettings)
+        .filter(([, v]) => v?.type === 'stateful')
+        .map(([k]) => k)
+    )
+
+    const resourceOperation = pc
+      .filter((change) => change.operation !== ParameterOperation.NOOP)
+      .reduce((operation: ResourceOperation, curr: ParameterChange<T>) => {
+        let newOperation: ResourceOperation;
+        if (statefulParameterKeys.has(curr.name)) {
+          newOperation = ResourceOperation.MODIFY // All stateful parameters are modify only
+        } else if (parameterSettings[curr.name]?.canModify) {
+          newOperation = ResourceOperation.MODIFY
+        } else {
+          newOperation = ResourceOperation.RECREATE; // Default to Re-create. Should handle the majority of use cases
+        }
+
+        return ChangeSet.combineResourceOperations(operation, newOperation);
+      }, ResourceOperation.NOOP);
+
+    return new ChangeSet<T>(resourceOperation, pc);
+  }
+
+  /**
+   * Calculates the differences between the desired and current parameters,
+   * and returns a list of parameter changes that describe what needs to be added,
+   * removed, or modified to match the desired state.
+   *
+   * @param {Partial<T>} desiredParameters - The desired target state of the parameters.
+   * @param {Partial<T>} currentParameters - The current state of the parameters.
+   * @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 calculateParameterChanges<T extends StringIndexedObject>(
+    desiredParameters: Partial<T>,
+    currentParameters: Partial<T>,
+    parameterOptions?: Partial<Record<keyof T, ParameterSetting>>,
+  ): ParameterChange<T>[] {
+    const parameterChangeSet = new Array<ParameterChange<T>>();
+
+    // 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)
+    ) as Partial<T>
+
+    const current = Object.fromEntries(
+      Object.entries(currentParameters).filter(([, v]) => v !== null && v !== undefined)
+    ) as Partial<T>
+
+    for (const [k, v] of Object.entries(current)) {
+      if (desired?.[k] === null || desired?.[k] === undefined) {
+        parameterChangeSet.push({
+          name: k,
+          previousValue: v ?? null,
+          newValue: null,
+          operation: ParameterOperation.REMOVE,
+        })
+
+        delete current[k];
+        continue;
+      }
+
+      if (!ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
+        parameterChangeSet.push({
+          name: k,
+          previousValue: v ?? null,
+          newValue: desired[k] ?? null,
+          operation: ParameterOperation.MODIFY,
+        })
+
+        delete current[k];
+        delete desired[k];
+        continue;
+      }
+
+      parameterChangeSet.push({
+        name: k,
+        previousValue: v ?? null,
+        newValue: desired[k] ?? null,
+        operation: ParameterOperation.NOOP,
+      })
+
+      delete current[k];
+      delete desired[k];
+    }
+
+    if (Object.keys(current).length > 0) {
+      throw new Error('Diff algorithm error');
+    }
+
+    for (const [k, v] of Object.entries(desired)) {
+      parameterChangeSet.push({
+        name: k,
+        previousValue: null,
+        newValue: v ?? null,
+        operation: ParameterOperation.ADD,
+      })
+    }
+
+    return parameterChangeSet;
+  }
+
+  private static combineResourceOperations(prev: ResourceOperation, next: ResourceOperation) {
+    const orderOfOperations = [
+      ResourceOperation.NOOP,
+      ResourceOperation.MODIFY,
+      ResourceOperation.RECREATE,
+      ResourceOperation.CREATE,
+      ResourceOperation.DESTROY,
+    ]
+
+    const indexPrev = orderOfOperations.indexOf(prev);
+    const indexNext = orderOfOperations.indexOf(next);
+
+    return orderOfOperations[Math.max(indexPrev, indexNext)];
+  }
+
+  private static isSame(
+    desired: unknown,
+    current: unknown,
+    setting?: ParameterSetting,
+  ): 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)
+      }
+
+      default: {
+        return (setting?.isEqual ?? ((a, b) => a === b))(desired, current)
+      }
+    }
+  }
+}

package/src/plan/plan-types.ts

@@ -0,0 +1,27 @@
+import { StringIndexedObject } from 'codify-schemas';
+
+import { Plan } from './plan.js';
+
+/**
+ * A narrower type for plans for CREATE operations. Only desiredConfig is not null.
+ */
+export interface CreatePlan<T extends StringIndexedObject> extends Plan<T> {
+  desiredConfig: T;
+  currentConfig: null;
+}
+
+/**
+ * A narrower type for plans for DESTROY operations. Only currentConfig is not null.
+ */
+export interface DestroyPlan<T extends StringIndexedObject> extends Plan<T> {
+  desiredConfig: null;
+  currentConfig: T;
+}
+
+/**
+ * A narrower type for plans for MODIFY and RE-CREATE operations.
+ */
+export interface ModifyPlan<T extends StringIndexedObject> extends Plan<T> {
+  desiredConfig: T;
+  currentConfig: T;
+}

package/src/{entities → plan}/plan.test.ts

@@ -1,12 +1,15 @@
 import { describe, expect, it } from 'vitest';
 import { Plan } from './plan.js';
-import { TestResource } from './resource.test.js';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { Resource } from './resource.js';
+import { TestConfig, TestResource } from '../utils/test-utils.test.js';
+import { ResourceController } from '../resource/resource-controller.js';
+import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
+import { ResourceSettings } from '../resource/resource-settings.js';
 
 describe('Plan entity tests', () => {
   it('Adds default values properly when plan is parsed from request (Create)', () => {
-    const resource = createResource();
+    const resource = createTestResource()
+    const controller = new ResourceController(resource);
 
     const plan = Plan.fromResponse({
       operation: ResourceOperation.CREATE,
@@ -17,7 +20,7 @@ describe('Plan entity tests', () => {
         previousValue: null,
         newValue: 'propBValue'
       }]
-    }, resource.defaultValues);
+    }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).to.be.null;
 
@@ -33,7 +36,8 @@ describe('Plan entity tests', () => {
   })
 
   it('Adds default values properly when plan is parsed from request (Destroy)', () => {
-    const resource = createResource();
+    const resource = createTestResource()
+    const controller = new ResourceController(resource);
 
     const plan = Plan.fromResponse({
       operation: ResourceOperation.DESTROY,
@@ -44,7 +48,7 @@ describe('Plan entity tests', () => {
         previousValue: 'propBValue',
         newValue: null,
       }]
-    }, resource.defaultValues);
+    }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).toMatchObject({
       type: 'type',
@@ -60,7 +64,8 @@ describe('Plan entity tests', () => {
   })
 
   it('Adds default values properly when plan is parsed from request (No-op)', () => {
-    const resource = createResource();
+    const resource = createTestResource()
+    const controller = new ResourceController(resource);
 
     const plan = Plan.fromResponse({
       operation: ResourceOperation.NOOP,
@@ -71,7 +76,7 @@ describe('Plan entity tests', () => {
         previousValue: 'propBValue',
         newValue: 'propBValue',
       }]
-    }, resource.defaultValues);
+    }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).toMatchObject({
       type: 'type',
@@ -91,7 +96,8 @@ describe('Plan entity tests', () => {
   })
 
   it('Does not add default value if a value has already been specified', () => {
-    const resource = createResource();
+    const resource = createTestResource()
+    const controller = new ResourceController(resource);
 
     const plan = Plan.fromResponse({
       operation: ResourceOperation.CREATE,
@@ -107,7 +113,7 @@ describe('Plan entity tests', () => {
         previousValue: null,
         newValue: 'propAValue',
       }]
-    }, resource.defaultValues);
+    }, controller.parsedSettings.defaultValues);
 
     expect(plan.currentConfig).to.be.null
 
@@ -123,19 +129,17 @@ describe('Plan entity tests', () => {
   })
 
   it('Returns the original resource names', () => {
-    const resource = createResource();
-
-    const plan = Plan.create(
-      {
-        propA: 'propA',
-      },
-      {
-        propA: 'propA2',
-      },
-      {
+    const plan = Plan.calculate<TestConfig>({
+      desiredParameters: { propA: 'propA' },
+      currentParametersArray: [{ propA: 'propA2' }],
+      stateParameters: null,
+      coreParameters: {
         type: 'type',
         name: 'name1'
-      }, { statefulMode: false });
+      },
+      settings: new ParsedResourceSettings<TestConfig>({ id: 'type' }),
+      statefulMode: false,
+    });
 
     expect(plan.toResponse()).toMatchObject({
       resourceType: 'type',
@@ -145,15 +149,17 @@ describe('Plan entity tests', () => {
   })
 })
 
-function createResource(): Resource<any> {
+function createTestResource() {
   return new class extends TestResource {
-    constructor() {
-      super({
-        type: 'type',
-        parameterOptions: {
-          propA: { default: 'defaultA' }
+    getSettings(): ResourceSettings<TestConfig> {
+      return {
+        id: 'type',
+        parameterSettings: {
+          propA: {
+            default: 'defaultA'
+          }
         }
-      });
+      }
     }
-  }
+  };
 }