codify-plugin-lib 1.0.76 → 1.0.77

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

@@ -1,155 +0,0 @@
-import { ChangeSet } from './change-set.js';
-import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-import { describe, expect, it } from 'vitest';
-
-describe('Change set tests (stateful)', () => {
-  it ('Correctly diffs two resource configs (modify)', () => {
-    const after = {
-      propA: 'before',
-      propB: 'before'
-    }
-
-    const before = {
-      propA: 'after',
-      propB: 'after'
-    }
-
-    const cs = ChangeSet.calculateParameterChangeSet(after, before, { statefulMode: true });
-    expect(cs.length).to.eq(2);
-    expect(cs[0].operation).to.eq(ParameterOperation.MODIFY);
-    expect(cs[1].operation).to.eq(ParameterOperation.MODIFY);
-  })
-
-  it ('Correctly diffs two resource configs (add)', () => {
-    const after = {
-      propA: 'before',
-      propB: 'after'
-    }
-
-    const before = {
-      propA: 'after',
-    }
-
-    const cs = ChangeSet.calculateParameterChangeSet(after, before, { statefulMode: true });
-    expect(cs.length).to.eq(2);
-    expect(cs[0].operation).to.eq(ParameterOperation.MODIFY);
-    expect(cs[1].operation).to.eq(ParameterOperation.ADD);
-  })
-
-  it ('Correctly diffs two resource configs (remove)', () => {
-    const after = {
-      propA: 'after',
-    }
-
-    const before = {
-      propA: 'before',
-      propB: 'before'
-    }
-
-    const cs = ChangeSet.calculateParameterChangeSet(after, before, { statefulMode: true });
-    expect(cs.length).to.eq(2);
-    expect(cs[0].operation).to.eq(ParameterOperation.MODIFY);
-    expect(cs[1].operation).to.eq(ParameterOperation.REMOVE);
-  })
-
-  it ('Correctly diffs two resource configs (no-op)', () => {
-    const after = {
-      propA: 'prop',
-    }
-
-    const before = {
-      propA: 'prop',
-    }
-
-    const cs = ChangeSet.calculateParameterChangeSet(after, before, { statefulMode: true });
-    expect(cs.length).to.eq(1);
-    expect(cs[0].operation).to.eq(ParameterOperation.NOOP);
-  })
-
-  it ('handles simple arrays', () => {
-    const before = {
-      propA: ['a', 'b', 'c'],
-    }
-
-    const after = {
-      propA: ['b', 'a', 'c'],
-    }
-
-    const cs = ChangeSet.calculateParameterChangeSet(after, before, { statefulMode: true });
-    expect(cs.length).to.eq(1);
-    expect(cs[0].operation).to.eq(ParameterOperation.NOOP);
-  })
-
-  it ('handles simple arrays', () => {
-    const after = {
-      propA: ['a', 'b', 'c'],
-    }
-
-    const before = {
-      propA: ['b', 'a'],
-    }
-
-    const cs = ChangeSet.calculateParameterChangeSet(after, before, { statefulMode: true });
-    expect(cs.length).to.eq(1);
-    expect(cs[0].operation).to.eq(ParameterOperation.MODIFY);
-  })
-
-  it ('determines the order of operations 1', () => {
-    const op1 = ResourceOperation.MODIFY;
-    const op2 = ResourceOperation.CREATE
-
-    const opResult = ChangeSet.combineResourceOperations(op1, op2);
-    expect(opResult).to.eq(ResourceOperation.CREATE);
-  })
-
-  it ('determines the order of operations 2', () => {
-    const op1 = ResourceOperation.NOOP;
-    const op2 = ResourceOperation.MODIFY
-
-    const opResult = ChangeSet.combineResourceOperations(op1, op2);
-    expect(opResult).to.eq(ResourceOperation.MODIFY);
-  })
-
-  it ('determines the order of operations 3', () => {
-    const op1 = ResourceOperation.MODIFY;
-    const op2 = ResourceOperation.MODIFY
-
-    const opResult = ChangeSet.combineResourceOperations(op1, op2);
-    expect(opResult).to.eq(ResourceOperation.MODIFY);
-  })
-
-  it('correctly determines array equality', () => {
-    const arrA = ['a', 'b', 'd'];
-    const arrB = ['a', 'b', 'd'];
-
-    expect(ChangeSet.isSame(arrA, arrB)).to.be.true;
-  })
-
-  it('correctly determines array equality 2', () => {
-    const arrA = ['a', 'b'];
-    const arrB = ['a', 'b', 'd'];
-
-    expect(ChangeSet.isSame(arrA, arrB)).to.be.false;
-  })
-
-  it('correctly determines array equality 3', () => {
-    const arrA = ['b', 'a', 'd'];
-    const arrB = ['a', 'b', 'd'];
-
-    expect(ChangeSet.isSame(arrA, arrB)).to.be.true;
-  })
-
-  it('correctly determines array equality 4', () => {
-    const arrA = [{ key1: 'a' }, { key1: 'a' }, { key1: 'a' }];
-    const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
-
-    expect(ChangeSet.isSame(arrA, arrB)).to.be.false;
-  })
-
-  it('correctly determines array equality 5', () => {
-    const arrA = [{ key1: 'b' }, { key1: 'a' }, { key1: 'a' }];
-    const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
-
-    expect(ChangeSet.isSame(arrA, arrB)).to.be.false;
-  })
-})

