Add response error handling to IPC package

packages/ipc/src/IpcClientService.ts

@@ -3,7 +3,7 @@ import assert from "assert";
 import { Microservice } from "@autoplex/microservice";
 import AbstractIpcService from "./AbstractIpcService";
 import { IIpcResponse, IIpcRequest, IPC } from "./schema";
-import { IpcConnectionError, IpcTimeoutError } from "./IpcError";
+import { IpcConnectionError, IpcError, IpcResponseError, IpcTimeoutError } from "./IpcError";
 
 export abstract class IpcClientService<M extends Microservice = Microservice> extends AbstractIpcService<M>
 {
@@ -123,8 +123,8 @@ export abstract class IpcClientService<M extends Microservice = Microservice> ex
     /**
      * Perform a general request and wait for a response
      */
-    protected async request(method: string, data?: any, timeout: number|null = null) {
-        return new Promise<IIpcResponse>((resolve, reject) => {
+    protected async request<T = any>(method: string, data?: T, timeout: number|null = null) {
+        return new Promise<IIpcResponse<T>>((resolve, reject) => {
             // If the client is not connected to a server, reject immediately
             if (!this.__isConnected || this.__socket === null) {
                 reject(new IpcConnectionError("Not connected"));
@@ -143,12 +143,16 @@ export abstract class IpcClientService<M extends Microservice = Microservice> ex
                 this.__socket.off("destroy", respond);
             };
             // Handle the response
-            let respond = (response: IIpcResponse) => {
+            let respond = (response: IIpcResponse<T>) => {
                 cleanUp();
+                if (response.error !== undefined) {
+                    reject(new IpcResponseError<T>(response.error, response.data));
+                    return;
+                }
                 resolve(response);
             };
             // Abort the request
-            let abort = (error: Error) => {
+            let abort = (error: IpcError) => {
                 cleanUp();
                 reject(error);
             };

packages/ipc/src/IpcError.ts

@@ -27,3 +27,19 @@ export class IpcTimeoutError extends IpcError {
 		Object.setPrototypeOf(this, IpcTimeoutError.prototype);
 	}
 }
+
+/**
+ * IPC response error type
+ */
+export class IpcResponseError<T> extends IpcError {
+	/**
+	 * Store the response data
+	 */
+	public readonly data: T;
+
+	constructor(message: string, data: T) {
+		super(message);
+		this.data = data;
+		Object.setPrototypeOf(this, IpcResponseError.prototype);
+	}
+}

packages/ipc/src/schema.ts

@@ -4,16 +4,16 @@ import type RawIPC = require("node-ipc");
  * The IPC request structure
  */
 export interface IIpcRequest {
-	id: number|null,
-	data    ?: any
+	id   : number|null,
+	data?: any
 }
 
 /**
  * The IPC response structure
  */
-export interface IIpcResponse {
-	data ?: any,
-	error?: string | Error
+export interface IIpcResponse<T> {
+	data  : T,
+	error?: string
 }
 
 /**