Added transform parameters

Author: kevinwang5658

package.json

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

src/entities/resource-parameters.test.ts

@@ -4,6 +4,7 @@ import { Plan } from './plan.js';
 import { spy } from 'sinon';
 import { ResourceOperation } from 'codify-schemas';
 import { TestConfig, TestResource } from './resource.test.js';
+import { TransformParameter } from './transform-parameter.js';
 
 class TestParameter extends StatefulParameter<TestConfig, string> {
   constructor(configuration?: StatefulParameterConfiguration<TestConfig>) {
@@ -198,4 +199,46 @@ describe('Resource parameters tests', () => {
       }
     })
   })
+
+  it('Supports transform parameters', async () => {
+    const transformParameter = new class extends TransformParameter<TestConfig> {
+      async transform(value: any): Promise<Partial<TestConfig>> {
+        return {
+          propA: 'propA',
+          propB: 10,
+        }
+      }
+    }
+
+    const resource = spy(new class extends TestResource {
+      constructor() {
+        super({
+          type: 'resourceType',
+          transformParameters: {
+            propC: transformParameter
+          },
+        });
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'propA',
+          propB: 10,
+        }
+      }
+    });
+
+    const plan = await resource.plan({ type: 'resourceType', propC: 'abc' } as any);
+
+    expect(resource.refresh.called).to.be.true;
+    expect(resource.refresh.getCall(0).firstArg.has('propA')).to.be.true;
+    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.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
 })

src/entities/resource-types.ts

@@ -1,5 +1,6 @@
 import { StatefulParameter } from './stateful-parameter.js';
 import { ResourceOperation, StringIndexedObject } from 'codify-schemas';
+import { TransformParameter } from './transform-parameter.js';
 
 export type ErrorMessage = string;
 
@@ -35,6 +36,7 @@ export interface ResourceConfiguration<T extends StringIndexedObject> {
   callStatefulParameterRemoveOnDestroy?: boolean,
   dependencies?: string[];
   statefulParameters?: Array<StatefulParameter<T, T[keyof T]>>;
+  transformParameters?: Partial<Record<keyof T, TransformParameter<T>>>
   parameterConfigurations?: Partial<Record<keyof T, ResourceParameterConfiguration>>
 }
 

src/entities/resource.ts

@@ -5,6 +5,7 @@ import { StatefulParameter } from './stateful-parameter.js';
 import { ResourceConfiguration, ValidationResult } from './resource-types.js';
 import { setsEqual, splitUserConfig } from '../utils/utils.js';
 import { ParameterConfiguration, PlanConfiguration } from './plan-types.js';
+import { TransformParameter } from './transform-parameter.js';
 
 /**
  * Description of resource here
@@ -17,6 +18,7 @@ export abstract class Resource<T extends StringIndexedObject> {
 
   readonly typeId: string;
   readonly statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>;
+  readonly transformParameters: Map<keyof T, TransformParameter<T>>
   readonly dependencies: string[]; // TODO: Change this to a string
   readonly parameterConfigurations: Record<keyof T, ParameterConfiguration>
   readonly configuration: ResourceConfiguration<T>;
@@ -27,6 +29,7 @@ export abstract class Resource<T extends StringIndexedObject> {
 
     this.typeId = configuration.type;
     this.statefulParameters = new Map(configuration.statefulParameters?.map((sp) => [sp.name, sp]));
+    this.transformParameters = new Map(Object.entries(configuration.transformParameters ?? {})) as Map<keyof T, TransformParameter<T>>;
     this.parameterConfigurations = this.initializeParameterConfigurations(configuration);
     this.defaultValues = this.initializeDefaultValues(configuration);
 
@@ -50,6 +53,7 @@ export abstract class Resource<T extends StringIndexedObject> {
     const { resourceMetadata, parameters: desiredParameters } = splitUserConfig(desiredConfig);
 
     this.addDefaultValues(desiredParameters);
+    await this.applyTransformParameters(desiredParameters);
 
     const resourceParameters = Object.fromEntries([
       ...Object.entries(desiredParameters).filter(([key]) => !this.statefulParameters.has(key)),
@@ -210,7 +214,6 @@ export abstract class Resource<T extends StringIndexedObject> {
       ...resourceParameters,
       ...statefulParameters,
     }
-
   }
 
   private initializeDefaultValues(
@@ -258,6 +261,25 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     }
   }
 
+  private async applyTransformParameters(desired: Partial<T>): Promise<void> {
+    for (const [key, tp] of this.transformParameters.entries()) {
+      if (desired[key] !== null) {
+        const transformedValue = await tp.transform(desired[key]);
+
+        if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
+          throw new Error(`Transform parameter ${key as string} is attempting to override existing value ${desired[key]}`);
+        }
+
+        Object.entries(transformedValue).forEach(([tvKey, tvValue]) => {
+          // @ts-ignore
+          desired[tvKey] = tvValue;
+        })
+
+        delete desired[key];
+      }
+    }
+  }
+
   private addDefaultValues(desired: Partial<T>): void {
     Object.entries(this.defaultValues)
       .forEach(([key, defaultValue]) => {

src/entities/transform-parameter.ts

@@ -0,0 +1,7 @@
+import { StringIndexedObject } from 'codify-schemas';
+
+export abstract class TransformParameter<T extends StringIndexedObject> {
+
+  abstract transform(value: any): Promise<Partial<T>>
+
+}