codify-plugin-lib 1.0.48 → 1.0.50

package/dist/entities/plugin.js

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

package/dist/entities/resource-types.d.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;
 export interface ResourceParameterConfiguration {
     planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
@@ -11,6 +12,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>>;
 }
 export interface ResourceDefinition {

package/dist/entities/resource.d.ts

@@ -3,9 +3,11 @@ import { Plan } from './plan.js';
 import { StatefulParameter } from './stateful-parameter.js';
 import { ResourceConfiguration, ValidationResult } from './resource-types.js';
 import { ParameterConfiguration } from './plan-types.js';
+import { TransformParameter } from './transform-parameter.js';
 export declare 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[];
     readonly parameterConfigurations: Record<keyof T, ParameterConfiguration>;
     readonly configuration: ResourceConfiguration<T>;
@@ -21,6 +23,7 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     private initializeDefaultValues;
     private validateResourceConfiguration;
     private validateRefreshResults;
+    private applyTransformParameters;
     private addDefaultValues;
     abstract validate(parameters: unknown): Promise<ValidationResult>;
     abstract refresh(keys: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;

package/dist/entities/resource.js

@@ -4,6 +4,7 @@ import { setsEqual, splitUserConfig } from '../utils/utils.js';
 export class Resource {
     typeId;
     statefulParameters;
+    transformParameters;
     dependencies;
     parameterConfigurations;
     configuration;
@@ -12,6 +13,7 @@ export class Resource {
         this.validateResourceConfiguration(configuration);
         this.typeId = configuration.type;
         this.statefulParameters = new Map(configuration.statefulParameters?.map((sp) => [sp.name, sp]));
+        this.transformParameters = new Map(Object.entries(configuration.transformParameters ?? {}));
         this.parameterConfigurations = this.initializeParameterConfigurations(configuration);
         this.defaultValues = this.initializeDefaultValues(configuration);
         this.dependencies = configuration.dependencies ?? [];
@@ -25,6 +27,7 @@ export class Resource {
         };
         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)),
         ]);
@@ -174,6 +177,20 @@ Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
 Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         }
     }
+    async applyTransformParameters(desired) {
+        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} is attempting to override existing value ${desired[key]}`);
+                }
+                Object.entries(transformedValue).forEach(([tvKey, tvValue]) => {
+                    desired[tvKey] = tvValue;
+                });
+                delete desired[key];
+            }
+        }
+    }
     addDefaultValues(desired) {
         Object.entries(this.defaultValues)
             .forEach(([key, defaultValue]) => {

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

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

package/dist/entities/transform-parameter.js

@@ -0,0 +1,2 @@
+export class TransformParameter {
+}

package/package.json

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

package/src/entities/plugin.ts

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

package/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);
+  })
 })

package/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>>
 }
 

package/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]) => {

package/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>>
+
+}