codify-plugin-lib 1.0.131 → 1.0.133

package/.github/workflows/unit-test-ci.yaml

@@ -7,7 +7,7 @@ on: [ push ]
 
 jobs:
   build-and-test:
-    runs-on: ubuntu-latest
+    runs-on: macos-latest
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-node@v4
@@ -15,5 +15,4 @@ jobs:
           node-version: '20.x'
           cache: 'npm'
       - run: npm ci
-      - run: tsc
       - run: npm run test

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?: 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

@@ -31,11 +31,12 @@ export class ResourceController {
         return this.resource.initialize();
     }
     async validate(core, parameters) {
+        const originalParameters = structuredClone(parameters);
         await this.applyTransformParameters(parameters);
         this.addDefaultValues(parameters);
         if (this.schemaValidator) {
             // Schema validator uses pre transformation parameters
-            const isValid = this.schemaValidator(parameters);
+            const isValid = this.schemaValidator(originalParameters);
             if (!isValid) {
                 return {
                     isValid: false,
@@ -108,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()}`);
@@ -132,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?: 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,12 +1,13 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.131",
+  "version": "1.0.133",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "type": "module",
   "scripts": {
     "test": "vitest",
+    "posttest": "tsc",
     "prepublishOnly": "tsc"
   },
   "keywords": [],
@@ -33,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() {