feat: add import command (#11)

* Add getResourceInfo response and request

* Add import functionality

* Add import customization block

* Improved diff algorithm in change-set, added setting parameter type and added transformation defaults for string and directory

* Added array filtering for all array parameters and made it customizable with a parameter. Added documentation for the new import parameters

Author: kevinwang5658

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.88",
+  "version": "1.0.100",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -14,7 +14,7 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "codify-schemas": "1.0.45",
+    "codify-schemas": "1.0.52",
     "@npmcli/promise-spawn": "^7.0.1",
     "uuid": "^10.0.0"
   },

package.json

@@ -3,6 +3,10 @@ import addFormats from 'ajv-formats';
 import {
   ApplyRequestDataSchema,
   ApplyResponseDataSchema,
+  GetResourceInfoRequestDataSchema,
+  GetResourceInfoResponseDataSchema,
+  ImportRequestDataSchema,
+  ImportResponseDataSchema,
   InitializeRequestDataSchema,
   InitializeResponseDataSchema,
   IpcMessage,
@@ -19,29 +23,39 @@ import { SudoError } from '../errors.js';
 import { Plugin } from '../plugin/plugin.js';
 
 const SupportedRequests: Record<string, { handler: (plugin: Plugin, data: any) => Promise<unknown>; requestValidator: SchemaObject; responseValidator: SchemaObject }> = {
-  'apply': {
-    async handler(plugin: Plugin, data: any) {
-      await plugin.apply(data);
-      return null;
-    },
-    requestValidator: ApplyRequestDataSchema,
-    responseValidator: ApplyResponseDataSchema
-  },
   'initialize': {
     handler: async (plugin: Plugin) => plugin.initialize(),
     requestValidator: InitializeRequestDataSchema,
     responseValidator: InitializeResponseDataSchema
   },
+  'validate': {
+    handler: async (plugin: Plugin, data: any) => plugin.validate(data),
+    requestValidator: ValidateRequestDataSchema,
+    responseValidator: ValidateResponseDataSchema
+  },
+  'getResourceInfo': {
+    handler: async (plugin: Plugin, data: any) => plugin.getResourceInfo(data),
+    requestValidator: GetResourceInfoRequestDataSchema,
+    responseValidator: GetResourceInfoResponseDataSchema
+  },
+  'import': {
+    handler: async (plugin: Plugin, data: any) => plugin.import(data),
+    requestValidator: ImportRequestDataSchema,
+    responseValidator: ImportResponseDataSchema
+  },
   'plan': {
     handler: async (plugin: Plugin, data: any) => plugin.plan(data),
     requestValidator: PlanRequestDataSchema,
     responseValidator: PlanResponseDataSchema
   },
-  'validate': {
-    handler: async (plugin: Plugin, data: any) => plugin.validate(data),
-    requestValidator: ValidateRequestDataSchema,
-    responseValidator: ValidateResponseDataSchema
-  }
+  'apply': {
+    async handler(plugin: Plugin, data: any) {
+      await plugin.apply(data);
+      return null;
+    },
+    requestValidator: ApplyRequestDataSchema,
+    responseValidator: ApplyResponseDataSchema
+  },
 }
 
 export class MessageHandler {

src/messages/handlers.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,
       })
     }
 

src/plan/change-set.ts

@@ -147,6 +147,84 @@ describe('Plan entity tests', () => {
       operation: ResourceOperation.RECREATE
     })
   })
+
+  it('Filters array parameters in stateless mode (by default)', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'type',
+          parameterSettings: {
+            propZ: { type: 'array', isElementEqual: (a, b) => b.includes(a) }
+          }
+        }
+      }
+
+      async refresh(): Promise<Partial<any> | null> {
+        return {
+          propZ: [
+            '20.15.0',
+            '20.15.1'
+          ]
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({
+      propZ: ['20.15'],
+    } as any)
+
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
+
+  it('Doesn\'t filters array parameters if filtering is disabled', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'type',
+          parameterSettings: {
+            propZ: {
+              type: 'array',
+              canModify: true,
+              isElementEqual: (a, b) => b.includes(a),
+              filterInStatelessMode: false
+            }
+          }
+        }
+      }
+
+      async refresh(): Promise<Partial<any> | null> {
+        return {
+          propZ: [
+            '20.15.0',
+            '20.15.1'
+          ]
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({
+      propZ: ['20.15'],
+    } as any)
+
+    expect(plan.changeSet).toMatchObject({
+      operation: ResourceOperation.MODIFY,
+      parameterChanges: expect.arrayContaining([
+        expect.objectContaining({
+          name: 'propZ',
+          previousValue: expect.arrayContaining([
+            '20.15.0',
+            '20.15.1'
+          ]),
+          newValue: expect.arrayContaining([
+            '20.15'
+          ]),
+          operation: 'modify'
+        })
+      ])
+    })
+  })
 })
 
 function createTestResource() {

src/plan/plan.test.ts

@@ -220,7 +220,7 @@ export class Plan<T extends StringIndexedObject> {
     // TODO: Add object handling here in addition to arrays in the future
     const arrayStatefulParameters = Object.fromEntries(
       Object.entries(filteredCurrent)
-        .filter(([k, v]) => isArrayStatefulParameter(k, v))
+        .filter(([k, v]) => isArrayParameterWithFiltering(k, v))
         .map(([k, v]) => [k, filterArrayStatefulParameter(k, v)])
     )
 
@@ -247,19 +247,27 @@ export class Plan<T extends StringIndexedObject> {
       ) as Partial<T>;
     }
 
-    function isArrayStatefulParameter(k: string, v: T[keyof T]): boolean {
-      return settings.parameterSettings?.[k]?.type === 'stateful'
-        && (settings.parameterSettings[k] as StatefulParameterSetting).definition.getSettings().type === 'array'
+    function isArrayParameterWithFiltering(k: string, v: T[keyof T]): boolean {
+      return (((settings.parameterSettings?.[k]?.type === 'stateful'
+            && (settings.parameterSettings[k] as StatefulParameterSetting).definition.getSettings().type === 'array')
+          && (((settings.parameterSettings[k] as StatefulParameterSetting).definition.getSettings() as ArrayParameterSetting).filterInStatelessMode ?? true)
+        ) || (
+          settings.parameterSettings?.[k]?.type === 'array'
+          && ((settings.parameterSettings?.[k] as ArrayParameterSetting).filterInStatelessMode ?? true)
+        ))
         && Array.isArray(v)
     }
 
     // For stateless mode, we must filter the current array so that the diff algorithm will not detect any deletes
     function filterArrayStatefulParameter(k: string, v: unknown[]): unknown[] {
       const desiredArray = desired![k] as unknown[];
-      const matcher = ((settings.parameterSettings![k] as StatefulParameterSetting)
+      const matcher = settings.parameterSettings![k]!.type === 'stateful'
+        ? ((settings.parameterSettings![k] as StatefulParameterSetting)
         .definition
         .getSettings() as ArrayParameterSetting)
-        .isElementEqual ?? ((a, b) => a === b);
+        .isElementEqual ?? ((a, b) => a === b)
+        : (settings.parameterSettings![k] as ArrayParameterSetting)
+        .isElementEqual ?? ((a, b) => a === b)
 
       const desiredCopy = [...desiredArray];
       const currentCopy = [...v];

src/plan/plan.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: []
+    })
+  })
 });