codify-plugin-lib 1.0.144 → 1.0.146

package/dist/messages/handlers.js

@@ -1,6 +1,6 @@
 import { Ajv } from 'ajv';
 import addFormats from 'ajv-formats';
-import { ApplyRequestDataSchema, ApplyResponseDataSchema, GetResourceInfoRequestDataSchema, GetResourceInfoResponseDataSchema, ImportRequestDataSchema, ImportResponseDataSchema, InitializeRequestDataSchema, InitializeResponseDataSchema, IpcMessageSchema, IpcMessageV2Schema, MessageStatus, PlanRequestDataSchema, PlanResponseDataSchema, ResourceSchema, ValidateRequestDataSchema, ValidateResponseDataSchema } from 'codify-schemas';
+import { ApplyRequestDataSchema, ApplyResponseDataSchema, GetResourceInfoRequestDataSchema, GetResourceInfoResponseDataSchema, ImportRequestDataSchema, ImportResponseDataSchema, InitializeRequestDataSchema, InitializeResponseDataSchema, IpcMessageSchema, IpcMessageV2Schema, MatchRequestDataSchema, MatchResponseDataSchema, MessageStatus, PlanRequestDataSchema, PlanResponseDataSchema, ResourceSchema, ValidateRequestDataSchema, ValidateResponseDataSchema } from 'codify-schemas';
 import { SudoError } from '../errors.js';
 const SupportedRequests = {
     'initialize': {
@@ -18,6 +18,11 @@ const SupportedRequests = {
         requestValidator: GetResourceInfoRequestDataSchema,
         responseValidator: GetResourceInfoResponseDataSchema
     },
+    'match': {
+        handler: async (plugin, data) => plugin.match(data),
+        requestValidator: MatchRequestDataSchema,
+        responseValidator: MatchResponseDataSchema
+    },
     'import': {
         handler: async (plugin, data) => plugin.import(data),
         requestValidator: ImportRequestDataSchema,

package/dist/plan/plan.js

@@ -156,30 +156,14 @@ 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?.identifyingParameters ?? 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;
+        const { matcher: parameterMatcher, id } = settings;
+        const matcher = (desired, currentArray) => {
+            const matched = currentArray.filter((c) => parameterMatcher(desired, c));
+            if (matched.length > 0) {
+                console.log(`Resource: ${id} did not uniquely match resources when allow multiple is set to true`);
+            }
+            return matched[0];
+        };
         if (isStateful) {
             return state
                 ? matcher(state, currentArray) ?? null

package/dist/plugin/plugin.d.ts

@@ -1,4 +1,4 @@
-import { ApplyRequestData, GetResourceInfoRequestData, GetResourceInfoResponseData, ImportRequestData, ImportResponseData, InitializeResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ResourceJson, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
+import { ApplyRequestData, GetResourceInfoRequestData, GetResourceInfoResponseData, ImportRequestData, ImportResponseData, InitializeResponseData, MatchRequestData, MatchResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ResourceJson, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
 import { Plan } from '../plan/plan.js';
 import { BackgroundPty } from '../pty/background-pty.js';
 import { Resource } from '../resource/resource.js';
@@ -12,6 +12,7 @@ export declare class Plugin {
     static create(name: string, resources: Resource<any>[]): Plugin;
     initialize(): Promise<InitializeResponseData>;
     getResourceInfo(data: GetResourceInfoRequestData): Promise<GetResourceInfoResponseData>;
+    match(data: MatchRequestData): Promise<MatchResponseData>;
     import(data: ImportRequestData): Promise<ImportResponseData>;
     validate(data: ValidateRequestData): Promise<ValidateResponseData>;
     plan(data: PlanRequestData): Promise<PlanResponseData>;

package/dist/plugin/plugin.js

@@ -42,9 +42,7 @@ export class Plugin {
             ?? schema?.required
             ?? undefined);
         const allowMultiple = resource.settings.allowMultiple !== undefined
-            ? (typeof resource.settings.allowMultiple === 'boolean'
-                ? { identifyingParameters: schema?.required ?? [] }
-                : { identifyingParameters: resource.settings.allowMultiple.identifyingParameters ?? schema?.required ?? [] }) : undefined;
+            && resource.settings.allowMultiple !== false;
         return {
             plugin: this.name,
             type: data.type,
@@ -60,6 +58,30 @@ export class Plugin {
             allowMultiple
         };
     }
+    async match(data) {
+        const { resource: resourceConfig, array } = data;
+        const resource = this.resourceControllers.get(resourceConfig.core.type);
+        if (!resource) {
+            throw new Error(`Resource of type ${resourceConfig.core.type} could not be found for match`);
+        }
+        if (!resource.settings.allowMultiple) {
+            return { match: array.find((r) => r.core.type === resourceConfig.core.type) };
+        }
+        const parameterMatcher = resource?.parsedSettings.matcher;
+        const match = array.find((r) => {
+            if (resourceConfig.core.type !== r.core.type) {
+                return false;
+            }
+            // If the user specifies the same name for the resource and it's not auto-generated (a number) then it's the same resource
+            if (resourceConfig.core.name === r.core.name
+                && resourceConfig.core.name
+                && Number.isInteger(Number.parseInt(resourceConfig.core.name, 10))) {
+                return true;
+            }
+            return parameterMatcher(resourceConfig.parameters, r.parameters);
+        });
+        return { match };
+    }
     async import(data) {
         const { core, parameters } = data;
         if (!this.resourceControllers.has(core.type)) {

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

@@ -20,7 +20,7 @@ export declare class ParsedResourceSettings<T extends StringIndexedObject> imple
     id: string;
     schema?: Partial<JSONSchemaType<T | any>>;
     allowMultiple?: {
-        matcher?: (desired: Partial<T>, current: Partial<T>[]) => Partial<T>;
+        matcher?: (desired: Partial<T>, current: Partial<T>) => boolean;
         requiredParameters?: string[];
     } | boolean;
     removeStatefulParametersBeforeDestroy?: boolean | undefined;
@@ -34,6 +34,7 @@ export declare class ParsedResourceSettings<T extends StringIndexedObject> imple
     get defaultValues(): Partial<Record<keyof T, unknown>>;
     get inputTransformations(): Partial<Record<keyof T, InputTransformation>>;
     get statefulParameterOrder(): Map<keyof T, number>;
+    get matcher(): (desired: Partial<T>, current: Partial<T>) => boolean;
     private validateSettings;
     private validateParameterEqualsFn;
     private getFromCacheOrCreate;

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

@@ -1,5 +1,5 @@
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
-import { resolveElementEqualsFn, resolveEqualsFn, resolveParameterTransformFn } from './resource-settings.js';
+import { resolveElementEqualsFn, resolveEqualsFn, resolveMatcher, resolveParameterTransformFn } from './resource-settings.js';
 export class ParsedResourceSettings {
     cache = new Map();
     id;
@@ -45,7 +45,6 @@ export class ParsedResourceSettings {
                         ...v,
                         controller: spController,
                         nestedSettings: spController?.parsedSettings,
-                        definition: undefined,
                     };
                     return [k, parsed];
                 }
@@ -101,6 +100,9 @@ export class ParsedResourceSettings {
             return new Map(resultArray.map((key, idx) => [key, idx]));
         });
     }
+    get matcher() {
+        return resolveMatcher(this);
+    }
     validateSettings() {
         // validate parameter settings
         if (this.settings.parameterSettings) {
@@ -111,10 +113,10 @@ export class ParsedResourceSettings {
                 this.validateParameterEqualsFn(v, k);
             }
         }
-        if (this.allowMultiple
-            && Object.values(this.parameterSettings).some((v) => v.type === 'stateful')) {
-            throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed if multiples of a resource exist`);
-        }
+        // if (this.allowMultiple
+        //   && Object.values(this.parameterSettings).some((v) => v.type === 'stateful')) {
+        //   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.importAndDestroy && (schema?.oneOf
             && Array.isArray(schema.oneOf)

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

@@ -42,7 +42,7 @@ 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>) => boolean;
     } | boolean;
     /**
      * If true, {@link StatefulParameter} remove() will be called before resource destruction. This is useful
@@ -255,3 +255,4 @@ export declare function resolveEqualsFn(parameter: ParameterSetting): (desired:
 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): InputTransformation | undefined;
+export declare function resolveMatcher<T extends StringIndexedObject>(settings: ResourceSettings<T>): (desired: Partial<T>, current: Partial<T>) => boolean;

package/dist/resource/resource-settings.js

@@ -85,3 +85,37 @@ export function resolveParameterTransformFn(parameter) {
     }
     return parameter.transformation ?? ParameterTransformationDefaults[parameter.type] ?? undefined;
 }
+export function resolveMatcher(settings) {
+    return typeof settings.allowMultiple === 'boolean' || !settings.allowMultiple?.matcher
+        ? ((desired, current) => {
+            if (!desired || !current) {
+                return false;
+            }
+            if (!settings.allowMultiple) {
+                throw new Error(`Matching only works when allow multiple is enabled. Type: ${settings.id}`);
+            }
+            const requiredParameters = typeof settings.allowMultiple === 'object'
+                ? settings.allowMultiple?.identifyingParameters ?? settings.schema?.required ?? []
+                : settings.schema?.required ?? [];
+            return requiredParameters.every((key) => {
+                const currentParameter = current[key];
+                const desiredParameter = desired[key];
+                // If both desired and current don't have a certain parameter then we assume they are the same
+                if (!currentParameter && !desiredParameter) {
+                    return true;
+                }
+                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;
+                }
+                const parameterSetting = settings.parameterSettings?.[key];
+                const isEq = parameterSetting ? resolveEqualsFn(parameterSetting) : null;
+                return isEq?.(desiredParameter, currentParameter) ?? currentParameter === desiredParameter;
+            });
+        })
+        : settings.allowMultiple.matcher;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.144",
+  "version": "1.0.146",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -16,7 +16,7 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "codify-schemas": "1.0.70",
+    "codify-schemas": "1.0.73",
     "@npmcli/promise-spawn": "^7.0.1",
     "@homebridge/node-pty-prebuilt-multiarch": "^0.12.0-beta.5",
     "uuid": "^10.0.0",

package/src/messages/handlers.ts

@@ -13,6 +13,8 @@ import {
   IpcMessageSchema,
   IpcMessageV2,
   IpcMessageV2Schema,
+  MatchRequestDataSchema,
+  MatchResponseDataSchema,
   MessageStatus,
   PlanRequestDataSchema,
   PlanResponseDataSchema,
@@ -40,6 +42,11 @@ const SupportedRequests: Record<string, { handler: (plugin: Plugin, data: any) =
     requestValidator: GetResourceInfoRequestDataSchema,
     responseValidator: GetResourceInfoResponseDataSchema
   },
+  'match': {
+    handler: async (plugin: Plugin, data: any) => plugin.match(data),
+    requestValidator: MatchRequestDataSchema,
+    responseValidator: MatchResponseDataSchema
+  },
   'import': {
     handler: async (plugin: Plugin, data: any) => plugin.import(data),
     requestValidator: ImportRequestDataSchema,

package/src/plan/plan.ts

@@ -241,7 +241,7 @@ export class Plan<T extends StringIndexedObject> {
     desired: Partial<T> | null,
     currentArray: Partial<T>[] | null,
     state: Partial<T> | null,
-    settings: ResourceSettings<T>,
+    settings: ParsedResourceSettings<T>,
     isStateful: boolean,
   }): Partial<T> | null {
     const {
@@ -260,36 +260,15 @@ 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?.identifyingParameters ?? (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`);
-        }
+    const { matcher: parameterMatcher, id } = settings;
+    const matcher = (desired: Partial<T>, currentArray: Partial<T>[]): Partial<T> | undefined => {
+      const matched = currentArray.filter((c) => parameterMatcher(desired, c))
+      if (matched.length > 0) {
+        console.log(`Resource: ${id} did not uniquely match resources when allow multiple is set to true`)
+      }
 
-        return matched[0];
-      })
-      : settings.allowMultiple.matcher
+      return matched[0];
+    }
 
     if (isStateful) {
       return state

package/src/plugin/plugin.test.ts

@@ -5,7 +5,7 @@ import { Resource } from '../resource/resource.js';
 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 { TestConfig, TestStatefulParameter } from '../utils/test-utils.test.js';
 import { getPty } from '../pty/index.js';
 
 interface TestConfig extends StringIndexedObject {
@@ -343,27 +343,109 @@ describe('Plugin tests', () => {
       type: 'testResource',
     })
 
-    expect(resourceInfo.allowMultiple?.requiredParameters).toMatchObject([
-      'path', 'paths'
-    ])
+    expect(resourceInfo.allowMultiple).to.be.true;
   })
 
-  it('Returns an empty array by default for allowMultiple for getResourceInfo', async () => {
+  it('Can match resources together', async () => {
     const resource = spy(new class extends TestResource {
       getSettings(): ResourceSettings<TestConfig> {
         return {
           ...super.getSettings(),
-          allowMultiple: true
+          parameterSettings: {
+            path: { type: 'directory' },
+            paths: { type: 'array', itemType: 'directory' }
+          },
+          allowMultiple: {
+            identifyingParameters: ['path', 'paths']
+          }
         }
       }
     })
 
     const testPlugin = Plugin.create('testPlugin', [resource as any]);
 
-    const resourceInfo = await testPlugin.getResourceInfo({
-      type: 'testResource',
+    const { match } = await testPlugin.match({
+      resource: {
+        core: { type: 'testResource' },
+        parameters: { path: '/my/path', propA: 'abc' },
+      },
+      array: [
+        {
+          core: { type: 'testResource' },
+          parameters: { path: '/my/other/path', propA: 'abc' },
+        },
+        {
+          core: { type: 'testResource' },
+          parameters: { paths: ['/my/path'], propA: 'def' },
+        },
+        {
+          core: { type: 'testResource' },
+          parameters: { path: '/my/path', propA: 'hig' },
+        },
+      ]
+    })
+    expect(match).toMatchObject({
+      core: { type: 'testResource' },
+      parameters: { path: '/my/path', propA: 'hig' },
+    })
+
+    const match2 = await testPlugin.match({
+      resource: {
+        core: { type: 'testResource' },
+        parameters: { path: '/my/path', propA: 'abc' },
+      },
+      array: []
+    })
+
+    expect(match2).toMatchObject({
+      match: undefined,
+    })
+  })
+
+  it('Can match resources together 2', { timeout: 3000000 }, async () => {
+    const resource = spy(new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'ssh-config',
+          parameterSettings: {
+            hosts: { type: 'stateful', definition: new TestStatefulParameter() }
+          },
+          importAndDestroy: {
+            refreshKeys: ['hosts'],
+            defaultRefreshValues: { hosts: [] },
+            requiredParameters: []
+          },
+          dependencies: ['ssh-key'],
+          allowMultiple: {
+            matcher: (a, b) => a.hosts === b.hosts
+          }
+        }
+      }
+    })
+
+    const testPlugin = Plugin.create('testPlugin', [resource as any]);
+
+    const { match } = await testPlugin.match({
+      resource: {
+        core: { type: 'ssh-config' },
+        parameters: { hosts: 'a' },
+      },
+      array: [
+        {
+          core: { type: 'ssh-config' },
+          parameters: { hosts: 'b' },
+        },
+        {
+          core: { type: 'ssh-config' },
+          parameters: { hosts: 'a' },
+        },
+        {
+          core: { type: 'ssh-config' },
+          parameters: { hosts: 'c' },
+        },
+      ]
     })
 
-    expect(resourceInfo.allowMultiple?.requiredParameters).toMatchObject([])
+    console.log(match)
   })
 });

package/src/plugin/plugin.ts

@@ -6,6 +6,8 @@ import {
   ImportRequestData,
   ImportResponseData,
   InitializeResponseData,
+  MatchRequestData,
+  MatchResponseData,
   PlanRequestData,
   PlanResponseData,
   ResourceConfig,
@@ -73,10 +75,7 @@ export class Plugin {
     ) as any;
 
     const allowMultiple = resource.settings.allowMultiple !== undefined
-      ? (typeof resource.settings.allowMultiple === 'boolean'
-          ? { identifyingParameters: schema?.required ?? [] }
-          : { identifyingParameters: resource.settings.allowMultiple.identifyingParameters ?? schema?.required ?? [] }
-      ) : undefined
+      && resource.settings.allowMultiple !== false;
 
     return {
       plugin: this.name,
@@ -94,6 +93,38 @@ export class Plugin {
     }
   }
 
+  async match(data: MatchRequestData): Promise<MatchResponseData> {
+    const { resource: resourceConfig, array } = data;
+
+    const resource = this.resourceControllers.get(resourceConfig.core.type);
+    if (!resource) {
+      throw new Error(`Resource of type ${resourceConfig.core.type} could not be found for match`);
+    }
+
+    if (!resource.settings.allowMultiple) {
+      return { match: array.find((r) => r.core.type === resourceConfig.core.type) }
+    }
+
+    const parameterMatcher = resource?.parsedSettings.matcher;
+    const match = array.find((r) => {
+      if (resourceConfig.core.type !== r.core.type) {
+        return false;
+      }
+
+      // If the user specifies the same name for the resource and it's not auto-generated (a number) then it's the same resource
+      if (resourceConfig.core.name === r.core.name
+        && resourceConfig.core.name
+        && Number.isInteger(Number.parseInt(resourceConfig.core.name, 10))
+      ) {
+        return true;
+      }
+
+      return parameterMatcher(resourceConfig.parameters, r.parameters);
+    });
+
+    return { match }
+  }
+
   async import(data: ImportRequestData): Promise<ImportResponseData> {
     const { core, parameters } = data;
 

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

@@ -9,6 +9,7 @@ import {
   ParameterSetting,
   resolveElementEqualsFn,
   resolveEqualsFn,
+  resolveMatcher,
   resolveParameterTransformFn,
   ResourceSettings,
   StatefulParameterSetting
@@ -38,7 +39,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
   id!: string;
   schema?: Partial<JSONSchemaType<T | any>>;
   allowMultiple?: {
-    matcher?: (desired: Partial<T>, current: Partial<T>[]) => Partial<T>;
+    matcher?: (desired: Partial<T>, current: Partial<T>) => boolean;
     requiredParameters?: string[]
   } | boolean;
 
@@ -91,7 +92,6 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
               ...v,
               controller: spController,
               nestedSettings: spController?.parsedSettings,
-              definition: undefined,
             };
 
             return [k, parsed as ParsedStatefulParameterSetting];
@@ -172,6 +172,10 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
     });
   }
 
+  get matcher(): (desired: Partial<T>, current: Partial<T>) => boolean {
+    return resolveMatcher(this);
+  }
+
   private validateSettings(): void {
     // validate parameter settings
     if (this.settings.parameterSettings) {
@@ -184,10 +188,10 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
       }
     }
 
-    if (this.allowMultiple
-      && Object.values(this.parameterSettings).some((v) => v.type === 'stateful')) {
-      throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed if multiples of a resource exist`)
-    }
+    // if (this.allowMultiple
+    //   && Object.values(this.parameterSettings).some((v) => v.type === 'stateful')) {
+    //   throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed if multiples of a resource exist`)
+    // }
 
     const schema = this.settings.schema as JSONSchemaType<any>;
     if (!this.settings.importAndDestroy && (schema?.oneOf

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

@@ -1054,4 +1054,69 @@ describe('Resource parameter tests', () => {
       operation: ResourceOperation.NOOP,
     })
   })
+
+  it('Supports matching using the identfying parameters', 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' }
+          },
+          allowMultiple: {
+            identifyingParameters: ['propA']
+          }
+        }
+      }
+    };
+
+    const controller = new ResourceController(resource);
+    expect(controller.parsedSettings.matcher({
+      propA: [testPath],
+      propB: 'random1',
+    }, {
+      propA: [testPath],
+      propB: 'random2',
+    })).to.be.true;
+
+    expect(controller.parsedSettings.matcher({
+      propA: [testPath],
+      propB: 'random1',
+    }, {
+      propA: [testPath, testPath],
+      propB: 'random2',
+    })).to.be.false;
+  })
+
+  it('Supports matching using custom matcher', 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' }
+          },
+          allowMultiple: {
+            identifyingParameters: ['propA'],
+            matcher: () => false,
+          }
+        }
+      }
+    };
+
+    const controller = new ResourceController(resource);
+    expect(controller.parsedSettings.matcher({
+      propA: [testPath],
+      propB: 'random1',
+    }, {
+      propA: [testPath],
+      propB: 'random2',
+    })).to.be.false;
+  })
 })

