codify-plugin-lib 1.0.52 → 1.0.53

package/dist/entities/plan.js

@@ -58,39 +58,40 @@ export class Plan {
             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;
-                        }
+                    .parameters
+                    .some((p) => p.name === key);
+                if (configValueExists) {
+                    return;
+                }
+                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;
                     }
                 }
             });

package/dist/entities/plugin.js

@@ -66,10 +66,10 @@ export class Plugin {
             return this.planStorage.get(planId);
         }
         if (!planRequest?.resourceType || !this.resources.has(planRequest.resourceType)) {
-            throw new Error('Malformed plan. Resource type must be supplied');
+            throw new Error('Malformed plan. Resource type must be supplied or resource type was not found');
         }
         const resource = this.resources.get(planRequest.resourceType);
-        return Plan.fromResponse(data.plan, resource?.defaultValues);
+        return Plan.fromResponse(data.plan, resource.defaultValues);
     }
     async crossValidateResources(configs) { }
 }

package/dist/entities/resource-options.js

@@ -46,8 +46,8 @@ export class ResourceOptionsParser {
             return {};
         }
         return Object.fromEntries([...this.resourceParameters.entries()]
-            .filter(([, rp]) => rp.defaultValue !== undefined)
-            .map(([name, rp]) => [name, rp.defaultValue]));
+            .filter(([, rp]) => rp.default !== undefined)
+            .map(([name, rp]) => [name, rp.default]));
     }
     get statefulParameterOrder() {
         const entries = Object.entries(this.options.parameterOptions ?? {})

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

@@ -3,7 +3,7 @@ export type ErrorMessage = string;
 export interface ResourceParameterOptions {
     planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
     isEqual?: (desired: any, current: any) => boolean;
-    defaultValue?: unknown;
+    default?: unknown;
 }
 export interface ResourceDefinition {
     [x: string]: {

package/package.json

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

package/src/entities/plan.test.ts

@@ -141,9 +141,7 @@ function createResource(): Resource<any> {
       super({
         type: 'type',
         parameterOptions: {
-          propA: {
-            defaultValue: 'defaultA'
-          }
+          propA: { default: 'defaultA' }
         }
       });
     }

package/src/entities/plan.ts

@@ -97,43 +97,46 @@ export class Plan<T extends StringIndexedObject> {
    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;
-              }
+          const configValueExists = data!
+            .parameters
+            .some((p) => p.name === key);
+
+          // Only set default values if the value does not exist in the config
+          if (configValueExists) {
+            return;
+          }
+
+          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;
             }
           }
         });

package/src/entities/plugin.ts

@@ -95,11 +95,11 @@ export class Plugin {
     }
 
     if (!planRequest?.resourceType || !this.resources.has(planRequest.resourceType)) {
-      throw new Error('Malformed plan. Resource type must be supplied');
+      throw new Error('Malformed plan. Resource type must be supplied or resource type was not found');
     }
 
-    const resource = this.resources.get(planRequest.resourceType);
-    return Plan.fromResponse(data.plan, resource?.defaultValues!);
+    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-options.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { ResourceOptions, ResourceOptionsParser } from './resource-options.js';
+import { TestConfig } from './resource.test.js';
+
+describe('Resource options parser tests', () => {
+  it('Parses default values from options', () => {
+    const option: ResourceOptions<TestConfig> = {
+      type: 'typeId',
+      parameterOptions: {
+        propA: { default: 'propA' },
+        propB: { default: 'propB' },
+        propC: { isEqual: () => true },
+        propD: { },
+      }
+    }
+
+    const result = new ResourceOptionsParser(option);
+    expect(result.defaultValues).to.deep.eq({
+      propA: 'propA',
+      propB: 'propB'
+    })
+  })
+})

package/src/entities/resource-options.ts

@@ -113,8 +113,8 @@ export class ResourceOptionsParser<T extends StringIndexedObject> {
 
     return Object.fromEntries(
       [...this.resourceParameters.entries()]
-        .filter(([, rp]) => rp.defaultValue !== undefined)
-        .map(([name, rp]) => [name, rp.defaultValue])
+        .filter(([, rp]) => rp.default !== undefined)
+        .map(([name, rp]) => [name, rp.default])
     ) as Partial<Record<keyof T, unknown>>;
   }
 

package/src/entities/resource-types.ts

@@ -19,7 +19,7 @@ export interface ResourceParameterOptions {
   /**
    * Default value for the parameter. If a value is not provided in the config, the library will use this value.
    */
-  defaultValue?: unknown,
+  default?: unknown,
 }
 
 /**

package/src/entities/resource.test.ts

@@ -296,7 +296,7 @@ describe('Resource tests', () => {
         super({
           type: 'type',
           parameterOptions: {
-            propA: { defaultValue: 'propADefault' }
+            propA: { default: 'propADefault' }
           }
         });
       }
@@ -325,7 +325,7 @@ describe('Resource tests', () => {
         super({
           type: 'type',
           parameterOptions: {
-            propA: { defaultValue: 'propADefault' }
+            propA: { default: 'propADefault' }
           }
         });
       }
@@ -346,4 +346,21 @@ describe('Resource tests', () => {
     expect(plan.desiredConfig.propA).to.eq('propA');
     expect(plan.changeSet.operation).to.eq(ResourceOperation.RECREATE);
   });
+
+  it('Sets the default value properly on the resource', () => {
+    const resource = new class extends TestResource {
+      constructor() {
+        super({
+          type: 'type',
+          parameterOptions: {
+            propA: { default: 'propADefault' }
+          }
+        });
+      }
+    }
+
+    expect(resource.defaultValues).to.deep.eq({
+      propA: 'propADefault',
+    })
+  })
 });