Added default value to stateful parameters + tests. Removed un-used name property from stateless parameter options.

Author: kevinwang5658

src/entities/resource-parameters.test.ts

@@ -7,10 +7,8 @@ import { TestConfig, TestResource } from './resource.test.js';
 import { TransformParameter } from './transform-parameter.js';
 
 class TestParameter extends StatefulParameter<TestConfig, string> {
-  constructor(options?: StatefulParameterOptions<TestConfig>) {
-    super(options ?? {
-      name: 'propA'
-    })
+  constructor(options?: StatefulParameterOptions<string>) {
+    super(options ?? {})
   }
 
   applyAdd(valueToAdd: string, plan: Plan<TestConfig>): Promise<void> {
@@ -140,6 +138,51 @@ describe('Resource parameter tests', () => {
     expect(resourceSpy.applyModify.calledOnce).to.be.true;
   })
 
+  it('Allows stateful parameters to have default values', async () => {
+    const statefulParameter = spy(new class extends TestParameter {
+      constructor() {
+        super({
+          default: 'abc'
+        });
+      }
+
+      async refresh(): Promise<string | null> {
+        return null;
+      }
+    });
+
+    const resource = new class extends TestResource {
+      constructor() {
+        super({
+          type: 'resource',
+          parameterOptions: {
+            propA: { statefulParameter }
+          },
+        });
+      }
+
+      async refresh(): Promise<any> {
+        return null;
+      }
+    }
+
+    const plan = await resource.plan({
+      type: 'resource',
+    })
+
+    expect(statefulParameter.refresh.notCalled).to.be.true;
+    expect(plan.currentConfig).toMatchObject({
+      type: 'resource',
+      propA: null,
+    })
+    expect(plan.desiredConfig).toMatchObject({
+      type: 'resource',
+      propA: 'abc',
+    })
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.CREATE);
+  })
+
+
   it('Filters array results in stateless mode to prevent modify from being called', async () => {
     const statefulParameter = new class extends TestParameter {
       async refresh(): Promise<any | null> {
@@ -210,7 +253,6 @@ describe('Resource parameter tests', () => {
     const statefulParameter = new class extends ArrayStatefulParameter<TestConfig, string> {
       constructor() {
         super({
-          name: 'propA',
           isElementEqual: (desired, current) => current.includes(desired),
         });
       }
@@ -531,4 +573,44 @@ describe('Resource parameter tests', () => {
     expect(plan.desiredConfig.propE).to.be.lessThan(plan.desiredConfig.propF as any);
     expect(plan.desiredConfig.propF).to.be.lessThan(plan.desiredConfig.propD as any);
   })
+
+  it('Plans transform even for creating new resources', async () => {
+    const transformParameterA = spy(new class extends TransformParameter<TestConfig> {
+      async transform(value: any): Promise<Partial<TestConfig>> {
+        return { propD: 'abc', propE: 10 }
+      }
+    });
+
+    const resource = spy(new class extends TestResource {
+      constructor() {
+        super({
+          type: 'resourceType',
+          parameterOptions: {
+            propA: { transformParameter: transformParameterA },
+          },
+        });
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    });
+
+    const plan = await resource.plan({
+      type: 'resourceType',
+      propA: 'propA',
+      propB: 10,
+      propC: 'propC',
+    });
+    expect(plan.currentConfig).toMatchObject({
+      type: 'resourceType',
+      propD: null,
+      propE: null,
+    })
+    expect(plan.desiredConfig).toMatchObject({
+      type: 'resourceType',
+      propD: 'abc',
+      propE: 10,
+    })
+  })
 })

src/entities/resource.ts

@@ -95,6 +95,8 @@ export abstract class Resource<T extends StringIndexedObject> {
       transformParameters,
     } = parsedConfig;
 
+    // Apply transform parameters. Transform parameters turn into other parameters.
+    // Ex: csvFile: './location' => { password: 'pass', 'username': 'user' }
     await this.applyTransformParameters(transformParameters, resourceParameters);
 
     // Refresh resource parameters. This refreshes the parameters that configure the resource itself

src/entities/stateful-parameter.ts

@@ -1,8 +1,7 @@
 import { Plan } from './plan.js';
 import { StringIndexedObject } from 'codify-schemas';
 
-export interface StatefulParameterOptions<T> {
-  name: keyof T;
+export interface StatefulParameterOptions<V> {
   isEqual?: (desired: any, current: any) => boolean;
 
   /**
@@ -15,20 +14,19 @@ export interface StatefulParameterOptions<T> {
    * Set this flag to true to disable this behaviour
    */
   disableStatelessModeArrayFiltering?: boolean;
+  default?: V;
 }
 
-export interface ArrayStatefulParameterOptions<T> extends StatefulParameterOptions<T> {
+export interface ArrayStatefulParameterOptions<V> extends StatefulParameterOptions<V> {
   isEqual?: (desired: any[], current: any[]) => boolean;
   isElementEqual?: (desired: any, current: any) => boolean;
 }
 
 
 export abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
-  readonly name: keyof T;
-  readonly options: StatefulParameterOptions<T>;
+  readonly options: StatefulParameterOptions<V>;
 
-  protected constructor(options: StatefulParameterOptions<T>) {
-    this.name = options.name;
+  protected constructor(options: StatefulParameterOptions<V>) {
     this.options = options
   }
 
@@ -41,9 +39,9 @@ export abstract class StatefulParameter<T extends StringIndexedObject, V extends
 }
 
 export abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any>{
-  options: ArrayStatefulParameterOptions<T>;
+  options: ArrayStatefulParameterOptions<V>;
 
-  constructor(options: ArrayStatefulParameterOptions<T>) {
+  constructor(options: ArrayStatefulParameterOptions<V>) {
     super(options);
     this.options = options;
   }
@@ -55,7 +53,7 @@ export abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> e
   }
 
   async applyModify(newValues: V[], previousValues: V[], allowDeletes: boolean, plan: Plan<T>): Promise<void> {
-    const options = this.options as ArrayStatefulParameterOptions<T>;
+    const options = this.options as ArrayStatefulParameterOptions<V>;
 
     const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
       if (options.isElementEqual) {