more error/warning fixes

1 files changed, 51 insertions, 45 deletions

diff --git a/src/server/DashSession/Session/agents/promisified_ipc_manager.ts b/src/server/DashSession/Session/agents/promisified_ipc_manager.ts
index f6c8de521..76e218977 100644
--- a/src/server/DashSession/Session/agents/promisified_ipc_manager.ts
+++ b/src/server/DashSession/Session/agents/promisified_ipc_manager.ts
@@ -1,9 +1,9 @@
-import { Utilities } from "../utilities/utilities";
-import { ChildProcess } from "child_process";
+import { Utilities } from '../utilities/utilities';
+import { ChildProcess } from 'child_process';
 
 /**
  * Convenience constructor
- * @param target the process / worker to which to attach the specialized listeners 
+ * @param target the process / worker to which to attach the specialized listeners
  */
 export function manage(target: IPCTarget, handlers?: HandlerMap) {
     return new PromisifiedIPCManager(target, handlers);
@@ -18,26 +18,30 @@ export type HandlerMap = { [name: string]: MessageHandler[] };
 /**
  * This will always literally be a child process. But, though setting
  * up a manager in the parent will indeed see the target as the ChildProcess,
- * setting up a manager in the child will just see itself as a regular NodeJS.Process. 
+ * setting up a manager in the child will just see itself as a regular NodeJS.Process.
  */
 export type IPCTarget = NodeJS.Process | ChildProcess;
 
 /**
- * Specifies a general message format for this API 
+ * Specifies a general message format for this API
  */
 export type Message<T = any> = {
     name: string;
     args?: T;
 };
-export type MessageHandler<T = any> = (args: T) => (any | Promise<any>);
+export type MessageHandler<T = any> = (args: T) => any | Promise<any>;
 
 /**
  * When a message is emitted, it is embedded with private metadata
  * to facilitate the resolution of promises, etc.
  */
-interface InternalMessage extends Message { metadata: Metadata; }
-interface Metadata { isResponse: boolean; id: string; }
-type InternalMessageHandler = (message: InternalMessage) => (any | Promise<any>);
+interface InternalMessage extends Message {
+    metadata: Metadata;
+}
+interface Metadata {
+    isResponse: boolean;
+    id: string;
+}
 
 /**
  * Allows for the transmission of the error's key features over IPC.
@@ -56,12 +60,12 @@ export interface Response<T = any> {
     error?: ErrorLike;
 }
 
-const destroyEvent = "__destroy__";
+const destroyEvent = '__destroy__';
 
 /**
  * This is a wrapper utility class that allows the caller process
  * to emit an event and return a promise that resolves when it and all
- * other processes listening to its emission of this event have completed. 
+ * other processes listening to its emission of this event have completed.
  */
 export class PromisifiedIPCManager {
     private readonly target: IPCTarget;
@@ -75,7 +79,7 @@ export class PromisifiedIPCManager {
         this.target = target;
         if (handlers) {
             handlers[destroyEvent] = [this.destroyHelper];
-            this.target.addListener("message", this.generateInternalHandler(handlers));
+            this.target.addListener('message', this.generateInternalHandler(handlers));
         }
     }
 
@@ -86,26 +90,27 @@ export class PromisifiedIPCManager {
      */
     public emit = async <T = any>(name: string, args?: any): Promise<Response<T>> => {
         if (this.isDestroyed) {
-            const error = { name: "FailedDispatch", message: "Cannot use a destroyed IPC manager to emit a message." };
+            const error = { name: 'FailedDispatch', message: 'Cannot use a destroyed IPC manager to emit a message.' };
             return { error };
         }
         return new Promise<Response<T>>(resolve => {
             const messageId = Utilities.guid();
+            type InternalMessageHandler = (message: any /* MessageListener*/) => any | Promise<any>;
             const responseHandler: InternalMessageHandler = ({ metadata: { id, isResponse }, args }) => {
                 if (isResponse && id === messageId) {
-                    this.target.removeListener("message", responseHandler);
+                    this.target.removeListener('message', responseHandler);
                     resolve(args);
                 }
             };
-            this.target.addListener("message", responseHandler);
+            this.target.addListener('message', responseHandler);
             const message = { name, args, metadata: { id: messageId, isResponse: false } };
             if (!(this.target.send && this.target.send(message))) {
-                const error: ErrorLike = { name: "FailedDispatch", message: "Either the target's send method was undefined or the act of sending failed." };
+                const error: ErrorLike = { name: 'FailedDispatch', message: "Either the target's send method was undefined or the act of sending failed." };
                 resolve({ error });
-                this.target.removeListener("message", responseHandler);
+                this.target.removeListener('message', responseHandler);
             }
         });
-    }
+    };
 
     /**
      * Invoked from either the parent or the child process, this allows
@@ -122,7 +127,7 @@ export class PromisifiedIPCManager {
             }
             resolve();
         });
-    }
+    };
 
     /**
      * Dispatches the dummy responses and sets the isDestroyed flag to true.
@@ -131,12 +136,12 @@ export class PromisifiedIPCManager {
         const { pendingMessages } = this;
         this.isDestroyed = true;
         Object.keys(pendingMessages).forEach(id => {
-            const error: ErrorLike = { name: "ManagerDestroyed", message: "The IPC manager was destroyed before the response could be returned." };
+            const error: ErrorLike = { name: 'ManagerDestroyed', message: 'The IPC manager was destroyed before the response could be returned.' };
             const message: InternalMessage = { name: pendingMessages[id], args: { error }, metadata: { id, isResponse: true } };
             this.target.send?.(message);
         });
         this.pendingMessages = {};
-    }
+    };
 
     /**
      * This routine receives a uniquely identified message. If the message is itself a response,
@@ -145,29 +150,30 @@ export class PromisifiedIPCManager {
      * which will ultimately invoke the responseHandler of the original emission and resolve the
      * sender's promise.
      */
-    private generateInternalHandler = (handlers: HandlerMap): MessageHandler => async (message: InternalMessage) => {
-        const { name, args, metadata } = message;
-        if (name && metadata && !metadata.isResponse) {
-            const { id } = metadata;
-            this.pendingMessages[id] = name;
-            let error: Error | undefined;
-            let results: any[] | undefined;
-            try {
-                const registered = handlers[name];
-                if (registered) {
-                    results = await Promise.all(registered.map(handler => handler(args)));
+    private generateInternalHandler =
+        (handlers: HandlerMap): MessageHandler =>
+        async (message: InternalMessage) => {
+            const { name, args, metadata } = message;
+            if (name && metadata && !metadata.isResponse) {
+                const { id } = metadata;
+                this.pendingMessages[id] = name;
+                let error: Error | undefined;
+                let results: any[] | undefined;
+                try {
+                    const registered = handlers[name];
+                    if (registered) {
+                        results = await Promise.all(registered.map(handler => handler(args)));
+                    }
+                } catch (e: any) {
+                    error = e;
+                }
+                if (!this.isDestroyed && this.target.send) {
+                    const metadata = { id, isResponse: true };
+                    const response: Response = { results, error };
+                    const message = { name, args: response, metadata };
+                    delete this.pendingMessages[id];
+                    this.target.send(message);
                 }
-            } catch (e: any) {
-                error = e;
-            }
-            if (!this.isDestroyed && this.target.send) {
-                const metadata = { id, isResponse: true };
-                const response: Response = { results, error };
-                const message = { name, args: response, metadata };
-                delete this.pendingMessages[id];
-                this.target.send(message);
             }
-        }
-    }
-
-}
\ No newline at end of file
+        };
+}