codify-plugin-lib 1.0.75 → 1.0.77

package/src/plan/change-set.test.ts

@@ -0,0 +1,220 @@
+import { ChangeSet } from './change-set.js';
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+import { describe, expect, it } from 'vitest';
+
+describe('Change set tests', () => {
+  it ('Correctly diffs two resource configs (modify)', () => {
+    const after = {
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const before = {
+      propA: 'after',
+      propB: 'after'
+    }
+
+    const cs = ChangeSet.calculateModification(after, before);
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+  })
+
+  it ('Correctly diffs two resource configs (add)', () => {
+    const after = {
+      propA: 'before',
+      propB: 'after'
+    }
+
+    const before = {
+      propA: 'after',
+    }
+
+    const cs = ChangeSet.calculateModification(after, before,);
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.ADD);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+
+  })
+
+  it ('Correctly diffs two resource configs (remove)', () => {
+    const after = {
+      propA: 'after',
+    }
+
+    const before = {
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const cs = ChangeSet.calculateModification(after, before);
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+  })
+
+  it ('Correctly diffs two resource configs (no-op)', () => {
+    const after = {
+      propA: 'prop',
+    }
+
+    const before = {
+      propA: 'prop',
+    }
+
+    const cs = ChangeSet.calculateModification(after, before);
+    expect(cs.parameterChanges.length).to.eq(1);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
+    expect(cs.operation).to.eq(ResourceOperation.NOOP)
+  })
+
+  it('Correctly diffs two resource configs (create)', () => {
+    const cs = ChangeSet.create({
+      propA: 'prop',
+      propB: 'propB'
+    });
+
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.ADD);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.ADD);
+    expect(cs.operation).to.eq(ResourceOperation.CREATE)
+  })
+
+  it('Correctly diffs two resource configs (destory)', () => {
+    const cs = ChangeSet.destroy({
+      propA: 'prop',
+      propB: 'propB'
+    });
+
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.operation).to.eq(ResourceOperation.DESTROY)
+  })
+
+  it ('handles simple arrays', () => {
+    const before = {
+      propA: ['a', 'b', 'c'],
+    }
+
+    const after = {
+      propA: ['b', 'a', 'c'],
+    }
+
+    const cs = ChangeSet.calculateModification(after, before, { propA: { type: 'array' } });
+    expect(cs.parameterChanges.length).to.eq(1);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
+    expect(cs.operation).to.eq(ResourceOperation.NOOP)
+  })
+
+  it('handles simple arrays 2', () => {
+    const after = {
+      propA: ['a', 'b', 'c'],
+    }
+
+    const before = {
+      propA: ['b', 'a'],
+    }
+
+    const cs = ChangeSet.calculateModification(after, before, { propA: { type: 'array' } });
+    expect(cs.parameterChanges.length).to.eq(1);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+  })
+
+  it('determines the order of operations with canModify 1', () => {
+    const after = {
+      propA: 'after',
+    }
+
+    const before = {
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const cs = ChangeSet.calculateModification(after, before, { propA: { canModify: true } });
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+  })
+
+  it('determines the order of operations with canModify 2', () => {
+    const after = {
+      propA: 'after',
+    }
+
+    const before = {
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const cs = ChangeSet.calculateModification<any>(after, before, {
+      propA: { canModify: true },
+      propB: { canModify: true }
+    });
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.operation).to.eq(ResourceOperation.MODIFY)
+  })
+
+
+  it('correctly determines array equality', () => {
+    const arrA = ['a', 'b', 'd'];
+    const arrB = ['a', 'b', 'd'];
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+
+    expect(result.operation).to.eq(ResourceOperation.NOOP);
+  })
+
+  it('correctly determines array equality 2', () => {
+    const arrA = ['a', 'b'];
+    const arrB = ['a', 'b', 'd'];
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+
+    expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+  })
+
+  it('correctly determines array equality 3', () => {
+    const arrA = ['b', 'a', 'd'];
+    const arrB = ['a', 'b', 'd'];
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+
+    expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
+  })
+
+  it('correctly determines array equality 4', () => {
+    const arrA = [{ key1: 'a' }, { key1: 'a' }, { key1: 'a' }];
+    const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, {
+      propA: {
+        type: 'array',
+        isElementEqual: (a, b) => a.key1 === b.key1
+      }
+    })
+
+    expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+  })
+
+  it('correctly determines array equality 5', () => {
+    const arrA = [{ key1: 'b' }, { key1: 'a' }, { key1: 'a' }];
+    const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, {
+      propA: {
+        type: 'array',
+        isElementEqual: (a, b) => a.key1 === b.key1
+      }
+    })
+
+    expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
+  })
+})

package/src/plan/change-set.ts

@@ -0,0 +1,225 @@
+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);
+  }
+
+  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'
+          }
         }
-      });
+      }
     }
-  }
+  };
 }