codify-plugin-lib 1.0.77 → 1.0.79

package/dist/plan/change-set.d.ts

@@ -30,7 +30,17 @@ export declare class ChangeSet<T extends StringIndexedObject> {
     static empty<T extends StringIndexedObject>(): ChangeSet<T>;
     static create<T extends StringIndexedObject>(desired: Partial<T>): ChangeSet<T>;
     static destroy<T extends StringIndexedObject>(current: Partial<T>): ChangeSet<T>;
-    static calculateModification<T extends StringIndexedObject>(desired: Partial<T>, current: Partial<T>, parameterSettings?: Partial<Record<keyof T, ParameterSetting>>): ChangeSet<T>;
+    static calculateModification<T extends StringIndexedObject>(desired: Partial<T>, current: Partial<T>, parameterSettings?: Partial<Record<keyof T, ParameterSetting>>): Promise<ChangeSet<T>>;
+    /**
+     * Calculates the differences between the desired and current parameters,
+     * and returns a list of parameter changes that describe what needs to be added,
+     * removed, or modified to match the desired state.
+     *
+     * @param {Partial<T>} desiredParameters - The desired target state of the parameters.
+     * @param {Partial<T>} currentParameters - The current state of the parameters.
+     * @param {Partial<Record<keyof T, ParameterSetting>>} [parameterOptions] - Optional settings used when comparing parameters.
+     * @return {ParameterChange<T>[]} A list of changes required to transition from the current state to the desired state.
+     */
     private static calculateParameterChanges;
     private static combineResourceOperations;
     private static isSame;

package/dist/plan/change-set.js

@@ -45,8 +45,8 @@ export class ChangeSet {
         }));
         return new ChangeSet(ResourceOperation.DESTROY, parameterChanges);
     }
-    static calculateModification(desired, current, parameterSettings = {}) {
-        const pc = ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
+    static async calculateModification(desired, current, parameterSettings = {}) {
+        const pc = await ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
         const statefulParameterKeys = new Set(Object.entries(parameterSettings)
             .filter(([, v]) => v?.type === 'stateful')
             .map(([k]) => k));
@@ -67,7 +67,17 @@ export class ChangeSet {
         }, ResourceOperation.NOOP);
         return new ChangeSet(resourceOperation, pc);
     }
