codify-plugin-lib 1.0.153 → 1.0.155

package/dist/plan/plan.js

@@ -159,7 +159,7 @@ export class Plan {
         const { matcher: parameterMatcher, id } = settings;
         const matcher = (desired, currentArray) => {
             const matched = currentArray.filter((c) => parameterMatcher(desired, c));
-            if (matched.length > 0) {
+            if (matched.length > 1) {
                 console.log(`Resource: ${id} did not uniquely match resources when allow multiple is set to true`);
             }
             return matched[0];

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
@@ -197,7 +207,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 +322,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-settings.js

@@ -1,12 +1,12 @@
 import isObjectsEqual from 'lodash.isequal';
 import path from 'node:path';
-import { areArraysEqual, tildify, unhome, untildify } from '../utils/utils.js';
+import { addVariablesToPath, areArraysEqual, resolvePathWithVariables, tildify, untildify } from '../utils/utils.js';
 const ParameterEqualsDefaults = {
     'boolean': (a, b) => Boolean(a) === Boolean(b),
     'directory': (a, b) => {
         const notCaseSensitive = process.platform === 'darwin';
-        const transformedA = path.resolve(unhome(untildify(notCaseSensitive ? String(a).toLowerCase() : String(a))));
-        const transformedB = path.resolve(unhome(untildify(notCaseSensitive ? String(b).toLowerCase() : String(b))));
+        const transformedA = path.resolve(resolvePathWithVariables(untildify(notCaseSensitive ? String(a).toLowerCase() : String(a))));
+        const transformedB = path.resolve(resolvePathWithVariables(untildify(notCaseSensitive ? String(b).toLowerCase() : String(b))));
         return transformedA === transformedB;
     },
     'number': (a, b) => Number(a) === Number(b),
@@ -53,8 +53,8 @@ export function resolveFnFromEqualsFnOrString(fnOrString) {
 }
 const ParameterTransformationDefaults = {
     'directory': {
-        to: (a) => path.resolve(unhome(untildify(String(a)))),
-        from: (a) => tildify(String(a)),
+        to: (a) => path.resolve(resolvePathWithVariables((untildify(String(a))))),
+        from: (a) => addVariablesToPath(tildify(String(a))),
     },
     'string': {
         to: String,

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/dist/utils/utils.d.ts

@@ -7,5 +7,7 @@ export declare function splitUserConfig<T extends StringIndexedObject>(config: R
 export declare function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean;
 export declare function untildify(pathWithTilde: string): string;
 export declare function tildify(pathWithTilde: string): string;
+export declare function resolvePathWithVariables(pathWithVariables: string): string;
+export declare function addVariablesToPath(pathWithoutVariables: string): string;
 export declare function unhome(pathWithHome: string): string;
 export declare function areArraysEqual(isElementEqual: ((desired: unknown, current: unknown) => boolean) | undefined, desired: unknown, current: unknown): boolean;

package/dist/utils/utils.js

@@ -1,4 +1,5 @@
 import os from 'node:os';
+import path from 'node:path';
 export function isDebug() {
     return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
 }
@@ -25,6 +26,20 @@ export function untildify(pathWithTilde) {
 export function tildify(pathWithTilde) {
     return homeDirectory ? pathWithTilde.replace(homeDirectory, '~') : pathWithTilde;
 }
+export function resolvePathWithVariables(pathWithVariables) {
+    // @ts-expect-error Ignore this for now
+    return pathWithVariables.replace(/\$([A-Z_]+[A-Z0-9_]*)|\${([A-Z0-9_]*)}/ig, (_, a, b) => process.env[a || b]);
+}
+export function addVariablesToPath(pathWithoutVariables) {
+    let result = pathWithoutVariables;
+    for (const [key, value] of Object.entries(process.env)) {
+        if (!value || !path.isAbsolute(value) || value === '/') {
+            continue;
+        }
+        result = result.replaceAll(value, `$${key}`);
+    }
+    return result;
+}
 export function unhome(pathWithHome) {
     return pathWithHome.includes('$HOME') ? pathWithHome.replaceAll('$HOME', os.homedir()) : pathWithHome;
 }

package/package.json

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

package/src/plan/plan.ts

@@ -263,7 +263,7 @@ export class Plan<T extends StringIndexedObject> {
     const { matcher: parameterMatcher, id } = settings;
     const matcher = (desired: Partial<T>, currentArray: Partial<T>[]): Partial<T> | undefined => {
       const matched = currentArray.filter((c) => parameterMatcher(desired, c))
-      if (matched.length > 0) {
+      if (matched.length > 1) {
         console.log(`Resource: ${id} did not uniquely match resources when allow multiple is set to true`)
       }
 

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

@@ -746,4 +746,51 @@ 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) => {
+              // console.log('Matcher');
+              // console.log(desired);
+              // console.log(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;
+    console.log(JSON.stringify(plan, null, 2));
+  })
 });

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);
 
@@ -287,7 +298,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 +445,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-settings.ts

@@ -4,7 +4,7 @@ import isObjectsEqual from 'lodash.isequal'
 import path from 'node:path';
 
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
-import { areArraysEqual, tildify, unhome, untildify } from '../utils/utils.js';
+import { addVariablesToPath, areArraysEqual, resolvePathWithVariables, tildify, untildify } from '../utils/utils.js';
 
 export interface InputTransformation {
   to: (input: any) => Promise<any> | any;
@@ -304,8 +304,8 @@ const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown,
   'boolean': (a: unknown, b: unknown) => Boolean(a) === Boolean(b),
   'directory': (a: unknown, b: unknown) => {
     const notCaseSensitive = process.platform === 'darwin';
-    const transformedA = path.resolve(unhome(untildify(notCaseSensitive ? String(a).toLowerCase() : String(a))))
-    const transformedB = path.resolve(unhome(untildify(notCaseSensitive ? String(b).toLowerCase() : String(b))))
+    const transformedA = path.resolve(resolvePathWithVariables(untildify(notCaseSensitive ? String(a).toLowerCase() : String(a))))
+    const transformedB = path.resolve(resolvePathWithVariables(untildify(notCaseSensitive ? String(b).toLowerCase() : String(b))))
 
     return transformedA === transformedB;
   },
@@ -368,8 +368,8 @@ export function resolveFnFromEqualsFnOrString(
 
 const ParameterTransformationDefaults: Partial<Record<ParameterSettingType, InputTransformation>> = {
   'directory': {
-    to: (a: unknown) => path.resolve(unhome(untildify(String(a)))),
-    from: (a: unknown) => tildify(String(a)),
+    to: (a: unknown) => path.resolve(resolvePathWithVariables((untildify(String(a))))),
+    from: (a: unknown) => addVariablesToPath(tildify(String(a))),
   },
   'string': {
     to: String,

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

package/src/utils/utils.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
-import { splitUserConfig } from './utils.js';
+import { addVariablesToPath, resolvePathWithVariables, splitUserConfig } from './utils.js';
+import os from 'node:os';
 
 describe('Utils tests', () => {
   it('Can split a config correctly', () => {
@@ -26,4 +27,25 @@ describe('Utils tests', () => {
       propD: 'propD',
     })
   })
+
+  it('Can remove variables from a path', () => {
+    const testPath1 = '$HOME/my/path';
+    const result1 = resolvePathWithVariables(testPath1);
+
+    const home = os.homedir();
+    expect(result1).to.eq(home + '/my/path');
+
+
+    const testPath2 = '/var$HOME/my/path';
+    const result2 = resolvePathWithVariables(testPath2);
+    expect(result2).to.eq('/var' + home + '/my/path');
+  })
+
+  it('Can add variables to a path', () => {
+    const testPath1 = os.homedir() + '/my/path';
+    const result1 = addVariablesToPath(testPath1);
+
+    const home = os.homedir();
+    expect(result1).to.eq('$HOME/my/path');
+  })
 })

package/src/utils/utils.ts

@@ -1,5 +1,6 @@
 import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
 import os from 'node:os';
+import path from 'node:path';
 
 export function isDebug(): boolean {
   return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
@@ -37,6 +38,24 @@ export function tildify(pathWithTilde: string) {
   return homeDirectory ? pathWithTilde.replace(homeDirectory, '~') : pathWithTilde;
 }
 
+export function resolvePathWithVariables(pathWithVariables: string) {
+  // @ts-expect-error Ignore this for now
+  return pathWithVariables.replace(/\$([A-Z_]+[A-Z0-9_]*)|\${([A-Z0-9_]*)}/ig, (_, a, b) => process.env[a || b])
+}
+
+export function addVariablesToPath(pathWithoutVariables: string) {
+  let result = pathWithoutVariables;
+  for (const [key, value] of Object.entries(process.env)) {
+    if (!value || !path.isAbsolute(value) || value === '/') {
+      continue;
+    }
+
+    result = result.replaceAll(value, `$${key}`)
+  }
+
+  return result;
+}
+
 export function unhome(pathWithHome: string): string {
   return pathWithHome.includes('$HOME') ? pathWithHome.replaceAll('$HOME', os.homedir()) : pathWithHome;
 }