codify-plugin-lib 1.0.54 → 1.0.56

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

@@ -20,4 +20,5 @@ export declare class ChangeSet<T extends StringIndexedObject> {
     static isSame(desired: unknown, current: unknown, options?: ParameterOptions): boolean;
     private static calculateStatefulModeChangeSet;
     private static calculateStatelessModeChangeSet;
+    private static addDefaultValues;
 }

package/dist/entities/change-set.js

@@ -61,6 +61,7 @@ export class ChangeSet {
         const parameterChangeSet = new Array();
         const _desired = { ...desired };
         const _current = { ...current };
+        this.addDefaultValues(_desired, parameterOptions);
         for (const [k, v] of Object.entries(_current)) {
             if (_desired[k] == null) {
                 parameterChangeSet.push({
@@ -109,6 +110,7 @@ export class ChangeSet {
         const parameterChangeSet = new Array();
         const _desired = { ...desired };
         const _current = { ...current };
+        this.addDefaultValues(_desired, parameterOptions);
         for (const [k, v] of Object.entries(_desired)) {
             if (_current[k] == null) {
                 parameterChangeSet.push({
@@ -137,4 +139,14 @@ export class ChangeSet {
         }
         return parameterChangeSet;
     }
+    static addDefaultValues(obj, options) {
+        Object.entries(options ?? {})
+            .filter(([, option]) => option.default !== undefined)
+            .map(([name, option]) => [name, option.default])
+            .forEach(([key, defaultValue]) => {
+            if (obj[key] === undefined) {
+                obj[key] = defaultValue;
+            }
+        });
+    }
 }

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

@@ -3,6 +3,7 @@ export interface ParameterOptions {
     planOperation?: ResourceOperation.MODIFY | ResourceOperation.RECREATE;
     isEqual?: (desired: any, current: any) => boolean;
     isElementEqual?: (desired: any, current: any) => boolean;
+    default?: unknown;
     isStatefulParameter?: boolean;
 }
 export interface PlanOptions<T> {

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.d.ts

@@ -29,7 +29,6 @@ export declare abstract class Resource<T extends StringIndexedObject> {
     private _applyModify;
     private _applyDestroy;
     private validateRefreshResults;
-    private applyDefaultValueToRefreshResults;
     private applyTransformParameters;
     private addDefaultValues;
     private refreshResourceParameters;

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);
@@ -142,10 +142,8 @@ export class Resource {
         if (!refresh) {
             return;
         }
-        const desiredKeys = new Set([...desiredMap.keys()]
-            .filter((key) => this.defaultValues[key] === undefined));
-        const refreshKeys = new Set([...Object.keys(refresh)]
-            .filter((key) => this.defaultValues[key] === undefined));
+        const desiredKeys = new Set(desiredMap.keys());
+        const refreshKeys = new Set(Object.keys(refresh));
         if (!setsEqual(desiredKeys, refreshKeys)) {
             throw new Error(`Resource ${this.typeId}
 refresh() must return back exactly the keys that were provided
@@ -153,30 +151,17 @@ Missing: ${[...desiredKeys].filter((k) => !refreshKeys.has(k))};
 Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         }
     }
-    applyDefaultValueToRefreshResults(refresh) {
-        if (!refresh) {
-            return;
-        }
-        for (const [key, defaultValue] of Object.entries(this.defaultValues)) {
-            if (refresh[key] === undefined) {
-                refresh[key] = defaultValue;
-            }
-        }
-    }
     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) {
@@ -191,7 +176,6 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`);
         const entriesToRefresh = new Map(Object.entries(resourceParameters));
         const currentParameters = await this.refresh(entriesToRefresh);
         this.validateRefreshResults(currentParameters, entriesToRefresh);
-        this.applyDefaultValueToRefreshResults(currentParameters);
         return currentParameters;
     }
     async refreshStatefulParameters(statefulParametersConfig, isStatefulMode) {

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.54",
+  "version": "1.0.56",
   "description": "",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/entities/change-set.ts

@@ -126,6 +126,8 @@ export class ChangeSet<T extends StringIndexedObject> {
     const _desired = { ...desired };
     const _current = { ...current };
 
+    this.addDefaultValues(_desired, parameterOptions);
+
     for (const [k, v] of Object.entries(_current)) {
       if (_desired[k] == null) {
         parameterChangeSet.push({
@@ -191,6 +193,8 @@ export class ChangeSet<T extends StringIndexedObject> {
     const _desired = { ...desired };
     const _current = { ...current };
 
+    this.addDefaultValues(_desired, parameterOptions);
+
     for (const [k, v] of Object.entries(_desired)) {
       if (_current[k] == null) {
         parameterChangeSet.push({
@@ -224,5 +228,16 @@ export class ChangeSet<T extends StringIndexedObject> {
 
     return parameterChangeSet;
   }
+
+  private static addDefaultValues<T extends StringIndexedObject>(obj: Record<string, unknown>, options?: Record<keyof T, ParameterOptions>) {
+    Object.entries(options ?? {})
+      .filter(([, option]) => option.default !== undefined)
+      .map(([name, option]) => [name, option.default] as const)
+      .forEach(([key, defaultValue]) => {
+        if (obj[key] === undefined) {
+          obj[key] = defaultValue;
+        }
+      })
+  }
     
 }

package/src/entities/plan-types.ts

@@ -17,6 +17,8 @@ export interface ParameterOptions {
 
   isElementEqual?: (desired: any, current: any) => boolean;
 
+  default?: unknown,
+
   isStatefulParameter?: boolean;
 }
 

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

@@ -27,7 +27,7 @@ class TestParameter extends StatefulParameter<TestConfig, string> {
   }
 }
 
-describe('Resource parameters tests', () => {
+describe('Resource parameter tests', () => {
   it('supports the creation of stateful parameters', async () => {
 
     const statefulParameter = new class extends TestParameter {

package/src/entities/resource.test.ts

@@ -26,7 +26,7 @@ export class TestResource extends Resource<TestConfig> {
     return Promise.resolve(undefined);
   }
 
-  async refresh(): Promise<Partial<TestConfig> | null> {
+  async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
     return {
       propA: 'a',
       propB: 10,
@@ -329,8 +329,12 @@ describe('Resource tests', () => {
         });
       }
 
-      async refresh(): Promise<Partial<TestConfig> | null> {
-        return {};
+      async refresh(keys: Map<string, unknown>): Promise<Partial<TestConfig> | null> {
+        expect(keys.has('propE')).to.be.true;
+
+        return {
+          propE: keys.get('propE'),
+        };
       }
     }
 
@@ -340,6 +344,28 @@ describe('Resource tests', () => {
     expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
   })
 
+  it('Allows default values to be added even when refresh returns null', async () => {
+    const resource = new class extends TestResource {
+      constructor() {
+        super({
+          type: 'type',
+          parameterOptions: {
+            propE: { default: 'propEDefault' }
+          }
+        });
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    }
+
+    const plan = await resource.plan({ type: 'resource'})
+    expect(plan.currentConfig.propE).to.eq(null);
+    expect(plan.desiredConfig.propE).to.eq('propEDefault');
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.CREATE);
+  })
+
   it('Allows default values to be added (ignore default value if already present)', async () => {
     const resource = new class extends TestResource {
       constructor() {

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
@@ -211,15 +211,8 @@ export abstract class Resource<T extends StringIndexedObject> {
       return;
     }
 
-    const desiredKeys = new Set<keyof T>(
-      [...desiredMap.keys()]
-        .filter((key) => this.defaultValues[key] === undefined)
-    );
-
-    const refreshKeys = new Set(
-      [...Object.keys(refresh)]
-        .filter((key) => this.defaultValues[key] === undefined)
-    ) as Set<keyof T>;
+    const desiredKeys = new Set<keyof T>(desiredMap.keys());
+    const refreshKeys = new Set(Object.keys(refresh)) as Set<keyof T>;
 
     if (!setsEqual(desiredKeys, refreshKeys)) {
       throw new Error(
@@ -231,38 +224,21 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     }
   }
 
-  private applyDefaultValueToRefreshResults(refresh: Partial<T> | null) {
-    if (!refresh) {
-      return;
-    }
-
-    for (const [key, defaultValue] of Object.entries(this.defaultValues)) {
-      if (refresh[key] === undefined) {
-        // @ts-ignore
-        refresh[key] = defaultValue;
-      }
-    }
-  }
-
   private async applyTransformParameters(transformParameters: Partial<T>, desired: Partial<T>): Promise<void> {
     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 as string} is attempting to override existing value ${desired[key]}`);
-        }
-
-        Object.entries(transformedValue).forEach(([tvKey, tvValue]) => {
-          // @ts-ignore
-          desired[tvKey] = tvValue;
-        })
+    for (const [key, value] of orderedEntries) {
+      const transformedValue = await this.transformParameters.get(key)!.transform(value);
 
-        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;
+      })
     }
   }
 
@@ -281,8 +257,6 @@ Additional: ${[...refreshKeys].filter(k => !desiredKeys.has(k))};`
     const currentParameters = await this.refresh(entriesToRefresh);
 
     this.validateRefreshResults(currentParameters, entriesToRefresh);
-    this.applyDefaultValueToRefreshResults(currentParameters);
-
     return currentParameters;
   }
 

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 () => {