codify-plugin-lib 1.0.140 → 1.0.142

package/dist/plan/plan.js

@@ -159,7 +159,7 @@ export class Plan {
         const matcher = typeof settings.allowMultiple === 'boolean' || !settings.allowMultiple.matcher
             ? ((desired, currentArr) => {
                 const requiredParameters = typeof settings.allowMultiple === 'object'
-                    ? settings.allowMultiple?.requiredParameters ?? settings.schema?.required ?? []
+                    ? settings.allowMultiple?.identifyingParameters ?? settings.schema?.required ?? []
                     : settings.schema?.required ?? [];
                 const matched = currentArr.filter((c) => requiredParameters.every((key) => {
                     const currentParameter = c[key];

package/dist/plugin/plugin.js

@@ -43,14 +43,15 @@ export class Plugin {
             ?? null);
         const allowMultiple = resource.settings.allowMultiple !== undefined
             ? (typeof resource.settings.allowMultiple === 'boolean'
-                ? { requiredParameters: schema?.required ?? [] }
-                : { requiredParameters: resource.settings.allowMultiple.requiredParameters ?? schema?.required ?? [] }) : undefined;
+                ? { identifyingParameters: schema?.required ?? [] }
+                : { identifyingParameters: resource.settings.allowMultiple.identifyingParameters ?? schema?.required ?? [] }) : undefined;
         return {
             plugin: this.name,
             type: data.type,
             dependencies: resource.dependencies,
             schema: schema,
             importAndDestroy: {
+                preventImport: resource.settings.importAndDestroy?.preventImport,
                 requiredParameters: requiredPropertyNames,
             },
             import: {

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

@@ -25,6 +25,7 @@ export declare class ResourceController<T extends StringIndexedObject> {
     private validateRefreshResults;
     private applyTransformParameters;
     private addDefaultValues;
+    private removeDefaultValues;
     private refreshNonStatefulParameters;
     private refreshStatefulParameters;
     private validatePlanInputs;

package/dist/resource/resource-controller.js

@@ -147,6 +147,9 @@ export class ResourceController {
         }
     }
     async import(core, parameters) {
+        if (this.settings.importAndDestroy?.preventImport) {
+            throw new Error(`Type: ${this.typeId} cannot be imported`);
+        }
         this.addDefaultValues(parameters);
         await this.applyTransformParameters(parameters);
         // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
@@ -176,6 +179,7 @@ export class ResourceController {
         const statefulCurrentParameters = await this.refreshStatefulParameters(allStatefulParameters, parametersToRefresh);
         const resultParameters = { ...currentParametersArray[0], ...statefulCurrentParameters };
         await this.applyTransformParameters(resultParameters, true);
+        this.removeDefaultValues(resultParameters, parameters);
         return [{ core, parameters: resultParameters }];
     }
     async applyCreate(plan) {
@@ -268,6 +272,16 @@ ${JSON.stringify(refresh, null, 2)}
             }
         }
     }
+    removeDefaultValues(newConfig, originalConfig) {
+        if (!newConfig) {
+            return;
+        }
+        for (const [key, defaultValue] of Object.entries(this.parsedSettings.defaultValues)) {
+            if (defaultValue !== undefined && (newConfig[key] === defaultValue || originalConfig[key] === undefined || originalConfig[key] === null)) {
+                delete newConfig[key];
+            }
+        }
+    }
     async refreshNonStatefulParameters(resourceParameters) {
         const result = await this.resource.refresh(resourceParameters);
         const currentParametersArray = Array.isArray(result) || result === null

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

@@ -32,7 +32,7 @@ export interface ResourceSettings<T extends StringIndexedObject> {
          * 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[];
+        identifyingParameters?: 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.
@@ -87,6 +87,13 @@ export interface ResourceSettings<T extends StringIndexedObject> {
      * ```
      */
     importAndDestroy?: {
+        /**
+         * Can this resources be imported? If set to false then the codifyCLI will skip over/not consider this
+         * resource valid for imports. Defaults to true.
+         *
+         * Resources that can't be imported in the core library for example are: action resources
+         */
+        preventImport?: boolean;
         /**
          * Customize the required parameters needed to import this resource. By default, the `requiredParameters` are taken
          * from the JSON schema. The `requiredParameters` parameter must be declared if a complex required is declared in

package/dist/resource/resource-settings.js

@@ -54,6 +54,10 @@ const ParameterTransformationDefaults = {
     'string': {
         to: String,
         from: String,
+    },
+    'boolean': {
+        to: Boolean,
+        from: Boolean,
     }
 };
 export function resolveParameterTransformFn(parameter) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.140",
+  "version": "1.0.142",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -16,7 +16,7 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
-    "codify-schemas": "1.0.66",
+    "codify-schemas": "1.0.70",
     "@npmcli/promise-spawn": "^7.0.1",
     "@homebridge/node-pty-prebuilt-multiarch": "^0.12.0-beta.5",
     "uuid": "^10.0.0",

package/src/plan/plan.test.ts

@@ -241,7 +241,7 @@ describe('Plan entity tests', () => {
             propB: { type: 'string', canModify: true },
           },
           allowMultiple: {
-            requiredParameters: ['propA']
+            identifyingParameters: ['propA']
           }
         }
       }

package/src/plan/plan.ts

@@ -263,7 +263,7 @@ export class Plan<T extends StringIndexedObject> {
     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.allowMultiple?.identifyingParameters ?? (settings.schema?.required as string[]) ?? []
           : (settings.schema?.required as string[]) ?? []
 
         const matched = currentArr.filter((c) => requiredParameters.every((key) => {

package/src/plugin/plugin.test.ts

@@ -324,4 +324,46 @@ describe('Plugin tests', () => {
 
     console.log(result);
   })
+
+  it('Returns allowMultiple for getResourceInfo', async () => {
+    const resource = spy(new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          ...super.getSettings(),
+          allowMultiple: {
+            identifyingParameters: ['path', 'paths']
+          }
+        }
+      }
+    })
+
+    const testPlugin = Plugin.create('testPlugin', [resource as any]);
+
+    const resourceInfo = await testPlugin.getResourceInfo({
+      type: 'testResource',
+    })
+
+    expect(resourceInfo.allowMultiple?.requiredParameters).toMatchObject([
+      'path', 'paths'
+    ])
+  })
+
+  it('Returns an empty array by default for allowMultiple for getResourceInfo', async () => {
+    const resource = spy(new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          ...super.getSettings(),
+          allowMultiple: true
+        }
+      }
+    })
+
+    const testPlugin = Plugin.create('testPlugin', [resource as any]);
+
+    const resourceInfo = await testPlugin.getResourceInfo({
+      type: 'testResource',
+    })
+
+    expect(resourceInfo.allowMultiple?.requiredParameters).toMatchObject([])
+  })
 });

package/src/plugin/plugin.ts

@@ -74,8 +74,8 @@ export class Plugin {
 
     const allowMultiple = resource.settings.allowMultiple !== undefined
       ? (typeof resource.settings.allowMultiple === 'boolean'
-          ? { requiredParameters: schema?.required ?? [] }
-          : { requiredParameters: resource.settings.allowMultiple.requiredParameters ?? schema?.required ?? [] }
+          ? { identifyingParameters: schema?.required ?? [] }
+          : { identifyingParameters: resource.settings.allowMultiple.identifyingParameters ?? schema?.required ?? [] }
       ) : undefined
 
     return {
@@ -84,6 +84,7 @@ export class Plugin {
       dependencies: resource.dependencies,
       schema: schema as Record<string, unknown> | undefined,
       importAndDestroy: {
+        preventImport: resource.settings.importAndDestroy?.preventImport,
         requiredParameters: requiredPropertyNames,
       },
       import: {

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

@@ -711,4 +711,39 @@ describe('Resource tests', () => {
       }
     })
   })
+
+  it('Applies removes default values if they remain default for imports', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          parameterSettings: {
+            propA: { type: 'string', default: 'defaultValue' },
+            propB: { type: 'boolean', default: true }
+          },
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'defaultValue',
+          propB: false,
+          propC: 'newPropC'
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.import({ type: 'resourceType' }, {});
+
+    expect(plan![0]).toMatchObject({
+      'core': {
+        'type': 'resourceType'
+      },
+      'parameters': {
+        propB: false,
+        propC: 'newPropC'
+      }
+    })
+  })
 });

package/src/resource/resource-controller.ts

@@ -214,6 +214,10 @@ export class ResourceController<T extends StringIndexedObject> {
     core: ResourceConfig,
     parameters: Partial<T>
   ): Promise<Array<ResourceJson> | null> {
+    if (this.settings.importAndDestroy?.preventImport) {
+      throw new Error(`Type: ${this.typeId} cannot be imported`);
+    }
+
     this.addDefaultValues(parameters);
     await this.applyTransformParameters(parameters);
 
@@ -257,6 +261,8 @@ export class ResourceController<T extends StringIndexedObject> {
     const resultParameters = { ...currentParametersArray[0], ...statefulCurrentParameters };
 
     await this.applyTransformParameters(resultParameters, true);
+    this.removeDefaultValues(resultParameters, parameters)
+
     return [{ core, parameters: resultParameters }];
   }
 
@@ -373,6 +379,19 @@ ${JSON.stringify(refresh, null, 2)}
     }
   }
 
+  private removeDefaultValues(newConfig: Partial<T> | null, originalConfig: Partial<T>): void {
+    if (!newConfig) {
+      return;
+    }
+
+    for (const [key, defaultValue] of Object.entries(this.parsedSettings.defaultValues)) {
+      if (defaultValue !== undefined && (newConfig[key] === defaultValue || originalConfig[key] === undefined || originalConfig[key] === null)) {
+        delete newConfig[key];
+      }
+    }
+
+  }
+
   private async refreshNonStatefulParameters(resourceParameters: Partial<T>): Promise<Array<Partial<T>> | null> {
     const result = await this.resource.refresh(resourceParameters);
 

package/src/resource/resource-settings.ts

@@ -42,7 +42,7 @@ export interface ResourceSettings<T extends StringIndexedObject> {
      * 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[]
+    identifyingParameters?: string[]
 
     /**
      * If multiple copies are allowed then a matcher must be defined to match the desired
@@ -103,6 +103,13 @@ export interface ResourceSettings<T extends StringIndexedObject> {
    * ```
    */
   importAndDestroy?: {
+    /**
+     * Can this resources be imported? If set to false then the codifyCLI will skip over/not consider this
+     * resource valid for imports. Defaults to true.
+     *
+     * Resources that can't be imported in the core library for example are: action resources
+     */
+    preventImport?: boolean;
 
     /**
      * Customize the required parameters needed to import this resource. By default, the `requiredParameters` are taken
@@ -133,7 +140,7 @@ export interface ResourceSettings<T extends StringIndexedObject> {
      *
      * See {@link importAndDestroy} for more information on how importing works.
      */
-    defaultRefreshValues?: Partial<T>
+    defaultRefreshValues?: Partial<T>;
   }
 }
 
@@ -361,6 +368,10 @@ const ParameterTransformationDefaults: Partial<Record<ParameterSettingType, Inpu
   'string': {
     to: String,
     from: String,
+  },
+  'boolean': {
+    to: Boolean,
+    from: Boolean,
   }
 }