codify-plugin-lib 1.0.46 → 1.0.48

package/dist/entities/plan.d.ts

@@ -8,7 +8,7 @@ export declare class Plan<T extends StringIndexedObject> {
     constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig);
     static create<T extends StringIndexedObject>(desiredParameters: Partial<T> | null, currentParameters: Partial<T> | null, resourceMetadata: ResourceConfig, configuration: PlanConfiguration<T>): Plan<T>;
     getResourceType(): string;
-    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan']): Plan<T>;
+    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues: Partial<Record<keyof T, unknown>>): Plan<T>;
     get desiredConfig(): T;
     get currentConfig(): T;
     toResponse(): PlanResponseData;

package/dist/entities/plan.js

@@ -45,18 +45,56 @@ export class Plan {
     getResourceType() {
         return this.resourceMetadata.type;
     }
-    static fromResponse(data) {
+    static fromResponse(data, defaultValues) {
         if (!data) {
             throw new Error('Data is empty');
         }
-        return new Plan(randomUUID(), new ChangeSet(data.operation, data.parameters.map(value => ({
-            ...value,
-            previousValue: null,
-        }))), {
+        addDefaultValues();
+        return new Plan(randomUUID(), new ChangeSet(data.operation, data.parameters), {
             type: data.resourceType,
             name: data.resourceName,
-            ...(data.parameters.reduce((prev, { name, newValue }) => Object.assign(prev, { [name]: newValue }), {}))
         });
+        function addDefaultValues() {
+            Object.entries(defaultValues)
+                .forEach(([key, defaultValue]) => {
+                const configValueExists = data
+                    ?.parameters
+                    .find((p) => p.name === key) !== undefined;
+                if (!configValueExists) {
+                    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() {
         return {

package/dist/entities/plugin.js

@@ -65,7 +65,11 @@ export class Plugin {
             }
             return this.planStorage.get(planId);
         }
-        return Plan.fromResponse(data.plan);
+        if (!planRequest?.resourceName || !this.resources.has(planRequest.resourceName)) {
+            throw new Error('Malformed plan. Resource name must be supplied');
+        }
+        const resource = this.resources.get(planRequest.resourceName);
+        return Plan.fromResponse(data.plan, resource?.defaultValues);
     }
     async crossValidateResources(configs) { }
 }

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

@@ -4,6 +4,7 @@ export type ErrorMessage = string;
 export interface ResourceParameterConfiguration {
     planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
     isEqual?: (desired: any, current: any) => boolean;
+    defaultValue?: unknown;
 }
 export interface ResourceConfiguration<T extends StringIndexedObject> {
     type: string;

package/dist/entities/resource.d.ts

@@ -9,6 +9,7 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     readonly dependencies: string[];
     readonly parameterConfigurations: Record<keyof T, ParameterConfiguration>;
     readonly configuration: ResourceConfiguration<T>;
+    readonly defaultValues: Partial<Record<keyof T, unknown>>;
     protected constructor(configuration: ResourceConfiguration<T>);
     onInitialize(): Promise<void>;
     plan(desiredConfig: Partial<T> & ResourceConfig): Promise<Plan<T>>;
@@ -16,11 +17,13 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     private _applyCreate;
     private _applyModify;
     private _applyDestroy;
-    private generateParameterConfigurations;
+    private initializeParameterConfigurations;
+    private initializeDefaultValues;
     private validateResourceConfiguration;
     private validateRefreshResults;
+    private addDefaultValues;
     abstract validate(parameters: unknown): Promise<ValidationResult>;
-    abstract refresh(keys: Set<keyof T>): Promise<Partial<T> | null>;
+    abstract refresh(keys: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
     abstract applyCreate(plan: Plan<T>): Promise<void>;
     applyModify(parameterName: keyof T, newValue: unknown, previousValue: unknown, allowDeletes: boolean, plan: Plan<T>): Promise<void>;
     abstract applyDestroy(plan: Plan<T>): Promise<void>;

package/dist/entities/resource.js

@@ -7,11 +7,13 @@ export class Resource {
     dependencies;
     parameterConfigurations;
     configuration;
+    defaultValues;
     constructor(configuration) {
         this.validateResourceConfiguration(configuration);
         this.typeId = configuration.type;
         this.statefulParameters = new Map(configuration.statefulParameters?.map((sp) => [sp.name, sp]));
-        this.parameterConfigurations = this.generateParameterConfigurations(configuration);
+        this.parameterConfigurations = this.initializeParameterConfigurations(configuration);
+        this.defaultValues = this.initializeDefaultValues(configuration);
         this.dependencies = configuration.dependencies ?? [];
         this.configuration = configuration;
     }
@@ -22,20 +24,21 @@ export class Resource {
             parameterConfigurations: this.parameterConfigurations,
         };
         const { resourceMetadata, parameters: desiredParameters } = splitUserConfig(desiredConfig);
+        this.addDefaultValues(desiredParameters);
         const resourceParameters = Object.fromEntries([
             ...Object.entries(desiredParameters).filter(([key]) => !this.statefulParameters.has(key)),
         ]);
         const statefulParameters = [...this.statefulParameters.values()]
             .filter((sp) => desiredParameters[sp.name] !== undefined);
-        const keysToRefresh = new Set(Object.keys(resourceParameters));
-        const currentParameters = await this.refresh(keysToRefresh);
+        const entriesToRefresh = new Map(Object.entries(resourceParameters));
+        const currentParameters = await this.refresh(entriesToRefresh);
         if (currentParameters == null) {
             return Plan.create(desiredParameters, null, resourceMetadata, planConfiguration);
         }
-        this.validateRefreshResults(currentParameters, keysToRefresh);
+        this.validateRefreshResults(currentParameters, entriesToRefresh);
         for (const statefulParameter of statefulParameters) {
             const desiredValue = desiredParameters[statefulParameter.name];
-            let currentValue = await statefulParameter.refresh() ?? undefined;
+            let currentValue = await statefulParameter.refresh(desiredValue ?? null) ?? undefined;
             if (Array.isArray(currentValue)
                 && Array.isArray(desiredValue)
                 && !planConfiguration.statefulMode
@@ -122,7 +125,7 @@ export class Resource {
         }
         await this.applyDestroy(plan);
     }
-    generateParameterConfigurations(resourceConfiguration) {
+    initializeParameterConfigurations(resourceConfiguration) {
         const resourceParameters = Object.fromEntries(Object.entries(resourceConfiguration.parameterConfigurations ?? {})
             ?.map(([name, value]) => ([name, { ...value, isStatefulParameter: false }])));
         const statefulParameters = resourceConfiguration.statefulParameters
@@ -140,6 +143,14 @@ export class Resource {
             ...statefulParameters,
         };
     }
+    initializeDefaultValues(resourceConfiguration) {
+        if (!resourceConfiguration.parameterConfigurations) {
+            return {};
+        }
+        return Object.fromEntries(Object.entries(resourceConfiguration.parameterConfigurations)
+            .filter((p) => p[1]?.defaultValue !== undefined)
+            .map((config) => [config[0], config[1].defaultValue]));
+    }
     validateResourceConfiguration(data) {
         if (data.parameterConfigurations && data.statefulParameters) {
             const parameters = [...Object.keys(data.parameterConfigurations)];
@@ -150,10 +161,11 @@ export class Resource {
             }
         }
     }
-    validateRefreshResults(refresh, desiredKeys) {
+    validateRefreshResults(refresh, desiredMap) {
         if (!refresh) {
             return;
         }
+        const desiredKeys = new Set(desiredMap.keys());
         const refreshKeys = new Set(Object.keys(refresh));
         if (!setsEqual(desiredKeys, refreshKeys)) {
             throw new Error(`Resource ${this.configuration.type}
@@ -162,6 +174,14 @@ Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
 Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         }
     }
+    addDefaultValues(desired) {
+        Object.entries(this.defaultValues)
+            .forEach(([key, defaultValue]) => {
+            if (defaultValue !== undefined && desired[key] === undefined) {
+                desired[key] = defaultValue;
+            }
+        });
+    }
     async applyModify(parameterName, newValue, previousValue, allowDeletes, plan) { }
     ;
 }

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

@@ -13,7 +13,7 @@ export declare abstract class StatefulParameter<T extends StringIndexedObject, V
     readonly name: keyof T;
     readonly configuration: StatefulParameterConfiguration<T>;
     protected constructor(configuration: StatefulParameterConfiguration<T>);
-    abstract refresh(): Promise<V | null>;
+    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>;
@@ -24,7 +24,7 @@ export declare abstract class ArrayStatefulParameter<T extends StringIndexedObje
     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>;
-    abstract refresh(): Promise<V[] | null>;
+    abstract refresh(desired: V[] | null): Promise<V[] | null>;
     abstract applyAddItem(item: V, plan: Plan<T>): Promise<void>;
     abstract applyRemoveItem(item: V, plan: Plan<T>): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "description": "",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -14,7 +14,7 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "codify-schemas": "1.0.32",
+    "codify-schemas": "1.0.33",
     "@npmcli/promise-spawn": "^7.0.1"
   },
   "devDependencies": {

package/src/entities/plan.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, it } from 'vitest';
+import { Plan } from './plan.js';
+import { TestResource } from './resource.test.js';
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+import { Resource } from './resource.js';
+
+describe('Plan entity tests', () => {
+  it('Adds default values properly when plan is parsed from request (Create)', () => {
+    const resource = createResource();
+
+    const plan = Plan.fromResponse({
+      operation: ResourceOperation.CREATE,
+      resourceType: 'type',
+      parameters: [{
+        name: 'propB',
+        operation: ParameterOperation.ADD,
+        previousValue: null,
+        newValue: 'propBValue'
+      }]
+    }, resource.defaultValues);
+
+    expect(plan.currentConfig).toMatchObject({
+      type: 'type',
+      propA: null,
+      propB: null,
+    })
+
+    expect(plan.desiredConfig).toMatchObject({
+      type: 'type',
+      propA: 'defaultA',
+      propB: 'propBValue',
+    })
+
+    expect(plan.changeSet.parameterChanges
+      .every((pc) => pc.operation === ParameterOperation.ADD)
+    ).to.be.true;
+  })
+
+  it('Adds default values properly when plan is parsed from request (Destroy)', () => {
+    const resource = createResource();
+
+    const plan = Plan.fromResponse({
+      operation: ResourceOperation.DESTROY,
+      resourceType: 'type',
+      parameters: [{
+        name: 'propB',
+        operation: ParameterOperation.REMOVE,
+        previousValue: 'propBValue',
+        newValue: null,
+      }]
+    }, resource.defaultValues);
+
+    expect(plan.currentConfig).toMatchObject({
+      type: 'type',
+      propA: 'defaultA',
+      propB: 'propBValue',
+    })
+
+    expect(plan.desiredConfig).toMatchObject({
+      type: 'type',
+      propA: null,
+      propB: null,
+    })
+
+    expect(plan.changeSet.parameterChanges
+      .every((pc) => pc.operation === ParameterOperation.REMOVE)
+    ).to.be.true;
+  })
+
+  it('Adds default values properly when plan is parsed from request (No-op)', () => {
+    const resource = createResource();
+
+    const plan = Plan.fromResponse({
+      operation: ResourceOperation.NOOP,
+      resourceType: 'type',
+      parameters: [{
+        name: 'propB',
+        operation: ParameterOperation.NOOP,
+        previousValue: 'propBValue',
+        newValue: 'propBValue',
+      }]
+    }, resource.defaultValues);
+
+    expect(plan.currentConfig).toMatchObject({
+      type: 'type',
+      propA: 'defaultA',
+      propB: 'propBValue',
+    })
+
+    expect(plan.desiredConfig).toMatchObject({
+      type: 'type',
+      propA: 'defaultA',
+      propB: 'propBValue',
+    })
+
+    expect(plan.changeSet.parameterChanges
+      .every((pc) => pc.operation === ParameterOperation.NOOP)
+    ).to.be.true;
+  })
+
+  it('Does not add default value if a value has already been specified', () => {
+    const resource = createResource();
+
+    const plan = Plan.fromResponse({
+      operation: ResourceOperation.CREATE,
+      resourceType: 'type',
+      parameters: [{
+        name: 'propB',
+        operation: ParameterOperation.ADD,
+        previousValue: null,
+        newValue: 'propBValue',
+      }, {
+        name: 'propA',
+        operation: ParameterOperation.ADD,
+        previousValue: null,
+        newValue: 'propAValue',
+      }]
+    }, resource.defaultValues);
+
+    expect(plan.currentConfig).toMatchObject({
+      type: 'type',
+      propA: null,
+      propB: null,
+    })
+
+    expect(plan.desiredConfig).toMatchObject({
+      type: 'type',
+      propA: 'propAValue',
+      propB: 'propBValue',
+    })
+
+    expect(plan.changeSet.parameterChanges
+      .every((pc) => pc.operation === ParameterOperation.ADD)
+    ).to.be.true;
+  })
+})
+
+function createResource(): Resource<any> {
+  return new class extends TestResource {
+    constructor() {
+      super({
+        type: 'type',
+        parameterConfigurations: {
+          propA: {
+            defaultValue: 'defaultA'
+          }
+        }
+      });
+    }
+  }
+}

package/src/entities/plan.ts

@@ -75,29 +75,70 @@ export class Plan<T extends StringIndexedObject> {
     return this.resourceMetadata.type
   }
 
-  static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan']): Plan<T> {
+  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.map(value => ({
-          ...value,
-          previousValue: null,
-        })),
+        data.parameters
       ),
       {
         type: data.resourceType,
         name: data.resourceName,
-        ...(data.parameters.reduce(
-          (prev, { name, newValue }) => Object.assign(prev, { [name]: newValue }),
-          {}
-        ))
       },
     );
+
+   function addDefaultValues(): void {
+      Object.entries(defaultValues)
+        .forEach(([key, defaultValue]) => {
+          const configValueExists = data
+            ?.parameters
+            .find((p) => p.name === key) !== undefined;
+
+          if (!configValueExists) {
+            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 {

package/src/entities/plugin.ts

@@ -94,7 +94,12 @@ export class Plugin {
       return this.planStorage.get(planId)!
     }
 
-    return Plan.fromResponse(data.plan);
+    if (!planRequest?.resourceName || !this.resources.has(planRequest.resourceName)) {
+      throw new Error('Malformed plan. Resource name must be supplied');
+    }
+
+    const resource = this.resources.get(planRequest.resourceName);
+    return Plan.fromResponse(data.plan, resource?.defaultValues!);
   }
 
   protected async crossValidateResources(configs: ResourceConfig[]): Promise<void> {}

package/src/entities/resource-types.ts

@@ -17,6 +17,10 @@ export interface ResourceParameterConfiguration {
    * @param current
    */
   isEqual?: (desired: any, current: any) => boolean;
+  /**
+   * Default value for the parameter. If a value is not provided in the config, the library will use this value.
+   */
+  defaultValue?: unknown,
 }
 
 /**

package/src/entities/resource.test.ts

@@ -293,4 +293,61 @@ describe('Resource tests', () => {
     }).to.not.throw;
   })
 
+  it('Allows default values to be added', async () => {
+    const resource = new class extends TestResource {
+      constructor() {
+        super({
+          type: 'type',
+          parameterConfigurations: {
+            propA: { defaultValue: 'propADefault' }
+          }
+        });
+      }
+
+      // @ts-ignore
+      async refresh(desired: Map<string, unknown>): Promise<Partial<TestConfig>> {
+        expect(desired.has('propA')).to.be.true;
+        expect(desired.get('propA')).to.be.eq('propADefault');
+
+        return {
+          propA: 'propAAfter'
+        };
+      }
+    }
+
+    const plan = await resource.plan({ type: 'resource'})
+    expect(plan.currentConfig.propA).to.eq('propAAfter');
+    expect(plan.desiredConfig.propA).to.eq('propADefault');
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.RECREATE);
+
+  })
+
+  it('Allows default values to be added (ignore default value if already present)', async () => {
+    const resource = new class extends TestResource {
+      constructor() {
+        super({
+          type: 'type',
+          parameterConfigurations: {
+            propA: { defaultValue: 'propADefault' }
+          }
+        });
+      }
+
+      // @ts-ignore
+      async refresh(desired: Map<string, unknown>): Promise<Partial<TestConfig>> {
+        expect(desired.has('propA')).to.be.true;
+        expect(desired.get('propA')).to.be.eq('propA');
+
+        return {
+          propA: 'propAAfter'
+        };
+      }
+    }
+
+    const plan = await resource.plan({ type: 'resource', propA: 'propA'})
+    expect(plan.currentConfig.propA).to.eq('propAAfter');
+    expect(plan.desiredConfig.propA).to.eq('propA');
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.RECREATE);
+
+  })
 });

package/src/entities/resource.ts

@@ -20,13 +20,15 @@ export abstract class Resource<T extends StringIndexedObject> {
   readonly dependencies: string[]; // TODO: Change this to a string
   readonly parameterConfigurations: Record<keyof T, ParameterConfiguration>
   readonly configuration: ResourceConfiguration<T>;
+  readonly defaultValues: Partial<Record<keyof T, unknown>>;
 
   protected constructor(configuration: ResourceConfiguration<T>) {
     this.validateResourceConfiguration(configuration);
 
     this.typeId = configuration.type;
     this.statefulParameters = new Map(configuration.statefulParameters?.map((sp) => [sp.name, sp]));
-    this.parameterConfigurations = this.generateParameterConfigurations(configuration);
+    this.parameterConfigurations = this.initializeParameterConfigurations(configuration);
+    this.defaultValues = this.initializeDefaultValues(configuration);
 
     this.dependencies = configuration.dependencies ?? [];
     this.configuration = configuration;
@@ -47,6 +49,8 @@ export abstract class Resource<T extends StringIndexedObject> {
 
     const { resourceMetadata, parameters: desiredParameters } = splitUserConfig(desiredConfig);
 
+    this.addDefaultValues(desiredParameters);
+
     const resourceParameters = Object.fromEntries([
       ...Object.entries(desiredParameters).filter(([key]) => !this.statefulParameters.has(key)),
     ]) as Partial<T>;
@@ -56,22 +60,22 @@ export abstract class Resource<T extends StringIndexedObject> {
 
     // Refresh resource parameters
     // This refreshes the parameters that configure the resource itself
-    const keysToRefresh = new Set(Object.keys(resourceParameters));
-    const currentParameters = await this.refresh(keysToRefresh);
+    const entriesToRefresh = new Map(Object.entries(resourceParameters));
+    const currentParameters = await this.refresh(entriesToRefresh);
 
     // Short circuit here. If resource is non-existent, then there's no point checking stateful parameters
     if (currentParameters == null) {
       return Plan.create(desiredParameters, null, resourceMetadata, planConfiguration);
     }
 
-    this.validateRefreshResults(currentParameters, keysToRefresh);
+    this.validateRefreshResults(currentParameters, entriesToRefresh);
 
     // Refresh stateful parameters
     // This refreshes parameters that are stateful (they can be added, deleted separately from the resource)
     for(const statefulParameter of statefulParameters) {
       const desiredValue = desiredParameters[statefulParameter.name];
 
-      let currentValue = await statefulParameter.refresh() ?? undefined;
+      let currentValue = await statefulParameter.refresh(desiredValue ?? null) ?? undefined;
 
       // In stateless mode, filter the refreshed parameters by the desired to ensure that no deletes happen
       if (Array.isArray(currentValue)
@@ -183,7 +187,7 @@ export abstract class Resource<T extends StringIndexedObject> {
     await this.applyDestroy(plan);
   }
 
-  private generateParameterConfigurations(
+  private initializeParameterConfigurations(
     resourceConfiguration: ResourceConfiguration<T>
   ): Record<keyof T, ParameterConfiguration>  {
     const resourceParameters = Object.fromEntries(
@@ -209,6 +213,20 @@ export abstract class Resource<T extends StringIndexedObject> {
 
   }
 
+  private initializeDefaultValues(
+    resourceConfiguration: ResourceConfiguration<T>
+  ): Partial<Record<keyof T, unknown>>  {
+    if (!resourceConfiguration.parameterConfigurations) {
+      return {};
+    }
+
+    return Object.fromEntries(
+      Object.entries(resourceConfiguration.parameterConfigurations)
+        .filter((p) => p[1]?.defaultValue !== undefined)
+        .map((config) => [config[0], config[1]!.defaultValue])
+    ) as Partial<Record<keyof T, unknown>>;
+  }
+
   private validateResourceConfiguration(data: ResourceConfiguration<T>) {
     // Stateful parameters are configured within the object not in the resource.
     if (data.parameterConfigurations && data.statefulParameters) {
@@ -220,15 +238,14 @@ export abstract class Resource<T extends StringIndexedObject> {
         throw new Error(`Resource ${this.typeId} cannot declare a parameter as both stateful and non-stateful`);
       }
     }
-
-
   }
 
-  private validateRefreshResults(refresh: Partial<T> | null, desiredKeys: Set<keyof T>) {
+  private validateRefreshResults(refresh: Partial<T> | null, desiredMap: Map<keyof T, T[keyof T]>) {
     if (!refresh) {
       return;
     }
 
+    const desiredKeys = new Set<keyof T>(desiredMap.keys());
     const refreshKeys = new Set(Object.keys(refresh)) as Set<keyof T>;
 
     if (!setsEqual(desiredKeys, refreshKeys)) {
@@ -241,9 +258,19 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     }
   }
 
+  private addDefaultValues(desired: Partial<T>): void {
+    Object.entries(this.defaultValues)
+      .forEach(([key, defaultValue]) => {
+        if (defaultValue !== undefined && desired[key as any] === undefined) {
+          // @ts-ignore
+          desired[key] = defaultValue;
+        }
+      });
+  }
+
   abstract validate(parameters: unknown): Promise<ValidationResult>;
 
-  abstract refresh(keys: Set<keyof T>): Promise<Partial<T> | null>;
+  abstract refresh(keys: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
 
   abstract applyCreate(plan: Plan<T>): Promise<void>;
 

package/src/entities/stateful-parameter.ts

@@ -32,7 +32,7 @@ export abstract class StatefulParameter<T extends StringIndexedObject, V extends
     this.configuration = configuration
   }
 
-  abstract refresh(): Promise<V | null>;
+  abstract refresh(desired: V | null): Promise<V | null>;
 
   // TODO: Add an additional parameter here for what has actually changed.
   abstract applyAdd(valueToAdd: V, plan: Plan<T>): Promise<void>;
@@ -88,7 +88,7 @@ export abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> e
     }
   }
 
-  abstract refresh(): Promise<V[] | null>;
+  abstract refresh(desired: V[] | null): Promise<V[] | null>;
   abstract applyAddItem(item: V, plan: Plan<T>): Promise<void>;
   abstract applyRemoveItem(item: V, plan: Plan<T>): Promise<void>;
 }