package/src/entities/change-set.ts

@@ -1,244 +0,0 @@
-import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
-import { ParameterOptions } from './plan-types.js';
-
-export interface ParameterChange<T extends StringIndexedObject> {
-  name: keyof T & string;
-  operation: ParameterOperation;
-  previousValue: any | null;
-  newValue: any | null;
-}
-
-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 create<T extends Record<string, unknown>>(prev: T, next: T, options: {
-  //   statefulMode: boolean,
-  // }): ChangeSet {
-  //   const parameterChanges = ChangeSet.calculateParameterChangeSet(prev, prev, options);
-  //   const operation = ChangeSet.combineResourceOperations(prev, );
-  // }
-
-  // static newCreate<T extends {}>(desiredConfig: T) {
-  //   const parameterChangeSet = Object.entries(desiredConfig)
-  //     .filter(([k,]) => k !== 'type' && k !== 'name')
-  //     .map(([k, v]) => {
-  //       return {
-  //         name: k,
-  //         operation: ParameterOperation.ADD,
-  //         previousValue: null,
-  //         newValue: v,
-  //       }
-  //     })
-  //
-  //   return new ChangeSet(ResourceOperation.CREATE, parameterChangeSet);
-  // }
-
-  static calculateParameterChangeSet<T extends StringIndexedObject>(
-    desired: T | null,
-    current: T | null,
-    options: { statefulMode: boolean, parameterOptions?: Record<keyof T, ParameterOptions> },
-  ): ParameterChange<T>[] {
-    if (options.statefulMode) {
-      return ChangeSet.calculateStatefulModeChangeSet(desired, current, options.parameterOptions);
-    } else {
-      return ChangeSet.calculateStatelessModeChangeSet(desired, current, options.parameterOptions);
-    }
-  }
-
-  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)];
-  }
-
-  static isSame(
-    desired: unknown,
-    current: unknown,
-    options?: ParameterOptions,
-  ): boolean {
-    if (options?.isEqual) {
-      return options.isEqual(desired, current);
-    }
-
-    if (Array.isArray(desired) && Array.isArray(current)) {
-      const sortedDesired = desired.map((x) => x).sort();
-      const sortedCurrent = current.map((x) => x).sort();
-
-      if (sortedDesired.length !== sortedCurrent.length) {
-        return false;
-      }
-
-      if (options?.isElementEqual) {
-        return sortedDesired.every((value, index) =>
-          options.isElementEqual!(value, sortedCurrent[index])
-        );
-      }
-
-      return JSON.stringify(sortedDesired) === JSON.stringify(sortedCurrent);
-    }
-
-    return desired === current;
-  }
-
-  // Explanation: Stateful mode means that codify maintains a stateful to keep track of resources it has added. 
-  // When a resource is removed from a stateful config, it will be deleted from the system.
-  private static calculateStatefulModeChangeSet<T extends StringIndexedObject>(
-    desired: T | null,
-    current: T | null,
-    parameterOptions?: Record<keyof T, ParameterOptions>,
-  ): ParameterChange<T>[] {
-    const parameterChangeSet = new Array<ParameterChange<T>>();
-    
-    const _desired = Object.fromEntries(Object.entries(desired ?? {}).filter(([, v]) => v != null));
-    const _current = Object.fromEntries(Object.entries(current ?? {}).filter(([, v]) => v != null));
-
-    this.addDefaultValues(_desired, parameterOptions);
-
-    for (const [k, v] of Object.entries(_current)) {
-      if (_desired[k] == null) {
-        parameterChangeSet.push({
-          name: k,
-          previousValue: v,
-          newValue: null,
-          operation: ParameterOperation.REMOVE,
-        })
-
-        delete _current[k];
-        continue;
-      }
-
-      if (!ChangeSet.isSame(_desired[k], _current[k], parameterOptions?.[k])) {
-        parameterChangeSet.push({
-          name: k,
-          previousValue: v,
-          newValue: _desired[k],
-          operation: ParameterOperation.MODIFY,
-        })
-
-        delete _current[k];
-        delete _desired[k];
-        continue;
-      }
-
-      parameterChangeSet.push({
-        name: k,
-        previousValue: v,
-        newValue: _desired[k],
-        operation: ParameterOperation.NOOP,
-      })
-
-      delete _current[k];
-      delete _desired[k];
-    }
-
-    if (Object.keys(_current).length !== 0) {
-      throw Error('Diff algorithm error');
-    }
-
-    for (const [k, v] of Object.entries(_desired)) {
-      parameterChangeSet.push({
-        name: k,
-        previousValue: null,
-        newValue: v,
-        operation: ParameterOperation.ADD,
-      })
-    }
-
-    return parameterChangeSet;
-  }
-
-  // Explanation: Stateful mode means that codify does not keep track of state. Resources in stateless mode can only
-  // be added by Codify and not destroyed.
-  private static calculateStatelessModeChangeSet<T extends StringIndexedObject>(
-    desired: T | null,
-    current: T | null,
-    parameterOptions?: Record<keyof T, ParameterOptions>,
-  ): ParameterChange<T>[] {
-    const parameterChangeSet = new Array<ParameterChange<T>>();
-
-    const _desired = Object.fromEntries(Object.entries(desired ?? {}).filter(([, v]) => v != null));
-    const _current = Object.fromEntries(Object.entries(current ?? {}).filter(([, v]) => v != null));
-
-
-    this.addDefaultValues(_desired, parameterOptions);
-
-    for (const [k, v] of Object.entries(_desired)) {
-      if (_current[k] == null) {
-        parameterChangeSet.push({
-          name: k,
-          previousValue: null,
-          newValue: v,
-          operation: ParameterOperation.ADD,
-        });
-
-        continue;
-      }
-
-      if (!ChangeSet.isSame(_desired[k], _current[k], parameterOptions?.[k])) {
-        parameterChangeSet.push({
-          name: k,
-          previousValue: _current[k],
-          newValue: _desired[k],
-          operation: ParameterOperation.MODIFY,
-        });
-
-        continue;
-      }
-
-      parameterChangeSet.push({
-        name: k,
-        previousValue: v,
-        newValue: v,
-        operation: ParameterOperation.NOOP,
-      })
-    }
-
-    return parameterChangeSet;
-  }
-
-  private static addDefaultValues<T extends StringIndexedObject>(obj: Record<string, unknown>, options?: Record<keyof T, ParameterOptions>) {
-    Object.entries(options ?? {})
-      .filter(([, option]) => option.default !== undefined)
-      .map(([name, option]) => [name, option.default] as const)
-      .forEach(([key, defaultValue]) => {
-        if (obj[key] === undefined) {
-          obj[key] = defaultValue;
-        }
-      })
-  }
-    
-}

