codify-plugin-lib 1.0.135 → 1.0.136

package/dist/resource/parsed-resource-settings.d.ts

@@ -25,6 +25,7 @@ export declare class ParsedResourceSettings<T extends StringIndexedObject> imple
     } | boolean;
     removeStatefulParametersBeforeDestroy?: boolean | undefined;
     dependencies?: string[] | undefined;
+    transformation?: InputTransformation;
     private settings;
     constructor(settings: ResourceSettings<T>);
     get typeId(): string;

package/dist/resource/parsed-resource-settings.js

@@ -7,6 +7,7 @@ export class ParsedResourceSettings {
     allowMultiple;
     removeStatefulParametersBeforeDestroy;
     dependencies;
+    transformation;
     settings;
     constructor(settings) {
         this.settings = settings;
@@ -15,6 +16,7 @@ export class ParsedResourceSettings {
         this.allowMultiple = settings.allowMultiple;
         this.removeStatefulParametersBeforeDestroy = settings.removeStatefulParametersBeforeDestroy;
         this.dependencies = settings.dependencies;
+        this.transformation = settings.transformation;
         this.validateSettings();
     }
     get typeId() {

package/dist/resource/resource-controller.js

@@ -250,6 +250,13 @@ ${JSON.stringify(refresh, null, 2)}
                 ? await inputTransformation.from(config[key])
                 : await inputTransformation.to(config[key]);
         }
+        if (this.settings.transformation) {
+            const transformed = reverse
+                ? await this.settings.transformation.from({ ...config })
+                : await this.settings.transformation.to({ ...config });
+            Object.keys(config).forEach((k) => delete config[k]);
+            Object.assign(config, transformed);
+        }
     }
     addDefaultValues(config) {
         if (!config) {

package/dist/resource/resource-settings.d.ts

@@ -60,6 +60,13 @@ export interface ResourceSettings<T extends StringIndexedObject> {
      * and applying any input transformations. Use parameter settings to define stateful parameters as well.
      */
     parameterSettings?: Partial<Record<keyof T, ParameterSetting>>;
+    /**
+     * A config level transformation that is only applied to the user supplied desired config. This transformation is allowed
+     * to add, remove or modify keys as well as values. Changing this transformation for existing libraries will mess up existing states.
+     *
+     * @param desired
+     */
+    transformation?: InputTransformation;
     /**
      * Customize the import and destory behavior of the resource. By default, <code>codify import</code> and <code>codify destroy</code> will call
      * `refresh()` with every parameter set to null and return the result of the refresh as the imported config. It looks for required parameters
@@ -144,7 +151,7 @@ export interface DefaultParameterSetting {
      *
      * @param input The original parameter value from the desired config.
      */
-    inputTransformation?: InputTransformation;
+    transformation?: InputTransformation;
     /**
      * Customize the equality comparison for a parameter. This is used in the diffing algorithm for generating the plan.
      * This value will override the pre-set equality function from the type. Return true if the desired value is

package/dist/resource/resource-settings.js

@@ -54,17 +54,17 @@ const ParameterTransformationDefaults = {
     }
 };
 export function resolveParameterTransformFn(parameter) {
-    if (parameter.type === 'stateful' && !parameter.inputTransformation) {
+    if (parameter.type === 'stateful' && !parameter.transformation) {
         const sp = parameter.definition.getSettings();
-        if (sp.inputTransformation) {
-            return parameter.definition?.getSettings()?.inputTransformation;
+        if (sp.transformation) {
+            return parameter.definition?.getSettings()?.transformation;
         }
         return sp.type ? ParameterTransformationDefaults[sp.type] : undefined;
     }
     if (parameter.type === 'array'
         && parameter.itemType
         && ParameterTransformationDefaults[parameter.itemType]
-        && !parameter.inputTransformation) {
+        && !parameter.transformation) {
         const itemType = parameter.itemType;
         const itemTransformation = ParameterTransformationDefaults[itemType];
         return {
@@ -76,5 +76,5 @@ export function resolveParameterTransformFn(parameter) {
             }
         };
     }
-    return parameter.inputTransformation ?? ParameterTransformationDefaults[parameter.type] ?? undefined;
+    return parameter.transformation ?? ParameterTransformationDefaults[parameter.type] ?? undefined;
 }

package/package.json

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

package/src/resource/parsed-resource-settings.ts

@@ -44,6 +44,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
 
   removeStatefulParametersBeforeDestroy?: boolean | undefined;
   dependencies?: string[] | undefined;
+  transformation?: InputTransformation;
   private settings: ResourceSettings<T>;
 
   constructor(settings: ResourceSettings<T>) {
@@ -53,6 +54,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
     this.allowMultiple = settings.allowMultiple;
     this.removeStatefulParametersBeforeDestroy = settings.removeStatefulParametersBeforeDestroy;
     this.dependencies = settings.dependencies;
+    this.transformation = settings.transformation;
 
     this.validateSettings();
   }

package/src/resource/resource-controller.test.ts

@@ -20,7 +20,7 @@ describe('Resource tests', () => {
           id: 'type',
           dependencies: ['homebrew', 'python'],
           parameterSettings: {
-            propA: { canModify: true, inputTransformation: { to: (input) => untildify(input), from: (input) => tildify(input) } },
+            propA: { canModify: true, transformation: { to: (input) => untildify(input), from: (input) => tildify(input) } },
           },
         }
       }
@@ -543,7 +543,7 @@ describe('Resource tests', () => {
           parameterSettings: {
             propD: {
               type: 'array',
-              inputTransformation: {
+              transformation: {
                 to: (hosts: Record<string, unknown>[]) => hosts.map((h) => Object.fromEntries(
                     Object.entries(h)
                       .map(([k, v]) => [
@@ -618,4 +618,94 @@ describe('Resource tests', () => {
       }
     })
   })
+
+  it('Applies reverse input transformations for imports (object level)', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          parameterSettings: {
+            propD: {
+              type: 'array',
+            }
+          },
+          transformation: {
+            to: (input: any) => ({
+              ...input,
+              propD: input.propD?.map((h) => Object.fromEntries(
+                  Object.entries(h)
+                    .map(([k, v]) => [
+                      k,
+                      typeof v === 'boolean'
+                        ? (v ? 'yes' : 'no') // The file takes 'yes' or 'no' instead of booleans
+                        : v,
+                    ])
+                )
+              )
+            }),
+            from: (output: any) => ({
+              ...output,
+              propD: output.propD?.map((h) => Object.fromEntries(
+                Object.entries(h)
+                  .map(([k, v]) => [
+                    k,
+                    v === 'yes' || v === 'no'
+                      ? (v === 'yes')
+                      : v,
+                  ])
+              ))
+            })
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          propD: [
+            {
+              Host: 'new.com',
+              AddKeysToAgent: true,
+              IdentityFile: 'id_ed25519'
+            },
+            {
+              Host: 'github.com',
+              AddKeysToAgent: true,
+              UseKeychain: true,
+            },
+            {
+              Match: 'User bob,joe,phil',
+              PasswordAuthentication: true,
+            }
+          ],
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.import({ type: 'resourceType' }, {});
+
+    expect(plan![0]).toMatchObject({
+      'core': {
+        'type': 'resourceType'
+      },
+      'parameters': {
+        'propD': [
+          {
+            'Host': 'new.com',
+            'AddKeysToAgent': true,
+            'IdentityFile': 'id_ed25519'
+          },
+          {
+            'Host': 'github.com',
+            'AddKeysToAgent': true,
+            'UseKeychain': true
+          },
+          {
+            'Match': 'User bob,joe,phil',
+            'PasswordAuthentication': true
+          }
+        ]
+      }
+    })
+  })
 });

package/src/resource/resource-controller.ts

@@ -350,6 +350,15 @@ ${JSON.stringify(refresh, null, 2)}
         ? await inputTransformation.from(config[key])
         : await inputTransformation.to(config[key]);
     }
+
+    if (this.settings.transformation) {
+      const transformed = reverse
+        ? await this.settings.transformation.from({ ...config })
+        : await this.settings.transformation.to({ ...config })
+
+      Object.keys(config).forEach((k) => delete config[k])
+      Object.assign(config, transformed);
+    }
   }
 
   private addDefaultValues(config: Partial<T> | null): void {

package/src/resource/resource-settings.test.ts

@@ -564,6 +564,86 @@ describe('Resource parameter tests', () => {
     expect(timestampC).to.be.lessThan(timestampA as any);
   })
 
+  it('Supports transform parameters', async () => {
+    const resource = spy(new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          transformation: {
+            to: (desired) => ({
+              propA: 'propA',
+              propB: 10,
+            }),
+            from: (current) => ({
+              propA: 'propA',
+              propB: 10,
+            })
+          }
+        }
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'propA',
+          propB: 10,
+        }
+      }
+    });
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({ type: 'resourceType' }, { propC: 'abc' } as any, null, false);
+
+    expect(resource.refresh.called).to.be.true;
+    expect(resource.refresh.getCall(0).firstArg['propA']).to.exist;
+    expect(resource.refresh.getCall(0).firstArg['propB']).to.exist;
+    expect(resource.refresh.getCall(0).firstArg['propC']).to.not.exist;
+
+    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);
+  })
+
+  it('Supports transform parameters for state parameters', async () => {
+    const resource = spy(new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          transformation: {
+            to: (desired) => ({
+              propA: 'propA',
+              propB: 10,
+            }),
+            from: (desired) => ({
+              propA: 'propA',
+              propB: 10,
+            })
+          }
+        }
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'propA',
+          propB: 10,
+        }
+      }
+    });
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({ type: 'resourceType' }, null, { propC: 'abc' }, true);
+
+    expect(resource.refresh.called).to.be.true;
+    expect(resource.refresh.getCall(0).firstArg['propA']).to.exist;
+    expect(resource.refresh.getCall(0).firstArg['propB']).to.exist;
+    expect(resource.refresh.getCall(0).firstArg['propC']).to.not.exist;
+
+    expect(plan.currentConfig?.propA).to.eq('propA');
+    expect(plan.currentConfig?.propB).to.eq(10);
+    expect(plan.currentConfig?.propC).to.be.undefined;
+  })
+
   it('Allows import required parameters customization', () => {
     const resource = new class extends TestResource {
       getSettings(): ResourceSettings<TestConfig> {
@@ -784,7 +864,7 @@ describe('Resource parameter tests', () => {
           parameterSettings: {
             propD: {
               type: 'array',
-              inputTransformation: {
+              transformation: {
                 to: (hosts: Record<string, unknown>[]) => hosts.map((h) => Object.fromEntries(
                     Object.entries(h)
                       .map(([k, v]) => [
@@ -850,7 +930,7 @@ describe('Resource parameter tests', () => {
       getSettings(): any {
         return {
           type: 'array',
-          inputTransformation: {
+          transformation: {
             to: (hosts: Record<string, unknown>[]) => hosts.map((h) => Object.fromEntries(
                 Object.entries(h)
                   .map(([k, v]) => [

package/src/resource/resource-settings.ts

@@ -75,6 +75,14 @@ export interface ResourceSettings<T extends StringIndexedObject> {
    */
   parameterSettings?: Partial<Record<keyof T, ParameterSetting>>;
 
+  /**
+   * A config level transformation that is only applied to the user supplied desired config. This transformation is allowed
+   * to add, remove or modify keys as well as values. Changing this transformation for existing libraries will mess up existing states.
+   *
+   * @param desired
+   */
+  transformation?: InputTransformation;
+
   /**
    * Customize the import and destory behavior of the resource. By default, <code>codify import</code> and <code>codify destroy</code> will call
    * `refresh()` with every parameter set to null and return the result of the refresh as the imported config. It looks for required parameters
@@ -181,7 +189,7 @@ export interface DefaultParameterSetting {
    *
    * @param input The original parameter value from the desired config.
    */
-  inputTransformation?: InputTransformation;
+  transformation?: InputTransformation;
 
   /**
    * Customize the equality comparison for a parameter. This is used in the diffing algorithm for generating the plan.
@@ -346,10 +354,10 @@ export function resolveParameterTransformFn(
   parameter: ParameterSetting
 ): InputTransformation | undefined {
 
-  if (parameter.type === 'stateful' && !parameter.inputTransformation) {
+  if (parameter.type === 'stateful' && !parameter.transformation) {
     const sp = (parameter as StatefulParameterSetting).definition.getSettings();
-    if (sp.inputTransformation) {
-      return (parameter as StatefulParameterSetting).definition?.getSettings()?.inputTransformation
+    if (sp.transformation) {
+      return (parameter as StatefulParameterSetting).definition?.getSettings()?.transformation
     }
 
     return sp.type ? ParameterTransformationDefaults[sp.type] : undefined;
@@ -358,7 +366,7 @@ export function resolveParameterTransformFn(
   if (parameter.type === 'array'
     && (parameter as ArrayParameterSetting).itemType
     && ParameterTransformationDefaults[(parameter as ArrayParameterSetting).itemType!]
-    && !parameter.inputTransformation
+    && !parameter.transformation
   ) {
     const itemType = (parameter as ArrayParameterSetting).itemType!;
     const itemTransformation = ParameterTransformationDefaults[itemType]!;
@@ -373,5 +381,5 @@ export function resolveParameterTransformFn(
     }
   }
 
-  return parameter.inputTransformation ?? ParameterTransformationDefaults[parameter.type as ParameterSettingType] ?? undefined;
+  return parameter.transformation ?? ParameterTransformationDefaults[parameter.type as ParameterSettingType] ?? undefined;
 }