codify-plugin-lib 1.0.76 → 1.0.78

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

@@ -1,6 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
-import { SpawnOptions } from 'child_process';
 import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { SpawnOptions } from 'node:child_process';
+import { ArrayParameterSetting } from '../resource/resource-settings.js';
 export declare enum SpawnStatus {
     SUCCESS = "success",
     ERROR = "error"
@@ -13,13 +14,28 @@ type CodifySpawnOptions = {
     cwd?: string;
     stdioString?: boolean;
 } & SpawnOptions;
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param args Optional additional arguments to append
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ * @param extras From PromiseSpawn
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
 export declare function codifySpawn(cmd: string, args?: string[], opts?: Omit<CodifySpawnOptions, 'stdio' | 'stdioString'> & {
     throws?: boolean;
 }, extras?: Record<any, any>): Promise<SpawnResult>;
 export declare function isDebug(): boolean;
-export declare function splitUserConfig<T extends StringIndexedObject>(config: T & ResourceConfig): {
+export declare function splitUserConfig<T extends StringIndexedObject>(config: ResourceConfig & T): {
     parameters: T;
-    resourceMetadata: ResourceConfig;
+    coreParameters: ResourceConfig;
 };
 export declare function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean;
+export declare function untildify(pathWithTilde: string): string;
+export declare function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown): boolean;
 export {};

package/dist/utils/utils.js

@@ -1,11 +1,27 @@
 import promiseSpawn from '@npmcli/promise-spawn';
+import os from 'node:os';
 export var SpawnStatus;
 (function (SpawnStatus) {
     SpawnStatus["SUCCESS"] = "success";
     SpawnStatus["ERROR"] = "error";
 })(SpawnStatus || (SpawnStatus = {}));
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param args Optional additional arguments to append
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ * @param extras From PromiseSpawn
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
 export async function codifySpawn(cmd, args, opts, extras) {
     try {
+        // TODO: Need to benchmark the effects of using sh vs zsh for shell.
+        //  Seems like zsh shells run slower
         const result = await promiseSpawn(cmd, args ?? [], { ...opts, stdio: 'pipe', stdioString: true, shell: opts?.shell ?? process.env.SHELL }, extras);
         if (isDebug()) {
             console.log(`codifySpawn result for: ${cmd}`);
@@ -34,20 +50,53 @@ export async function codifySpawn(cmd, args, opts, extras) {
     }
 }
 export function isDebug() {
-    return process.env.DEBUG != null && process.env.DEBUG.includes('codify');
+    return process.env.DEBUG != null && process.env.DEBUG.includes('codify'); // TODO: replace with debug library
 }
 export function splitUserConfig(config) {
-    const resourceMetadata = {
+    const coreParameters = {
         type: config.type,
         ...(config.name ? { name: config.name } : {}),
         ...(config.dependsOn ? { dependsOn: config.dependsOn } : {}),
     };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { type, name, dependsOn, ...parameters } = config;
     return {
         parameters: parameters,
-        resourceMetadata,
+        coreParameters,
     };
 }
 export function setsEqual(set1, set2) {
     return set1.size === set2.size && [...set1].every((v) => set2.has(v));
 }
+const homeDirectory = os.homedir();
+export function untildify(pathWithTilde) {
+    return homeDirectory ? pathWithTilde.replace(/^~(?=$|\/|\\)/, homeDirectory) : pathWithTilde;
+}
+export function areArraysEqual(parameter, desired, current) {
+    if (!Array.isArray(desired) || !Array.isArray(current)) {
+        throw new Error(`A non-array value:
+          
+Desired: ${JSON.stringify(desired, null, 2)}
+
+Current: ${JSON.stringify(desired, null, 2)}
+
+Was provided even though type array was specified.
+`);
+    }
+    if (desired.length !== current.length) {
+        return false;
+    }
+    const desiredCopy = [...desired];
+    const currentCopy = [...current];
+    // Algorithm for to check equality between two un-ordered; un-hashable arrays using
+    // an isElementEqual method. Time: O(n^2)
+    for (let counter = desiredCopy.length - 1; counter >= 0; counter--) {
+        const idx = currentCopy.findIndex((e2) => (parameter.isElementEqual ?? ((a, b) => a === b))(desiredCopy[counter], e2));
+        if (idx === -1) {
+            return false;
+        }
+        desiredCopy.splice(counter, 1);
+        currentCopy.splice(idx, 1);
+    }
+    return currentCopy.length === 0;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.76",
-  "description": "",
+  "version": "1.0.78",
+  "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "type": "module",
@@ -15,7 +15,8 @@
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "codify-schemas": "1.0.45",
-    "@npmcli/promise-spawn": "^7.0.1"
+    "@npmcli/promise-spawn": "^7.0.1",
+    "uuid": "^10.0.0"
   },
   "devDependencies": {
     "@oclif/prettier-config": "^0.2.1",
@@ -24,6 +25,7 @@
     "@types/node": "^18",
     "@types/semver": "^7.5.4",
     "@types/sinon": "^17.0.3",
+    "@types/uuid": "^10.0.0",
     "chai-as-promised": "^7.1.1",
     "vitest": "^1.4.0",
     "vitest-mock-extended": "^1.3.1",

package/src/index.ts

@@ -1,16 +1,15 @@
-import { Plugin } from './entities/plugin.js';
 import { MessageHandler } from './messages/handlers.js';
+import { Plugin } from './plugin/plugin.js';
 
-export * from './entities/resource.js'
-export * from './entities/resource-types.js'
-export * from './entities/resource-options.js'
-export * from './entities/plugin.js'
-export * from './entities/change-set.js'
-export * from './entities/plan.js'
-export * from './entities/plan-types.js'
-export * from './entities/stateful-parameter.js'
-export * from './entities/errors.js'
-
+export * from './errors.js'
+export * from './plan/change-set.js'
+export * from './plan/plan.js'
+export * from './plan/plan-types.js'
+export * from './plugin/plugin.js'
+export * from './resource/parsed-resource-settings.js';
+export * from './resource/resource.js'
+export * from './resource/resource-settings.js'
+export * from './resource/stateful-parameter.js'
 export * from './utils/utils.js'
 
 export async function runPlugin(plugin: Plugin) {

package/src/messages/handlers.test.ts

@@ -1,10 +1,10 @@
 import { MessageHandler } from './handlers.js';
-import { Plugin } from '../entities/plugin.js';
+import { Plugin } from '../plugin/plugin.js';
 import { describe, expect, it } from 'vitest';
 import { mock } from 'vitest-mock-extended'
-import { Resource } from '../entities/resource.js';
-import { Plan } from '../entities/plan.js';
+import { Resource } from '../resource/resource.js';
 import { MessageStatus, ResourceOperation } from 'codify-schemas';
+import { TestResource } from '../utils/test-utils.test.js';
 
 describe('Message handler tests', () => {
   it('handles plan requests', async () => {
@@ -151,7 +151,7 @@ describe('Message handler tests', () => {
   })
 
   it('handles errors for plan', async () => {
-    const resource= testResource();
+    const resource = new TestResource()
     const plugin = testPlugin(resource);
 
     const handler = new MessageHandler(plugin);
@@ -179,7 +179,7 @@ describe('Message handler tests', () => {
   })
 
   it('handles errors for apply (create)', async () => {
-    const resource= testResource();
+    const resource = new TestResource()
     const plugin = testPlugin(resource);
 
     const handler = new MessageHandler(plugin);
@@ -188,7 +188,6 @@ describe('Message handler tests', () => {
       expect(message).toMatchObject({
         cmd: 'apply_Response',
         status: MessageStatus.ERROR,
-        data: 'Create error',
       })
       return true;
     }
@@ -206,7 +205,7 @@ describe('Message handler tests', () => {
   })
 
   it('handles errors for apply (destroy)', async () => {
-    const resource= testResource();
+    const resource = new TestResource()
     const plugin = testPlugin(resource);
 
     const handler = new MessageHandler(plugin);
@@ -215,7 +214,6 @@ describe('Message handler tests', () => {
       expect(message).toMatchObject({
         cmd: 'apply_Response',
         status: MessageStatus.ERROR,
-        data: 'Destroy error',
       })
       return true;
     }
@@ -231,33 +229,8 @@ describe('Message handler tests', () => {
       }
     })).rejects.to.not.throw;
   })
-
-
-  const testResource = () => new class extends Resource<any> {
-    constructor() {
-      super({ type: 'resourceA' });
-    }
-
-    async refresh(keys: Map<keyof any, any>): Promise<Partial<any> | null> {
-      throw new Error('Refresh error');
-    }
-
-    applyCreate(plan: Plan<any>): Promise<void> {
-      throw new Error('Create error');
-    }
-
-    applyDestroy(plan: Plan<any>): Promise<void> {
-      throw new Error('Destroy error');
-    }
-  }
-
-  const testPlugin = (resource: Resource<any>) => new class extends Plugin {
-    constructor() {
-      const map = new Map();
-      map.set('resourceA', resource);
-
-      super('name', map);
-    }
-  }
-
 });
+
+function testPlugin(resource: Resource<any>) {
+  return Plugin.create('plugin', [resource])
+}

package/src/messages/handlers.ts

@@ -15,8 +15,8 @@ import {
   ValidateResponseDataSchema
 } from 'codify-schemas';
 
-import { SudoError } from '../entities/errors.js';
-import { Plugin } from '../entities/plugin.js';
+import { SudoError } from '../errors.js';
+import { Plugin } from '../plugin/plugin.js';
 
 const SupportedRequests: Record<string, { handler: (plugin: Plugin, data: any) => Promise<unknown>; requestValidator: SchemaObject; responseValidator: SchemaObject }> = {
   'apply': {

package/src/plan/change-set.test.ts

@@ -0,0 +1,220 @@
+import { ChangeSet } from './change-set.js';
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+import { describe, expect, it } from 'vitest';
+
+describe('Change set tests', () => {
+  it ('Correctly diffs two resource configs (modify)', () => {
+    const after = {
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const before = {
+      propA: 'after',
+      propB: 'after'
+    }
+
+    const cs = ChangeSet.calculateModification(after, before);
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+  })
+
+  it ('Correctly diffs two resource configs (add)', () => {
+    const after = {
+      propA: 'before',
+      propB: 'after'
+    }
+
+    const before = {
+      propA: 'after',
+    }
+
+    const cs = ChangeSet.calculateModification(after, before,);
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.ADD);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+
+  })
+
+  it ('Correctly diffs two resource configs (remove)', () => {
+    const after = {
+      propA: 'after',
+    }
+
+    const before = {
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const cs = ChangeSet.calculateModification(after, before);
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+  })
+
+  it ('Correctly diffs two resource configs (no-op)', () => {
+    const after = {
+      propA: 'prop',
+    }
+
+    const before = {
+      propA: 'prop',
+    }
+
+    const cs = ChangeSet.calculateModification(after, before);
+    expect(cs.parameterChanges.length).to.eq(1);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
+    expect(cs.operation).to.eq(ResourceOperation.NOOP)
+  })
+
+  it('Correctly diffs two resource configs (create)', () => {
+    const cs = ChangeSet.create({
+      propA: 'prop',
+      propB: 'propB'
+    });
+
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.ADD);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.ADD);
+    expect(cs.operation).to.eq(ResourceOperation.CREATE)
+  })
+
+  it('Correctly diffs two resource configs (destory)', () => {
+    const cs = ChangeSet.destroy({
+      propA: 'prop',
+      propB: 'propB'
+    });
+
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.operation).to.eq(ResourceOperation.DESTROY)
+  })
+
+  it ('handles simple arrays', () => {
+    const before = {
+      propA: ['a', 'b', 'c'],
+    }
+
+    const after = {
+      propA: ['b', 'a', 'c'],
+    }
+
+    const cs = ChangeSet.calculateModification(after, before, { propA: { type: 'array' } });
+    expect(cs.parameterChanges.length).to.eq(1);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
+    expect(cs.operation).to.eq(ResourceOperation.NOOP)
+  })
+
+  it('handles simple arrays 2', () => {
+    const after = {
+      propA: ['a', 'b', 'c'],
+    }
+
+    const before = {
+      propA: ['b', 'a'],
+    }
+
+    const cs = ChangeSet.calculateModification(after, before, { propA: { type: 'array' } });
+    expect(cs.parameterChanges.length).to.eq(1);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+  })
+
+  it('determines the order of operations with canModify 1', () => {
+    const after = {
+      propA: 'after',
+    }
+
+    const before = {
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const cs = ChangeSet.calculateModification(after, before, { propA: { canModify: true } });
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.operation).to.eq(ResourceOperation.RECREATE)
+  })
+
+  it('determines the order of operations with canModify 2', () => {
+    const after = {
+      propA: 'after',
+    }
+
+    const before = {
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const cs = ChangeSet.calculateModification<any>(after, before, {
+      propA: { canModify: true },
+      propB: { canModify: true }
+    });
+    expect(cs.parameterChanges.length).to.eq(2);
+    expect(cs.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs.parameterChanges[1].operation).to.eq(ParameterOperation.REMOVE);
+    expect(cs.operation).to.eq(ResourceOperation.MODIFY)
+  })
+
+
+  it('correctly determines array equality', () => {
+    const arrA = ['a', 'b', 'd'];
+    const arrB = ['a', 'b', 'd'];
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+
+    expect(result.operation).to.eq(ResourceOperation.NOOP);
+  })
+
+  it('correctly determines array equality 2', () => {
+    const arrA = ['a', 'b'];
+    const arrB = ['a', 'b', 'd'];
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+
+    expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+  })
+
+  it('correctly determines array equality 3', () => {
+    const arrA = ['b', 'a', 'd'];
+    const arrB = ['a', 'b', 'd'];
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, { propA: { type: 'array' } })
+
+    expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
+  })
+
+  it('correctly determines array equality 4', () => {
+    const arrA = [{ key1: 'a' }, { key1: 'a' }, { key1: 'a' }];
+    const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, {
+      propA: {
+        type: 'array',
+        isElementEqual: (a, b) => a.key1 === b.key1
+      }
+    })
+
+    expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.MODIFY);
+  })
+
+  it('correctly determines array equality 5', () => {
+    const arrA = [{ key1: 'b' }, { key1: 'a' }, { key1: 'a' }];
+    const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];
+
+    const result = ChangeSet.calculateModification({ propA: arrA }, { propA: arrB }, {
+      propA: {
+        type: 'array',
+        isElementEqual: (a, b) => a.key1 === b.key1
+      }
+    })
+
+    expect(result.parameterChanges[0].operation).to.eq(ParameterOperation.NOOP);
+  })
+})