package/src/entities/plan-types.ts

@@ -1,44 +0,0 @@
-import { Plan } from './plan.js';
-import { StringIndexedObject } from 'codify-schemas';
-
-/**
- * Customize properties for specific parameters. This will alter the way the library process changes to the parameter.
- */
-export interface ParameterOptions {
-  /**
-   * Chose if the resource should be re-created or modified if this parameter is changed. Defaults to false (re-creates resource on change).
-   */
-  modifyOnChange?: boolean;
-  /**
-   * Customize the equality comparison for a parameter.
-   * @param a
-   * @param b
-   */
-  isEqual?: (desired: any, current: any) => boolean;
-
-  isElementEqual?: (desired: any, current: any) => boolean;
-
-  default?: unknown,
-
-  isStatefulParameter?: boolean;
-}
-
-export interface PlanOptions<T> {
-  statefulMode: boolean;
-  parameterOptions?: Record<keyof T, ParameterOptions>;
-}
-
-export interface CreatePlan<T extends StringIndexedObject> extends Plan<T> {
-  desiredConfig: T;
-  currentConfig: null;
-}
-
-export interface DestroyPlan<T extends StringIndexedObject> extends Plan<T> {
-  desiredConfig: null;
-  currentConfig: T;
-}
-
-export interface ModifyPlan<T extends StringIndexedObject> extends Plan<T> {
-  desiredConfig: T;
-  currentConfig: T;
-}

package/src/entities/plan.ts

