codify-plugin-lib 1.0.47 → 1.0.49

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?.resourceType || !this.resources.has(planRequest.resourceType)) {
+            throw new Error('Malformed plan. Resource type must be supplied');
+        }
+        const resource = this.resources.get(planRequest.resourceType);
+        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,9 +17,11 @@ 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: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
     abstract applyCreate(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,6 +24,7 @@ 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)),
         ]);
@@ -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)];
@@ -163,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/package.json

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

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?.resourceType || !this.resources.has(planRequest.resourceType)) {
+      throw new Error('Malformed plan. Resource type must be supplied');
+    }
+
+    const resource = this.resources.get(planRequest.resourceType);
+    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>;
@@ -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,8 +238,6 @@ 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, desiredMap: Map<keyof T, T[keyof T]>) {
@@ -242,6 +258,16 @@ 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: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;