package/src/resource/resource-settings.ts

@@ -53,7 +53,7 @@ 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>) => boolean
   } | boolean
 
   /**
@@ -408,3 +408,47 @@ export function resolveParameterTransformFn(
 
   return parameter.transformation ?? ParameterTransformationDefaults[parameter.type as ParameterSettingType] ?? undefined;
 }
+
+export function resolveMatcher<T extends StringIndexedObject>(
+  settings: ResourceSettings<T>
+): (desired: Partial<T>, current: Partial<T>) => boolean {
+  return typeof settings.allowMultiple === 'boolean' || !settings.allowMultiple?.matcher
+    ? ((desired: Partial<T>, current: Partial<T>) => {
+      if (!desired || !current) {
+        return false;
+      }
+
+      if (!settings.allowMultiple) {
+        throw new Error(`Matching only works when allow multiple is enabled. Type: ${settings.id}`)
+      }
+
+      const requiredParameters = typeof settings.allowMultiple === 'object'
+        ? settings.allowMultiple?.identifyingParameters ?? (settings.schema?.required as string[]) ?? []
+        : (settings.schema?.required as string[]) ?? []
+
+      return requiredParameters.every((key) => {
+        const currentParameter = current[key];
+        const desiredParameter = desired[key];
+
+        // If both desired and current don't have a certain parameter then we assume they are the same
+        if (!currentParameter && !desiredParameter) {
+          return true;
+        }
+
+        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;
+        }
+
+        const parameterSetting = settings.parameterSettings?.[key];
+        const isEq = parameterSetting ? resolveEqualsFn(parameterSetting) : null
+        return isEq?.(desiredParameter, currentParameter) ?? currentParameter === desiredParameter;
+      })
+    })
+    : settings.allowMultiple.matcher
+}