codify-plugin-lib 1.0.154 → 1.0.156

package/dist/resource/resource-controller.js

@@ -104,6 +104,11 @@ export class ResourceController {
     }
     async plan(core, desired, state, isStateful = false) {
         this.validatePlanInputs(core, desired, state, isStateful);
+        const context = {
+            commandType: 'plan',
+            isStateful,
+            originalDesiredConfig: structuredClone(desired),
+        };
         this.addDefaultValues(desired);
         await this.applyTransformParameters(desired);
         this.addDefaultValues(state);
@@ -112,7 +117,7 @@ export class ResourceController {
         const parsedConfig = new ConfigParser(desired, state, this.parsedSettings.statefulParameters);
         const { allParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
         // Refresh resource parameters. This refreshes the parameters that configure the resource itself
-        const currentArray = await this.refreshNonStatefulParameters(allNonStatefulParameters);
+        const currentArray = await this.refreshNonStatefulParameters(allNonStatefulParameters, context);
         // Short circuit here. If the resource is non-existent, there's no point checking stateful parameters
         if (currentArray === null
             || currentArray === undefined
@@ -180,6 +185,11 @@ export class ResourceController {
         if (this.settings.importAndDestroy?.preventImport) {
             throw new Error(`Type: ${this.typeId} cannot be imported`);
         }
+        const context = {
+            commandType: 'import',
+            isStateful: true,
+            originalDesiredConfig: structuredClone(parameters),
+        };
         this.addDefaultValues(parameters);
         await this.applyTransformParameters(parameters);
         // Use refresh parameters if specified, otherwise try to refresh as many parameters as possible here
@@ -188,6 +198,11 @@ export class ResourceController {
                 ...Object.fromEntries(this.settings.importAndDestroy?.refreshKeys.map((k) => [k, null])),
                 ...this.settings.importAndDestroy?.defaultRefreshValues,
                 ...parameters,
+                ...(Object.fromEntries(// If a default value was used, but it was also declared in the defaultRefreshValues, prefer the defaultRefreshValue instead
+                Object.entries(parameters).filter(([k, v]) => this.parsedSettings.defaultValues[k] !== undefined
+                    && v === this.parsedSettings.defaultValues[k]
+                    && context.originalDesiredConfig?.[k] === undefined
+                    && this.settings.importAndDestroy?.defaultRefreshValues?.[k] !== undefined).map(([k]) => [k, this.settings.importAndDestroy.defaultRefreshValues[k]])))
             }
             : {
                 ...Object.fromEntries(this.getAllParameterKeys().map((k) => [k, null])),
@@ -197,7 +212,7 @@ export class ResourceController {
         // Parse data from the user supplied config
         const parsedConfig = new ConfigParser(parametersToRefresh, null, this.parsedSettings.statefulParameters);
         const { allParameters, allNonStatefulParameters, allStatefulParameters, } = parsedConfig;
-        const currentParametersArray = await this.refreshNonStatefulParameters(allNonStatefulParameters);
+        const currentParametersArray = await this.refreshNonStatefulParameters(allNonStatefulParameters, context);
         if (currentParametersArray === null
             || currentParametersArray === undefined
             || currentParametersArray.filter(Boolean).length === 0) {
@@ -312,8 +327,8 @@ ${JSON.stringify(refresh, null, 2)}
             }
         }
     }
-    async refreshNonStatefulParameters(resourceParameters) {
-        const result = await this.resource.refresh(resourceParameters);
+    async refreshNonStatefulParameters(resourceParameters, context) {
+        const result = await this.resource.refresh(resourceParameters, context);
         const currentParametersArray = Array.isArray(result) || result === null
             ? result
             : [result];

package/dist/resource/resource.d.ts

@@ -2,6 +2,11 @@ import { StringIndexedObject } from 'codify-schemas';
 import { ParameterChange } from '../plan/change-set.js';
 import { CreatePlan, DestroyPlan, ModifyPlan } from '../plan/plan-types.js';
 import { ResourceSettings } from './resource-settings.js';
+export interface RefreshContext<T extends StringIndexedObject> {
+    isStateful: boolean;
+    commandType: 'destroy' | 'import' | 'plan';
+    originalDesiredConfig: Partial<T> | null;
+}
 /**
  * A resource represents an object on the system (application, CLI tool, or setting)
  * that has state and can be created and destroyed. Examples of resources include CLI tools
@@ -65,10 +70,12 @@ export declare abstract class Resource<T extends StringIndexedObject> {
      * of the desired config. In stateful mode, this will be parameters of the state config + the desired
      * config of any new parameters.
      *
+     * @param context Context surrounding the request
+     *
      * @return A config or an array of configs representing the status of the resource on the
      * system currently
      */
-    abstract refresh(parameters: Partial<T>): Promise<Array<Partial<T>> | Partial<T> | null>;
+    abstract refresh(parameters: Partial<T>, context: RefreshContext<T>): Promise<Array<Partial<T>> | Partial<T> | null>;
     /**
      * Create the resource (install) based on the parameters passed in. Only the desired parameters will
      * be non-null because in a CREATE plan, the current value is null.

package/package.json

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

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

@@ -746,4 +746,88 @@ describe('Resource tests', () => {
       }
     })
   })
+
+  it('Can plan with settings', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'path',
+          parameterSettings: {
+            path: { type: 'string', isEqual: 'directory' },
+            paths: { canModify: true, type: 'array', isElementEqual: 'directory' },
+            prepend: { default: false, setting: true },
+            declarationsOnly: { default: false, setting: true },
+          },
+          importAndDestroy: {
+            refreshKeys: ['paths', 'declarationsOnly'],
+            defaultRefreshValues: {
+              paths: [],
+              declarationsOnly: true,
+            }
+          },
+          allowMultiple: {
+            matcher: (desired, current) => {
+              if (desired.path) {
+                return desired.path === current.path;
+              }
+
+              const currentPaths = new Set(current.paths)
+              return desired.paths?.some((p) => currentPaths.has(p));
+            }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return { path: '$HOME/.bun/bin', prepend: false, declarationsOnly: false }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({ type: 'path' }, { path: '$HOME/.bun/bin' }, null, false);
+
+    expect(plan.requiresChanges()).to.be.false;
+  })
+
+  it('Can import with the correct default parameters', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'path',
+          parameterSettings: {
+            path: { type: 'string', isEqual: 'directory' },
+            paths: { canModify: true, type: 'array', isElementEqual: 'directory' },
+            prepend: { default: false, setting: true },
+            declarationsOnly: { default: false, setting: true },
+          },
+          importAndDestroy: {
+            refreshKeys: ['paths', 'declarationsOnly'],
+            defaultRefreshValues: {
+              paths: [],
+              declarationsOnly: true,
+            }
+          },
+          allowMultiple: {
+            matcher: (desired, current) => {
+              if (desired.path) {
+                return desired.path === current.path;
+              }
+
+              const currentPaths = new Set(current.paths)
+              return desired.paths?.some((p) => currentPaths.has(p));
+            }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        expect(parameters.declarationsOnly).to.be.true;
+
+        return null;
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.import({ type: 'path' }, {});
+  })
 });

package/src/resource/resource-controller.ts

@@ -13,7 +13,7 @@ import { Plan } from '../plan/plan.js';
 import { CreatePlan, DestroyPlan, ModifyPlan } from '../plan/plan-types.js';
 import { ConfigParser } from './config-parser.js';
 import { ParsedResourceSettings } from './parsed-resource-settings.js';
-import { Resource } from './resource.js';
+import { RefreshContext, Resource } from './resource.js';
 import { ResourceSettings } from './resource-settings.js';
 
 export class ResourceController<T extends StringIndexedObject> {
@@ -151,6 +151,11 @@ export class ResourceController<T extends StringIndexedObject> {
     isStateful = false,
   ): Promise<Plan<T>> {
     this.validatePlanInputs(core, desired, state, isStateful);
+    const context: RefreshContext<T> = {
+      commandType: 'plan',
+      isStateful,
+      originalDesiredConfig: structuredClone(desired),
+    };
 
     this.addDefaultValues(desired);
     await this.applyTransformParameters(desired);
@@ -167,7 +172,7 @@ export class ResourceController<T extends StringIndexedObject> {
     } = parsedConfig;
 
     // Refresh resource parameters. This refreshes the parameters that configure the resource itself
-    const currentArray = await this.refreshNonStatefulParameters(allNonStatefulParameters);
+    const currentArray = await this.refreshNonStatefulParameters(allNonStatefulParameters, context);
 
     // Short circuit here. If the resource is non-existent, there's no point checking stateful parameters
     if (currentArray === null
@@ -259,6 +264,12 @@ export class ResourceController<T extends StringIndexedObject> {
       throw new Error(`Type: ${this.typeId} cannot be imported`);
     }
 
+    const context: RefreshContext<T> = {
+      commandType: 'import',
+      isStateful: true,
+      originalDesiredConfig: structuredClone(parameters),
+    };
+
     this.addDefaultValues(parameters);
     await this.applyTransformParameters(parameters);
 
@@ -270,6 +281,14 @@ export class ResourceController<T extends StringIndexedObject> {
         ),
         ...this.settings.importAndDestroy?.defaultRefreshValues,
         ...parameters,
+        ...(Object.fromEntries( // If a default value was used, but it was also declared in the defaultRefreshValues, prefer the defaultRefreshValue instead
+          Object.entries(parameters).filter(([k, v]) =>
+            this.parsedSettings.defaultValues[k] !== undefined
+            && v === this.parsedSettings.defaultValues[k]
+            && context.originalDesiredConfig?.[k] === undefined
+            && this.settings.importAndDestroy?.defaultRefreshValues?.[k] !== undefined
+          ).map(([k]) => [k, this.settings.importAndDestroy!.defaultRefreshValues![k]])
+        ))
       }
       : {
         ...Object.fromEntries(
@@ -287,7 +306,7 @@ export class ResourceController<T extends StringIndexedObject> {
       allStatefulParameters,
     } = parsedConfig;
 
-    const currentParametersArray = await this.refreshNonStatefulParameters(allNonStatefulParameters);
+    const currentParametersArray = await this.refreshNonStatefulParameters(allNonStatefulParameters, context);
 
     if (currentParametersArray === null
       || currentParametersArray === undefined
@@ -434,8 +453,8 @@ ${JSON.stringify(refresh, null, 2)}
 
   }
 
-  private async refreshNonStatefulParameters(resourceParameters: Partial<T>): Promise<Array<Partial<T>> | null> {
-    const result = await this.resource.refresh(resourceParameters);
+  private async refreshNonStatefulParameters(resourceParameters: Partial<T>, context: RefreshContext<T>): Promise<Array<Partial<T>> | null> {
+    const result = await this.resource.refresh(resourceParameters, context);
 
     const currentParametersArray = Array.isArray(result) || result === null
       ? result

package/src/resource/resource.ts

@@ -4,6 +4,12 @@ import { ParameterChange } from '../plan/change-set.js';
 import { CreatePlan, DestroyPlan, ModifyPlan } from '../plan/plan-types.js';
 import { ResourceSettings } from './resource-settings.js';
 
+export interface RefreshContext<T extends StringIndexedObject> {
+  isStateful: boolean;
+  commandType: 'destroy' | 'import' | 'plan';
+  originalDesiredConfig: Partial<T> | null;
+}
+
 /**
  * A resource represents an object on the system (application, CLI tool, or setting)
  * that has state and can be created and destroyed. Examples of resources include CLI tools
@@ -73,10 +79,12 @@ export abstract class Resource<T extends StringIndexedObject> {
    * of the desired config. In stateful mode, this will be parameters of the state config + the desired
    * config of any new parameters.
    *
+   * @param context Context surrounding the request
+   *
    * @return A config or an array of configs representing the status of the resource on the
    * system currently
    */
-  abstract refresh(parameters: Partial<T>): Promise<Array<Partial<T>> | Partial<T> | null>;
+  abstract refresh(parameters: Partial<T>, context: RefreshContext<T>): Promise<Array<Partial<T>> | Partial<T> | null>;
 
   /**
    * Create the resource (install) based on the parameters passed in. Only the desired parameters will