codify-plugin-lib 1.0.94 → 1.0.96

package/dist/plan/change-set.js

@@ -81,46 +81,39 @@ export class ChangeSet {
         // Filter out null and undefined values or else the diff below will not work
         const desired = Object.fromEntries(Object.entries(desiredParameters).filter(([, v]) => v !== null && v !== undefined));
         const current = Object.fromEntries(Object.entries(currentParameters).filter(([, v]) => v !== null && v !== undefined));
-        for (const [k, v] of Object.entries(current)) {
-            if (desired?.[k] === null || desired?.[k] === undefined) {
+        for (const k of new Set([...Object.keys(current), ...Object.keys(desired)])) {
+            if (ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
                 parameterChangeSet.push({
                     name: k,
-                    previousValue: v ?? null,
+                    previousValue: current[k] ?? null,
+                    newValue: desired[k] ?? null,
+                    operation: ParameterOperation.NOOP,
+                });
+                continue;
+            }
+            if ((desired?.[k] === null || desired?.[k] === undefined) && (current?.[k] !== null && current?.[k] !== undefined)) {
+                parameterChangeSet.push({
+                    name: k,
+                    previousValue: current[k] ?? null,
                     newValue: null,
                     operation: ParameterOperation.REMOVE,
                 });
-                delete current[k];
                 continue;
             }
-            if (!ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
+            if ((current?.[k] === null || current?.[k] === undefined) && (desired?.[k] !== null && desired?.[k] !== undefined)) {
                 parameterChangeSet.push({
                     name: k,
-                    previousValue: v ?? null,
+                    previousValue: null,
                     newValue: desired[k] ?? null,
-                    operation: ParameterOperation.MODIFY,
+                    operation: ParameterOperation.ADD,
                 });
-                delete current[k];
-                delete desired[k];
                 continue;
             }
             parameterChangeSet.push({
                 name: k,
-                previousValue: v ?? null,
+                previousValue: current[k] ?? null,
                 newValue: desired[k] ?? null,
-                operation: ParameterOperation.NOOP,
-            });
-            delete current[k];
-            delete desired[k];
-        }
-        if (Object.keys(current).length > 0) {
-            throw new Error('Diff algorithm error');
-        }
-        for (const [k, v] of Object.entries(desired)) {
-            parameterChangeSet.push({
-                name: k,
-                previousValue: null,
-                newValue: v ?? null,
-                operation: ParameterOperation.ADD,
+                operation: ParameterOperation.MODIFY,
             });
         }
         return parameterChangeSet;

package/dist/plugin/plugin.js

@@ -34,16 +34,16 @@ export class Plugin {
         const resource = this.resourceControllers.get(data.type);
         const schema = resource.settings.schema;
         const requiredPropertyNames = (resource.settings.import?.requiredParameters
-            ?? schema.required
+            ?? schema?.required
             ?? null);
         return {
             plugin: this.name,
             type: data.type,
             dependencies: resource.dependencies,
             schema: schema,
-            import: resource.settings.import ? {
+            import: {
                 requiredParameters: requiredPropertyNames,
-            } : undefined,
+            },
         };
     }
     async import(data) {

package/dist/resource/parsed-resource-settings.js

@@ -1,4 +1,4 @@
-import { resolveEqualsFn } from './resource-settings.js';
+import { resolveEqualsFn, resolveParameterTransformFn } from './resource-settings.js';
 export class ParsedResourceSettings {
     cache = new Map();
     id;
@@ -61,8 +61,8 @@ export class ParsedResourceSettings {
                 return {};
             }
             return Object.fromEntries(Object.entries(this.settings.parameterSettings)
-                .filter(([, v]) => v.inputTransformation !== undefined)
-                .map(([k, v]) => [k, v.inputTransformation]));
+                .filter(([, v]) => resolveParameterTransformFn(v) !== undefined)
+                .map(([k, v]) => [k, resolveParameterTransformFn(v)]));
         });
     }
     get statefulParameterOrder() {
@@ -94,6 +94,27 @@ export class ParsedResourceSettings {
             && Object.values(this.parameterSettings).some((v) => v.type === 'stateful')) {
             throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed if multiples of a resource exist`);
         }
+        const schema = this.settings.schema;
+        if (!this.settings.import && (schema?.oneOf
+            && Array.isArray(schema.oneOf)
+            && schema.oneOf.some((s) => s.required))
+            || (schema?.anyOf
+                && Array.isArray(schema.anyOf)
+                && schema.anyOf.some((s) => s.required))
+            || (schema?.allOf
+                && Array.isArray(schema.allOf)
+                && schema.allOf.some((s) => s.required))
+            || (schema?.then
+                && Array.isArray(schema.then)
+                && schema.then.some((s) => s.required))
+            || (schema?.else
+                && Array.isArray(schema.else)
+                && schema.else.some((s) => s.required))) {
+            throw new Error(`In the schema of ${this.settings.id}, a conditional required was declared (within anyOf, allOf, oneOf, else, or then) but an` +
+                'import.requiredParameters was not found in the resource settings. This is required because Codify uses the required parameter to' +
+                'determine the prompt to ask users during imports. It can\'t parse which parameters are needed when ' +
+                'required is declared conditionally.');
+        }
     }
     validateParameterEqualsFn(parameter, key) {
         if (parameter.type === 'stateful') {

package/dist/resource/resource-settings.d.ts

@@ -61,7 +61,7 @@ export interface ResourceSettings<T extends StringIndexedObject> {
  * config with desired config. Certain types will have additional options to help support it. For example the type
  * stateful requires a stateful parameter definition and type array takes an isElementEqual method.
  */
-export type ParameterSettingType = 'any' | 'array' | 'boolean' | 'directory' | 'number' | 'stateful' | 'string' | 'version';
+export type ParameterSettingType = 'any' | 'array' | 'boolean' | 'directory' | 'number' | 'setting' | 'stateful' | 'string' | 'version';
 /**
  * Typing information for the parameter setting. This represents a setting on a specific parameter within a
  * resource. Options for configuring parameters operations including overriding the equals function, adding default values
@@ -150,3 +150,4 @@ export interface StatefulParameterSetting extends DefaultParameterSetting {
     order?: number;
 }
 export declare function resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => boolean;
+export declare function resolveParameterTransformFn(parameter: ParameterSetting): ((input: any) => Promise<any> | any) | undefined;

package/dist/resource/resource-settings.js

@@ -5,7 +5,8 @@ const ParameterEqualsDefaults = {
     'directory': (a, b) => path.resolve(untildify(String(a))) === path.resolve(untildify(String(b))),
     'number': (a, b) => Number(a) === Number(b),
     'string': (a, b) => String(a) === String(b),
-    'version': (desired, current) => String(current).includes(String(desired))
+    'version': (desired, current) => String(current).includes(String(desired)),
+    'setting': (a, b) => true,
 };
 export function resolveEqualsFn(parameter, key) {
     if (parameter.type === 'array') {
@@ -16,3 +17,10 @@ export function resolveEqualsFn(parameter, key) {
     }
     return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type] ?? (((a, b) => a === b));
 }
+const ParameterTransformationDefaults = {
+    'directory': (a) => path.resolve(untildify(String(a))),
+    'string': String,
+};
+export function resolveParameterTransformFn(parameter) {
+    return parameter.inputTransformation ?? ParameterTransformationDefaults[parameter.type] ?? undefined;
+}

package/package.json

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

package/src/plan/change-set.ts

@@ -141,53 +141,45 @@ export class ChangeSet<T extends StringIndexedObject> {
       Object.entries(currentParameters).filter(([, v]) => v !== null && v !== undefined)
     ) as Partial<T>
 
-    for (const [k, v] of Object.entries(current)) {
-      if (desired?.[k] === null || desired?.[k] === undefined) {
+    for (const k of new Set([...Object.keys(current), ...Object.keys(desired)])) {
+      if (ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
         parameterChangeSet.push({
           name: k,
-          previousValue: v ?? null,
+          previousValue: current[k] ?? null,
+          newValue: desired[k] ?? null,
+          operation: ParameterOperation.NOOP,
+        })
+
+        continue;
+      }
+
+      if ((desired?.[k] === null || desired?.[k] === undefined) && (current?.[k] !== null && current?.[k] !== undefined)) {
+        parameterChangeSet.push({
+          name: k,
+          previousValue: current[k] ?? null,
           newValue: null,
           operation: ParameterOperation.REMOVE,
         })
 
-        delete current[k];
         continue;
       }
 
-      if (!ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
+      if ((current?.[k] === null || current?.[k] === undefined) && (desired?.[k] !== null && desired?.[k] !== undefined)) {
         parameterChangeSet.push({
           name: k,
-          previousValue: v ?? null,
+          previousValue: null,
           newValue: desired[k] ?? null,
-          operation: ParameterOperation.MODIFY,
+          operation: ParameterOperation.ADD,
         })
 
-        delete current[k];
-        delete desired[k];
         continue;
       }
 
       parameterChangeSet.push({
         name: k,
-        previousValue: v ?? null,
+        previousValue: current[k] ?? null,
         newValue: desired[k] ?? null,
-        operation: ParameterOperation.NOOP,
-      })
-
-      delete current[k];
-      delete desired[k];
-    }
-
-    if (Object.keys(current).length > 0) {
-      throw new Error('Diff algorithm error');
-    }
-
-    for (const [k, v] of Object.entries(desired)) {
-      parameterChangeSet.push({
-        name: k,
-        previousValue: null,
-        newValue: v ?? null,
-        operation: ParameterOperation.ADD,
+        operation: ParameterOperation.MODIFY,
       })
     }
 

package/src/plugin/plugin.test.ts

@@ -101,4 +101,81 @@ describe('Plugin tests', () => {
     await testPlugin.apply({ plan })
     expect(resource.modify.calledOnce).to.be.true;
   });
+
+  it('Can get resource info', async () => {
+    const schema = {
+      '$schema': 'http://json-schema.org/draft-07/schema',
+      '$id': 'https://www.codifycli.com/asdf-schema.json',
+      'title': 'Asdf resource',
+      'type': 'object',
+      'properties': {
+        'plugins': {
+          'type': 'array',
+          'description': 'Asdf plugins to install. See: https://github.com/asdf-community for a full list',
+          'items': {
+            'type': 'string'
+          }
+        }
+      },
+      'required': ['plugins'],
+      'additionalProperties': false
+    }
+
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'typeId',
+          schema,
+        }
+      }
+    }
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
+
+    const resourceInfo = await testPlugin.getResourceInfo({ type: 'typeId' })
+    expect(resourceInfo.import).toMatchObject({
+      requiredParameters: [
+        'plugins'
+      ]
+    })
+  })
+
+  it('Get resource info to default import to the one specified in the resource settings', async () => {
+    const schema = {
+      '$schema': 'http://json-schema.org/draft-07/schema',
+      '$id': 'https://www.codifycli.com/asdf-schema.json',
+      'title': 'Asdf resource',
+      'type': 'object',
+      'properties': {
+        'plugins': {
+          'type': 'array',
+          'description': 'Asdf plugins to install. See: https://github.com/asdf-community for a full list',
+          'items': {
+            'type': 'string'
+          }
+        }
+      },
+      'required': ['plugins'],
+      'additionalProperties': false
+    }
+
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'typeId',
+          schema,
+          import: {
+            requiredParameters: []
+          }
+        }
+      }
+    }
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
+
+    const resourceInfo = await testPlugin.getResourceInfo({ type: 'typeId' })
+    expect(resourceInfo.import).toMatchObject({
+      requiredParameters: []
+    })
+  })
 });

package/src/plugin/plugin.ts

@@ -59,11 +59,11 @@ export class Plugin {
 
     const resource = this.resourceControllers.get(data.type)!;
 
-    const schema = resource.settings.schema as JSONSchemaType<any>;
+    const schema = resource.settings.schema as JSONSchemaType<any> | undefined;
     const requiredPropertyNames = (
       resource.settings.import?.requiredParameters
-        ?? schema.required 
-        ?? null
+      ?? schema?.required
+      ?? null
     ) as null | string[];
 
     return {
@@ -71,9 +71,9 @@ export class Plugin {
       type: data.type,
       dependencies: resource.dependencies,
       schema: schema as Record<string, unknown> | undefined,
-      import: resource.settings.import ? {
+      import: {
         requiredParameters: requiredPropertyNames,
-      } : undefined,
+      },
     }
   }
 

package/src/resource/parsed-resource-settings.test.ts

@@ -21,4 +21,48 @@ describe('Resource options parser tests', () => {
       propB: 'propB'
     })
   })
+
+  it('Throws an error when an import.requiredParameters is not declared', () => {
+    const schema = {
+      '$schema': 'http://json-schema.org/draft-07/schema',
+      '$id': 'https://www.codifycli.com/git-clone.json',
+      'title': 'Git-clone resource',
+      'type': 'object',
+      'properties': {
+        'remote': {
+          'type': 'string',
+          'description': 'Remote tracking url to clone repo from. Equivalent to repository and only one should be specified'
+        },
+        'repository': {
+          'type': 'string',
+          'description': 'Remote repository to clone repo from. Equivalent to remote and only one should be specified'
+        },
+        'parentDirectory': {
+          'type': 'string',
+          'description': 'Parent directory to clone into. The folder name will use default git semantics which extracts the last part of the clone url. Only one of parentDirectory or directory can be specified'
+        },
+        'directory': {
+          'type': 'string',
+          'description': 'Directory to clone contents into. This value is directly passed into git clone. This differs from parent directory in that the last part of the path will be the folder name of the repo'
+        },
+        'autoVerifySSH': {
+          'type': 'boolean',
+          'description': 'Automatically verifies the ssh connection for ssh git clones. Defaults to true.'
+        }
+      },
+      'additionalProperties': false,
+      'oneOf': [
+        { 'required': ['repository', 'directory'] },
+        { 'required': ['repository', 'parentDirectory'] },
+        { 'required': ['remote', 'directory'] }
+      ]
+    }
+
+    const option: ResourceSettings<TestConfig> = {
+      id: 'typeId',
+      schema,
+    }
+
+    expect(() => new ParsedResourceSettings(option)).throws;
+  })
 })

package/src/resource/parsed-resource-settings.ts

@@ -1,6 +1,13 @@
+import { JSONSchemaType } from 'ajv';
 import { StringIndexedObject } from 'codify-schemas';
 
-import { ParameterSetting, resolveEqualsFn, ResourceSettings, StatefulParameterSetting } from './resource-settings.js';
+import {
+  ParameterSetting,
+  ResourceSettings,
+  StatefulParameterSetting,
+  resolveEqualsFn,
+  resolveParameterTransformFn
+} from './resource-settings.js';
 import { StatefulParameter as StatefulParameterImpl } from './stateful-parameter.js'
 
 export class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
@@ -87,8 +94,8 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
 
       return Object.fromEntries(
         Object.entries(this.settings.parameterSettings)
-          .filter(([, v]) => v!.inputTransformation !== undefined)
-          .map(([k, v]) => [k, v!.inputTransformation!] as const)
+          .filter(([, v]) => resolveParameterTransformFn(v!) !== undefined)
+          .map(([k, v]) => [k, resolveParameterTransformFn(v!)] as const)
       ) as Record<keyof T, (a: unknown) => unknown>;
     });
   }
@@ -130,6 +137,36 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
       && Object.values(this.parameterSettings).some((v) => v.type === 'stateful')) {
       throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed if multiples of a resource exist`)
     }
+
+
+    const schema = this.settings.schema as JSONSchemaType<any>;
+    if (!this.settings.import && (schema?.oneOf
+        && Array.isArray(schema.oneOf)
+        && schema.oneOf.some((s) => s.required)
+      )
+      || (schema?.anyOf
+        && Array.isArray(schema.anyOf)
+        && schema.anyOf.some((s) => s.required)
+      )
+      || (schema?.allOf
+        && Array.isArray(schema.allOf)
+        && schema.allOf.some((s) => s.required)
+      )
+      || (schema?.then
+        && Array.isArray(schema.then)
+        && schema.then.some((s) => s.required)
+      )
+      || (schema?.else
+        && Array.isArray(schema.else)
+        && schema.else.some((s) => s.required)
+      )
+    ) {
+      throw new Error(`In the schema of ${this.settings.id}, a conditional required was declared (within anyOf, allOf, oneOf, else, or then) but an` +
+        'import.requiredParameters was not found in the resource settings. This is required because Codify uses the required parameter to' +
+        'determine the prompt to ask users during imports. It can\'t parse which parameters are needed when ' +
+        'required is declared conditionally.'
+      )
+    }
   }
 
   private validateParameterEqualsFn(parameter: ParameterSetting, key: string): void {

package/src/resource/resource-settings.test.ts

@@ -11,6 +11,8 @@ import {
 } from '../utils/test-utils.test.js';
 import { ArrayParameterSetting, ParameterSetting, ResourceSettings } from './resource-settings.js';
 import { ResourceController } from './resource-controller.js';
+import os from 'node:os';
+import path from 'node:path';
 
 describe('Resource parameter tests', () => {
   it('Generates a resource plan that includes stateful parameters (create)', async () => {
@@ -540,4 +542,74 @@ describe('Resource parameter tests', () => {
       }
     };
   })
+
+  it('Applies default input transformations', 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: 'directory' }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return { propA: testPath }
+      }
+    };
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({ type: 'resourceType', propA: '~/test/folder' } as any);
+
+    expect(plan.changeSet.parameterChanges[0]).toMatchObject({
+      operation: ParameterOperation.NOOP,
+      newValue: testPath,
+      previousValue: testPath,
+    })
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
+
+  it('Ignores setting parameters when planning', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          parameterSettings: {
+            propA: { type: 'setting' },
+            propB: { type: 'number' }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return { propB: 64 }
+      }
+    };
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({ type: 'resourceType', propA: 'setting', propB: 64 } as any);
+
+    expect(plan.changeSet.parameterChanges).toMatchObject(
+      expect.arrayContaining([
+        {
+          name: 'propA',
+          operation: ParameterOperation.NOOP,
+          previousValue: null,
+          newValue: 'setting',
+        },
+        {
+          name: 'propB',
+          operation: ParameterOperation.NOOP,
+          previousValue: 64,
+          newValue: 64,
+        }
+      ])
+    )
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
 })

