codify-plugin-lib 1.0.131 → 1.0.133

package/src/resource/resource-settings.ts

@@ -1,9 +1,15 @@
+import { JSONSchemaType } from 'ajv';
 import { StringIndexedObject } from 'codify-schemas';
 import isObjectsEqual from 'lodash.isequal'
 import path from 'node:path';
 
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
-import { areArraysEqual, untildify } from '../utils/utils.js';
+import { areArraysEqual, tildify, untildify } from '../utils/utils.js';
+
+export interface InputTransformation {
+  to: (input: any) => Promise<any> | any;
+  from: (current: any) => Promise<any> | any;
+}
 
 /**
  * The configuration and settings for a resource.
@@ -18,7 +24,7 @@ export interface ResourceSettings<T extends StringIndexedObject> {
   /**
    * Schema to validate user configs with. Must be in the format JSON Schema draft07
    */
-  schema?: unknown;
+  schema?: JSONSchemaType<T | any>;
 
   /**
    * Allow multiple of the same resource to unique. Set truthy if
@@ -27,6 +33,17 @@ export interface ResourceSettings<T extends StringIndexedObject> {
    */
   allowMultiple?: {
 
+    /**
+     * A set of parameters that uniquely identifies a resource. The value of these parameters is used to determine which
+     * resource is which when multiple can exist at the same time. Defaults to the required parameters inside the json
+     * schema.
+     *
+     * For example:
+     * If paramA is required, then if resource1.paramA === resource2.paramA then are the same resource.
+     * If resource1.paramA !== resource1.paramA, then they are different.
+     */
+    requiredParameters?: string[]
+
     /**
      * If multiple copies are allowed then a matcher must be defined to match the desired
      * config with one of the resources currently existing on the system. Return null if there is no match.
@@ -36,8 +53,8 @@ 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>[],) => Partial<T>
+  } | boolean
 
   /**
    * If true, {@link StatefulParameter} remove() will be called before resource destruction. This is useful
@@ -67,9 +84,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 +102,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 +113,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 +124,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>
   }
@@ -166,12 +183,13 @@ export interface DefaultParameterSetting {
   default?: unknown;
 
   /**
-   * A transformation of the input value for this parameter. This transformation is only applied to the desired parameter
-   * value supplied by the user.
+   * A transformation of the input value for this parameter. Two transformations need to be provided: to (from desired to
+   * the internal type), and from (from the internal type back to desired). All transformations need to be bi-directional
+   * to support imports properly
    *
    * @param input The original parameter value from the desired config.
    */
-  inputTransformation?: (input: any) => Promise<any> | any;
+  inputTransformation?: InputTransformation;
 
   /**
    * Customize the equality comparison for a parameter. This is used in the diffing algorithm for generating the plan.
@@ -233,6 +251,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 +297,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 +307,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(
@@ -303,19 +339,47 @@ export function resolveFnFromEqualsFnOrString(
   return fnOrString as ((a: unknown, b: unknown) => boolean) | undefined;
 }
 
-const ParameterTransformationDefaults: Partial<Record<ParameterSettingType, (input: any, parameter: ParameterSetting) => Promise<any> | any>> = {
-  'directory': (a: unknown) => path.resolve(untildify(String(a))),
-  'stateful': (a: unknown, b: ParameterSetting) => {
-    const sp = b as StatefulParameterSetting;
-    return (sp.definition?.getSettings()?.inputTransformation)
-      ? (sp.definition.getSettings().inputTransformation!(a))
-      : a;
+const ParameterTransformationDefaults: Partial<Record<ParameterSettingType, InputTransformation>> = {
+  'directory': {
+    to: (a: unknown) => path.resolve(untildify(String(a))),
+    from: (a: unknown) => tildify(String(a)),
   },
-  'string': String,
+  'string': {
+    to: String,
+    from: String,
+  }
 }
 
 export function resolveParameterTransformFn(
   parameter: ParameterSetting
-): ((input: any, parameter: ParameterSetting) => Promise<any> | any) | undefined {
+): InputTransformation | undefined {
+
+  if (parameter.type === 'stateful' && !parameter.inputTransformation) {
+    const sp = (parameter as StatefulParameterSetting).definition.getSettings();
+    if (sp.inputTransformation) {
+      return (parameter as StatefulParameterSetting).definition?.getSettings()?.inputTransformation
+    }
+
+    return sp.type ? ParameterTransformationDefaults[sp.type] : 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 {
+      to(input: unknown[]) {
+        return input.map((i) => itemTransformation.to(i))
+      },
+      from(input: unknown[]) {
+        return input.map((i) => itemTransformation.from(i))
+      }
+    }
+  }
+
   return parameter.inputTransformation ?? ParameterTransformationDefaults[parameter.type as ParameterSettingType] ?? undefined;
 }

package/src/stateful-parameter/stateful-parameter-controller.ts

@@ -5,8 +5,8 @@ import { ParsedArrayParameterSetting, ParsedParameterSetting, } from '../resourc
 import {
   ArrayParameterSetting,
   ParameterSetting,
+  resolveElementEqualsFn,
   resolveEqualsFn,
-  resolveFnFromEqualsFnOrString
 } from '../resource/resource-settings.js';
 import { ArrayStatefulParameter, StatefulParameter } from './stateful-parameter.js';
 
@@ -31,8 +31,7 @@ export class StatefulParameterController<T extends StringIndexedObject, V extend
     this.parsedSettings = (this.isArrayStatefulParameter || this.settings.type === 'array') ? {
       ...this.settings,
       isEqual: resolveEqualsFn(this.settings),
-      isElementEqual: resolveFnFromEqualsFnOrString((this.settings as ArrayParameterSetting).isElementEqual)
-        ?? ((a: unknown, b: unknown) => a === b)
+      isElementEqual: resolveElementEqualsFn(this.settings as ArrayParameterSetting)
     } as ParsedParameterSetting : {
       ...this.settings,
       isEqual: resolveEqualsFn(this.settings),

package/src/utils/test-utils.test.ts

@@ -5,6 +5,7 @@ import { Resource } from '../resource/resource.js';
 import { CreatePlan, DestroyPlan } from '../plan/plan-types.js';
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
 import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
+import { describe, it } from 'vitest';
 
 export function testPlan<T extends StringIndexedObject>(params: {
   desired?: Partial<T> | null;
@@ -85,3 +86,8 @@ export class TestArrayStatefulParameter extends ArrayStatefulParameter<TestConfi
     return Promise.resolve(undefined);
   }
 }
+
+describe('Empty tests', () => {
+  it('empty', () => {
+  })
+})

package/src/utils/utils.ts

@@ -33,6 +33,10 @@ export function untildify(pathWithTilde: string) {
   return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
 }
 
+export function tildify(pathWithTilde: string) {
+  return homeDirectory ? pathWithTilde.replace(homeDirectory, '~') : pathWithTilde;
+}
+
 export function areArraysEqual(
   isElementEqual: ((desired: unknown, current: unknown) => boolean) | undefined,
   desired: unknown,

package/vitest.config.ts

@@ -2,10 +2,9 @@ import { defaultExclude, defineConfig } from 'vitest/config';
 
 export default defineConfig({
   test: {
+    pool: 'forks',
     exclude: [
-      ...defaultExclude,
-      './src/utils/test-utils.test.ts',
-      './src/pty/*'
+      ...defaultExclude
     ]
   },
 });

package/src/pty/vitest.config.ts

@@ -1,11 +0,0 @@
-import { defaultExclude, defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    pool: 'forks',
-    fileParallelism: false,
-    exclude: [
-      ...defaultExclude,
-    ]
-  },
-});