@@ -1,178 +0,0 @@
-import { ChangeSet, ParameterChange } from './change-set.js';
-import {
-  ApplyRequestData,
-  ParameterOperation,
-  PlanResponseData,
-  ResourceConfig,
-  ResourceOperation,
-  StringIndexedObject,
-} from 'codify-schemas';
-import { randomUUID } from 'crypto';
-import { ParameterOptions, PlanOptions } from './plan-types.js';
-
-export class Plan<T extends StringIndexedObject> {
-  id: string;
-  changeSet: ChangeSet<T>;
-  resourceMetadata: ResourceConfig
-
-  constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig) {
-    this.id = id;
-    this.changeSet = changeSet;
-    this.resourceMetadata = resourceMetadata;
-  }
-
-  static create<T extends StringIndexedObject>(
-    desiredParameters: Partial<T> | null,
-    currentParameters: Partial<T> | null,
-    resourceMetadata: ResourceConfig,
-    options: PlanOptions<T>
-  ): Plan<T> {
-    const parameterOptions = options.parameterOptions ?? {} as Record<keyof T, ParameterOptions>;
-    const statefulParameterNames = new Set(
-      [...Object.entries(parameterOptions)]
-        .filter(([k, v]) => v.isStatefulParameter)
-        .map(([k, v]) => k)
-    );
-
-    // Explanation: This calculates the change set of the parameters between the
-    // two configs and then passes it to ChangeSet to calculate the overall
-    // operation for the resource
-    const parameterChangeSet = ChangeSet.calculateParameterChangeSet(
-      desiredParameters,
-      currentParameters,
-      { statefulMode: options.statefulMode, parameterOptions }
-    );
-
-    let resourceOperation: ResourceOperation;
-    if (!currentParameters && desiredParameters) {
-      resourceOperation = ResourceOperation.CREATE;
-    } else if (currentParameters && !desiredParameters) {
-      resourceOperation = ResourceOperation.DESTROY;
-    } else {
-      resourceOperation = parameterChangeSet
-        .filter((change) => change.operation !== ParameterOperation.NOOP)
-        .reduce((operation: ResourceOperation, curr: ParameterChange<T>) => {
-          let newOperation: ResourceOperation;
-          if (statefulParameterNames.has(curr.name)) {
-            newOperation = ResourceOperation.MODIFY // All stateful parameters are modify only
-          } else if (parameterOptions[curr.name]?.modifyOnChange) {
-            newOperation = parameterOptions[curr.name].modifyOnChange ? ResourceOperation.MODIFY : ResourceOperation.RECREATE;
-          } else {
-            newOperation = ResourceOperation.RECREATE; // Default to Re-create. Should handle the majority of use cases
-          }
-          return ChangeSet.combineResourceOperations(operation, newOperation);
-        }, ResourceOperation.NOOP);
-    }
-
-    return new Plan(
-      randomUUID(),
-      new ChangeSet<T>(resourceOperation, parameterChangeSet),
-      resourceMetadata,
-    );
-  }
-
-  getResourceType(): string {
-    return this.resourceMetadata.type
-  }
-
-  static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T> {
-    if (!data) {
-      throw new Error('Data is empty');
-    }
-
-    addDefaultValues();
-
-    return new Plan(
-      randomUUID(),
-      new ChangeSet<T>(
-        data.operation,
-        data.parameters
-      ),
-      {
-        type: data.resourceType,
-        name: data.resourceName,
-      },
-    );
-
-   function addDefaultValues(): void {
-      Object.entries(defaultValues ?? {})
-        .forEach(([key, defaultValue]) => {
-          const configValueExists = data!
-            .parameters
-            .some((p) => p.name === key);
-
-          // Only set default values if the value does not exist in the config
-          if (configValueExists) {
-            return;
-          }
-
-          switch (data!.operation) {
-            case ResourceOperation.CREATE: {
-              data!.parameters.push({
-                name: key,
-                operation: ParameterOperation.ADD,
-                previousValue: null,
-                newValue: defaultValue,
-              });
-              break;
-            }
-
-            case ResourceOperation.DESTROY: {
-              data!.parameters.push({
-                name: key,
-                operation: ParameterOperation.REMOVE,
-                previousValue: defaultValue,
-                newValue: null,
-              });
-              break;
-            }
-
-            case ResourceOperation.MODIFY:
-            case ResourceOperation.RECREATE:
-            case ResourceOperation.NOOP: {
-              data!.parameters.push({
-                name: key,
-                operation: ParameterOperation.NOOP,
-                previousValue: defaultValue,
-                newValue: defaultValue,
-              });
-              break;
-            }
-          }
-        });
-    }
-
-  }
-
-  get desiredConfig(): T | null {
-    if (this.changeSet.operation === ResourceOperation.DESTROY) {
-      return null;
-    }
-
-    return {
-      ...this.resourceMetadata,
-      ...this.changeSet.desiredParameters,
-    }
-  }
-
-  get currentConfig(): T | null {
-    if (this.changeSet.operation === ResourceOperation.CREATE) {
-      return null;
-    }
-
-    return {
-      ...this.resourceMetadata,
-      ...this.changeSet.currentParameters,
-    }
-  }
-
-  toResponse(): PlanResponseData {
-    return {
-      planId: this.id,
-      operation: this.changeSet.operation,
-      resourceName: this.resourceMetadata.name,
-      resourceType: this.resourceMetadata.type,
-      parameters: this.changeSet.parameterChanges,
-    }
-  }
-}