codify-plugin-lib 1.0.60 → 1.0.61

package/dist/entities/resource.js

@@ -54,13 +54,13 @@ export class Resource {
             statefulMode: false,
             parameterOptions: this.parameterOptions,
         };
+        this.addDefaultValues(desiredConfig);
         const parsedConfig = new ConfigParser(desiredConfig, this.statefulParameters, this.transformParameters);
         const { parameters: desiredParameters, resourceMetadata, resourceParameters, statefulParameters, transformParameters, } = parsedConfig;
-        this.addDefaultValues(resourceParameters);
         await this.applyTransformParameters(transformParameters, resourceParameters);
         const currentParameters = await this.refreshResourceParameters(resourceParameters);
         if (currentParameters == null) {
-            return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
+            return Plan.create({ ...resourceParameters, ...statefulParameters }, null, resourceMetadata, planOptions);
         }
         const statefulCurrentParameters = await this.refreshStatefulParameters(statefulParameters, planOptions.statefulMode);
         return Plan.create({ ...resourceParameters, ...statefulParameters }, { ...currentParameters, ...statefulCurrentParameters }, resourceMetadata, planOptions);

package/dist/entities/stateful-parameter.d.ts

@@ -1,26 +1,25 @@
 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;
     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 declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
-    readonly name: keyof T;
-    readonly options: StatefulParameterOptions<T>;
-    protected constructor(options: StatefulParameterOptions<T>);
+    readonly options: StatefulParameterOptions<V>;
+    protected constructor(options: StatefulParameterOptions<V>);
     abstract refresh(desired: V | null): Promise<V | null>;
     abstract applyAdd(valueToAdd: V, plan: Plan<T>): Promise<void>;
     abstract applyModify(newValue: V, previousValue: V, allowDeletes: boolean, plan: Plan<T>): Promise<void>;
     abstract applyRemove(valueToRemove: V, plan: Plan<T>): Promise<void>;
 }
 export declare abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any> {
-    options: ArrayStatefulParameterOptions<T>;
-    constructor(options: ArrayStatefulParameterOptions<T>);
+    options: ArrayStatefulParameterOptions<V>;
+    constructor(options: ArrayStatefulParameterOptions<V>);
     applyAdd(valuesToAdd: V[], plan: Plan<T>): Promise<void>;
     applyModify(newValues: V[], previousValues: V[], allowDeletes: boolean, plan: Plan<T>): Promise<void>;
     applyRemove(valuesToRemove: V[], plan: Plan<T>): Promise<void>;

package/dist/entities/stateful-parameter.js

@@ -1,8 +1,6 @@
 export class StatefulParameter {
-    name;
     options;
     constructor(options) {
-        this.name = options.name;
         this.options = options;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.60",
+  "version": "1.0.61",
   "description": "",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/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,
+    })
+  })
 })

package/src/entities/resource.ts

@@ -83,6 +83,8 @@ export abstract class Resource<T extends StringIndexedObject> {
       parameterOptions: this.parameterOptions,
     }
 
+    this.addDefaultValues(desiredConfig);
+
     // Parse data from the user supplied config
     const parsedConfig = new ConfigParser(desiredConfig, this.statefulParameters, this.transformParameters)
     const {
@@ -93,7 +95,8 @@ export abstract class Resource<T extends StringIndexedObject> {
       transformParameters,
     } = parsedConfig;
 
-    this.addDefaultValues(resourceParameters);
+    // 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
@@ -101,7 +104,12 @@ export abstract class Resource<T extends StringIndexedObject> {
 
     // Short circuit here. If the resource is non-existent, there's no point checking stateful parameters
     if (currentParameters == null) {
-      return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
+      return Plan.create(
+        { ...resourceParameters, ...statefulParameters },
+        null,
+        resourceMetadata,
+        planOptions,
+      );
     }
 
     // Refresh stateful parameters. These parameters have state external to the resource

package/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) {