codify-plugin-lib 1.0.77 → 1.0.78

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

@@ -31,6 +31,16 @@ export declare class ChangeSet<T extends StringIndexedObject> {
     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>;
+    /**
+     * 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

@@ -67,6 +67,16 @@ export class ChangeSet {
         }, ResourceOperation.NOOP);
         return new ChangeSet(resourceOperation, pc);
     }
+    /**
+     * 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 calculateParameterChanges(desiredParameters, currentParameters, parameterOptions) {
         const parameterChangeSet = new Array();
         // Filter out null and undefined values or else the diff below will not work

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

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.78",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/plan/change-set.ts

@@ -116,6 +116,16 @@ export class ChangeSet<T extends StringIndexedObject> {
     return new ChangeSet<T>(resourceOperation, pc);
   }
 
+  /**
+   * 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<T extends StringIndexedObject>(
     desiredParameters: Partial<T>,
     currentParameters: Partial<T>,

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.