codify-plugin-lib 1.0.65 → 1.0.67

package/dist/entities/change-set.js

@@ -59,8 +59,8 @@ export class ChangeSet {
     }
     static calculateStatefulModeChangeSet(desired, current, parameterOptions) {
         const parameterChangeSet = new Array();
-        const _desired = { ...desired };
-        const _current = { ...current };
+        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) {
@@ -108,8 +108,8 @@ export class ChangeSet {
     }
     static calculateStatelessModeChangeSet(desired, current, parameterOptions) {
         const parameterChangeSet = new Array();
-        const _desired = { ...desired };
-        const _current = { ...current };
+        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) {

package/dist/entities/plan-types.d.ts

@@ -1,3 +1,5 @@
+import { Plan } from './plan.js';
+import { StringIndexedObject } from 'codify-schemas';
 export interface ParameterOptions {
     modifyOnChange?: boolean;
     isEqual?: (desired: any, current: any) => boolean;
@@ -9,3 +11,9 @@ export interface PlanOptions<T> {
     statefulMode: boolean;
     parameterOptions?: Record<keyof T, ParameterOptions>;
 }
+export type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type CreatePlan<T extends StringIndexedObject> = WithRequired<Plan<T>, 'desiredConfig'>;
+export type DestroyPlan<T extends StringIndexedObject> = WithRequired<Plan<T>, 'currentConfig'>;
+export type ModifyPlan<T extends StringIndexedObject> = WithRequired<Plan<T>, 'currentConfig' | 'desiredConfig'>;

package/dist/entities/plan.d.ts

@@ -9,7 +9,7 @@ export declare class Plan<T extends StringIndexedObject> {
     static create<T extends StringIndexedObject>(desiredParameters: Partial<T> | null, currentParameters: Partial<T> | null, resourceMetadata: ResourceConfig, options: PlanOptions<T>): Plan<T>;
     getResourceType(): string;
     static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T>;
-    get desiredConfig(): T;
-    get currentConfig(): T;
+    get desiredConfig(): T | null;
+    get currentConfig(): T | null;
     toResponse(): PlanResponseData;
 }

package/dist/entities/plan.js

@@ -98,12 +98,18 @@ export class Plan {
         }
     }
     get desiredConfig() {
+        if (this.changeSet.operation === ResourceOperation.DESTROY) {
+            return null;
+        }
         return {
             ...this.resourceMetadata,
             ...this.changeSet.desiredParameters,
         };
     }
     get currentConfig() {
+        if (this.changeSet.operation === ResourceOperation.CREATE) {
+            return null;
+        }
         return {
             ...this.resourceMetadata,
             ...this.changeSet.currentParameters,

package/dist/entities/plugin.js

@@ -64,7 +64,7 @@ export class Plugin {
             throw new Error('Malformed plan with resource that cannot be found');
         }
         await resource.apply(plan);
-        const validationPlan = await resource.plan({ ...plan.resourceMetadata, ...plan.desiredConfig });
+        const validationPlan = await resource.plan(plan.desiredConfig, plan.currentConfig, true);
         if (validationPlan.changeSet.operation !== ResourceOperation.NOOP) {
             throw new ApplyValidationError(plan, validationPlan);
         }

package/dist/entities/resource.d.ts

@@ -3,7 +3,7 @@ import { ParameterChange } from './change-set.js';
 import { Plan } from './plan.js';
 import { StatefulParameter } from './stateful-parameter.js';
 import { ResourceParameterOptions, ValidationResult } from './resource-types.js';
-import { ParameterOptions } from './plan-types.js';
+import { CreatePlan, DestroyPlan, ModifyPlan, ParameterOptions } from './plan-types.js';
 import { TransformParameter } from './transform-parameter.js';
 import { ResourceOptions } from './resource-options.js';
 import Ajv from 'ajv';
@@ -24,7 +24,7 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     protected constructor(options: ResourceOptions<T>);
     onInitialize(): Promise<void>;
     validateResource(parameters: unknown): Promise<ValidationResult>;
-    plan(desiredConfig: Partial<T> & ResourceConfig): Promise<Plan<T>>;
+    plan(desiredConfig: Partial<T> & ResourceConfig | null, currentConfig?: Partial<T> & ResourceConfig | null, statefulMode?: boolean): Promise<Plan<T>>;
     apply(plan: Plan<T>): Promise<void>;
     private _applyCreate;
     private _applyModify;
@@ -32,11 +32,12 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     private validateRefreshResults;
     private applyTransformParameters;
     private addDefaultValues;
-    private refreshResourceParameters;
+    private refreshNonStatefulParameters;
     private refreshStatefulParameters;
+    private validatePlanInputs;
     validate(parameters: unknown): Promise<ValidationResult>;
-    abstract refresh(keys: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
-    abstract applyCreate(plan: Plan<T>): Promise<void>;
-    applyModify(pc: ParameterChange<T>, plan: Plan<T>): Promise<void>;
-    abstract applyDestroy(plan: Plan<T>): Promise<void>;
+    abstract refresh(values: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
+    abstract applyCreate(plan: CreatePlan<T>): Promise<void>;
+    applyModify(pc: ParameterChange<T>, plan: ModifyPlan<T>): Promise<void>;
+    abstract applyDestroy(plan: DestroyPlan<T>): Promise<void>;
 }

package/dist/entities/resource.js

@@ -49,21 +49,22 @@ export class Resource {
         }
         return this.validate(parameters);
     }
-    async plan(desiredConfig) {
+    async plan(desiredConfig, currentConfig = null, statefulMode = false) {
+        this.validatePlanInputs(desiredConfig, currentConfig, statefulMode);
         const planOptions = {
-            statefulMode: false,
+            statefulMode,
             parameterOptions: this.parameterOptions,
         };
         this.addDefaultValues(desiredConfig);
-        const parsedConfig = new ConfigParser(desiredConfig, this.statefulParameters, this.transformParameters);
-        const { parameters: desiredParameters, resourceMetadata, resourceParameters, statefulParameters, transformParameters, } = parsedConfig;
-        await this.applyTransformParameters(transformParameters, resourceParameters);
-        const currentParameters = await this.refreshResourceParameters(resourceParameters);
+        await this.applyTransformParameters(desiredConfig);
+        const parsedConfig = new ConfigParser(desiredConfig, currentConfig, this.statefulParameters, this.transformParameters);
+        const { desiredParameters, resourceMetadata, nonStatefulParameters, statefulParameters, } = parsedConfig;
+        const currentParameters = await this.refreshNonStatefulParameters(nonStatefulParameters);
         if (currentParameters == null) {
-            return Plan.create({ ...resourceParameters, ...statefulParameters }, null, resourceMetadata, planOptions);
+            return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
         }
         const statefulCurrentParameters = await this.refreshStatefulParameters(statefulParameters, planOptions.statefulMode);
-        return Plan.create({ ...resourceParameters, ...statefulParameters }, { ...currentParameters, ...statefulCurrentParameters }, resourceMetadata, planOptions);
+        return Plan.create(desiredParameters, { ...currentParameters, ...statefulCurrentParameters }, resourceMetadata, planOptions);
     }
     async apply(plan) {
         if (plan.getResourceType() !== this.typeId) {
@@ -151,20 +152,30 @@ Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
 Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         }
     }
-    async applyTransformParameters(transformParameters, desired) {
-        const orderedEntries = [...Object.entries(transformParameters)]
+    async applyTransformParameters(desired) {
+        if (!desired) {
+            return;
+        }
+        const transformParameters = [...this.transformParameters.entries()]
             .sort(([keyA], [keyB]) => this.transformParameterOrder.get(keyA) - this.transformParameterOrder.get(keyB));
-        for (const [key, value] of orderedEntries) {
-            const transformedValue = await this.transformParameters.get(key).transform(value);
+        for (const [key, transformParameter] of transformParameters) {
+            if (desired[key] === undefined) {
+                continue;
+            }
+            const transformedValue = await transformParameter.transform(desired[key]);
             if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
                 throw new Error(`Transform parameter ${key} is attempting to override existing values ${JSON.stringify(transformedValue, null, 2)}`);
             }
+            delete desired[key];
             Object.entries(transformedValue).forEach(([tvKey, tvValue]) => {
                 desired[tvKey] = tvValue;
             });
         }
     }
     addDefaultValues(desired) {
+        if (!desired) {
+            return;
+        }
         Object.entries(this.defaultValues)
             .forEach(([key, defaultValue]) => {
             if (defaultValue !== undefined && desired[key] === undefined) {
@@ -172,7 +183,7 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
             }
         });
     }
-    async refreshResourceParameters(resourceParameters) {
+    async refreshNonStatefulParameters(resourceParameters) {
         const entriesToRefresh = new Map(Object.entries(resourceParameters));
         const currentParameters = await this.refresh(entriesToRefresh);
         this.validateRefreshResults(currentParameters, entriesToRefresh);
@@ -204,6 +215,14 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         }
         return currentParameters;
     }
+    validatePlanInputs(desired, current, statefulMode) {
+        if (!desired && !current) {
+            throw new Error('Desired config and current config cannot both be missing');
+        }
+        if (!statefulMode && !desired) {
+            throw new Error('Desired config must be provided in non-stateful mode');
+        }
+    }
     async validate(parameters) {
         return {
             isValid: true,
@@ -214,23 +233,46 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
     ;
 }
 class ConfigParser {
-    config;
+    desiredConfig;
+    currentConfig;
     statefulParametersMap;
     transformParametersMap;
-    constructor(config, statefulParameters, transformParameters) {
-        this.config = config;
+    constructor(desiredConfig, currentConfig, statefulParameters, transformParameters) {
+        this.desiredConfig = desiredConfig;
+        this.currentConfig = currentConfig;
         this.statefulParametersMap = statefulParameters;
         this.transformParametersMap = transformParameters;
     }
     get resourceMetadata() {
-        const { resourceMetadata } = splitUserConfig(this.config);
-        return resourceMetadata;
+        const desiredMetadata = this.desiredConfig ? splitUserConfig(this.desiredConfig).resourceMetadata : undefined;
+        const currentMetadata = this.currentConfig ? splitUserConfig(this.currentConfig).resourceMetadata : undefined;
+        if (!desiredMetadata && !currentMetadata) {
+            throw new Error(`Unable to parse resource metadata from ${this.desiredConfig}, ${this.currentConfig}`);
+        }
+        if (currentMetadata && desiredMetadata && (Object.keys(desiredMetadata).length !== Object.keys(currentMetadata).length
+            || Object.entries(desiredMetadata).some(([key, value]) => currentMetadata[key] !== value))) {
+            throw new Error(`The metadata for the current config does not match the desired config. 
+Desired metadata:
+${JSON.stringify(desiredMetadata, null, 2)}
+
+Current metadata:
+${JSON.stringify(currentMetadata, null, 2)}`);
+        }
+        return desiredMetadata ?? currentMetadata;
     }
-    get parameters() {
-        const { parameters } = splitUserConfig(this.config);
+    get desiredParameters() {
+        if (!this.desiredConfig) {
+            return null;
+        }
+        const { parameters } = splitUserConfig(this.desiredConfig);
         return parameters;
     }
-    get resourceParameters() {
+    get parameters() {
+        const desiredParameters = this.desiredConfig ? splitUserConfig(this.desiredConfig).parameters : undefined;
+        const currentParameters = this.currentConfig ? splitUserConfig(this.currentConfig).parameters : undefined;
+        return { ...(desiredParameters ?? {}), ...(currentParameters ?? {}) };
+    }
+    get nonStatefulParameters() {
         const parameters = this.parameters;
         return Object.fromEntries([
             ...Object.entries(parameters).filter(([key]) => !(this.statefulParametersMap.has(key) || this.transformParametersMap.has(key))),
@@ -242,10 +284,4 @@ class ConfigParser {
             ...Object.entries(parameters).filter(([key]) => this.statefulParametersMap.has(key)),
         ]);
     }
-    get transformParameters() {
-        const parameters = this.parameters;
-        return Object.fromEntries([
-            ...Object.entries(parameters).filter(([key]) => this.transformParametersMap.has(key)),
-        ]);
-    }
 }

package/dist/index.d.ts

@@ -8,6 +8,5 @@ export * from './entities/plan.js';
 export * from './entities/plan-types.js';
 export * from './entities/stateful-parameter.js';
 export * from './entities/errors.js';
-export * from './utils/test-utils.js';
 export * from './utils/utils.js';
 export declare function runPlugin(plugin: Plugin): Promise<void>;

package/dist/index.js

@@ -8,7 +8,6 @@ export * from './entities/plan.js';
 export * from './entities/plan-types.js';
 export * from './entities/stateful-parameter.js';
 export * from './entities/errors.js';
-export * from './utils/test-utils.js';
 export * from './utils/utils.js';
 export async function runPlugin(plugin) {
     const messageHandler = new MessageHandler(plugin);

package/package.json

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

package/src/entities/change-set.ts

@@ -123,8 +123,8 @@ export class ChangeSet<T extends StringIndexedObject> {
   ): ParameterChange<T>[] {
     const parameterChangeSet = new Array<ParameterChange<T>>();
     
-    const _desired = { ...desired };
-    const _current = { ...current };
+    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);
 
@@ -190,8 +190,9 @@ export class ChangeSet<T extends StringIndexedObject> {
   ): ParameterChange<T>[] {
     const parameterChangeSet = new Array<ParameterChange<T>>();
 
-    const _desired = { ...desired };
-    const _current = { ...current };
+    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);
 

package/src/entities/plan-types.ts

@@ -1,3 +1,6 @@
+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.
  */
@@ -24,3 +27,8 @@ export interface PlanOptions<T> {
   statefulMode: boolean;
   parameterOptions?: Record<keyof T, ParameterOptions>;
 }
+
+export type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] }
+export type CreatePlan<T extends StringIndexedObject> = WithRequired<Plan<T>, 'desiredConfig'>
+export type DestroyPlan<T extends StringIndexedObject> = WithRequired<Plan<T>, 'currentConfig'>
+export type ModifyPlan<T extends StringIndexedObject> = WithRequired<Plan<T>, 'currentConfig' | 'desiredConfig'>

package/src/entities/plan.test.ts

@@ -19,11 +19,7 @@ describe('Plan entity tests', () => {
       }]
     }, resource.defaultValues);
 
-    expect(plan.currentConfig).toMatchObject({
-      type: 'type',
-      propA: null,
-      propB: null,
-    })
+    expect(plan.currentConfig).to.be.null;
 
     expect(plan.desiredConfig).toMatchObject({
       type: 'type',
@@ -56,11 +52,7 @@ describe('Plan entity tests', () => {
       propB: 'propBValue',
     })
 
-    expect(plan.desiredConfig).toMatchObject({
-      type: 'type',
-      propA: null,
-      propB: null,
-    })
+    expect(plan.desiredConfig).to.be.null;
 
     expect(plan.changeSet.parameterChanges
       .every((pc) => pc.operation === ParameterOperation.REMOVE)
@@ -117,11 +109,7 @@ describe('Plan entity tests', () => {
       }]
     }, resource.defaultValues);
 
-    expect(plan.currentConfig).toMatchObject({
-      type: 'type',
-      propA: null,
-      propB: null,
-    })
+    expect(plan.currentConfig).to.be.null
 
     expect(plan.desiredConfig).toMatchObject({
       type: 'type',

package/src/entities/plan.ts

@@ -144,14 +144,22 @@ export class Plan<T extends StringIndexedObject> {
 
   }
 
-  get desiredConfig(): T {
+  get desiredConfig(): T | null {
+    if (this.changeSet.operation === ResourceOperation.DESTROY) {
+      return null;
+    }
+
     return {
       ...this.resourceMetadata,
       ...this.changeSet.desiredParameters,
     }
   }
 
-  get currentConfig(): T {
+  get currentConfig(): T | null {
+    if (this.changeSet.operation === ResourceOperation.CREATE) {
+      return null;
+    }
+
     return {
       ...this.resourceMetadata,
       ...this.changeSet.currentParameters,

package/src/entities/plugin.test.ts

@@ -44,7 +44,7 @@ class TestResource extends Resource<TestConfig> {
 
 describe('Plugin tests', () => {
   it('Validates that applies were successfully applied', async () => {
-    const resource = new class extends TestResource {
+    const resource= new class extends TestResource {
       async applyCreate(plan: Plan<TestConfig>): Promise<void> {
       }
 
@@ -56,9 +56,9 @@ describe('Plugin tests', () => {
       }
     }
 
-    const testPlugin = Plugin.create('testPlugin', [resource])
+    const plugin = Plugin.create('testPlugin', [resource])
 
-    const desiredPlan = {
+    const plan = {
       operation: ResourceOperation.CREATE,
       resourceType: 'testResource',
       parameters: [
@@ -67,7 +67,7 @@ describe('Plugin tests', () => {
     };
 
     // If this doesn't throw then it passes the test
-    await testPlugin.apply({ plan: desiredPlan });
+    await plugin.apply({ plan });
   });
 
   it('Validates that applies were successfully applied (error)', async () => {
@@ -80,10 +80,9 @@ describe('Plugin tests', () => {
         return null;
       }
     }
+    const plugin = Plugin.create('testPlugin', [resource])
 
-    const testPlugin = Plugin.create('testPlugin', [resource])
-
-    const desiredPlan = {
+    const plan = {
       operation: ResourceOperation.CREATE,
       resourceType: 'testResource',
       parameters: [
@@ -91,6 +90,104 @@ describe('Plugin tests', () => {
       ]
     };
 
-    await expect(async () => testPlugin.apply({ plan: desiredPlan })).rejects.toThrowError(expect.any(ApplyValidationError));
+    await expect(async () => plugin.apply({ plan })).rejects.toThrowError(expect.any(ApplyValidationError));
+  });
+
+  it('Validates that deletes were successfully applied', async () => {
+    const resource = new class extends TestResource {
+      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
+      }
+
+      // Return null to indicate that the resource was deleted
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    }
+
+    const testPlugin = Plugin.create('testPlugin', [resource])
+
+    const plan = {
+      operation: ResourceOperation.DESTROY,
+      resourceType: 'testResource',
+      parameters: [
+        { name: 'propA', operation: ParameterOperation.REMOVE, newValue: null, previousValue: 'abc' },
+      ]
+    };
+
+    // If this doesn't throw then it passes the test
+    await testPlugin.apply({ plan })
+  });
+
+  it('Validates that deletes were successfully applied (error)', async () => {
+    const resource = new class extends TestResource {
+      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
+      }
+
+      // Return a value to indicate that the resource still exists
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return { propA: 'abc' };
+      }
+    }
+
+    const testPlugin = Plugin.create('testPlugin', [resource])
+
+    const plan = {
+      operation: ResourceOperation.DESTROY,
+      resourceType: 'testResource',
+      parameters: [
+        { name: 'propA', operation: ParameterOperation.REMOVE, newValue: null, previousValue: 'abc' },
+      ]
+    };
+
+    // If this doesn't throw then it passes the test
+    expect(async () => await testPlugin.apply({ plan })).rejects.toThrowError(expect.any(ApplyValidationError));
+  });
+
+  it('Validates that re-create was successfully applied', async () => {
+    const resource = new class extends TestResource {
+      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
+      }
+
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return { propA: 'def'};
+      }
+    }
+
+    const testPlugin = Plugin.create('testPlugin', [resource])
+
+    const plan = {
+      operation: ResourceOperation.RECREATE,
+      resourceType: 'testResource',
+      parameters: [
+        { name: 'propA', operation: ParameterOperation.MODIFY, newValue: 'def', previousValue: 'abc' },
+      ]
+    };
+
+    // If this doesn't throw then it passes the test
+    await testPlugin.apply({ plan })
+  });
+
+  it('Validates that modify was successfully applied (error)', async () => {
+    const resource = new class extends TestResource {
+      async applyCreate(plan: Plan<TestConfig>): Promise<void> {
+      }
+
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        return { propA: 'abc' };
+      }
+    }
+
+    const testPlugin = Plugin.create('testPlugin', [resource])
+
+    const plan = {
+      operation: ResourceOperation.DESTROY,
+      resourceType: 'testResource',
+      parameters: [
+        { name: 'propA', operation: ParameterOperation.REMOVE, newValue: 'def', previousValue: 'abc' },
+      ]
+    };
+
+    // If this doesn't throw then it passes the test
+    expect(async () => await testPlugin.apply({ plan })).rejects.toThrowError(expect.any(ApplyValidationError));
   });
 });

package/src/entities/plugin.ts

@@ -95,7 +95,11 @@ export class Plugin {
 
     // Perform a validation check after to ensure that the plan was properly applied.
     // Sometimes no errors are returned (exit code 0) but the apply was not successful
-    const validationPlan = await resource.plan({ ...plan.resourceMetadata, ...plan.desiredConfig });
+    const validationPlan = await resource.plan(
+      plan.desiredConfig,
+      plan.currentConfig,
+      true,
+    );
     if (validationPlan.changeSet.operation !== ResourceOperation.NOOP) {
       throw new ApplyValidationError(plan, validationPlan);
     }

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

@@ -6,7 +6,7 @@ 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> {
+export class TestParameter extends StatefulParameter<TestConfig, string> {
   constructor(options?: StatefulParameterOptions<string>) {
     super(options ?? {})
   }
@@ -55,11 +55,7 @@ describe('Resource parameter tests', () => {
     })
 
     expect(statefulParameter.refresh.notCalled).to.be.true;
-    expect(plan.currentConfig).toMatchObject({
-      type: 'resource',
-      propA: null,
-      propB: null,
-    })
+    expect(plan.currentConfig).to.be.null;
     expect(plan.desiredConfig).toMatchObject({
       type: 'resource',
       propA: 'a',
@@ -171,10 +167,7 @@ describe('Resource parameter tests', () => {
     })
 
     expect(statefulParameter.refresh.notCalled).to.be.true;
-    expect(plan.currentConfig).toMatchObject({
-      type: 'resource',
-      propA: null,
-    })
+    expect(plan.currentConfig).to.be.null;
     expect(plan.desiredConfig).toMatchObject({
       type: 'resource',
       propA: 'abc',
@@ -182,7 +175,6 @@ describe('Resource parameter tests', () => {
     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> {
@@ -350,10 +342,10 @@ describe('Resource parameter tests', () => {
       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);
+    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 () => {
@@ -483,9 +475,9 @@ describe('Resource parameter tests', () => {
     expect(resource.refresh.getCall(0).firstArg.has('propB')).to.be.true;
     expect(resource.refresh.getCall(0).firstArg.has('propC')).to.be.false;
 
-    expect(plan.desiredConfig.propA).to.eq('propA');
-    expect(plan.desiredConfig.propB).to.eq(10);
-    expect(plan.desiredConfig.propC).to.be.undefined;
+    expect(plan.desiredConfig?.propA).to.eq('propA');
+    expect(plan.desiredConfig?.propB).to.eq(10);
+    expect(plan.desiredConfig?.propC).to.be.undefined;
 
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
@@ -570,8 +562,8 @@ describe('Resource parameter tests', () => {
       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);
+    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 () => {
@@ -602,11 +594,7 @@ describe('Resource parameter tests', () => {
       propB: 10,
       propC: 'propC',
     });
-    expect(plan.currentConfig).toMatchObject({
-      type: 'resourceType',
-      propD: null,
-      propE: null,
-    })
+    expect(plan.currentConfig).to.be.null;
     expect(plan.desiredConfig).toMatchObject({
       type: 'resourceType',
       propD: 'abc',