codify-plugin-lib 1.0.55 → 1.0.57

package/dist/entities/plan-types.d.ts

@@ -1,6 +1,5 @@
-import { ResourceOperation } from 'codify-schemas';
 export interface ParameterOptions {
-    planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
+    canModify?: boolean;
     isEqual?: (desired: any, current: any) => boolean;
     isElementEqual?: (desired: any, current: any) => boolean;
     default?: unknown;

package/dist/entities/plan.js

@@ -31,8 +31,8 @@ export class Plan {
                 if (statefulParameterNames.has(curr.name)) {
                     newOperation = ResourceOperation.MODIFY;
                 }
-                else if (parameterOptions[curr.name]?.planOperation) {
-                    newOperation = parameterOptions[curr.name].planOperation;
+                else if (parameterOptions[curr.name]?.canModify) {
+                    newOperation = parameterOptions[curr.name].canModify ? ResourceOperation.MODIFY : ResourceOperation.RECREATE;
                 }
                 else {
                     newOperation = ResourceOperation.RECREATE;

package/dist/entities/plugin.d.ts

@@ -2,9 +2,10 @@ import { Resource } from './resource.js';
 import { ApplyRequestData, InitializeResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
 import { Plan } from './plan.js';
 export declare class Plugin {
+    name: string;
     resources: Map<string, Resource<ResourceConfig>>;
     planStorage: Map<string, Plan<ResourceConfig>>;
-    constructor(resources: Map<string, Resource<ResourceConfig>>);
+    constructor(name: string, resources: Map<string, Resource<ResourceConfig>>);
     initialize(): Promise<InitializeResponseData>;
     validate(data: ValidateRequestData): Promise<ValidateResponseData>;
     plan(data: PlanRequestData): Promise<PlanResponseData>;

package/dist/entities/plugin.js

@@ -1,9 +1,11 @@
 import { Plan } from './plan.js';
 import { splitUserConfig } from '../utils/utils.js';
 export class Plugin {
+    name;
     resources;
     planStorage;
-    constructor(resources) {
+    constructor(name, resources) {
+        this.name = name;
         this.resources = resources;
         this.planStorage = new Map();
     }

package/dist/entities/resource-types.d.ts

@@ -1,7 +1,6 @@
-import { ResourceOperation } from 'codify-schemas';
 export type ErrorMessage = string;
 export interface ResourceParameterOptions {
-    planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
+    canModify?: boolean;
     isEqual?: (desired: any, current: any) => boolean;
     default?: unknown;
 }

package/dist/entities/resource.d.ts

@@ -1,4 +1,5 @@
 import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { ParameterChange } from './change-set.js';
 import { Plan } from './plan.js';
 import { StatefulParameter } from './stateful-parameter.js';
 import { ResourceParameterOptions, ValidationResult } from './resource-types.js';
@@ -36,6 +37,6 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     validate(parameters: unknown): Promise<ValidationResult>;
     abstract refresh(keys: Map<keyof T, T[keyof T]>): Promise<Partial<T> | null>;
     abstract applyCreate(plan: Plan<T>): Promise<void>;
-    applyModify(parameterName: keyof T, newValue: unknown, previousValue: unknown, allowDeletes: boolean, plan: Plan<T>): Promise<void>;
+    applyModify(pc: ParameterChange<T>, plan: Plan<T>): Promise<void>;
     abstract applyDestroy(plan: Plan<T>): Promise<void>;
 }

package/dist/entities/resource.js

@@ -60,7 +60,7 @@ export class Resource {
         await this.applyTransformParameters(transformParameters, resourceParameters);
         const currentParameters = await this.refreshResourceParameters(resourceParameters);
         if (currentParameters == null) {
-            return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
+            return Plan.create(resourceParameters, null, resourceMetadata, planOptions);
         }
         const statefulCurrentParameters = await this.refreshStatefulParameters(statefulParameters, planOptions.statefulMode);
         return Plan.create({ ...resourceParameters, ...statefulParameters }, { ...currentParameters, ...statefulCurrentParameters }, resourceMetadata, planOptions);
@@ -103,7 +103,7 @@ export class Resource {
         const statelessParameterChanges = parameterChanges
             .filter((pc) => !this.statefulParameters.has(pc.name));
         for (const pc of statelessParameterChanges) {
-            await this.applyModify(pc.name, pc.newValue, pc.previousValue, false, plan);
+            await this.applyModify(pc, plan);
         }
         const statefulParameterChanges = parameterChanges
             .filter((pc) => this.statefulParameters.has(pc.name))
@@ -154,17 +154,14 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
     async applyTransformParameters(transformParameters, desired) {
         const orderedEntries = [...Object.entries(transformParameters)]
             .sort(([keyA], [keyB]) => this.transformParameterOrder.get(keyA) - this.transformParameterOrder.get(keyB));
-        for (const [key] of orderedEntries) {
-            if (desired[key] !== null) {
-                const transformedValue = await this.transformParameters.get(key).transform(desired[key]);
-                if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
-                    throw new Error(`Transform parameter ${key} is attempting to override existing value ${desired[key]}`);
-                }
-                Object.entries(transformedValue).forEach(([tvKey, tvValue]) => {
-                    desired[tvKey] = tvValue;
-                });
-                delete desired[key];
+        for (const [key, value] of orderedEntries) {
+            const transformedValue = await this.transformParameters.get(key).transform(value);
+            if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
+                throw new Error(`Transform parameter ${key} is attempting to override existing values ${JSON.stringify(transformedValue, null, 2)}`);
             }
+            Object.entries(transformedValue).forEach(([tvKey, tvValue]) => {
+                desired[tvKey] = tvValue;
+            });
         }
     }
     addDefaultValues(desired) {
@@ -213,7 +210,7 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         };
     }
     ;
-    async applyModify(parameterName, newValue, previousValue, allowDeletes, plan) { }
+    async applyModify(pc, plan) { }
     ;
 }
 class ConfigParser {

package/dist/index.d.ts

@@ -9,4 +9,3 @@ export * from './entities/stateful-parameter.js';
 export * from './utils/test-utils.js';
 export * from './utils/utils.js';
 export declare function runPlugin(plugin: Plugin): Promise<void>;
-export { ErrorMessage } from './entities/resource-types.js';

package/dist/messages/handlers.d.ts

@@ -8,4 +8,5 @@ export declare class MessageHandler {
     constructor(plugin: Plugin);
     onMessage(message: unknown): Promise<void>;
     private validateMessage;
+    private handleErrors;
 }

package/dist/messages/handlers.js

@@ -44,39 +44,48 @@ export class MessageHandler {
             .map(([k, v]) => [k, this.ajv.compile(v.responseValidator)]));
     }
     async onMessage(message) {
-        if (!this.validateMessage(message)) {
-            throw new Error(`Plugin: ${this.plugin}. Message is malformed: ${JSON.stringify(this.messageSchemaValidator.errors, null, 2)}`);
-        }
-        if (!this.requestValidators.has(message.cmd)) {
-            throw new Error(`Plugin: ${this.plugin}. Unsupported message: ${message.cmd}`);
-        }
-        const requestValidator = this.requestValidators.get(message.cmd);
-        if (!requestValidator(message.data)) {
-            throw new Error(`Plugin: ${this.plugin}. cmd: ${message.cmd}. Malformed message data: ${JSON.stringify(requestValidator.errors, null, 2)}`);
-        }
-        let result;
         try {
-            result = await SupportedRequests[message.cmd].handler(this.plugin, message.data);
-        }
-        catch (e) {
+            if (!this.validateMessage(message)) {
+                throw new Error(`Plugin: ${this.plugin}. Message is malformed: ${JSON.stringify(this.messageSchemaValidator.errors, null, 2)}`);
+            }
+            if (!this.requestValidators.has(message.cmd)) {
+                throw new Error(`Plugin: ${this.plugin}. Unsupported message: ${message.cmd}`);
+            }
+            const requestValidator = this.requestValidators.get(message.cmd);
+            if (!requestValidator(message.data)) {
+                throw new Error(`Plugin: ${this.plugin}. cmd: ${message.cmd}. Malformed message data: ${JSON.stringify(requestValidator.errors, null, 2)}`);
+            }
+            const result = await SupportedRequests[message.cmd].handler(this.plugin, message.data);
+            const responseValidator = this.responseValidators.get(message.cmd);
+            if (responseValidator && !responseValidator(result)) {
+                throw new Error(`Plugin: ${this.plugin}. Malformed response data: ${JSON.stringify(responseValidator.errors, null, 2)}`);
+            }
             process.send({
                 cmd: message.cmd + '_Response',
-                status: MessageStatus.ERROR,
-                data: e.message,
+                status: MessageStatus.SUCCESS,
+                data: result,
             });
-            return;
         }
-        const responseValidator = this.responseValidators.get(message.cmd);
-        if (responseValidator && !responseValidator(result)) {
-            throw new Error(`Plugin: ${this.plugin}. Malformed response data: ${JSON.stringify(responseValidator.errors, null, 2)}`);
+        catch (e) {
+            this.handleErrors(message, e);
         }
-        process.send({
-            cmd: message.cmd + '_Response',
-            status: MessageStatus.SUCCESS,
-            data: result,
-        });
     }
     validateMessage(message) {
         return this.messageSchemaValidator(message);
     }
+    handleErrors(message, e) {
+        if (!message) {
+            return;
+        }
+        if (!message.hasOwnProperty('cmd')) {
+            return;
+        }
+        const cmd = message.cmd + '_Response';
+        const isDebug = process.env.DEBUG?.includes('*') ?? false;
+        process.send?.({
+            cmd,
+            status: MessageStatus.ERROR,
+            data: isDebug ? e.stack : e.message,
+        });
+    }
 }

package/package.json

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

package/src/entities/plan-types.ts

@@ -1,13 +1,11 @@
-import { ResourceOperation } from 'codify-schemas';
-
 /**
  * Customize properties for specific parameters. This will alter the way the library process changes to the parameter.
  */
 export interface ParameterOptions {
   /**
-   * Chose if the resource should be re-created or modified if this parameter is changed. Defaults to re-create.
+   * Chose if the resource should be re-created or modified if this parameter is changed. Defaults to false (re-creates resource on change).
    */
-  planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
+  canModify?: boolean;
   /**
    * Customize the equality comparison for a parameter.
    * @param a

package/src/entities/plan.ts

@@ -55,8 +55,8 @@ export class Plan<T extends StringIndexedObject> {
           let newOperation: ResourceOperation;
           if (statefulParameterNames.has(curr.name)) {
             newOperation = ResourceOperation.MODIFY // All stateful parameters are modify only
-          } else if (parameterOptions[curr.name]?.planOperation) {
-            newOperation = parameterOptions[curr.name].planOperation!;
+          } else if (parameterOptions[curr.name]?.canModify) {
+            newOperation = parameterOptions[curr.name].canModify ? ResourceOperation.MODIFY : ResourceOperation.RECREATE;
           } else {
             newOperation = ResourceOperation.RECREATE; // Default to Re-create. Should handle the majority of use cases
           }

package/src/entities/plugin.ts

@@ -15,6 +15,7 @@ export class Plugin {
   planStorage: Map<string, Plan<ResourceConfig>>;
 
   constructor(
+    public name: string,
     public resources: Map<string, Resource<ResourceConfig>>
   ) {
     this.planStorage = new Map();

package/src/entities/resource-parameters.test.ts

@@ -80,7 +80,7 @@ describe('Resource parameter tests', () => {
           type: 'resource',
           parameterOptions: {
             propA: { statefulParameter: statefulParameterSpy },
-            propB: { planOperation: ResourceOperation.MODIFY },
+            propB: { canModify: true },
           }
         });
       }

package/src/entities/resource-types.ts

@@ -1,5 +1,3 @@
-import { ResourceOperation } from 'codify-schemas';
-
 export type ErrorMessage = string;
 
 /**
@@ -7,9 +5,9 @@ export type ErrorMessage = string;
  */
 export interface ResourceParameterOptions {
   /**
-   * Chose if the resource should be re-created or modified if this parameter is changed. Defaults to re-create.
+   * Chose if the resource should be re-created or modified if this parameter is changed. Defaults to false (re-create).
    */
-  planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
+  canModify?: boolean;
   /**
    * Customize the equality comparison for a parameter.
    * @param desired
@@ -19,7 +17,7 @@ export interface ResourceParameterOptions {
   /**
    * Default value for the parameter. If a value is not provided in the config, the library will use this value.
    */
-  default?: unknown,
+  default?: unknown;
 }
 
 /**

package/src/entities/resource.test.ts

@@ -195,8 +195,8 @@ describe('Resource tests', () => {
         super({
           type: 'resource',
           parameterOptions: {
-            propA: { planOperation: ResourceOperation.MODIFY },
-            propB: { planOperation: ResourceOperation.MODIFY },
+            propA: { canModify: true },
+            propB: { canModify: true },
           }
         });
       }
@@ -244,7 +244,7 @@ describe('Resource tests', () => {
           type: 'type',
           dependencies: ['homebrew', 'python'],
           parameterOptions: {
-            propA: { planOperation: ResourceOperation.MODIFY },
+            propA: { canModify: true },
             propB: { statefulParameter },
             propC: { isEqual: (a, b) => true },
           }
@@ -281,7 +281,7 @@ describe('Resource tests', () => {
           type: 'type',
           dependencies: ['homebrew', 'python'],
           parameterOptions: {
-            propA: { planOperation: ResourceOperation.MODIFY },
+            propA: { canModify: true },
             propB: { statefulParameter },
             propC: { isEqual: (a, b) => true },
           }

package/src/entities/resource.ts

@@ -101,7 +101,7 @@ export abstract class Resource<T extends StringIndexedObject> {
 
     // Short circuit here. If the resource is non-existent, there's no point checking stateful parameters
     if (currentParameters == null) {
-      return Plan.create(desiredParameters, null, resourceMetadata, planOptions);
+      return Plan.create(resourceParameters, null, resourceMetadata, planOptions);
     }
 
     // Refresh stateful parameters. These parameters have state external to the resource
@@ -161,7 +161,7 @@ export abstract class Resource<T extends StringIndexedObject> {
 
     for (const pc of statelessParameterChanges) {
       // TODO: When stateful mode is added in the future. Dynamically choose if deletes are allowed
-      await this.applyModify(pc.name, pc.newValue, pc.previousValue, false, plan);
+      await this.applyModify(pc, plan);
     }
 
     const statefulParameterChanges = parameterChanges
@@ -228,21 +228,17 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     const orderedEntries = [...Object.entries(transformParameters)]
       .sort(([keyA], [keyB]) => this.transformParameterOrder.get(keyA)! - this.transformParameterOrder.get(keyB)!)
 
-    for (const [key] of orderedEntries) {
-      if (desired[key] !== null) {
-        const transformedValue = await this.transformParameters.get(key)!.transform(desired[key]);
+    for (const [key, value] of orderedEntries) {
+      const transformedValue = await this.transformParameters.get(key)!.transform(value);
 
-        if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
-          throw new Error(`Transform parameter ${key as string} is attempting to override existing value ${desired[key]}`);
-        }
-
-        Object.entries(transformedValue).forEach(([tvKey, tvValue]) => {
-          // @ts-ignore
-          desired[tvKey] = tvValue;
-        })
-
-        delete desired[key];
+      if (Object.keys(transformedValue).some((k) => desired[k] !== undefined)) {
+        throw new Error(`Transform parameter ${key as string} is attempting to override existing values ${JSON.stringify(transformedValue, null, 2)}`);
       }
+
+      Object.entries(transformedValue).forEach(([tvKey, tvValue]) => {
+        // @ts-ignore
+        desired[tvKey] = tvValue;
+      })
     }
   }
 
@@ -314,7 +310,7 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
 
   abstract applyCreate(plan: Plan<T>): Promise<void>;
 
-  async applyModify(parameterName: keyof T, newValue: unknown, previousValue: unknown, allowDeletes: boolean, plan: Plan<T>): Promise<void> {};
+  async applyModify(pc: ParameterChange<T>, plan: Plan<T>): Promise<void> {};
 
   abstract applyDestroy(plan: Plan<T>): Promise<void>;
 }

package/src/entities/transform-parameter.ts

@@ -1,5 +1,11 @@
 import { StringIndexedObject } from 'codify-schemas';
 
+/**
+ * Transform parameters convert the provided value into
+ * other parameters. Transform parameters will not show up
+ * in the refresh or the plan. Transform parameters get processed after
+ * default values.
+ */
 export abstract class TransformParameter<T extends StringIndexedObject> {
 
   abstract transform(value: any): Promise<Partial<T>>

package/src/index.ts

@@ -16,4 +16,3 @@ export async function runPlugin(plugin: Plugin) {
   const messageHandler = new MessageHandler(plugin);
   process.on('message', (message) => messageHandler.onMessage(message))
 }
-export { ErrorMessage } from './entities/resource-types.js';

package/src/messages/handlers.test.ts

@@ -1,14 +1,25 @@
 import { MessageHandler } from './handlers.js';
 import { Plugin } from '../entities/plugin.js';
-import { describe, it, expect } from 'vitest';
-import { vi } from 'vitest'
+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 { MessageStatus, ResourceOperation } from 'codify-schemas';
 
 describe('Message handler tests', () => {
   it('handles plan requests', async () => {
     const plugin = mock<Plugin>();
     const handler = new MessageHandler(plugin);
 
+    process.send = (message) => {
+      expect(message).toMatchObject({
+        cmd: 'plan_Response',
+        status: MessageStatus.SUCCESS,
+      });
+
+      return true;
+    }
+
     // Message handler also validates the response. That part does not need to be tested
     try {
       await handler.onMessage({
@@ -23,12 +34,23 @@ describe('Message handler tests', () => {
     } catch (e) {}
 
     expect(plugin.plan.mock.calls.length).to.eq(1);
+    process.send = undefined;
   })
 
   it('rejects bad plan requests', async () => {
     const plugin = mock<Plugin>();
     const handler = new MessageHandler(plugin);
 
+    process.send = (message) => {
+      console.log(message);
+      expect(message).toMatchObject({
+        cmd: 'plan_Response',
+        status: MessageStatus.ERROR,
+      });
+
+      return true;
+    }
+
     // Message handler also validates the response. That part does not need to be tested
     try {
       await handler.onMessage({
@@ -39,9 +61,12 @@ describe('Message handler tests', () => {
           prop2: 'B',
         }
       })
-    } catch (e) {}
+    } catch (e) {
+      console.log(e);
+    }
 
     expect(plugin.plan.mock.calls.length).to.eq(0);
+    process.send = undefined;
   })
 
   it('handles apply requests', async () => {
@@ -110,15 +135,123 @@ describe('Message handler tests', () => {
     const plugin = mock<Plugin>();
     const handler = new MessageHandler(plugin);
 
+    process.send = () => true;
+
     // Message handler also validates the response. That part does not need to be tested
-    try {
-      await handler.onMessage({
-        cmd: 'validate',
-        data: {}
-      })
-    } catch (e) {}
+    // This should not throw
+    expect(await handler.onMessage({
+      cmd: 'validate',
+      data: {}
+    })).to.eq(undefined);
 
     expect(plugin.apply.mock.calls.length).to.be.eq(0);
   })
 
+  it('handles errors for plan', async () => {
+    const resource= testResource();
+    const plugin = testPlugin(resource);
+
+    const handler = new MessageHandler(plugin);
+
+    process.send = (message) => {
+      expect(message).toMatchObject({
+        cmd: 'plan_Response',
+        status: MessageStatus.ERROR,
+        data: 'Refresh error',
+      })
+      return true;
+    }
+
+    expect(async () => await handler.onMessage({
+      cmd: 'plan',
+      data: {
+        type: 'resourceA'
+      }
+    })).rejects.to.not.throw;
+
+    process.send = undefined;
+  })
+
+  it('handles errors for apply (create)', async () => {
+    const resource= testResource();
+    const plugin = testPlugin(resource);
+
+    const handler = new MessageHandler(plugin);
+
+    process.send = (message) => {
+      expect(message).toMatchObject({
+        cmd: 'apply_Response',
+        status: MessageStatus.ERROR,
+        data: 'Create error',
+      })
+      return true;
+    }
+
+    expect(async () => await handler.onMessage({
+      cmd: 'apply',
+      data: {
+        plan: {
+          resourceType: 'resourceA',
+          operation: ResourceOperation.CREATE,
+          parameters: []
+        }
+      }
+    })).rejects.to.not.throw;
+  })
+
+  it('handles errors for apply (destroy)', async () => {
+    const resource= testResource();
+    const plugin = testPlugin(resource);
+
+    const handler = new MessageHandler(plugin);
+
+    process.send = (message) => {
+      expect(message).toMatchObject({
+        cmd: 'apply_Response',
+        status: MessageStatus.ERROR,
+        data: 'Destroy error',
+      })
+      return true;
+    }
+
+    expect(async () => await handler.onMessage({
+      cmd: 'apply',
+      data: {
+        plan: {
+          resourceType: 'resourceA',
+          operation: ResourceOperation.DESTROY,
+          parameters: []
+        }
+      }
+    })).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);
+    }
+  }
+
 });

package/src/messages/handlers.ts

@@ -67,45 +67,60 @@ export class MessageHandler {
   }
 
   async onMessage(message: unknown): Promise<void> {
-    if (!this.validateMessage(message)) {
-      throw new Error(`Plugin: ${this.plugin}. Message is malformed: ${JSON.stringify(this.messageSchemaValidator.errors, null, 2)}`);
-    }
+    try {
+      if (!this.validateMessage(message)) {
+        throw new Error(`Plugin: ${this.plugin}. Message is malformed: ${JSON.stringify(this.messageSchemaValidator.errors, null, 2)}`);
+      }
 
-    if (!this.requestValidators.has(message.cmd)) {
-      throw new Error(`Plugin: ${this.plugin}. Unsupported message: ${message.cmd}`);
-    }
+      if (!this.requestValidators.has(message.cmd)) {
+        throw new Error(`Plugin: ${this.plugin}. Unsupported message: ${message.cmd}`);
+      }
 
-    const requestValidator = this.requestValidators.get(message.cmd)!;
-    if (!requestValidator(message.data)) {
-      throw new Error(`Plugin: ${this.plugin}. cmd: ${message.cmd}. Malformed message data: ${JSON.stringify(requestValidator.errors, null, 2)}`)
-    }
+      const requestValidator = this.requestValidators.get(message.cmd)!;
+      if (!requestValidator(message.data)) {
+        throw new Error(`Plugin: ${this.plugin}. cmd: ${message.cmd}. Malformed message data: ${JSON.stringify(requestValidator.errors, null, 2)}`)
+      }
+
+      const result = await SupportedRequests[message.cmd].handler(this.plugin, message.data);
+
+      const responseValidator = this.responseValidators.get(message.cmd);
+      if (responseValidator && !responseValidator(result)) {
+        throw new Error(`Plugin: ${this.plugin}. Malformed response data: ${JSON.stringify(responseValidator.errors, null, 2)}`)
+      }
 
-    let result: unknown;
-    try {
-      result = await SupportedRequests[message.cmd].handler(this.plugin, message.data);
-    } catch(e: any) {
       process.send!({
         cmd: message.cmd + '_Response',
-        status: MessageStatus.ERROR,
-        data: e.message,
+        status: MessageStatus.SUCCESS,
+        data: result,
       })
 
+    } catch (e: unknown) {
+      this.handleErrors(message, e as Error);
+    }
+  }
+
+  private validateMessage(message: unknown): message is IpcMessage {
+    return this.messageSchemaValidator(message);
+  }
+
+  private handleErrors(message: unknown, e: Error) {
+    if (!message) {
       return;
     }
 
-    const responseValidator = this.responseValidators.get(message.cmd);
-    if (responseValidator && !responseValidator(result)) {
-      throw new Error(`Plugin: ${this.plugin}. Malformed response data: ${JSON.stringify(responseValidator.errors, null, 2)}`)
+    if (!message.hasOwnProperty('cmd')) {
+      return;
     }
 
-    process.send!({
-      cmd: message.cmd + '_Response',
-      status: MessageStatus.SUCCESS,
-      data: result,
-    })
-  }
+    // @ts-ignore
+    const cmd = message.cmd + '_Response';
 
-  private validateMessage(message: unknown): message is IpcMessage {
-    return this.messageSchemaValidator(message);
+    const isDebug = process.env.DEBUG?.includes('*') ?? false;
+
+    process.send?.({
+      cmd,
+      status: MessageStatus.ERROR,
+      data: isDebug ? e.stack : e.message,
+    })
   }
 }

package/src/utils/test-utils.test.ts

@@ -3,8 +3,8 @@ import { ChildProcess } from 'node:child_process';
 import { Readable } from 'stream';
 import { mock } from 'node:test';
 import { AssertionError } from 'chai';
-import { CodifyTestUtils } from './test-utils';
-import { describe, it, expect } from 'vitest';
+import { CodifyTestUtils } from './test-utils.js';
+import { describe, expect, it } from 'vitest';
 
 describe('Test Utils tests', async () => {