feat: Bug fixes and improvements

Author: kevinwang5658

package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.145",
+  "version": "1.0.147",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

src/plan/plan.ts

@@ -229,56 +229,6 @@ export class Plan<T extends StringIndexedObject> {
     return this.coreParameters.type
   }
 
-  /**
-   * When multiples of the same resource are allowed, this matching function will match a given config with one of the
-   * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
-   * the application name and location to match it to our desired configs name and location.
-   *
-   * @param params
-   * @private
-   */
-  private static matchCurrentParameters<T extends StringIndexedObject>(params: {
-    desired: Partial<T> | null,
-    currentArray: Partial<T>[] | null,
-    state: Partial<T> | null,
-    settings: ParsedResourceSettings<T>,
-    isStateful: boolean,
-  }): Partial<T> | null {
-    const {
-      desired,
-      currentArray,
-      state,
-      settings,
-      isStateful
-    } = params;
-
-    if (!settings.allowMultiple) {
-      return currentArray?.[0] ?? null;
-    }
-
-    if (!currentArray) {
-      return null;
-    }
-
-    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];
-    }
-
-    if (isStateful) {
-      return state
-        ? matcher(state, currentArray) ?? null
-        : null
-    }
-
-    return matcher(desired!, currentArray) ?? null;
-  }
-
   /**
    *  Only keep relevant params for the plan. We don't want to change settings that were not already
    *  defined.

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 {
@@ -389,5 +389,63 @@ describe('Plugin tests', () => {
       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' },
+        },
+      ]
+    })
+
+    console.log(match)
   })
 });

src/plugin/plugin.ts

@@ -101,6 +101,10 @@ export class Plugin {
       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) {

src/resource/parsed-resource-settings.ts

@@ -92,7 +92,6 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
               ...v,
               controller: spController,
               nestedSettings: spController?.parsedSettings,
-              definition: undefined,
             };
 
             return [k, parsed as ParsedStatefulParameterSetting];

src/resource/resource-controller.ts

@@ -252,6 +252,11 @@ export class ResourceController<T extends StringIndexedObject> {
       || this.settings.allowMultiple // Stateful parameters are not supported currently if allowMultiple is true
       || currentParametersArray.filter(Boolean).length === 0
     ) {
+      for (const result of currentParametersArray ?? []) {
+        await this.applyTransformParameters(result, true);
+        this.removeDefaultValues(result, parameters)
+      }
+
       return currentParametersArray
           ?.map((r) => ({ core, parameters: r }))
         ?? null;
@@ -456,5 +461,39 @@ ${JSON.stringify(refresh, null, 2)}
       ? Object.keys((this.settings.schema as any)?.properties)
       : Object.keys(this.parsedSettings.parameterSettings);
   }
+
+  /**
+   * When multiples of the same resource are allowed, this matching function will match a given config with one of the
+   * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
+   * the application name and location to match it to our desired configs name and location.
+   *
+   * @param params
+   * @private
+   */
+  private matchParameters(
+    desired: Partial<T> | null,
+    currentArray: Partial<T>[] | null
+  ): Partial<T> | null {
+    if (!this.parsedSettings.allowMultiple) {
+      return currentArray?.[0] ?? null;
+    }
+
+    if (!currentArray) {
+      return null;
+    }
+
+    const { matcher: parameterMatcher, id } = this.parsedSettings;
+    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];
+    }
+
+    return matcher(desired!, currentArray) ?? null;
+  }
+
 }
 

src/resource/resource-settings.ts

@@ -412,13 +412,16 @@ export function resolveParameterTransformFn(
 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[]) ?? []