codify-plugin-lib 1.0.50 → 1.0.51

package/src/entities/resource-parameters.test.ts

@@ -1,14 +1,14 @@
 import { describe, expect, it } from 'vitest';
-import { ArrayStatefulParameter, StatefulParameter, StatefulParameterConfiguration } from './stateful-parameter.js';
+import { ArrayStatefulParameter, StatefulParameter, StatefulParameterOptions } from './stateful-parameter.js';
 import { Plan } from './plan.js';
 import { spy } from 'sinon';
-import { ResourceOperation } from 'codify-schemas';
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
 import { TestConfig, TestResource } from './resource.test.js';
 import { TransformParameter } from './transform-parameter.js';
 
 class TestParameter extends StatefulParameter<TestConfig, string> {
-  constructor(configuration?: StatefulParameterConfiguration<TestConfig>) {
-    super(configuration ?? {
+  constructor(options?: StatefulParameterOptions<TestConfig>) {
+    super(options ?? {
       name: 'propA'
     })
   }
@@ -43,7 +43,9 @@ describe('Resource parameters tests', () => {
       constructor() {
         super({
           type: 'resource',
-          statefulParameters: [statefulParameterSpy],
+          parameterOptions: {
+            propA: { statefulParameter: statefulParameterSpy }
+          },
         });
       }
     }
@@ -76,8 +78,8 @@ describe('Resource parameters tests', () => {
       constructor() {
         super({
           type: 'resource',
-          statefulParameters: [statefulParameterSpy],
-          parameterConfigurations: {
+          parameterOptions: {
+            propA: { statefulParameter: statefulParameterSpy },
             propB: { planOperation: ResourceOperation.MODIFY },
           }
         });
@@ -110,7 +112,9 @@ describe('Resource parameters tests', () => {
       constructor() {
         super({
           type: 'resource',
-          statefulParameters: [statefulParameterSpy],
+          parameterOptions: {
+            propA: { statefulParameter: statefulParameterSpy },
+          },
         });
       }
 
@@ -141,7 +145,9 @@ describe('Resource parameters tests', () => {
       constructor() {
         super({
           type: 'resource',
-          statefulParameters: [statefulParameterSpy],
+          parameterOptions: {
+            propA: { statefulParameter: statefulParameterSpy }
+          },
         });
       }
 
@@ -182,7 +188,9 @@ describe('Resource parameters tests', () => {
       constructor() {
         super({
           type: 'resource',
-          statefulParameters: [statefulParameterSpy],
+          parameterOptions: {
+            propA: { statefulParameter: statefulParameterSpy }
+          },
         });
       }
 
@@ -200,6 +208,163 @@ describe('Resource parameters tests', () => {
     })
   })
 
+  it('Plans stateful parameters in the order specified', async () => {
+    const statefulParameterA = spy(new class extends TestParameter {
+      async refresh(): Promise<any | null> {
+        return performance.now()
+      }
+    });
+
+    const statefulParameterB = spy(new class extends TestParameter {
+      async refresh(): Promise<any | null> {
+        return performance.now()
+      }
+    });
+
+    const statefulParameterC = spy(new class extends TestParameter {
+      async refresh(): Promise<any | null> {
+        return performance.now()
+      }
+    });
+
+    const statefulParameterD = spy(new class extends TestParameter {
+      async refresh(): Promise<any | null> {
+        return performance.now()
+      }
+    });
+
+    const statefulParameterE = spy(new class extends TestParameter {
+      async refresh(): Promise<any | null> {
+        return performance.now()
+      }
+    });
+
+    const resource = spy(new class extends TestResource {
+      constructor() {
+        super({
+          type: 'resourceType',
+          parameterOptions: {
+            propA: { statefulParameter: statefulParameterA, order: 3},
+            propB: { statefulParameter: statefulParameterB, order: 1 },
+            propC: { statefulParameter: statefulParameterC, order: 2 },
+            propD: { statefulParameter: statefulParameterD },
+            propE: { statefulParameter: statefulParameterE }
+          },
+        });
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return {};
+      }
+    });
+
+    const plan = await resource.plan({
+      type: 'resourceType',
+      propA: 'propA',
+      propB: 10,
+      propC: 'propC',
+      propD: 'propD',
+      propE: 'propE',
+    });
+
+    expect(plan.currentConfig.propB).to.be.lessThan(plan.currentConfig.propC as any);
+    expect(plan.currentConfig.propC).to.be.lessThan(plan.currentConfig.propA as any);
+    expect(plan.currentConfig.propA).to.be.lessThan(plan.currentConfig.propD as any);
+    expect(plan.currentConfig.propD).to.be.lessThan(plan.currentConfig.propE as any);
+  })
+
+  it('Applies stateful parameters in the order specified', async () => {
+    let timestampA;
+    const statefulParameterA = spy(new class extends TestParameter {
+      applyAdd = async (): Promise<void> => { timestampA = performance.now(); }
+      applyModify = async (): Promise<void> => { timestampA = performance.now(); }
+      applyRemove = async (): Promise<void> => { timestampA = performance.now(); }
+    });
+
+    let timestampB
+    const statefulParameterB = spy(new class extends TestParameter {
+      applyAdd = async (): Promise<void> => { timestampB = performance.now(); }
+      applyModify = async (): Promise<void> => { timestampB = performance.now(); }
+      applyRemove = async (): Promise<void> => { timestampB = performance.now(); }
+    });
+
+    let timestampC
+    const statefulParameterC = spy(new class extends TestParameter {
+      applyAdd = async (): Promise<void> => { timestampC = performance.now(); }
+      applyModify = async (): Promise<void> => { timestampC = performance.now(); }
+      applyRemove = async (): Promise<void> => { timestampC = performance.now(); }
+    });
+
+    const resource = spy(new class extends TestResource {
+      constructor() {
+        super({
+          type: 'resourceType',
+          parameterOptions: {
+            propA: { statefulParameter: statefulParameterA, order: 3},
+            propB: { statefulParameter: statefulParameterB, order: 1 },
+            propC: { statefulParameter: statefulParameterC, order: 2 },
+          },
+          callStatefulParameterRemoveOnDestroy: true,
+        });
+      }
+    });
+
+    await resource.apply(
+      Plan.fromResponse({
+        resourceType: 'resourceType',
+        operation: ResourceOperation.CREATE,
+        parameters: [
+          { name: 'propA', operation: ParameterOperation.ADD, previousValue: null, newValue: null },
+          { name: 'propB', operation: ParameterOperation.ADD, previousValue: null, newValue: null },
+          { name: 'propC', operation: ParameterOperation.ADD, previousValue: null, newValue: null },
+        ]
+      }, {}) as any
+    );
+
+    expect(timestampB).to.be.lessThan(timestampC as any);
+    expect(timestampC).to.be.lessThan(timestampA as any);
+    timestampA = 0;
+    timestampB = 0;
+    timestampC = 0;
+
+    await resource.apply(
+      Plan.fromResponse({
+        resourceType: 'resourceType',
+        operation: ResourceOperation.MODIFY,
+        parameters: [
+          { name: 'propA', operation: ParameterOperation.MODIFY, previousValue: null, newValue: null },
+          { name: 'propB', operation: ParameterOperation.MODIFY, previousValue: null, newValue: null },
+          { name: 'propC', operation: ParameterOperation.MODIFY, previousValue: null, newValue: null },
+        ]
+      }, {}) as any
+    );
+
+    expect(timestampB).to.be.lessThan(timestampC as any);
+    expect(timestampC).to.be.lessThan(timestampA as any);
+    timestampA = 0;
+    timestampB = 0;
+    timestampC = 0;
+
+    await resource.apply(
+      Plan.fromResponse({
+        resourceType: 'resourceType',
+        operation: ResourceOperation.DESTROY,
+        parameters: [
+          { name: 'propA', operation: ParameterOperation.REMOVE, previousValue: null, newValue: null },
+          { name: 'propB', operation: ParameterOperation.REMOVE, previousValue: null, newValue: null },
+          { name: 'propC', operation: ParameterOperation.REMOVE, previousValue: null, newValue: null },
+        ]
+      }, {}) as any
+    );
+
+    expect(timestampB).to.be.lessThan(timestampC as any);
+    expect(timestampC).to.be.lessThan(timestampA as any);
+    timestampA = 0;
+    timestampB = 0;
+    timestampC = 0;
+
+  })
+
   it('Supports transform parameters', async () => {
     const transformParameter = new class extends TransformParameter<TestConfig> {
       async transform(value: any): Promise<Partial<TestConfig>> {
@@ -214,8 +379,8 @@ describe('Resource parameters tests', () => {
       constructor() {
         super({
           type: 'resourceType',
-          transformParameters: {
-            propC: transformParameter
+          parameterOptions: {
+            propC: { transformParameter }
           },
         });
       }
@@ -241,4 +406,51 @@ describe('Resource parameters tests', () => {
 
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
+
+  it('Plans transform parameters in the order specified', async () => {
+    const transformParameterA = spy(new class extends TransformParameter<TestConfig> {
+      async transform(value: any): Promise<Partial<TestConfig>> {
+          return { propD: performance.now() as any }
+      }
+    });
+
+    const transformParameterB = spy(new class extends TransformParameter<TestConfig> {
+      async transform(value: any): Promise<Partial<TestConfig>> {
+        return { propE: performance.now() }
+      }
+    });
+
+    const transformParameterC = spy(new class extends TransformParameter<TestConfig> {
+      async transform(value: any): Promise<Partial<TestConfig>> {
+        return { propF: performance.now() as any }
+      }
+    });
+
+    const resource = spy(new class extends TestResource {
+      constructor() {
+        super({
+          type: 'resourceType',
+          parameterOptions: {
+            propA: { transformParameter: transformParameterA, order: 3},
+            propB: { transformParameter: transformParameterB, order: 1 },
+            propC: { transformParameter: transformParameterC, order: 2 },
+          },
+        });
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return { propD: 'propD', propE: 10, propF: 'propF' };
+      }
+    });
+
+    const plan = await resource.plan({
+      type: 'resourceType',
+      propA: 'propA',
+      propB: 10,
+      propC: 'propC',
+    });
+
+    expect(plan.desiredConfig.propE).to.be.lessThan(plan.desiredConfig.propF as any);
+    expect(plan.desiredConfig.propF).to.be.lessThan(plan.desiredConfig.propD as any);
+  })
 })

package/src/entities/resource-types.ts

@@ -1,13 +1,11 @@
-import { StatefulParameter } from './stateful-parameter.js';
-import { ResourceOperation, StringIndexedObject } from 'codify-schemas';
-import { TransformParameter } from './transform-parameter.js';
+import { ResourceOperation } from 'codify-schemas';
 
 export type ErrorMessage = string;
 
 /**
  * Customize properties for specific parameters. This will alter the way the library process changes to the parameter.
  */
-export interface ResourceParameterConfiguration {
+export interface ResourceParameterOptions {
   /**
    * Chose if the resource should be re-created or modified if this parameter is changed. Defaults to re-create.
    */
@@ -27,18 +25,6 @@ export interface ResourceParameterConfiguration {
 /**
  * @param
  */
-export interface ResourceConfiguration<T extends StringIndexedObject> {
-  type: string;
-  /**
-   * If true, statefulParameter.applyRemove() will be called before resource destruction.
-   * Defaults to false.
-   */
-  callStatefulParameterRemoveOnDestroy?: boolean,
-  dependencies?: string[];
-  statefulParameters?: Array<StatefulParameter<T, T[keyof T]>>;
-  transformParameters?: Partial<Record<keyof T, TransformParameter<T>>>
-  parameterConfigurations?: Partial<Record<keyof T, ResourceParameterConfiguration>>
-}
 
 export interface ResourceDefinition {
   [x: string]: {

package/src/entities/resource.test.ts

@@ -3,8 +3,9 @@ import { ResourceOperation, StringIndexedObject } from 'codify-schemas';
 import { spy } from 'sinon';
 import { Plan } from './plan.js';
 import { describe, expect, it } from 'vitest'
-import { ResourceConfiguration, ValidationResult } from './resource-types.js';
+import { ValidationResult } from './resource-types.js';
 import { StatefulParameter } from './stateful-parameter.js';
+import { ResourceOptions } from './resource-options.js';
 
 export interface TestConfig extends StringIndexedObject {
   propA: string;
@@ -13,7 +14,7 @@ export interface TestConfig extends StringIndexedObject {
 }
 
 export class TestResource extends Resource<TestConfig> {
-  constructor(options: ResourceConfiguration<TestConfig>) {
+  constructor(options: ResourceOptions<TestConfig>) {
     super(options);
   }
 
@@ -33,7 +34,7 @@ export class TestResource extends Resource<TestConfig> {
     };
   }
 
-  async validate(config: unknown): Promise<ValidationResult> {
+  async validateResource(config: unknown): Promise<ValidationResult> {
     return {
       isValid: true
     }
@@ -193,7 +194,7 @@ describe('Resource tests', () => {
       constructor() {
         super({
           type: 'resource',
-          parameterConfigurations: {
+          parameterOptions: {
             propA: { planOperation: ResourceOperation.MODIFY },
             propB: { planOperation: ResourceOperation.MODIFY },
           }
@@ -215,8 +216,8 @@ describe('Resource tests', () => {
     expect(resourceSpy.applyModify.calledTwice).to.be.true;
   })
 
-  it('Validates the resource configuration correct (pass)', () => {
-    const parameter = new class extends StatefulParameter<TestConfig, string> {
+  it('Validates the resource options correct (pass)', () => {
+    const statefulParameter = new class extends StatefulParameter<TestConfig, string> {
       constructor() {
         super({
           name: 'propC',
@@ -242,11 +243,9 @@ describe('Resource tests', () => {
         super({
           type: 'type',
           dependencies: ['homebrew', 'python'],
-          statefulParameters: [
-            parameter
-          ],
-          parameterConfigurations: {
+          parameterOptions: {
             propA: { planOperation: ResourceOperation.MODIFY },
+            propB: { statefulParameter },
             propC: { isEqual: (a, b) => true },
           }
         });
@@ -254,8 +253,8 @@ describe('Resource tests', () => {
     }).to.not.throw;
   })
 
-  it('Validates the resource configuration correct (fail)', () => {
-    const parameter = new class extends StatefulParameter<TestConfig, string> {
+  it('Validates the resource options correct (fail)', () => {
+    const statefulParameter = new class extends StatefulParameter<TestConfig, string> {
       constructor() {
         super({
           name: 'propC',
@@ -281,11 +280,9 @@ describe('Resource tests', () => {
         super({
           type: 'type',
           dependencies: ['homebrew', 'python'],
-          statefulParameters: [
-            parameter
-          ],
-          parameterConfigurations: {
+          parameterOptions: {
             propA: { planOperation: ResourceOperation.MODIFY },
+            propB: { statefulParameter },
             propC: { isEqual: (a, b) => true },
           }
         });
@@ -298,7 +295,7 @@ describe('Resource tests', () => {
       constructor() {
         super({
           type: 'type',
-          parameterConfigurations: {
+          parameterOptions: {
             propA: { defaultValue: 'propADefault' }
           }
         });
@@ -327,7 +324,7 @@ describe('Resource tests', () => {
       constructor() {
         super({
           type: 'type',
-          parameterConfigurations: {
+          parameterOptions: {
             propA: { defaultValue: 'propADefault' }
           }
         });
@@ -348,6 +345,5 @@ describe('Resource tests', () => {
     expect(plan.currentConfig.propA).to.eq('propAAfter');
     expect(plan.desiredConfig.propA).to.eq('propA');
     expect(plan.changeSet.operation).to.eq(ResourceOperation.RECREATE);
-
-  })
+  });
 });