hl7v2-net 1.8.2 → 1.9.0

package/README.md

@@ -113,7 +113,7 @@ await server.close(5000); // Wait up to 5s for running handlers
 
 ##### .use()
 
-Adds a middleware handler to the server.
+Adds a middleware handler or another router to the server.
 `use(handler: HL7Middleware | HL7Router, priority?: number): void`
 example
 
@@ -124,6 +124,20 @@ server.use((req, res, next) => {
 });
 ```
 
+##### .onError()
+
+Adds an error middleware handler or another router to the server.
+`onError(handler: HL7ErrorMiddleware | HL7Router, priority?: number): void`
+example
+
+```typescript
+server.onError((err, req, res, next) => {
+  console.error(err);
+  res.failed(err);
+  next();
+});
+```
+
 ---
 
 ### Hl7Client
@@ -251,6 +265,18 @@ router.use((req, res) => { ... });
 server.use(router);
 ```
 
+##### .onError()
+
+Adds an error middleware or another router to this router.
+`onError(handler: HL7ErrorMiddleware | HL7Router, priority?: number): void`
+example
+
+```typescript
+const router = new HL7Router();
+router.onError((err, req, res, next) => { ... });
+server.use(router);
+```
+
 ---
 
 ### HL7Request

package/hl7-client.js

@@ -194,8 +194,8 @@ export class Hl7Client extends AsyncEventEmitter {
         const req = new HL7Request(this._socket, message);
         const res = new HL7Response(req);
         this._router.handle(req, res, () => {
-            if (res.errors.length)
-                this.emit('error', res.errors[0]);
+            if (res.error)
+                this.emit('error', res.error);
         });
     }
 }

package/hl7-response.d.ts

