codify-plugin-lib 1.0.132 → 1.0.134

package/dist/plan/plan.d.ts

@@ -61,8 +61,6 @@ export declare class Plan<T extends StringIndexedObject> {
      */
     private static filterCurrentParams;
     requiresChanges(): boolean;
-    /**
-     * Convert the plan to a JSON response object
-     */
+    /** Convert the plan to a JSON response object */
     toResponse(): PlanResponseData;
 }

package/dist/plan/plan.js

@@ -156,12 +156,36 @@ export class Plan {
         if (!currentArray) {
             return null;
         }
+        const matcher = typeof settings.allowMultiple === 'boolean' || !settings.allowMultiple.matcher
+            ? ((desired, currentArr) => {
+                const requiredParameters = typeof settings.allowMultiple === 'object'
+                    ? settings.allowMultiple?.requiredParameters ?? settings.schema?.required ?? []
+                    : settings.schema?.required ?? [];
+                const matched = currentArr.filter((c) => requiredParameters.every((key) => {
+                    const currentParameter = c[key];
+                    const desiredParameter = desired[key];
+                    if (!currentParameter) {
+                        console.warn(`Unable to find required parameter for current ${currentParameter}`);
+                        return false;
+                    }
+                    if (!desiredParameter) {
+                        console.warn(`Unable to find required parameter for current ${currentParameter}`);
+                        return false;
+                    }
+                    return currentParameter === desiredParameter;
+                }));
+                if (matched.length > 1) {
+                    console.warn(`Required parameters did not uniquely identify a resource: ${currentArray}. Defaulting to the first one`);
+                }
+                return matched[0];
+            })
+            : settings.allowMultiple.matcher;
         if (isStateful) {
             return state
-                ? settings.allowMultiple.matcher(state, currentArray)
+                ? matcher(state, currentArray) ?? null
                 : null;
         }
-        return settings.allowMultiple.matcher(desired, currentArray);
+        return matcher(desired, currentArray) ?? null;
     }
     /**
      *  Only keep relevant params for the plan. We don't want to change settings that were not already
@@ -241,13 +265,13 @@ export class Plan {
             const currentCopy = [...v];
             const defaultFilterMethod = ((desired, current) => {
                 const result = [];
-                for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
-                    const idx = currentCopy.findIndex((e2) => matcher(desiredCopy[counter], e2));
+                for (let counter = desired.length - 1; counter >= 0; counter--) {
+                    const idx = currentCopy.findIndex((e2) => matcher(desired[counter], e2));
                     if (idx === -1) {
                         continue;
                     }
-                    desiredCopy.splice(counter, 1);
-                    const [element] = currentCopy.splice(idx, 1);
+                    desired.splice(counter, 1);
+                    const [element] = current.splice(idx, 1);
                     result.push(element);
                 }
                 return result;
@@ -263,9 +287,7 @@ export class Plan {
     requiresChanges() {
         return this.changeSet.operation !== ResourceOperation.NOOP;
     }
-    /**
-     * Convert the plan to a JSON response object
-     */
+    /** Convert the plan to a JSON response object */
     toResponse() {
         return {
             planId: this.id,

package/dist/plugin/plugin.js

@@ -38,7 +38,7 @@ export class Plugin {
         }
         const resource = this.resourceControllers.get(data.type);
         const schema = resource.settings.schema;
-        const requiredPropertyNames = (resource.settings.import?.requiredParameters
+        const requiredPropertyNames = (resource.settings.importAndDestroy?.requiredParameters
             ?? schema?.required
             ?? null);
         return {

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

@@ -1,3 +1,4 @@
+import { JSONSchemaType } from 'ajv';
 import { StringIndexedObject } from 'codify-schemas';
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 import { ArrayParameterSetting, DefaultParameterSetting, ParameterSetting, ResourceSettings } from './resource-settings.js';
@@ -17,10 +18,11 @@ export type ParsedParameterSetting = {
 export declare class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
     private cache;
     id: string;
-    schema?: unknown;
+    schema?: Partial<JSONSchemaType<T | any>>;
     allowMultiple?: {
-        matcher: (desired: Partial<T>, current: Partial<T>[]) => Partial<T>;
-    } | undefined;
+        matcher?: (desired: Partial<T>, current: Partial<T>[]) => Partial<T>;
+        requiredParameters?: string[];
+    } | boolean;
     removeStatefulParametersBeforeDestroy?: boolean | undefined;
     dependencies?: string[] | undefined;
     inputTransformation?: ((desired: Partial<T>) => unknown) | undefined;

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

@@ -1,5 +1,5 @@
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
-import { resolveEqualsFn, resolveFnFromEqualsFnOrString, resolveParameterTransformFn } from './resource-settings.js';
+import { resolveElementEqualsFn, resolveEqualsFn, resolveParameterTransformFn } from './resource-settings.js';
 export class ParsedResourceSettings {
     cache = new Map();
     id;
@@ -52,8 +52,7 @@ export class ParsedResourceSettings {
                 if (v.type === 'array') {
                     const parsed = {
                         ...v,
-                        isElementEqual: resolveFnFromEqualsFnOrString(v.isElementEqual)
-                            ?? ((a, b) => a === b),
+                        isElementEqual: resolveElementEqualsFn(v)
                     };
                     return [k, parsed];
                 }
@@ -84,7 +83,7 @@ export class ParsedResourceSettings {
             }
             return Object.fromEntries(Object.entries(this.settings.parameterSettings)
                 .filter(([_, v]) => resolveParameterTransformFn(v) !== undefined)
-                .map(([k, v]) => [k, resolveParameterTransformFn(v)]));
+                .map(([k, v]) => [k, resolveParameterTransformFn(v).to]));
         });
     }
     get statefulParameterOrder() {
@@ -117,7 +116,7 @@ export class ParsedResourceSettings {
             throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed if multiples of a resource exist`);
         }
         const schema = this.settings.schema;
-        if (!this.settings.import && (schema?.oneOf
+        if (!this.settings.importAndDestroy && (schema?.oneOf
             && Array.isArray(schema.oneOf)
             && schema.oneOf.some((s) => s.required))
             || (schema?.anyOf
@@ -137,8 +136,8 @@ export class ParsedResourceSettings {
                 'determine the prompt to ask users during imports. It can\'t parse which parameters are needed when ' +
                 'required is declared conditionally.');
         }
-        if (this.settings.import) {
-            const { requiredParameters, refreshKeys, defaultRefreshValues } = this.settings.import;
+        if (this.settings.importAndDestroy) {
+            const { requiredParameters, refreshKeys, defaultRefreshValues } = this.settings.importAndDestroy;
             const requiredParametersNotInSchema = requiredParameters
                 ?.filter((p) => schema && !(schema.properties[p]));
             if (schema && requiredParametersNotInSchema && requiredParametersNotInSchema.length > 0) {

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

@@ -16,6 +16,7 @@ export declare class ResourceController<T extends StringIndexedObject> {
     initialize(): Promise<void>;
     validate(core: ResourceConfig, parameters: Partial<T>): Promise<ValidateResponseData['resourceValidations'][0]>;
     plan(core: ResourceConfig, desired: Partial<T> | null, state: Partial<T> | null, isStateful?: boolean): Promise<Plan<T>>;
+    planDestroy(core: ResourceConfig, parameters: Partial<T>): Promise<Plan<T>>;
     apply(plan: Plan<T>): Promise<void>;
     import(core: ResourceConfig, parameters: Partial<T>): Promise<Array<ResourceJson> | null>;
     private applyCreate;

package/dist/resource/resource-controller.js

@@ -109,6 +109,23 @@ export class ResourceController {
             isStateful
         });
     }
+    async planDestroy(core, parameters) {
+        this.addDefaultValues(parameters);
+        await this.applyTransformParameters(parameters);
+        // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
+        const parametersToRefresh = this.settings.importAndDestroy?.refreshKeys
+            ? {
+                ...Object.fromEntries(this.settings.importAndDestroy?.refreshKeys.map((k) => [k, null])),
+                ...this.settings.importAndDestroy?.defaultRefreshValues,
+                ...parameters,
+            }
+            : {
+                ...Object.fromEntries(this.getAllParameterKeys().map((k) => [k, null])),
+                ...this.settings.importAndDestroy?.defaultRefreshValues,
+                ...parameters,
+            };
+        return this.plan(core, null, parametersToRefresh, true);
+    }
     async apply(plan) {
         if (plan.getResourceType() !== this.typeId) {
             throw new Error(`Internal error: Plan set to wrong resource during apply. Expected ${this.typeId} but got: ${plan.getResourceType()}`);
@@ -133,15 +150,15 @@ export class ResourceController {
         this.addDefaultValues(parameters);
         await this.applyTransformParameters(parameters);
         // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
-        const parametersToRefresh = this.settings.import?.refreshKeys
+        const parametersToRefresh = this.settings.importAndDestroy?.refreshKeys
             ? {
-                ...Object.fromEntries(this.settings.import?.refreshKeys.map((k) => [k, null])),
-                ...this.settings.import?.defaultRefreshValues,
+                ...Object.fromEntries(this.settings.importAndDestroy?.refreshKeys.map((k) => [k, null])),
+                ...this.settings.importAndDestroy?.defaultRefreshValues,
                 ...parameters,
             }
             : {
                 ...Object.fromEntries(this.getAllParameterKeys().map((k) => [k, null])),
-                ...this.settings.import?.defaultRefreshValues,
+                ...this.settings.importAndDestroy?.defaultRefreshValues,
                 ...parameters,
             };
         // Parse data from the user supplied config

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

@@ -1,5 +1,10 @@
+import { JSONSchemaType } from 'ajv';
 import { StringIndexedObject } from 'codify-schemas';
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
+export interface InputTransformation {
+    to: (input: any) => Promise<any> | any;
+    from: (current: any) => Promise<any> | any;
+}
 /**
  * The configuration and settings for a resource.
  */
@@ -11,13 +16,23 @@ export interface ResourceSettings<T extends StringIndexedObject> {
     /**
      * Schema to validate user configs with. Must be in the format JSON Schema draft07
      */
-    schema?: unknown;
+    schema?: Partial<JSONSchemaType<T | any>>;
     /**
      * Allow multiple of the same resource to unique. Set truthy if
      * multiples are allowed, for example for applications, there can be multiple copy of the same application installed
      * on the system. Or there can be multiple git repos. Defaults to false.
      */
     allowMultiple?: {
+        /**
+         * A set of parameters that uniquely identifies a resource. The value of these parameters is used to determine which
+         * resource is which when multiple can exist at the same time. Defaults to the required parameters inside the json
+         * schema.
+         *
+         * For example:
+         * If paramA is required, then if resource1.paramA === resource2.paramA then are the same resource.
+         * If resource1.paramA !== resource1.paramA, then they are different.
+         */
+        requiredParameters?: string[];
         /**
          * If multiple copies are allowed then a matcher must be defined to match the desired
          * config with one of the resources currently existing on the system. Return null if there is no match.
@@ -27,8 +42,8 @@ export interface ResourceSettings<T extends StringIndexedObject> {
          *
          * @return The matched resource.
          */
-        matcher: (desired: Partial<T>, current: Partial<T>[]) => Partial<T>;
-    };
+        matcher?: (desired: Partial<T>, current: Partial<T>[]) => Partial<T>;
+    } | boolean;
     /**
      * If true, {@link StatefulParameter} remove() will be called before resource destruction. This is useful
      * if the stateful parameter needs to be first uninstalled (cleanup) before the overall resource can be
@@ -53,9 +68,9 @@ export interface ResourceSettings<T extends StringIndexedObject> {
      */
     inputTransformation?: (desired: Partial<T>) => Promise<unknown> | unknown;
     /**
-     * Customize the import behavior of the resource. By default, <code>codify import</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
-     * in the schema and will prompt the user for these values before performing the import.
+     * 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
+     * in the schema and will prompt the user for these values before performing the import or destroy.
      *
      * <b>Example:</b><br>
      * Resource `alias` with parameters
@@ -71,7 +86,7 @@ export interface ResourceSettings<T extends StringIndexedObject> {
      * { type: 'alias', alias: 'user-input', value: 'git push' }
      * ```
      */
-    import?: {
+    importAndDestroy?: {
         /**
          * Customize the required parameters needed to import this resource. By default, the `requiredParameters` are taken
          * from the JSON schema. The `requiredParameters` parameter must be declared if a complex required is declared in
@@ -81,7 +96,7 @@ export interface ResourceSettings<T extends StringIndexedObject> {
          * the required parameters change the behaviour of the refresh (for example for the `alias` resource, the `alias` parmaeter
          * chooses which alias the resource is managing).
          *
-         * See {@link import} for more information on how importing works.
+         * See {@link importAndDestroy} for more information on how importing works.
          */
         requiredParameters?: Array<Partial<keyof T>>;
         /**
@@ -91,13 +106,13 @@ export interface ResourceSettings<T extends StringIndexedObject> {
          * By default all parameters (except for {@link requiredParameters }) are passed in with the value `null`. The passed
          * in value can be customized using {@link defaultRefreshValues}
          *
-         * See {@link import} for more information on how importing works.
+         * See {@link importAndDestroy} for more information on how importing works.
          */
         refreshKeys?: Array<Partial<keyof T>>;
         /**
          * Customize the value that is passed into refresh when importing. This must only contain keys found in {@link refreshKeys}.
          *
-         * See {@link import} for more information on how importing works.
+         * See {@link importAndDestroy} for more information on how importing works.
          */
         defaultRefreshValues?: Partial<T>;
     };
@@ -130,12 +145,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.
      * This value will override the pre-set equality function from the type. Return true if the desired value is
@@ -192,6 +208,11 @@ export interface ArrayParameterSetting extends DefaultParameterSetting {
      * Defaults to true.
      */
     filterInStatelessMode?: ((desired: any[], current: any[]) => any[]) | boolean;
+    /**
+     * The type of the array item. See {@link ParameterSettingType} for the available options. This value
+     * is mainly used to determine the equality method when performing diffing.
+     */
+    itemType?: ParameterSettingType;
 }
 /**
  * Stateful parameter type specific settings. A stateful parameter is a sub-resource that can hold its own
@@ -215,5 +236,6 @@ export interface StatefulParameterSetting extends DefaultParameterSetting {
     order?: number;
 }
 export declare function resolveEqualsFn(parameter: ParameterSetting): (desired: unknown, current: unknown) => boolean;
+export declare function resolveElementEqualsFn(parameter: ArrayParameterSetting): (desired: unknown, current: unknown) => boolean;
 export declare function resolveFnFromEqualsFnOrString(fnOrString: ((a: unknown, b: unknown) => boolean) | ParameterSettingType | undefined): ((a: unknown, b: unknown) => boolean) | undefined;
-export declare function resolveParameterTransformFn(parameter: ParameterSetting): ((input: any, parameter: ParameterSetting) => Promise<any> | any) | undefined;
+export declare function resolveParameterTransformFn(parameter: ParameterSetting): InputTransformation | undefined;

package/dist/resource/resource-settings.js

@@ -1,6 +1,6 @@
 import isObjectsEqual from 'lodash.isequal';
 import path from 'node:path';
-import { areArraysEqual, untildify } from '../utils/utils.js';
+import { areArraysEqual, tildify, untildify } from '../utils/utils.js';
 const ParameterEqualsDefaults = {
     'boolean': (a, b) => Boolean(a) === Boolean(b),
     'directory': (a, b) => path.resolve(untildify(String(a))) === path.resolve(untildify(String(b))),
@@ -13,15 +13,25 @@ const ParameterEqualsDefaults = {
 export function resolveEqualsFn(parameter) {
     const isEqual = resolveFnFromEqualsFnOrString(parameter.isEqual);
     if (parameter.type === 'array') {
-        const arrayParameter = parameter;
-        const isElementEqual = resolveFnFromEqualsFnOrString(arrayParameter.isElementEqual);
-        return isEqual ?? areArraysEqual.bind(areArraysEqual, isElementEqual);
+        return isEqual ?? areArraysEqual.bind(areArraysEqual, resolveElementEqualsFn(parameter));
     }
     if (parameter.type === 'stateful') {
         return resolveEqualsFn(parameter.definition.getSettings());
     }
     return isEqual ?? ParameterEqualsDefaults[parameter.type] ?? (((a, b) => a === b));
 }
+export function resolveElementEqualsFn(parameter) {
+    if (parameter.isElementEqual) {
+        const elementEq = resolveFnFromEqualsFnOrString(parameter.isElementEqual);
+        if (elementEq) {
+            return elementEq;
+        }
+    }
+    if (parameter.itemType && ParameterEqualsDefaults[parameter.itemType]) {
+        return ParameterEqualsDefaults[parameter.itemType];
+    }
+    return (a, b) => a === b;
+}
 // This resolves the fn if it is a string.
 // A string can be specified to use a default equals method
 export function resolveFnFromEqualsFnOrString(fnOrString) {
@@ -34,15 +44,37 @@ export function resolveFnFromEqualsFnOrString(fnOrString) {
     return fnOrString;
 }
 const ParameterTransformationDefaults = {
-    'directory': (a) => path.resolve(untildify(String(a))),
-    'stateful': (a, b) => {
-        const sp = b;
-        return (sp.definition?.getSettings()?.inputTransformation)
-            ? (sp.definition.getSettings().inputTransformation(a))
-            : a;
+    'directory': {
+        to: (a) => path.resolve(untildify(String(a))),
+        from: (a) => tildify(String(a)),
     },
-    'string': String,
+    'string': {
+        to: String,
+        from: String,
+    }
 };
 export function resolveParameterTransformFn(parameter) {
+    if (parameter.type === 'stateful' && !parameter.inputTransformation) {
+        const sp = parameter.definition.getSettings();
+        if (sp.inputTransformation) {
+            return parameter.definition?.getSettings()?.inputTransformation;
+        }
+        return sp.type ? ParameterTransformationDefaults[sp.type] : undefined;
+    }
+    if (parameter.type === 'array'
+        && parameter.itemType
+        && ParameterTransformationDefaults[parameter.itemType]
+        && !parameter.inputTransformation) {
+        const itemType = parameter.itemType;
+        const itemTransformation = ParameterTransformationDefaults[itemType];
+        return {
+            to(input) {
+                return input.map((i) => itemTransformation.to(i));
+            },
+            from(input) {
+                return input.map((i) => itemTransformation.from(i));
+            }
+        };
+    }
     return parameter.inputTransformation ?? ParameterTransformationDefaults[parameter.type] ?? undefined;
 }

package/dist/stateful-parameter/stateful-parameter-controller.js

@@ -1,4 +1,4 @@
-import { resolveEqualsFn, resolveFnFromEqualsFnOrString } from '../resource/resource-settings.js';
+import { resolveElementEqualsFn, resolveEqualsFn, } from '../resource/resource-settings.js';
 /**
  * This class is analogous to what {@link ResourceController} is for {@link Resource}
  * It's a bit messy because this class supports both {@link StatefulParameter} and {@link ArrayStatefulParameter}
@@ -15,8 +15,7 @@ export class StatefulParameterController {
         this.parsedSettings = (this.isArrayStatefulParameter || this.settings.type === 'array') ? {
             ...this.settings,
             isEqual: resolveEqualsFn(this.settings),
-            isElementEqual: resolveFnFromEqualsFnOrString(this.settings.isElementEqual)
-                ?? ((a, b) => a === b)
+            isElementEqual: resolveElementEqualsFn(this.settings)
         } : {
             ...this.settings,
             isEqual: resolveEqualsFn(this.settings),

package/dist/utils/utils.d.ts

@@ -6,4 +6,5 @@ export declare function splitUserConfig<T extends StringIndexedObject>(config: R
 };
 export declare function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean;
 export declare function untildify(pathWithTilde: string): string;
+export declare function tildify(pathWithTilde: string): string;
 export declare function areArraysEqual(isElementEqual: ((desired: unknown, current: unknown) => boolean) | undefined, desired: unknown, current: unknown): boolean;

package/dist/utils/utils.js

@@ -22,6 +22,9 @@ const homeDirectory = os.homedir();
 export function untildify(pathWithTilde) {
     return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
 }
+export function tildify(pathWithTilde) {
+    return homeDirectory ? pathWithTilde.replace(homeDirectory, '~') : pathWithTilde;
+}
 export function areArraysEqual(isElementEqual, desired, current) {
     if (!desired || !current) {
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.132",
+  "version": "1.0.134",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -34,7 +34,7 @@
     "@types/uuid": "^10.0.0",
     "@types/lodash.isequal": "^4.5.8",
     "chai-as-promised": "^7.1.1",
-    "vitest": "^1.4.0",
+    "vitest": "^3.0.5",
     "vitest-mock-extended": "^1.3.1",
     "sinon": "^17.0.1",
     "eslint": "^8.51.0",

package/src/plan/plan.test.ts

@@ -230,6 +230,120 @@ describe('Plan entity tests', () => {
       ])
     })
   })
+
+  it('Can use the requiredParameters to match the correct resources together', async () => {
+    const resource1 = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          parameterSettings: {
+            propA: { type: 'string' },
+            propB: { type: 'string', canModify: true },
+          },
+          allowMultiple: {
+            requiredParameters: ['propA']
+          }
+        }
+      }
+
+      async refresh(): Promise<Partial<any> | null> {
+        return [{
+          propA: 'same',
+          propB: 'old',
+        }, {
+          propA: 'different',
+          propB: 'different',
+        }]
+      }
+    }
+
+    const controller = new ResourceController(resource1);
+    const plan = await controller.plan(
+      { type: 'type' },
+      { propA: 'same', propB: 'new' },
+      null,
+      false
+    )
+
+    expect(plan.changeSet).toMatchObject({
+      operation: ResourceOperation.MODIFY,
+      parameterChanges: expect.arrayContaining([
+        expect.objectContaining({
+          name: 'propA',
+          previousValue: 'same',
+          newValue: 'same',
+          operation: 'noop'
+        }),
+        expect.objectContaining({
+          name: 'propB',
+          previousValue: 'old',
+          newValue: 'new',
+          operation: 'modify'
+        })
+      ])
+    })
+  })
+
+  it('Can use the schema to determine required parameters for multiple allowed', async () => {
+    const resource1 = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          parameterSettings: {
+            propA: { type: 'string' },
+            propB: { type: 'string', canModify: true },
+          },
+          allowMultiple: true,
+          schema: {
+            '$schema': 'http://json-schema.org/draft-07/schema',
+            '$id': 'https://www.codifycli.com/type.json',
+            'type': 'object',
+            'properties': {
+              propA: { type: 'string' },
+              propB: { type: 'string' }
+            },
+            required: ['propA']
+          }
+        }
+      }
+
+      async refresh(): Promise<Partial<any> | null> {
+        return [{
+          propA: 'same',
+          propB: 'old',
+        }, {
+          propA: 'different',
+          propB: 'different',
+        }]
+      }
+    }
+
+    const controller = new ResourceController(resource1);
+    const plan = await controller.plan(
+      { type: 'type' },
+      { propA: 'same', propB: 'new' },
+      null,
+      false
+    )
+
+    expect(plan.changeSet).toMatchObject({
+      operation: ResourceOperation.MODIFY,
+      parameterChanges: expect.arrayContaining([
+        expect.objectContaining({
+          name: 'propA',
+          previousValue: 'same',
+          newValue: 'same',
+          operation: 'noop'
+        }),
+        expect.objectContaining({
+          name: 'propB',
+          previousValue: 'old',
+          newValue: 'new',
+          operation: 'modify'
+        })
+      ])
+    })
+  })
 })
 
 function createTestResource() {

package/src/plan/plan.ts

@@ -260,13 +260,44 @@ export class Plan<T extends StringIndexedObject> {
       return null;
     }
 
+    const matcher = typeof settings.allowMultiple === 'boolean' || !settings.allowMultiple.matcher
+      ? ((desired: Partial<T>, currentArr: Array<Partial<T>>) => {
+        const requiredParameters = typeof settings.allowMultiple === 'object'
+          ? settings.allowMultiple?.requiredParameters ?? (settings.schema?.required as string[]) ?? []
+          : (settings.schema?.required as string[]) ?? []
+
+        const matched = currentArr.filter((c) => requiredParameters.every((key) => {
+          const currentParameter = c[key];
+          const desiredParameter = desired[key];
+
+          if (!currentParameter) {
+            console.warn(`Unable to find required parameter for current ${currentParameter}`)
+            return false;
+          }
+
+          if (!desiredParameter) {
+            console.warn(`Unable to find required parameter for current ${currentParameter}`)
+            return false;
+          }
+
+          return currentParameter === desiredParameter;
+        }))
+
+        if (matched.length > 1) {
+          console.warn(`Required parameters did not uniquely identify a resource: ${currentArray}. Defaulting to the first one`);
+        }
+
+        return matched[0];
+      })
+      : settings.allowMultiple.matcher
+
     if (isStateful) {
       return state
-        ? settings.allowMultiple.matcher(state, currentArray)
+        ? matcher(state, currentArray) ?? null
         : null
     }
 
-    return settings.allowMultiple.matcher(desired!, currentArray);
+    return matcher(desired!, currentArray) ?? null;
   }
 
   /**
@@ -384,15 +415,15 @@ export class Plan<T extends StringIndexedObject> {
       const defaultFilterMethod = ((desired: any[], current: any[]) => {
         const result = [];
 
-        for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
-          const idx = currentCopy.findIndex((e2) => matcher(desiredCopy[counter], e2))
+        for (let counter = desired.length - 1; counter >= 0; counter--) {
+          const idx = currentCopy.findIndex((e2) => matcher(desired[counter], e2))
 
           if (idx === -1) {
             continue;
           }
 
-          desiredCopy.splice(counter, 1)
-          const [element] = currentCopy.splice(idx, 1)
+          desired.splice(counter, 1)
+          const [element] = current.splice(idx, 1)
           result.push(element)
         }
 
@@ -413,9 +444,7 @@ export class Plan<T extends StringIndexedObject> {
     return this.changeSet.operation !== ResourceOperation.NOOP;
   }
 
-  /**
-   * Convert the plan to a JSON response object
-   */
+  /** Convert the plan to a JSON response object */
   toResponse(): PlanResponseData {
     return {
       planId: this.id,

package/src/plugin/plugin.test.ts

@@ -6,7 +6,6 @@ import { Plan } from '../plan/plan.js';
 import { spy } from 'sinon';
 import { ResourceSettings } from '../resource/resource-settings.js';
 import { TestConfig } from '../utils/test-utils.test.js';
-import { ApplyValidationError } from '../common/errors.js';
 import { getPty } from '../pty/index.js';
 
 interface TestConfig extends StringIndexedObject {
@@ -194,7 +193,7 @@ describe('Plugin tests', () => {
         return {
           id: 'typeId',
           schema,
-          import: {
+          importAndDestroy: {
             requiredParameters: []
           }
         }
@@ -229,7 +228,7 @@ describe('Plugin tests', () => {
 
     await expect(() => testPlugin.apply({ plan }))
       .rejects
-      .toThrowError(new ApplyValidationError(Plan.fromResponse(plan)));
+      .toThrowError();
     expect(resource.modify.calledOnce).to.be.true;
   })
 

package/src/plugin/plugin.ts

@@ -67,7 +67,7 @@ export class Plugin {
 
     const schema = resource.settings.schema as JSONSchemaType<any> | undefined;
     const requiredPropertyNames = (
-      resource.settings.import?.requiredParameters
+      resource.settings.importAndDestroy?.requiredParameters
       ?? schema?.required
       ?? null
     ) as null | string[];

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

@@ -81,7 +81,7 @@ describe('Resource options parser tests', () => {
     const option: ResourceSettings<TestConfig> = {
       id: 'typeId',
       schema,
-      import: {
+      importAndDestroy: {
         requiredParameters: ['import-error']
       }
     }
@@ -104,7 +104,7 @@ describe('Resource options parser tests', () => {
     const option: ResourceSettings<TestConfig> = {
       id: 'typeId',
       schema,
-      import: {
+      importAndDestroy: {
         refreshKeys: ['import-error']
       }
     }
@@ -127,7 +127,7 @@ describe('Resource options parser tests', () => {
     const option: ResourceSettings<TestConfig> = {
       id: 'typeId',
       schema,
-      import: {
+      importAndDestroy: {
         refreshKeys: ['remote'],
       }
     }
@@ -150,7 +150,7 @@ describe('Resource options parser tests', () => {
     const option: ResourceSettings<TestConfig> = {
       id: 'typeId',
       schema,
-      import: {
+      importAndDestroy: {
         defaultRefreshValues: {
           repository: 'abc'
         }

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

@@ -6,8 +6,8 @@ import {
   ArrayParameterSetting,
   DefaultParameterSetting,
   ParameterSetting,
+  resolveElementEqualsFn,
   resolveEqualsFn,
-  resolveFnFromEqualsFnOrString,
   resolveParameterTransformFn,
   ResourceSettings,
   StatefulParameterSetting
@@ -35,8 +35,12 @@ export type ParsedParameterSetting =
 export class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
   private cache = new Map<string, unknown>();
   id!: string;
-  schema?: unknown;
-  allowMultiple?: { matcher: (desired: Partial<T>, current: Partial<T>[]) => Partial<T>; } | undefined;
+  schema?: Partial<JSONSchemaType<T | any>>;
+  allowMultiple?: {
+    matcher?: (desired: Partial<T>, current: Partial<T>[]) => Partial<T>;
+    requiredParameters?: string[]
+  } | boolean;
+
   removeStatefulParametersBeforeDestroy?: boolean | undefined;
   dependencies?: string[] | undefined;
   inputTransformation?: ((desired: Partial<T>) => unknown) | undefined;
@@ -95,8 +99,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
           if (v.type === 'array') {
             const parsed = {
               ...v,
-              isElementEqual: resolveFnFromEqualsFnOrString((v as ArrayParameterSetting).isElementEqual)
-                ?? ((a: unknown, b: unknown) => a === b),
+              isElementEqual: resolveElementEqualsFn(v as ArrayParameterSetting)
             }
 
             return [k, parsed as ParsedArrayParameterSetting];
@@ -142,7 +145,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>;
     });
   }
@@ -186,7 +189,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
     }
 
     const schema = this.settings.schema as JSONSchemaType<any>;
-    if (!this.settings.import && (schema?.oneOf
+    if (!this.settings.importAndDestroy && (schema?.oneOf
         && Array.isArray(schema.oneOf)
         && schema.oneOf.some((s) => s.required)
       )
@@ -214,8 +217,8 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
       )
     }
 
-    if (this.settings.import) {
-      const { requiredParameters, refreshKeys, defaultRefreshValues } = this.settings.import;
+    if (this.settings.importAndDestroy) {
+      const { requiredParameters, refreshKeys, defaultRefreshValues } = this.settings.importAndDestroy;
 
       const requiredParametersNotInSchema = requiredParameters
         ?.filter(

package/src/resource/resource-controller.ts

@@ -158,6 +158,33 @@ export class ResourceController<T extends StringIndexedObject> {
     })
   }
 
+  async planDestroy(
+    core: ResourceConfig,
+    parameters: Partial<T>
+  ): Promise<Plan<T>> {
+    this.addDefaultValues(parameters);
+    await this.applyTransformParameters(parameters);
+
+    // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
+    const parametersToRefresh = this.settings.importAndDestroy?.refreshKeys
+      ? {
+        ...Object.fromEntries(
+          this.settings.importAndDestroy?.refreshKeys.map((k) => [k, null])
+        ),
+        ...this.settings.importAndDestroy?.defaultRefreshValues,
+        ...parameters,
+      }
+      : {
+        ...Object.fromEntries(
+          this.getAllParameterKeys().map((k) => [k, null])
+        ),
+        ...this.settings.importAndDestroy?.defaultRefreshValues,
+        ...parameters,
+      };
+
+    return this.plan(core, null, parametersToRefresh, true);
+  }
+
   async apply(plan: Plan<T>): Promise<void> {
     if (plan.getResourceType() !== this.typeId) {
       throw new Error(`Internal error: Plan set to wrong resource during apply. Expected ${this.typeId} but got: ${plan.getResourceType()}`);
@@ -191,19 +218,19 @@ export class ResourceController<T extends StringIndexedObject> {
     await this.applyTransformParameters(parameters);
 
     // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
-    const parametersToRefresh = this.settings.import?.refreshKeys
+    const parametersToRefresh = this.settings.importAndDestroy?.refreshKeys
       ? {
         ...Object.fromEntries(
-          this.settings.import?.refreshKeys.map((k) => [k, null])
+          this.settings.importAndDestroy?.refreshKeys.map((k) => [k, null])
         ),
-        ...this.settings.import?.defaultRefreshValues,
+        ...this.settings.importAndDestroy?.defaultRefreshValues,
         ...parameters,
       }
       : {
         ...Object.fromEntries(
           this.getAllParameterKeys().map((k) => [k, null])
         ),
-        ...this.settings.import?.defaultRefreshValues,
+        ...this.settings.importAndDestroy?.defaultRefreshValues,
         ...parameters,
       };
 

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

@@ -637,7 +637,7 @@ describe('Resource parameter tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'resourceType',
-          import: {
+          importAndDestroy: {
             requiredParameters: [
               'propA',
               'propB',
@@ -723,7 +723,7 @@ describe('Resource parameter tests', () => {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           id: 'resourceType',
-          import: {
+          importAndDestroy: {
             requiredParameters: ['propA'],
             refreshKeys: ['propB', 'propA'],
             defaultRefreshValues: {
@@ -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',
                 ])
-            )
-          )
+            ))
+          }
         }
       }
 
@@ -969,4 +987,59 @@ describe('Resource parameter tests', () => {
     );
 
   })
+
+  it('Supports equality check for itemType', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          parameterSettings: {
+            propA: { type: 'array', itemType: 'version' }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: ['10.0.0']
+        }
+      }
+    };
+
+    const controller = new ResourceController(resource);
+
+    const result = await controller.plan({ type: 'resourceType' }, { propA: ['10.0'] }, null, false);
+    expect(result.changeSet).toMatchObject({
+      operation: ResourceOperation.NOOP,
+    })
+  })
+
+  it('Supports transformations for itemType', async () => {
+    const home = os.homedir()
+    const testPath = path.join(home, 'test/folder');
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          parameterSettings: {
+            propA: { type: 'array', itemType: 'directory' }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: [testPath]
+        }
+      }
+    };
+
+    const controller = new ResourceController(resource);
+
+    const result = await controller.plan({ type: 'resourceType' }, { propA: ['~/test/folder'] }, null, false);
+    expect(result.changeSet).toMatchObject({
+      operation: ResourceOperation.NOOP,
+    })
+  })
 })

package/src/resource/resource-settings.ts

@@ -1,9 +1,15 @@
+import { JSONSchemaType } from 'ajv';
 import { StringIndexedObject } from 'codify-schemas';
 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.
@@ -18,7 +24,7 @@ export interface ResourceSettings<T extends StringIndexedObject> {
   /**
    * Schema to validate user configs with. Must be in the format JSON Schema draft07
    */
-  schema?: unknown;
+  schema?: Partial<JSONSchemaType<T | any>>;
 
   /**
    * Allow multiple of the same resource to unique. Set truthy if
@@ -27,6 +33,17 @@ export interface ResourceSettings<T extends StringIndexedObject> {
    */
   allowMultiple?: {
 
+    /**
+     * A set of parameters that uniquely identifies a resource. The value of these parameters is used to determine which
+     * resource is which when multiple can exist at the same time. Defaults to the required parameters inside the json
+     * schema.
+     *
+     * For example:
+     * If paramA is required, then if resource1.paramA === resource2.paramA then are the same resource.
+     * If resource1.paramA !== resource1.paramA, then they are different.
+     */
+    requiredParameters?: string[]
+
     /**
      * If multiple copies are allowed then a matcher must be defined to match the desired
      * config with one of the resources currently existing on the system. Return null if there is no match.
@@ -36,8 +53,8 @@ export interface ResourceSettings<T extends StringIndexedObject> {
      *
      * @return The matched resource.
      */
-    matcher: (desired: Partial<T>, current: Partial<T>[],) => Partial<T>
-  }
+    matcher?: (desired: Partial<T>, current: Partial<T>[],) => Partial<T>
+  } | boolean
 
   /**
    * If true, {@link StatefulParameter} remove() will be called before resource destruction. This is useful
@@ -67,9 +84,9 @@ export interface ResourceSettings<T extends StringIndexedObject> {
   inputTransformation?: (desired: Partial<T>) => Promise<unknown> | unknown;
 
   /**
-   * Customize the import behavior of the resource. By default, <code>codify import</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
-   * in the schema and will prompt the user for these values before performing the import.
+   * 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
+   * in the schema and will prompt the user for these values before performing the import or destroy.
    *
    * <b>Example:</b><br>
    * Resource `alias` with parameters
@@ -85,7 +102,7 @@ export interface ResourceSettings<T extends StringIndexedObject> {
    * { type: 'alias', alias: 'user-input', value: 'git push' }
    * ```
    */
-  import?: {
+  importAndDestroy?: {
 
     /**
      * Customize the required parameters needed to import this resource. By default, the `requiredParameters` are taken
@@ -96,7 +113,7 @@ export interface ResourceSettings<T extends StringIndexedObject> {
      * the required parameters change the behaviour of the refresh (for example for the `alias` resource, the `alias` parmaeter
      * chooses which alias the resource is managing).
      *
-     * See {@link import} for more information on how importing works.
+     * See {@link importAndDestroy} for more information on how importing works.
      */
     requiredParameters?: Array<Partial<keyof T>>;
 
@@ -107,14 +124,14 @@ export interface ResourceSettings<T extends StringIndexedObject> {
      * By default all parameters (except for {@link requiredParameters }) are passed in with the value `null`. The passed
      * in value can be customized using {@link defaultRefreshValues}
      *
-     * See {@link import} for more information on how importing works.
+     * See {@link importAndDestroy} for more information on how importing works.
      */
     refreshKeys?: Array<Partial<keyof T>>;
 
     /**
      * Customize the value that is passed into refresh when importing. This must only contain keys found in {@link refreshKeys}.
      *
-     * See {@link import} for more information on how importing works.
+     * See {@link importAndDestroy} for more information on how importing works.
      */
     defaultRefreshValues?: Partial<T>
   }
@@ -166,12 +183,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.
@@ -233,6 +251,12 @@ export interface ArrayParameterSetting extends DefaultParameterSetting {
    * Defaults to true.
    */
   filterInStatelessMode?: ((desired: any[], current: any[]) => any[]) | boolean,
+
+  /**
+   * The type of the array item. See {@link ParameterSettingType} for the available options. This value
+   * is mainly used to determine the equality method when performing diffing.
+   */
+  itemType?: ParameterSettingType,
 }
 
 /**
@@ -273,10 +297,7 @@ export function resolveEqualsFn(parameter: ParameterSetting): (desired: unknown,
   const isEqual = resolveFnFromEqualsFnOrString(parameter.isEqual);
 
   if (parameter.type === 'array') {
-    const arrayParameter = parameter as ArrayParameterSetting;
-    const isElementEqual = resolveFnFromEqualsFnOrString(arrayParameter.isElementEqual);
-
-    return isEqual ?? areArraysEqual.bind(areArraysEqual, isElementEqual)
+    return isEqual ?? areArraysEqual.bind(areArraysEqual, resolveElementEqualsFn(parameter as ArrayParameterSetting))
   }
 
   if (parameter.type === 'stateful') {
@@ -286,6 +307,21 @@ export function resolveEqualsFn(parameter: ParameterSetting): (desired: unknown,
   return isEqual ?? ParameterEqualsDefaults[parameter.type as ParameterSettingType] ?? (((a, b) => a === b));
 }
 
+export function resolveElementEqualsFn(parameter: ArrayParameterSetting): (desired: unknown, current: unknown) => boolean {
+  if (parameter.isElementEqual) {
+    const elementEq = resolveFnFromEqualsFnOrString(parameter.isElementEqual);
+    if (elementEq) {
+      return elementEq;
+    }
+  }
+
+  if (parameter.itemType && ParameterEqualsDefaults[parameter.itemType]) {
+    return ParameterEqualsDefaults[parameter.itemType]!
+  }
+
+  return (a, b) => a === b;
+}
+
 // This resolves the fn if it is a string.
 // A string can be specified to use a default equals method
 export function resolveFnFromEqualsFnOrString(
@@ -303,19 +339,47 @@ 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,
+  '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
+    && ParameterTransformationDefaults[(parameter as ArrayParameterSetting).itemType!]
+    && !parameter.inputTransformation
+  ) {
+    const itemType = (parameter as ArrayParameterSetting).itemType!;
+    const itemTransformation = ParameterTransformationDefaults[itemType]!;
+
+    return {
+      to(input: unknown[]) {
+        return input.map((i) => itemTransformation.to(i))
+      },
+      from(input: unknown[]) {
+        return input.map((i) => itemTransformation.from(i))
+      }
+    }
+  }
+
   return parameter.inputTransformation ?? ParameterTransformationDefaults[parameter.type as ParameterSettingType] ?? undefined;
 }

package/src/stateful-parameter/stateful-parameter-controller.ts

@@ -5,8 +5,8 @@ import { ParsedArrayParameterSetting, ParsedParameterSetting, } from '../resourc
 import {
   ArrayParameterSetting,
   ParameterSetting,
+  resolveElementEqualsFn,
   resolveEqualsFn,
-  resolveFnFromEqualsFnOrString
 } from '../resource/resource-settings.js';
 import { ArrayStatefulParameter, StatefulParameter } from './stateful-parameter.js';
 
@@ -31,8 +31,7 @@ export class StatefulParameterController<T extends StringIndexedObject, V extend
     this.parsedSettings = (this.isArrayStatefulParameter || this.settings.type === 'array') ? {
       ...this.settings,
       isEqual: resolveEqualsFn(this.settings),
-      isElementEqual: resolveFnFromEqualsFnOrString((this.settings as ArrayParameterSetting).isElementEqual)
-        ?? ((a: unknown, b: unknown) => a === b)
+      isElementEqual: resolveElementEqualsFn(this.settings as ArrayParameterSetting)
     } as ParsedParameterSetting : {
       ...this.settings,
       isEqual: resolveEqualsFn(this.settings),

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