codify-plugin-lib 1.0.131 → 1.0.133

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;
   })
 
@@ -280,4 +279,49 @@ describe('Plugin tests', () => {
     await testPlugin.apply({ plan })
     expect(resource.refresh.calledOnce).to.be.true;
   })
+
+  it('Maintains types for validate', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          schema: {
+            '$schema': 'http://json-schema.org/draft-07/schema',
+            '$id': 'https://www.codifycli.com/ssh-config.json',
+            'type': 'object',
+            'properties': {
+              'hosts': {
+                'description': 'The host blocks inside of the ~/.ssh/config file. See http://man.openbsd.org/OpenBSD-current/man5/ssh_config.5 ',
+                'type': 'array',
+                'items': {
+                  'type': 'object',
+                  'description': 'The individual host blocks inside of the ~/.ssh/config file',
+                  'properties': {
+                    'UseKeychain': {
+                      'type': 'boolean',
+                      'description': 'A UseKeychain option was introduced in macOS Sierra allowing users to specify whether they would like for the passphrase to be stored in the keychain'
+                    },
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+    }
+
+    const plugin = Plugin.create('testPlugin', [resource as any]);
+    const result = await plugin.validate({
+      configs: [{
+        core: { type: 'type' },
+        parameters: {
+          hosts: [{
+            UseKeychain: true,
+          }]
+        }
+      }]
+    })
+
+    console.log(result);
+  })
 });

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/pty/background-pty.test.ts

@@ -18,21 +18,22 @@ describe('BackgroundPty tests', () => {
     });
   })
 
-  it('Can launch 100 commands in parallel', { timeout: 15000 }, async () => {
-    const pty = new BackgroundPty();
-
-    const fn = async () => pty.spawnSafe('ls');
-
-    const results = await Promise.all(
-      Array.from({ length: 100 }, (_, i) => i + 1)
-        .map(() => fn())
-    )
-
-    expect(results.length).to.eq(100);
-    expect(results.every((r) => r.exitCode === 0))
-
-    await pty.kill();
-  })
+  // This test takes forever so going to disable for now.
+  // it('Can launch 100 commands in parallel', { timeout: 15000 }, async () => {
+  //   const pty = new BackgroundPty();
+  //
+  //   const fn = async () => pty.spawnSafe('ls');
+  //
+  //   const results = await Promise.all(
+  //     Array.from({ length: 100 }, (_, i) => i + 1)
+  //       .map(() => fn())
+  //   )
+  //
+  //   expect(results.length).to.eq(100);
+  //   expect(results.every((r) => r.exitCode === 0))
+  //
+  //   await pty.kill();
+  // })
 
   it('Reports back the correct exit code and status', async () => {
     const pty = new BackgroundPty();

package/src/pty/index.test.ts

@@ -25,9 +25,8 @@ describe('General tests for PTYs', () => {
 
     const plugin = Plugin.create('test plugin', [testResource])
     const plan = await plugin.plan({
-      desired: {
-        type: 'type'
-      },
+      core: { type: 'type' },
+      desired: {},
       state: undefined,
       isStateful: false,
     })
@@ -84,17 +83,15 @@ describe('General tests for PTYs', () => {
 
     const plugin = Plugin.create('test plugin', [testResource1, testResource2]);
     await plugin.plan({
-      desired: {
-        type: 'type1'
-      },
+      core: { type: 'type1' },
+      desired: {},
       state: undefined,
       isStateful: false,
     })
 
     await plugin.plan({
-      desired: {
-        type: 'type2'
-      },
+      core: { type: 'type2' },
+      desired: {},
       state: undefined,
       isStateful: false,
     })

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

@@ -57,12 +57,13 @@ export class ResourceController<T extends StringIndexedObject> {
     core: ResourceConfig,
     parameters: Partial<T>,
   ): Promise<ValidateResponseData['resourceValidations'][0]> {
+    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 {
@@ -157,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()}`);
@@ -190,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,
+    })
+  })
 })