feat: Added itemType parameter, it's like type but for items of arrays (sets default transformation and isElementEqual fns)

Author: kevinwang5658

package.json

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

src/plan/plan.ts

@@ -384,15 +384,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 +413,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,

src/plugin/plugin.test.ts

@@ -194,7 +194,7 @@ describe('Plugin tests', () => {
         return {
           id: 'typeId',
           schema,
-          import: {
+          importAndDestroy: {
             requiredParameters: []
           }
         }

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[];

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'
         }

src/resource/parsed-resource-settings.ts

@@ -6,8 +6,8 @@ import {
   ArrayParameterSetting,
   DefaultParameterSetting,
   ParameterSetting,
+  resolveElementEqualsFn,
   resolveEqualsFn,
-  resolveFnFromEqualsFnOrString,
   resolveParameterTransformFn,
   ResourceSettings,
   StatefulParameterSetting
@@ -95,8 +95,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];
@@ -186,7 +185,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 +213,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(

src/resource/resource-controller.ts

@@ -158,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()}`);
@@ -191,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,
       };
 

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: {
@@ -969,4 +969,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,
+    })
+  })
 })

src/resource/resource-settings.ts

@@ -67,9 +67,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
@@ -85,7 +85,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
@@ -96,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>>;
 
@@ -107,14 +107,14 @@ 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>
   }
@@ -233,6 +233,12 @@ 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,
 }
 
 /**
@@ -273,10 +279,7 @@ export function resolveEqualsFn(parameter: ParameterSetting): (desired: unknown,
   const isEqual = resolveFnFromEqualsFnOrString(parameter.isEqual);
 
   if (parameter.type === 'array') {
-    const arrayParameter = parameter as ArrayParameterSetting;
-    const isElementEqual = resolveFnFromEqualsFnOrString(arrayParameter.isElementEqual);
-
-    return isEqual ?? areArraysEqual.bind(areArraysEqual, isElementEqual)
+    return isEqual ?? areArraysEqual.bind(areArraysEqual, resolveElementEqualsFn(parameter as ArrayParameterSetting))
   }
 
   if (parameter.type === 'stateful') {
@@ -286,6 +289,21 @@ export function resolveEqualsFn(parameter: ParameterSetting): (desired: unknown,
   return isEqual ?? ParameterEqualsDefaults[parameter.type as ParameterSettingType] ?? (((a, b) => a === b));
 }
 
+export function resolveElementEqualsFn(parameter: ArrayParameterSetting): (desired: unknown, current: unknown) => boolean {
+  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(
@@ -312,10 +330,26 @@ const ParameterTransformationDefaults: Partial<Record<ParameterSettingType, (inp
       : a;
   },
   'string': String,
+  // TODO: Add a array parameter itemType parameter
+  // 'array': (arr: unknown[]) => arr.map((i) => (parameter as ArrayParameterSetting).itemType ? ParameterTransformationDefaults[])
 }
 
 export function resolveParameterTransformFn(
   parameter: ParameterSetting
 ): ((input: any, parameter: ParameterSetting) => Promise<any> | any) | undefined {
+
+  if (parameter.type === 'array'
+    && (parameter as ArrayParameterSetting).itemType
+    && ParameterTransformationDefaults[(parameter as ArrayParameterSetting).itemType!]
+    && !parameter.inputTransformation
+  ) {
+    const itemType = (parameter as ArrayParameterSetting).itemType!;
+    const itemTransformation = ParameterTransformationDefaults[itemType]!;
+
+    return (input: unknown[], parameter) => {
+      return input.map((i) => itemTransformation(i, parameter))
+    }
+  }
+
   return parameter.inputTransformation ?? ParameterTransformationDefaults[parameter.type as ParameterSettingType] ?? undefined;
 }