package/src/resource/resource-settings.ts

@@ -81,6 +81,7 @@ export type ParameterSettingType =
   | 'boolean'
   | 'directory'
   | 'number'
+  | 'setting'
   | 'stateful'
   | 'string'
   | 'version';
@@ -192,10 +193,10 @@ const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown,
   'directory': (a: unknown, b: unknown) => path.resolve(untildify(String(a))) === path.resolve(untildify(String(b))),
   'number': (a: unknown, b: unknown) => Number(a) === Number(b),
   'string': (a: unknown, b: unknown) => String(a) === String(b),
-  'version': (desired: unknown, current: unknown) => String(current).includes(String(desired))
+  'version': (desired: unknown, current: unknown) => String(current).includes(String(desired)),
+  'setting': (a: unknown, b: unknown) => true,
 }
 
-
 export function resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => boolean {
   if (parameter.type === 'array') {
     return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter as ArrayParameterSetting)
@@ -207,3 +208,14 @@ export function resolveEqualsFn(parameter: ParameterSetting, key: string): (desi
 
   return parameter.isEqual ?? ParameterEqualsDefaults[parameter.type as ParameterSettingType] ?? (((a, b) => a === b));
 }
+
+const ParameterTransformationDefaults: Partial<Record<ParameterSettingType, (input: any) => Promise<any> | any>> = {
+  'directory': (a: unknown) => path.resolve(untildify(String(a))),
+  'string': String,
+}
+
+export function resolveParameterTransformFn(
+  parameter: ParameterSetting
+): ((input: any) => Promise<any> | any) | undefined {
+  return parameter.inputTransformation ?? ParameterTransformationDefaults[parameter.type as ParameterSettingType] ?? undefined;
+}