feat: Added matcher request to match multiple requests together

Author: kevinwang5658

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.142",
+  "version": "1.0.145",
   "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.json

@@ -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,
@@ -106,7 +113,7 @@ export class MessageHandler {
 
       const responseValidator = this.responseValidators.get(message.cmd);
       if (responseValidator && !responseValidator(result)) {
-        throw new Error(`Plugin: ${this.plugin}. Malformed response data: ${JSON.stringify(responseValidator.errors, null, 2)}`)
+        throw new Error(`Plugin: ${this.plugin.name}. Malformed response data: ${JSON.stringify(responseValidator.errors, null, 2)}. Received ${JSON.stringify(result, null, 2)}`);
       }
 
       process.send!({

src/messages/handlers.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

src/plan/plan.ts

@@ -343,27 +343,51 @@ 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' },
     })
 
-    expect(resourceInfo.allowMultiple?.requiredParameters).toMatchObject([])
   })
 });

src/plugin/plugin.test.ts

@@ -6,6 +6,8 @@ import {
   ImportRequestData,
   ImportResponseData,
   InitializeResponseData,
+  MatchRequestData,
+  MatchResponseData,
   PlanRequestData,
   PlanResponseData,
   ResourceConfig,
@@ -69,14 +71,11 @@ export class Plugin {
     const requiredPropertyNames = (
       resource.settings.importAndDestroy?.requiredParameters
       ?? schema?.required
-      ?? null
-    ) as null | string[];
+      ?? undefined
+    ) 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,34 @@ 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`);
+    }
+
+    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;
 

src/plugin/plugin.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;
 
@@ -172,6 +173,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) {

src/resource/parsed-resource-settings.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;
+  })
 })