@@ -4,7 +4,7 @@ import type { HL7Socket } from './hl7-socket.js';
 export declare class HL7Response {
     protected _finished: boolean;
     readonly request: HL7Request;
-    errors: Error[];
+    error?: Error;
     message: HL7Message;
     constructor(request: HL7Request);
     get socket(): HL7Socket;

package/hl7-response.js

@@ -2,7 +2,7 @@ import { MSASegment } from 'hl7v2';
 export class HL7Response {
     _finished = false;
     request;
-    errors = [];
+    error;
     message;
     constructor(request) {
         this.request = request;
@@ -18,10 +18,9 @@ export class HL7Response {
         return this._finished;
     }
     failed(error) {
+        this.error = error;
         const msa = this.message.getSegment('MSA');
         if (msa?.field(MSASegment.AcknowledgmentCode).getValue() !== 'AE')
-            this.message = this.request.message.createNak(this.errors);
-        this.errors.push(error);
-        this.message.addError(error);
+            this.message = this.request.message.createNak([error]);
     }
 }

package/hl7-router.d.ts

@@ -1,11 +1,17 @@
 import { HL7Request } from './hl7-request.js';
 import { HL7Response } from './hl7-response.js';
-import type { HL7Middleware } from './types.js';
+import type { HL7ErrorMiddleware, HL7Middleware } from './types.js';
 export declare class HL7Router {
     protected _handlerStack: Map<number, (HL7Middleware | HL7Router)[]>;
+    protected _errorHandlerStack: Map<number, (HL7ErrorMiddleware | HL7Router)[]>;
     protected _needPrepare: boolean;
     protected _handlers: HL7Middleware[];
+    protected _errorHandlers: HL7ErrorMiddleware[];
     use(handler: HL7Middleware | HL7Router, priority?: number): void;
-    handle(req: HL7Request, res: HL7Response, callback: () => void): void | Promise<void>;
-    protected _prepareStack(root?: boolean): void;
+    onError(handler: HL7ErrorMiddleware | HL7Router, priority?: number): void;
+    handle(req: HL7Request, res: HL7Response, callback: (err?: Error) => void): void;
+    protected _handle(req: HL7Request, res: HL7Response, callback: (err?: Error) => void): void;
+    protected _handleError(error: any, req: HL7Request, res: HL7Response, callback: (err?: any) => void): void | Promise<void>;
+    protected _prepareStack(): void;
+    protected _finalHandler(req: HL7Request, res: HL7Response): void;
 }

package/hl7-router.js

@@ -1,7 +1,7 @@
 export class HL7Router {
     _handlerStack = new Map();
+    _errorHandlerStack = new Map();
     _needPrepare = true;
-    _handlers = [];
     use(handler, priority = 0) {
         let list = this._handlerStack.get(priority);
         if (!list) {
@@ -11,63 +11,118 @@ export class HL7Router {
         list.push(handler);
         this._needPrepare = true;
     }
+    onError(handler, priority = 0) {
+        let list = this._errorHandlerStack.get(priority);
+        if (!list) {
+            list = [];
+            this._errorHandlerStack.set(priority, list);
+        }
+        list.push(handler);
+        this._needPrepare = true;
+    }
     handle(req, res, callback) {
-        this._prepareStack(true);
-        let handlerIdx = -1;
+        this._prepareStack();
         let callbackCalled = false;
-        const doCallback = () => {
+        this._handle(req, res, err => {
             if (callbackCalled)
                 return;
             callbackCalled = true;
-            callback();
-        };
-        const next = async () => {
+            try {
+                if (err)
+                    res.failed(err);
+                this._finalHandler(req, res);
+                callback(err);
+            }
+            catch (e) {
+                callback(e instanceof Error ? e : new Error(e));
+            }
+        });
+    }
+    _handle(req, res, callback) {
+        let handlerIdx = -1;
+        const next = async (err) => {
+            if (err) {
+                this._handleError(err, req, res, callback);
+                return;
+            }
             try {
                 handlerIdx++;
                 const handler = this._handlers[handlerIdx];
-                if (handler) {
-                    if (handler.length < 3) {
-                        await handler(req, res);
-                        next();
-                        return;
-                    }
-                    handler(req, res, next);
+                if (!handler)
+                    return callback();
+                if (handler.length < 3) {
+                    await handler(req, res);
+                    next();
                     return;
                 }
-                doCallback();
-                return;
+                await handler(req, res, next);
+            }
+            catch (e) {
+                this._handleError(e, req, res, callback);
+            }
+        };
+        next();
+    }
+    _handleError(error, req, res, callback) {
+        let handlerIdx = -1;
+        const next = async (err) => {
+            if (err)
+                error = err;
+            try {
+                handlerIdx++;
+                const handler = this._errorHandlers[handlerIdx];
+                if (!handler)
+                    return callback(error);
+                if (handler.length < 4) {
+                    await handler(error, req, res);
+                    next();
+                    return;
+                }
+                await handler(error, req, res, next);
             }
             catch (e) {
-                res.failed(e);
-                return next();
+                callback(e);
             }
         };
-        return next();
+        return next(error);
     }
-    _prepareStack(root) {
+    _prepareStack() {
         if (!this._needPrepare)
             return;
         this._needPrepare = false;
+        this._handlers = [];
+        this._errorHandlers = [];
         Array.from(this._handlerStack.keys())
             .sort()
             .forEach(p => {
             const list = this._handlerStack.get(p);
-            for (const h of list) {
-                if (h instanceof HL7Router) {
-                    h._prepareStack(false);
-                    this._handlers.push(...h._handlers);
+            for (const x of list) {
+                if (x instanceof HL7Router) {
+                    x._prepareStack();
+                    this._handlers.push(...x._handlers);
+                }
+                else {
+                    this._handlers.push(x);
                 }
-                else
-                    this._handlers.push(h);
             }
         });
-        if (root) {
-            const finalHandler = (req, res) => {
-                if (res.finished || req.message.messageType.startsWith('ACK^'))
-                    return;
-                req.socket.sendMessage(res.message);
-            };
-            this._handlers.push(finalHandler);
-        }
+        Array.from(this._errorHandlerStack.keys())
+            .sort()
+            .forEach(p => {
+            const list = this._errorHandlerStack.get(p);
+            for (const x of list) {
+                if (x instanceof HL7Router) {
+                    x._prepareStack();
+                    this._errorHandlers.push(...x._errorHandlers);
+                }
+                else {
+                    this._errorHandlers.push(x);
+                }
+            }
+        });
+    }
+    _finalHandler(req, res) {
+        if (!res.finished)
+            req.socket.sendMessage(res.message);
     }
 }

package/hl7-server.d.ts

@@ -6,7 +6,7 @@ import { AddressInfo, ListenOptions, Socket } from 'net';
 import { AsyncEventEmitter } from 'node-events-async';
 import { HL7Router } from './hl7-router.js';
 import { HL7Socket } from './hl7-socket.js';
-import { HL7Middleware } from './types.js';
+import { HL7ErrorMiddleware, HL7Middleware } from './types.js';
 export declare class HL7Server extends AsyncEventEmitter<HL7Server.Events> {
     protected _server: net.Server | tls.Server;
     protected _sockets: Set<HL7Socket>;
@@ -78,7 +78,8 @@ export declare class HL7Server extends AsyncEventEmitter<HL7Server.Events> {
      * connections.
      */
     close(waitRunningHandlers?: number): Promise<void>;
-    use(handler: HL7Middleware, priority?: number): void;
+    use(handler: HL7Router | HL7Middleware, priority?: number): void;
+    onError(handler: HL7Router | HL7ErrorMiddleware, priority?: number): void;
     /**
      * Asynchronously get the number of concurrent connections on the server. Works
      * when sockets were sent to forks.

package/hl7-server.js

@@ -146,6 +146,9 @@ export class HL7Server extends AsyncEventEmitter {
     use(handler, priority = 0) {
         this._router.use(handler, priority);
     }
+    onError(handler, priority = 0) {
+        this._router.onError(handler, priority);
+    }
     /**
      * Asynchronously get the number of concurrent connections on the server. Works
      * when sockets were sent to forks.
@@ -217,10 +220,10 @@ export class HL7Server extends AsyncEventEmitter {
                     resolve();
                 }
             }, this.responseTimeout || 30000).unref();
-            this._router.handle(req, res, () => {
+            this._router.handle(req, res, err => {
                 clearTimeout(timeoutTimer);
-                if (res.errors.length)
-                    this.emit('error', res.errors[0], socket);
+                if (err)
+                    this.emit('error', err, socket);
                 resolve();
             });
         });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hl7v2-net",
   "description": "HL7 v2 server/client for NodeJS",
-  "version": "1.8.2",
+  "version": "1.9.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
@@ -17,8 +17,8 @@
     "uid": "^2.0.2"
   },
   "peerDependencies": {
-    "hl7v2": "^1.8.2",
-    "hl7v2-dictionary": "^1.8.2"
+    "hl7v2": "^1.9.0",
+    "hl7v2-dictionary": "^1.9.0"
   },
   "type": "module",
   "module": "./index.js",

package/types.d.ts

@@ -1,4 +1,5 @@
 import { HL7Request } from './hl7-request.js';
 import { HL7Response } from './hl7-response.js';
-export type NextFunction = () => void | Promise<void>;
+export type NextFunction = (err?: Error) => void | Promise<void>;
 export type HL7Middleware = ((req: HL7Request, res: HL7Response) => void) | ((req: HL7Request, res: HL7Response) => Promise<void>) | ((req: HL7Request, res: HL7Response, next: NextFunction) => void);
+export type HL7ErrorMiddleware = ((error: Error, req: HL7Request, res: HL7Response) => void) | ((error: Error, req: HL7Request, res: HL7Response) => Promise<void>) | ((error: Error, req: HL7Request, res: HL7Response, next: NextFunction) => void);