-    static calculateParameterChanges(desiredParameters, currentParameters, parameterOptions) {
+    /**
+     * Calculates the differences between the desired and current parameters,
+     * and returns a list of parameter changes that describe what needs to be added,
+     * removed, or modified to match the desired state.
+     *
+     * @param {Partial<T>} desiredParameters - The desired target state of the parameters.
+     * @param {Partial<T>} currentParameters - The current state of the parameters.
+     * @param {Partial<Record<keyof T, ParameterSetting>>} [parameterOptions] - Optional settings used when comparing parameters.
+     * @return {ParameterChange<T>[]} A list of changes required to transition from the current state to the desired state.
+     */
+    static async calculateParameterChanges(desiredParameters, currentParameters, parameterOptions) {
         const parameterChangeSet = new Array();
         // 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));
@@ -83,7 +93,7 @@ export class ChangeSet {
                 delete current[k];
                 continue;
             }
-            if (!ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
+            if (!await ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
                 parameterChangeSet.push({
                     name: k,
                     previousValue: v ?? null,
@@ -128,7 +138,7 @@ export class ChangeSet {
         const indexNext = orderOfOperations.indexOf(next);
         return orderOfOperations[Math.max(indexPrev, indexNext)];
     }
-    static isSame(desired, current, setting) {
+    static async isSame(desired, current, setting) {
         switch (setting?.type) {
             case 'stateful': {
                 const statefulSetting = setting.definition.getSettings();

package/dist/plan/plan.d.ts

@@ -41,7 +41,7 @@ export declare class Plan<T extends StringIndexedObject> {
         coreParameters: ResourceConfig;
         settings: ParsedResourceSettings<T>;
         statefulMode: boolean;
-    }): Plan<T>;
+    }): Promise<Plan<T>>;
     /**
      *  Only keep relevant params for the plan. We don't want to change settings that were not already
      *  defined.

package/dist/plan/plan.js

@@ -70,7 +70,7 @@ export class Plan {
     getResourceType() {
         return this.coreParameters.type;
     }
-    static calculate(params) {
+    static async calculate(params) {
         const { desiredParameters, currentParametersArray, stateParameters, coreParameters, settings, statefulMode } = params;
         const currentParameters = Plan.matchCurrentParameters({
             desiredParameters,
@@ -99,7 +99,7 @@ export class Plan {
             return new Plan(uuidV4(), ChangeSet.destroy(filteredCurrentParameters), coreParameters);
         }
         // NO-OP, MODIFY or RE-CREATE
-        const changeSet = ChangeSet.calculateModification(desiredParameters, filteredCurrentParameters, settings.parameterSettings);
+        const changeSet = await ChangeSet.calculateModification(desiredParameters, filteredCurrentParameters, settings.parameterSettings);
         return new Plan(uuidV4(), changeSet, coreParameters);
     }
     /**

package/dist/resource/resource-controller.js

@@ -1,6 +1,7 @@
 import { Ajv } from 'ajv';
 import { ParameterOperation, ResourceOperation } from 'codify-schemas';
 import { Plan } from '../plan/plan.js';
+import { splitUserConfig } from '../utils/utils.js';
 import { ConfigParser } from './config-parser.js';
 import { ParsedResourceSettings } from './parsed-resource-settings.js';
 export class ResourceController {
@@ -193,9 +194,10 @@ ${JSON.stringify(refresh, null, 2)}
             desired[key] = await inputTransformation(desired[key]);
         }
         if (this.settings.inputTransformation) {
-            const transformed = await this.settings.inputTransformation(desired);
+            const { parameters, coreParameters } = splitUserConfig(desired);
+            const transformed = await this.settings.inputTransformation(parameters);
             Object.keys(desired).forEach((k) => delete desired[k]);
-            Object.assign(desired, transformed);
+            Object.assign(desired, transformed, coreParameters);
         }
     }
     addDefaultValues(desired) {

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

@@ -86,7 +86,7 @@ export interface DefaultParameterSetting {
      *
      * @param input The original parameter value from the desired config.
      */
-    inputTransformation?: (input: any) => Promise<any> | unknown;
+    inputTransformation?: (input: any) => Promise<any> | any;
     /**
      * Customize the equality comparison for a parameter. This is used in the diffing algorithm for generating the plan.
      * This value will override the pre-set equality function from the type. Return true if the desired value is
@@ -97,7 +97,7 @@ export interface DefaultParameterSetting {
      *
      * @return Return true if equal
      */
-    isEqual?: (desired: any, current: any) => boolean;
+    isEqual?: (desired: any, current: any) => Promise<boolean> | boolean;
     /**
      * Chose if the resource can be modified instead of re-created when there is a change to this parameter.
      * Defaults to false (re-create).
@@ -123,7 +123,7 @@ export interface ArrayParameterSetting extends DefaultParameterSetting {
      *
      * @return Return true if desired is equivalent to current.
      */
-    isElementEqual?: (desired: any, current: any) => boolean;
+    isElementEqual?: (desired: any, current: any) => Promise<boolean> | boolean;
 }
 /**
  * Stateful parameter type specific settings. A stateful parameter is a sub-resource that can hold its own

package/dist/utils/spawn-2.d.ts

@@ -0,0 +1,5 @@
+import { Shell } from 'zx';
+export declare class ShellContext implements Shell {
+    zx: Shell;
+    static create(): ShellContext;
+}

package/dist/utils/spawn-2.js

@@ -0,0 +1,7 @@
+import { $ } from 'zx';
+export class ShellContext {
+    zx = $({ shell: true });
+    static create() {
+        return new ShellContext();
+    }
+}

package/dist/utils/spawn.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" resolution-mode="require"/>
+import { SpawnOptions } from 'node:child_process';
+export declare enum SpawnStatus {
+    SUCCESS = "success",
+    ERROR = "error"
+}
+export interface SpawnResult {
+    status: SpawnStatus;
+    data: string;
+}
+type CodifySpawnOptions = {
+    cwd?: string;
+    throws?: boolean;
+    requiresRoot?: boolean;
+} & Omit<SpawnOptions, 'detached' | 'shell' | 'stdio'>;
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
+export declare function $(cmd: string, opts?: CodifySpawnOptions): Promise<SpawnResult>;
+export declare function isDebug(): boolean;
+export {};

package/dist/utils/spawn.js

@@ -0,0 +1,124 @@
+import { Ajv } from 'ajv';
+import { MessageCmd, SudoRequestResponseDataSchema } from 'codify-schemas';
+import { spawn } from 'node:child_process';
+import { SudoError } from '../errors.js';
+const ajv = new Ajv({
+    strict: true,
+});
+const validateSudoRequestResponse = ajv.compile(SudoRequestResponseDataSchema);
+export var SpawnStatus;
+(function (SpawnStatus) {
+    SpawnStatus["SUCCESS"] = "success";
+    SpawnStatus["ERROR"] = "error";
+})(SpawnStatus || (SpawnStatus = {}));
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
+export async function $(cmd, opts) {
+    const throws = opts?.throws ?? true;
+    console.log(`Running command: ${cmd}`);
+    try {
+        // TODO: Need to benchmark the effects of using sh vs zsh for shell.
+        //  Seems like zsh shells run slower
+        let result;
+        if (!opts?.requiresRoot) {
+            result = await internalSpawn(cmd, opts ?? {});
+        }
+        else {
+            result = await externalSpawnWithSudo(cmd, opts);
+        }
+        if (result.status !== SpawnStatus.SUCCESS) {
+            throw new Error(result.data);
+        }
+        return result;
+    }
+    catch (error) {
+        if (isDebug()) {
+            console.error(`CodifySpawn error for command ${cmd}`, error);
+        }
+        if (error.message?.startsWith('sudo:')) {
+            throw new SudoError(cmd);
+        }
+        if (throws) {
+            throw error;
+        }
+        if (error instanceof Error) {
+            return {
+                status: SpawnStatus.ERROR,
+                data: error.message,
+            };
+        }
+        return {
+            status: SpawnStatus.ERROR,
+            data: error + '',
+        };
+    }
+}
+async function internalSpawn(cmd, opts) {
+    return new Promise((resolve, reject) => {
+        const output = [];
+        // Source start up shells to emulate a users environment vs. a non-interactive non-login shell script
+        // Ignore all stdin
+        const _process = spawn(`source ~/.zshrc; ${cmd}`, [], {
+            ...opts,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: 'zsh',
+        });
+        const { stdout, stderr, stdin } = _process;
+        stdout.setEncoding('utf8');
+        stderr.setEncoding('utf8');
+        stdout.on('data', (data) => {
+            output.push(data.toString());
+        });
+        stderr.on('data', (data) => {
+            output.push(data.toString());
+        });
+        _process.on('error', (data) => {
+        });
+        // please node that this is not a full replacement for 'inherit'
+        // the child process can and will detect if stdout is a pty and change output based on it
+        // the terminal context is lost & ansi information (coloring) etc will be lost
+        if (stdout && stderr) {
+            stdout.pipe(process.stdout);
+            stderr.pipe(process.stderr);
+        }
+        _process.on('close', (code) => {
+            resolve({
+                status: code === 0 ? SpawnStatus.SUCCESS : SpawnStatus.ERROR,
+                data: output.join('\n'),
+            });
+        });
+    });
+}
+async function externalSpawnWithSudo(cmd, opts) {
+    return await new Promise((resolve) => {
+        const listener = (data) => {
+            if (data.cmd === MessageCmd.SUDO_REQUEST + '_Response') {
+                process.removeListener('message', listener);
+                if (!validateSudoRequestResponse(data.data)) {
+                    throw new Error(`Invalid response for sudo request: ${JSON.stringify(validateSudoRequestResponse.errors, null, 2)}`);
+                }
+                resolve(data.data);
+            }
+        };
+        process.on('message', listener);
+        process.send({
+            cmd: MessageCmd.SUDO_REQUEST,
+            data: {
+                command: cmd,
+                options: opts ?? {},
+            }
+        });
+    });
+}
+export function isDebug() {
+    return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
+}

package/package.json

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

package/src/plan/change-set.ts

@@ -85,12 +85,12 @@ export class ChangeSet<T extends StringIndexedObject> {
     return new ChangeSet(ResourceOperation.DESTROY, parameterChanges);
   }
 
-  static calculateModification<T extends StringIndexedObject>(
+  static async calculateModification<T extends StringIndexedObject>(
     desired: Partial<T>,
     current: Partial<T>,
     parameterSettings: Partial<Record<keyof T, ParameterSetting>> = {},
-  ): ChangeSet<T> {
-    const pc = ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
+  ): Promise<ChangeSet<T>> {
+    const pc = await ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
 
     const statefulParameterKeys = new Set(
       Object.entries(parameterSettings)
@@ -116,11 +116,21 @@ export class ChangeSet<T extends StringIndexedObject> {
     return new ChangeSet<T>(resourceOperation, pc);
   }
 
-  private static calculateParameterChanges<T extends StringIndexedObject>(
+  /**
+   * Calculates the differences between the desired and current parameters,
+   * and returns a list of parameter changes that describe what needs to be added,
+   * removed, or modified to match the desired state.
+   *
+   * @param {Partial<T>} desiredParameters - The desired target state of the parameters.
+   * @param {Partial<T>} currentParameters - The current state of the parameters.
+   * @param {Partial<Record<keyof T, ParameterSetting>>} [parameterOptions] - Optional settings used when comparing parameters.
+   * @return {ParameterChange<T>[]} A list of changes required to transition from the current state to the desired state.
+   */
+  private static async calculateParameterChanges<T extends StringIndexedObject>(
     desiredParameters: Partial<T>,
     currentParameters: Partial<T>,
     parameterOptions?: Partial<Record<keyof T, ParameterSetting>>,
-  ): ParameterChange<T>[] {
+  ): Promise<ParameterChange<T>[]> {
     const parameterChangeSet = new Array<ParameterChange<T>>();
 
     // Filter out null and undefined values or else the diff below will not work
@@ -145,7 +155,7 @@ export class ChangeSet<T extends StringIndexedObject> {
         continue;
       }
 
-      if (!ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
+      if (!await ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
         parameterChangeSet.push({
           name: k,
           previousValue: v ?? null,
@@ -200,11 +210,11 @@ export class ChangeSet<T extends StringIndexedObject> {
     return orderOfOperations[Math.max(indexPrev, indexNext)];
   }
 
-  private static isSame(
+  private static async isSame(
     desired: unknown,
     current: unknown,
     setting?: ParameterSetting,
-  ): boolean {
+  ): Promise<boolean> {
     switch (setting?.type) {
       case 'stateful': {
         const statefulSetting = (setting as StatefulParameterSetting).definition.getSettings()

package/src/plan/plan.ts

@@ -105,14 +105,14 @@ export class Plan<T extends StringIndexedObject> {
     return this.coreParameters.type
   }
 
-  static calculate<T extends StringIndexedObject>(params: {
+  static async calculate<T extends StringIndexedObject>(params: {
     desiredParameters: Partial<T> | null,
     currentParametersArray: Partial<T>[] | null,
     stateParameters: Partial<T> | null,
     coreParameters: ResourceConfig,
     settings: ParsedResourceSettings<T>,
     statefulMode: boolean,
-  }): Plan<T> {
+  }): Promise<Plan<T>> {
     const {
       desiredParameters,
       currentParametersArray,
@@ -166,7 +166,7 @@ export class Plan<T extends StringIndexedObject> {
     }
 
     // NO-OP, MODIFY or RE-CREATE
-    const changeSet = ChangeSet.calculateModification(
+    const changeSet = await ChangeSet.calculateModification(
       desiredParameters!,
       filteredCurrentParameters!,
       settings.parameterSettings,

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

@@ -154,7 +154,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
     // The rest of the types have defaults set already
   }
 
-  private resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => boolean {
+  private resolveEqualsFn(parameter: ParameterSetting, key: string): (desired: unknown, current: unknown) => Promise<boolean> | boolean {
     if (parameter.type === 'array') {
       return parameter.isEqual ?? areArraysEqual.bind(areArraysEqual, parameter as ArrayParameterSetting)
     }

package/src/resource/resource-controller.ts

@@ -10,6 +10,7 @@ import {
 import { ParameterChange } from '../plan/change-set.js';
 import { Plan } from '../plan/plan.js';
 import { CreatePlan, DestroyPlan, ModifyPlan } from '../plan/plan-types.js';
+import { splitUserConfig } from '../utils/utils.js';
 import { ConfigParser } from './config-parser.js';
 import { ParsedResourceSettings } from './parsed-resource-settings.js';
 import { Resource } from './resource.js';
@@ -250,7 +251,7 @@ ${JSON.stringify(refresh, null, 2)}
     }
   }
 
-  private async applyTransformParameters(desired: Partial<T> | null): Promise<void> {
+  private async applyTransformParameters(desired: Partial<T> & ResourceConfig | null): Promise<void> {
     if (!desired) {
       return;
     }
@@ -264,9 +265,11 @@ ${JSON.stringify(refresh, null, 2)}
     }
 
     if (this.settings.inputTransformation) {
-      const transformed = await this.settings.inputTransformation(desired)
+      const { parameters, coreParameters } = splitUserConfig(desired);
+
+      const transformed = await this.settings.inputTransformation(parameters)
       Object.keys(desired).forEach((k) => delete desired[k])
-      Object.assign(desired, transformed);
+      Object.assign(desired, transformed, coreParameters);
     }
   }
 

package/src/resource/resource-settings.ts

@@ -115,7 +115,7 @@ export interface DefaultParameterSetting {
    *
    * @param input The original parameter value from the desired config.
    */
-  inputTransformation?: (input: any) => Promise<any> | unknown;
+  inputTransformation?: (input: any) => Promise<any> | any;
 
   /**
    * Customize the equality comparison for a parameter. This is used in the diffing algorithm for generating the plan.
@@ -127,7 +127,7 @@ export interface DefaultParameterSetting {
    *
    * @return Return true if equal
    */
-  isEqual?: (desired: any, current: any) => boolean;
+  isEqual?: (desired: any, current: any) => Promise<boolean> | boolean;
 
   /**
    * Chose if the resource can be modified instead of re-created when there is a change to this parameter.
@@ -156,7 +156,7 @@ export interface ArrayParameterSetting extends DefaultParameterSetting {
    *
    * @return Return true if desired is equivalent to current.
    */
-  isElementEqual?: (desired: any, current: any) => boolean
+  isElementEqual?: (desired: any, current: any) => Promise<boolean> | boolean;
 }
 
 /**