feat: Changed parameter inputTransformations to have to: and from: so they can be mapped back

Author: kevinwang5658

src/resource/parsed-resource-settings.ts

@@ -141,7 +141,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
       return Object.fromEntries(
         Object.entries(this.settings.parameterSettings)
           .filter(([_, v]) => resolveParameterTransformFn(v!) !== undefined)
-          .map(([k, v]) => [k, resolveParameterTransformFn(v!)] as const)
+          .map(([k, v]) => [k, resolveParameterTransformFn(v!)!.to] as const)
       ) as Record<keyof T, (a: unknown) => unknown>;
     });
   }

src/resource/resource-settings.test.ts

@@ -852,16 +852,25 @@ describe('Resource parameter tests', () => {
           parameterSettings: {
             propD: {
               type: 'array',
-              inputTransformation: (hosts: Record<string, unknown>[]) => hosts.map((h) => Object.fromEntries(
+              inputTransformation: {
+                to: (hosts: Record<string, unknown>[]) => hosts.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: (hosts: Record<string, unknown>[]) => hosts.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,
+                      v === 'yes',
                     ])
-                )
-              )
+                ))
+              }
             }
           }
         }
@@ -909,16 +918,25 @@ describe('Resource parameter tests', () => {
       getSettings(): any {
         return {
           type: 'array',
-          inputTransformation: (hosts: Record<string, unknown>[]) => hosts.map((h) => Object.fromEntries(
+          inputTransformation: {
+            to: (hosts: Record<string, unknown>[]) => hosts.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: (hosts: Record<string, unknown>[]) => hosts.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,
+                  v === 'yes',
                 ])
-            )
-          )
+            ))
+          }
         }
       }
 

src/resource/resource-settings.ts

@@ -3,7 +3,12 @@ import isObjectsEqual from 'lodash.isequal'
 import path from 'node:path';
 
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
-import { areArraysEqual, untildify } from '../utils/utils.js';
+import { areArraysEqual, tildify, untildify } from '../utils/utils.js';
+
+export interface InputTransformation {
+  to: (input: any) => Promise<any> | any;
+  from: (current: any) => Promise<any> | any;
+}
 
 /**
  * The configuration and settings for a resource.
@@ -166,12 +171,13 @@ export interface DefaultParameterSetting {
   default?: unknown;
 
   /**
-   * A transformation of the input value for this parameter. This transformation is only applied to the desired parameter
-   * value supplied by the user.
+   * A transformation of the input value for this parameter. Two transformations need to be provided: to (from desired to
+   * the internal type), and from (from the internal type back to desired). All transformations need to be bi-directional
+   * to support imports properly
    *
    * @param input The original parameter value from the desired config.
    */
-  inputTransformation?: (input: any) => Promise<any> | any;
+  inputTransformation?: InputTransformation;
 
   /**
    * Customize the equality comparison for a parameter. This is used in the diffing algorithm for generating the plan.
@@ -321,22 +327,29 @@ export function resolveFnFromEqualsFnOrString(
   return fnOrString as ((a: unknown, b: unknown) => boolean) | undefined;
 }
 
-const ParameterTransformationDefaults: Partial<Record<ParameterSettingType, (input: any, parameter: ParameterSetting) => Promise<any> | any>> = {
-  'directory': (a: unknown) => path.resolve(untildify(String(a))),
-  'stateful': (a: unknown, b: ParameterSetting) => {
-    const sp = b as StatefulParameterSetting;
-    return (sp.definition?.getSettings()?.inputTransformation)
-      ? (sp.definition.getSettings().inputTransformation!(a))
-      : a;
+const ParameterTransformationDefaults: Partial<Record<ParameterSettingType, InputTransformation>> = {
+  'directory': {
+    to: (a: unknown) => path.resolve(untildify(String(a))),
+    from: (a: unknown) => tildify(String(a)),
   },
-  'string': String,
-  // TODO: Add a array parameter itemType parameter
-  // 'array': (arr: unknown[]) => arr.map((i) => (parameter as ArrayParameterSetting).itemType ? ParameterTransformationDefaults[])
+  'string': {
+    to: String,
+    from: String,
+  }
 }
 
 export function resolveParameterTransformFn(
   parameter: ParameterSetting
-): ((input: any, parameter: ParameterSetting) => Promise<any> | any) | undefined {
+): InputTransformation | undefined {
+
+  if (parameter.type === 'stateful' && !parameter.inputTransformation) {
+    const sp = (parameter as StatefulParameterSetting).definition.getSettings();
+    if (sp.inputTransformation) {
+      return (parameter as StatefulParameterSetting).definition?.getSettings()?.inputTransformation
+    }
+
+    return sp.type ? ParameterTransformationDefaults[sp.type] : undefined;
+  }
 
   if (parameter.type === 'array'
     && (parameter as ArrayParameterSetting).itemType
@@ -346,8 +359,13 @@ export function resolveParameterTransformFn(
     const itemType = (parameter as ArrayParameterSetting).itemType!;
     const itemTransformation = ParameterTransformationDefaults[itemType]!;
 
-    return (input: unknown[], parameter) => {
-      return input.map((i) => itemTransformation(i, parameter))
+    return {
+      to(input: unknown[]) {
+        return input.map((i) => itemTransformation.to(i))
+      },
+      from(input: unknown[]) {
+        return input.map((i) => itemTransformation.from(i))
+      }
     }
   }
 

src/utils/utils.ts

@@ -33,6 +33,10 @@ export function untildify(pathWithTilde: string) {
   return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
 }
 
+export function tildify(pathWithTilde: string) {
+  return homeDirectory ? pathWithTilde.replace(homeDirectory, '~') : pathWithTilde;
+}
+
 export function areArraysEqual(
   isElementEqual: ((desired: unknown, current: unknown) => boolean) | undefined,
   desired: unknown,