hl7v2-net 1.0.2 → 1.1.0

package/cjs/h-l7-request-context.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HL7RequestContext = void 0;
+const hl7v2_1 = require("hl7v2");
+const node_events_async_1 = require("node-events-async");
+const uid_1 = require("uid");
+class HL7RequestContext extends node_events_async_1.AsyncEventEmitter {
+    constructor(socket, message) {
+        super();
+        this._finished = false;
+        this.socket = socket;
+        this.request = message;
+        if (!message.header.field(hl7v2_1.MSHSegment.MessageControlID).getValue())
+            message.header.field(hl7v2_1.MSHSegment.MessageControlID).setValue((0, uid_1.uid)(8));
+    }
+    get finished() {
+        return this._finished || !this.socket.connected;
+    }
+    end(message) {
+        if (this.finished || !this.socket.connected)
+            return;
+        if (message)
+            this.socket.sendMessage(message);
+        this._finished = true;
+        this.emit('finish', message);
+    }
+}
+exports.HL7RequestContext = HL7RequestContext;

package/cjs/hl7-client.js

@@ -4,8 +4,7 @@ exports.Hl7Client = void 0;
 const tslib_1 = require("tslib");
 const node_net_1 = tslib_1.__importDefault(require("node:net"));
 const node_events_async_1 = require("node-events-async");
-const hl7_request_js_1 = require("./hl7-request.js");
-const hl7_response_js_1 = require("./hl7-response.js");
+const h_l7_request_context_js_1 = require("./h-l7-request-context.js");
 const hl7_router_js_1 = require("./hl7-router.js");
 const hl7_socket_js_1 = require("./hl7-socket.js");
 class Hl7Client extends node_events_async_1.AsyncEventEmitter {
@@ -101,11 +100,10 @@ class Hl7Client extends node_events_async_1.AsyncEventEmitter {
         this._router.use(handler, priority);
     }
     _onMessage(message) {
-        const req = new hl7_request_js_1.HL7Request(this._socket, message);
-        const res = new hl7_response_js_1.HL7Response(req);
-        this._router.handle(undefined, req, res, error => {
-            if (error)
-                this.emit('error', error);
+        const context = new h_l7_request_context_js_1.HL7RequestContext(this._socket, message);
+        this._router.handle(context, () => {
+            if (context.error)
+                this.emit('error', context.error);
         });
     }
 }

package/cjs/hl7-router.js

@@ -1,104 +1,95 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HL7Router = void 0;
+const tslib_1 = require("tslib");
+const node_process_1 = tslib_1.__importDefault(require("node:process"));
+const hl7v2_dictionary_1 = require("hl7v2-dictionary");
+const hl7_exchange_error_js_1 = require("./helpers/hl7-exchange-error.js");
 class HL7Router {
     constructor() {
-        this._allHandlers = {};
+        this._handlerStack = new Map();
+        this._needPrepare = true;
         this._handlers = [];
-        this._errorHandlers = [];
     }
     use(handler, priority = 0) {
-        let list = this._allHandlers[priority];
+        let list = this._handlerStack[priority];
         if (!list) {
             list = [];
-            this._allHandlers[priority] = list;
-        }
-        if (typeof handler === 'function')
-            list.push(handler);
-        else {
-            // noinspection SuspiciousTypeOfGuard
-            if (handler instanceof HL7Router) {
-                list.push((req, res, next) => {
-                    handler.handle(undefined, req, res, error => {
-                        if (!res.finished)
-                            next(error);
-                    });
-                });
-                list.push((err, req, res, next) => {
-                    handler.handle(err, req, res, error => {
-                        if (!res.finished)
-                            next(error);
-                    });
-                });
-            } /* c8 ignore else */
-            else {
-                throw new TypeError('Router handler must be a function or HL7Router');
-            }
+            this._handlerStack.set(priority, list);
         }
+        list.push(handler);
         this._needPrepare = true;
     }
-    handle(error, req, res, callback) {
-        this._prepareStack();
-        let errIdx = -1;
+    handle(context, callback) {
+        this._prepareStack(true);
         let handlerIdx = -1;
-        let lastErr;
         let callbackCalled = false;
-        const doCallback = (err) => {
+        const doCallback = () => {
             if (callbackCalled)
                 return;
             callbackCalled = true;
-            res.removeListener('finish', onFinish);
-            callback(err);
+            context.removeListener('finish', onFinish);
+            callback();
         };
         const onFinish = () => doCallback();
-        res.once('finish', onFinish);
+        context.once('finish', onFinish);
         const next = (err) => {
-            lastErr = err || lastErr;
-            if (res.finished) {
-                doCallback();
+            if (context.finished)
                 return;
-            }
+            context.error = context.error || err;
             try {
-                if (err) {
-                    errIdx++;
-                    const handler = this._errorHandlers[errIdx];
-                    if (!handler) {
-                        doCallback(lastErr);
-                        return;
-                    }
-                    handler(err, req, res, next);
-                    return;
-                }
-                else {
-                    handlerIdx++;
-                    const handler = this._handlers[handlerIdx];
-                    if (!handler) {
-                        doCallback(lastErr);
-                        return;
-                    }
-                    handler(req, res, next);
+                handlerIdx++;
+                const handler = this._handlers[handlerIdx];
+                if (handler) {
+                    handler(context, next);
                     return;
                 }
+                doCallback();
             }
             catch (e) {
                 next(e);
             }
         };
-        next(error);
+        next();
     }
-    _prepareStack() {
+    _prepareStack(final) {
         if (!this._needPrepare)
             return;
-        delete this._needPrepare;
-        this._errorHandlers = [];
+        this._needPrepare = false;
         this._handlers = [];
-        Object.keys(this._allHandlers).forEach(p => {
-            const h = this._allHandlers[p];
-            if (h.length === 4)
-                this._errorHandlers.push(...h);
-            else
-                this._handlers.push(...h);
+        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);
+                }
+                else
+                    this._handlers.push(h);
+            }
         });
+        if (final) {
+            const finalHandler = (ctx) => {
+                if (ctx.finished)
+                    return;
+                const error = ctx.error ||
+                    new hl7_exchange_error_js_1.HL7ExchangeError('There is not handler to process this message', {
+                        request: ctx.request,
+                    });
+                const ack = ctx.request.createAck('AE', error);
+                if ((node_process_1.default?.env.NODE_ENV || '').startsWith('dev')) {
+                    const errSeg = ack.getSegment('ERR');
+                    if (errSeg)
+                        errSeg
+                            .field(hl7v2_dictionary_1.ERRSegment.DiagnosticInformation)
+                            .setValue(error.stack);
+                }
+                ctx.end(ack);
+            };
+            this._handlers.push(finalHandler);
+        }
     }
 }
 exports.HL7Router = HL7Router;

package/cjs/hl7-server.js

@@ -3,13 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HL7Server = void 0;
 const tslib_1 = require("tslib");
 const node_net_1 = tslib_1.__importDefault(require("node:net"));
-const process = tslib_1.__importStar(require("node:process"));
 const node_tls_1 = tslib_1.__importDefault(require("node:tls"));
-const hl7v2_1 = require("hl7v2");
 const node_events_async_1 = require("node-events-async");
+const h_l7_request_context_js_1 = require("./h-l7-request-context.js");
 const hl7_exchange_error_js_1 = require("./helpers/hl7-exchange-error.js");
-const hl7_request_js_1 = require("./hl7-request.js");
-const hl7_response_js_1 = require("./hl7-response.js");
 const hl7_router_js_1 = require("./hl7-router.js");
 const hl7_socket_js_1 = require("./hl7-socket.js");
 class HL7Server extends node_events_async_1.AsyncEventEmitter {
@@ -190,46 +187,27 @@ class HL7Server extends node_events_async_1.AsyncEventEmitter {
             this._sockets.delete(socket);
             this.emit('disconnect', socket);
         });
+        socket.on('error', error => this.emit('error', error, socket));
         this.emit('connection', socket);
     }
     _onMessage(socket, message) {
-        const req = new hl7_request_js_1.HL7Request(socket, message);
-        const res = new hl7_response_js_1.HL7Response(req);
         const waitPromise = new Promise(resolve => {
+            const context = new h_l7_request_context_js_1.HL7RequestContext(socket, message);
             const timeoutTimer = setTimeout(() => {
                 try {
                     const error = new hl7_exchange_error_js_1.HL7ExchangeError('Response timeout');
-                    const ack = req.message.createAck('AE', error);
-                    res.send(ack);
+                    const ack = context.request.createAck('AE', error);
+                    context.end(ack);
                 }
                 finally {
                     resolve();
                 }
             }, this.responseTimeout || 30000).unref();
-            this._router.handle(undefined, req, res, error => {
+            this._router.handle(context, () => {
                 clearTimeout(timeoutTimer);
-                try {
-                    if (!res.finished) {
-                        error =
-                            error ||
-                                new hl7_exchange_error_js_1.HL7ExchangeError('No middleware handled the request', {
-                                    request: req.message,
-                                });
-                        const ack = req.message.createAck('AE', error);
-                        if ((process?.env.NODE_ENV || '').startsWith('dev')) {
-                            const errSeg = ack.getSegment('ERR');
-                            if (errSeg)
-                                errSeg.field(hl7v2_1.ERRSegment.DiagnosticInformation).value =
-                                    error.stack;
-                        }
-                        res.send(ack);
-                    }
-                    if (error)
-                        this.emit('error', error, socket);
-                }
-                finally {
-                    resolve();
-                }
+                if (context.error)
+                    this.emit('error', context.error, socket);
+                resolve();
             });
         });
         this._runningHandlers.add(waitPromise);

package/cjs/hl7-socket.js

@@ -6,10 +6,10 @@ const hl7v2_1 = require("hl7v2");
 const iconv_lite_1 = tslib_1.__importDefault(require("iconv-lite"));
 const node_events_async_1 = require("node-events-async");
 const frame_stream_js_1 = require("./helpers/frame-stream.js");
-const hl7_exchange_error_js_1 = require("./helpers/hl7-exchange-error.js");
 class HL7Socket extends node_events_async_1.AsyncEventEmitter {
     constructor(socket, options) {
         super();
+        this._messageHooks = new Set();
         this._waitPromises = new Set();
         this.socket = socket;
         this._options = options;
@@ -74,10 +74,12 @@ class HL7Socket extends node_events_async_1.AsyncEventEmitter {
     sendMessage(message) {
         if (!this.connected)
             throw new Error('Socket is not connected');
-        let encoding = message.header.field(hl7v2_1.MSHSegment.CharacterSet).value;
+        if (!this.socket.writable)
+            throw new Error('Socket is not writable');
+        let encoding = message.header.field(hl7v2_1.MSHSegment.CharacterSet).getValue();
         if (!encoding) {
             encoding = 'UTF-8';
-            message.header.field(hl7v2_1.MSHSegment.CharacterSet).value = encoding;
+            message.header.field(hl7v2_1.MSHSegment.CharacterSet).setValue(encoding);
         }
         const str = message.toHL7String();
         const buf = iconv_lite_1.default.encode(str, encoding);
@@ -90,26 +92,17 @@ class HL7Socket extends node_events_async_1.AsyncEventEmitter {
         const responseTimeout = this.responseTimeout;
         const waitPromise = new Promise((resolve, reject) => {
             let responseTimer;
-            const onMessage = (resp) => {
-                const msgType2 = resp.header.field(hl7v2_1.MSHSegment.MessageType).value;
+            const messageHook = (resp) => {
+                const msgType2 = resp.header.field(hl7v2_1.MSHSegment.MessageType).getValue();
                 if (msgType2 !== 'ACK')
-                    return;
+                    return false;
                 const msa = resp.getSegment('MSA');
-                if (!msa) {
-                    const err = new hl7_exchange_error_js_1.HL7ExchangeError(`Invalid message returned from server. MSA segment not found.`, {
-                        response: message,
-                        request: resp,
-                        segmentType: 'MSA',
-                        hl7ErrorCode: 100,
-                    });
-                    onError(err);
-                    return;
-                }
-                const controlId2 = msa.field(hl7v2_1.MSASegment.MessageControlID).value;
+                const controlId2 = msa?.field(hl7v2_1.MSASegment.MessageControlID).getValue();
                 if (controlId2 !== controlId)
-                    return;
+                    return false;
                 cleanup();
                 resolve(resp);
+                return true;
             };
             const onError = (error) => {
                 cleanup();
@@ -117,12 +110,15 @@ class HL7Socket extends node_events_async_1.AsyncEventEmitter {
             };
             const cleanup = () => {
                 clearTimeout(responseTimer);
-                this.removeListener('message', onMessage);
+                this._messageHooks.delete(messageHook);
                 this.socket.removeListener('error', onError);
             };
-            const controlId = message.header.field(hl7v2_1.MSHSegment.MessageControlID).value;
+            const controlId = message.header
+                .field(hl7v2_1.MSHSegment.MessageControlID)
+                .getValue();
             this.socket.once('error', reject);
-            this.on('message', onMessage);
+            this._messageHooks.add(messageHook);
+            // this.on('message', messageHook);
             if (responseTimeout) {
                 responseTimer = setTimeout(() => {
                     onError(new Error('Response timeout'));
@@ -144,6 +140,10 @@ class HL7Socket extends node_events_async_1.AsyncEventEmitter {
         try {
             const message = new hl7v2_1.HL7Message();
             message.parse(data);
+            for (const hook of this._messageHooks) {
+                if (hook(message))
+                    break;
+            }
             this.emit('message', message);
         }
         catch (err) {

package/cjs/index.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./h-l7-request-context.js"), exports);
 tslib_1.__exportStar(require("./helpers/hl7-exchange-error.js"), exports);
 tslib_1.__exportStar(require("./hl7-client.js"), exports);
-tslib_1.__exportStar(require("./hl7-request.js"), exports);
-tslib_1.__exportStar(require("./hl7-response.js"), exports);
 tslib_1.__exportStar(require("./hl7-router.js"), exports);
 tslib_1.__exportStar(require("./hl7-server.js"), exports);
 tslib_1.__exportStar(require("./hl7-socket.js"), exports);

package/esm/h-l7-request-context.js

@@ -0,0 +1,24 @@
+import { MSHSegment } from 'hl7v2';
+import { AsyncEventEmitter } from 'node-events-async';
+import { uid } from 'uid';
+export class HL7RequestContext extends AsyncEventEmitter {
+    constructor(socket, message) {
+        super();
+        this._finished = false;
+        this.socket = socket;
+        this.request = message;
+        if (!message.header.field(MSHSegment.MessageControlID).getValue())
+            message.header.field(MSHSegment.MessageControlID).setValue(uid(8));
+    }
+    get finished() {
+        return this._finished || !this.socket.connected;
+    }
+    end(message) {
+        if (this.finished || !this.socket.connected)
+            return;
+        if (message)
+            this.socket.sendMessage(message);
+        this._finished = true;
+        this.emit('finish', message);
+    }
+}

package/esm/hl7-client.js

@@ -1,7 +1,6 @@
 import net from 'node:net';
 import { AsyncEventEmitter } from 'node-events-async';
-import { HL7Request } from './hl7-request.js';
-import { HL7Response } from './hl7-response.js';
+import { HL7RequestContext } from './h-l7-request-context.js';
 import { HL7Router } from './hl7-router.js';
 import { HL7Socket } from './hl7-socket.js';
 export class Hl7Client extends AsyncEventEmitter {
@@ -97,11 +96,10 @@ export class Hl7Client extends AsyncEventEmitter {
         this._router.use(handler, priority);
     }
     _onMessage(message) {
-        const req = new HL7Request(this._socket, message);
-        const res = new HL7Response(req);
-        this._router.handle(undefined, req, res, error => {
-            if (error)
-                this.emit('error', error);
+        const context = new HL7RequestContext(this._socket, message);
+        this._router.handle(context, () => {
+            if (context.error)
+                this.emit('error', context.error);
         });
     }
 }

package/esm/hl7-router.js

@@ -1,100 +1,90 @@
+import process from 'node:process';
+import { ERRSegment } from 'hl7v2-dictionary';
+import { HL7ExchangeError } from './helpers/hl7-exchange-error.js';
 export class HL7Router {
     constructor() {
-        this._allHandlers = {};
+        this._handlerStack = new Map();
+        this._needPrepare = true;
         this._handlers = [];
-        this._errorHandlers = [];
     }
     use(handler, priority = 0) {
-        let list = this._allHandlers[priority];
+        let list = this._handlerStack[priority];
         if (!list) {
             list = [];
-            this._allHandlers[priority] = list;
-        }
-        if (typeof handler === 'function')
-            list.push(handler);
-        else {
-            // noinspection SuspiciousTypeOfGuard
-            if (handler instanceof HL7Router) {
-                list.push((req, res, next) => {
-                    handler.handle(undefined, req, res, error => {
-                        if (!res.finished)
-                            next(error);
-                    });
-                });
-                list.push((err, req, res, next) => {
-                    handler.handle(err, req, res, error => {
-                        if (!res.finished)
-                            next(error);
-                    });
-                });
-            } /* c8 ignore else */
-            else {
-                throw new TypeError('Router handler must be a function or HL7Router');
-            }
+            this._handlerStack.set(priority, list);
         }
+        list.push(handler);
         this._needPrepare = true;
     }
-    handle(error, req, res, callback) {
-        this._prepareStack();
-        let errIdx = -1;
+    handle(context, callback) {
+        this._prepareStack(true);
         let handlerIdx = -1;
-        let lastErr;
         let callbackCalled = false;
-        const doCallback = (err) => {
+        const doCallback = () => {
             if (callbackCalled)
                 return;
             callbackCalled = true;
-            res.removeListener('finish', onFinish);
-            callback(err);
+            context.removeListener('finish', onFinish);
+            callback();
         };
         const onFinish = () => doCallback();
-        res.once('finish', onFinish);
+        context.once('finish', onFinish);
         const next = (err) => {
-            lastErr = err || lastErr;
-            if (res.finished) {
-                doCallback();
+            if (context.finished)
                 return;
-            }
+            context.error = context.error || err;
             try {
-                if (err) {
-                    errIdx++;
-                    const handler = this._errorHandlers[errIdx];
-                    if (!handler) {
-                        doCallback(lastErr);
-                        return;
-                    }
-                    handler(err, req, res, next);
-                    return;
-                }
-                else {
-                    handlerIdx++;
-                    const handler = this._handlers[handlerIdx];
-                    if (!handler) {
-                        doCallback(lastErr);
-                        return;
-                    }
-                    handler(req, res, next);
+                handlerIdx++;
+                const handler = this._handlers[handlerIdx];
+                if (handler) {
+                    handler(context, next);
                     return;
                 }
+                doCallback();
             }
             catch (e) {
                 next(e);
             }
         };
-        next(error);
+        next();
     }
-    _prepareStack() {
+    _prepareStack(final) {
         if (!this._needPrepare)
             return;
-        delete this._needPrepare;
-        this._errorHandlers = [];
+        this._needPrepare = false;
         this._handlers = [];
-        Object.keys(this._allHandlers).forEach(p => {
-            const h = this._allHandlers[p];
-            if (h.length === 4)
-                this._errorHandlers.push(...h);
-            else
-                this._handlers.push(...h);
+        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);
+                }
+                else
+                    this._handlers.push(h);
+            }
         });
+        if (final) {
+            const finalHandler = (ctx) => {
+                if (ctx.finished)
+                    return;
+                const error = ctx.error ||
+                    new HL7ExchangeError('There is not handler to process this message', {
+                        request: ctx.request,
+                    });
+                const ack = ctx.request.createAck('AE', error);
+                if ((process?.env.NODE_ENV || '').startsWith('dev')) {
+                    const errSeg = ack.getSegment('ERR');
+                    if (errSeg)
+                        errSeg
+                            .field(ERRSegment.DiagnosticInformation)
+                            .setValue(error.stack);
+                }
+                ctx.end(ack);
+            };
+            this._handlers.push(finalHandler);
+        }
     }
 }

package/esm/hl7-server.js

@@ -1,11 +1,8 @@
 import net from 'node:net';
-import * as process from 'node:process';
 import tls from 'node:tls';
-import { ERRSegment } from 'hl7v2';
 import { AsyncEventEmitter } from 'node-events-async';
+import { HL7RequestContext } from './h-l7-request-context.js';
 import { HL7ExchangeError } from './helpers/hl7-exchange-error.js';
-import { HL7Request } from './hl7-request.js';
-import { HL7Response } from './hl7-response.js';
 import { HL7Router } from './hl7-router.js';
 import { HL7Socket } from './hl7-socket.js';
 export class HL7Server extends AsyncEventEmitter {
@@ -186,46 +183,27 @@ export class HL7Server extends AsyncEventEmitter {
             this._sockets.delete(socket);
             this.emit('disconnect', socket);
         });
+        socket.on('error', error => this.emit('error', error, socket));
         this.emit('connection', socket);
     }
     _onMessage(socket, message) {
-        const req = new HL7Request(socket, message);
-        const res = new HL7Response(req);
         const waitPromise = new Promise(resolve => {
+            const context = new HL7RequestContext(socket, message);
             const timeoutTimer = setTimeout(() => {
                 try {
                     const error = new HL7ExchangeError('Response timeout');
-                    const ack = req.message.createAck('AE', error);
-                    res.send(ack);
+                    const ack = context.request.createAck('AE', error);
+                    context.end(ack);
                 }
                 finally {
                     resolve();
                 }
             }, this.responseTimeout || 30000).unref();
-            this._router.handle(undefined, req, res, error => {
+            this._router.handle(context, () => {
                 clearTimeout(timeoutTimer);
-                try {
-                    if (!res.finished) {
-                        error =
-                            error ||
-                                new HL7ExchangeError('No middleware handled the request', {
-                                    request: req.message,
-                                });
-                        const ack = req.message.createAck('AE', error);
-                        if ((process?.env.NODE_ENV || '').startsWith('dev')) {
-                            const errSeg = ack.getSegment('ERR');
-                            if (errSeg)
-                                errSeg.field(ERRSegment.DiagnosticInformation).value =
-                                    error.stack;
-                        }
-                        res.send(ack);
-                    }
-                    if (error)
-                        this.emit('error', error, socket);
-                }
-                finally {
-                    resolve();
-                }
+                if (context.error)
+                    this.emit('error', context.error, socket);
+                resolve();
             });
         });
         this._runningHandlers.add(waitPromise);

package/esm/hl7-socket.js

@@ -2,10 +2,10 @@ import { CR, FS, HL7Message, MSASegment, MSHSegment, VT } from 'hl7v2';
 import iconv from 'iconv-lite';
 import { AsyncEventEmitter } from 'node-events-async';
 import { FrameStream } from './helpers/frame-stream.js';
-import { HL7ExchangeError } from './helpers/hl7-exchange-error.js';
 export class HL7Socket extends AsyncEventEmitter {
     constructor(socket, options) {
         super();
+        this._messageHooks = new Set();
         this._waitPromises = new Set();
         this.socket = socket;
         this._options = options;
@@ -70,10 +70,12 @@ export class HL7Socket extends AsyncEventEmitter {
     sendMessage(message) {
         if (!this.connected)
             throw new Error('Socket is not connected');
-        let encoding = message.header.field(MSHSegment.CharacterSet).value;
+        if (!this.socket.writable)
+            throw new Error('Socket is not writable');
+        let encoding = message.header.field(MSHSegment.CharacterSet).getValue();
         if (!encoding) {
             encoding = 'UTF-8';
-            message.header.field(MSHSegment.CharacterSet).value = encoding;
+            message.header.field(MSHSegment.CharacterSet).setValue(encoding);
         }
         const str = message.toHL7String();
         const buf = iconv.encode(str, encoding);
@@ -86,26 +88,17 @@ export class HL7Socket extends AsyncEventEmitter {
         const responseTimeout = this.responseTimeout;
         const waitPromise = new Promise((resolve, reject) => {
             let responseTimer;
-            const onMessage = (resp) => {
-                const msgType2 = resp.header.field(MSHSegment.MessageType).value;
+            const messageHook = (resp) => {
+                const msgType2 = resp.header.field(MSHSegment.MessageType).getValue();
                 if (msgType2 !== 'ACK')
-                    return;
+                    return false;
                 const msa = resp.getSegment('MSA');
-                if (!msa) {
-                    const err = new HL7ExchangeError(`Invalid message returned from server. MSA segment not found.`, {
-                        response: message,
-                        request: resp,
-                        segmentType: 'MSA',
-                        hl7ErrorCode: 100,
-                    });
-                    onError(err);
-                    return;
-                }
-                const controlId2 = msa.field(MSASegment.MessageControlID).value;
+                const controlId2 = msa?.field(MSASegment.MessageControlID).getValue();
                 if (controlId2 !== controlId)
-                    return;
+                    return false;
                 cleanup();
                 resolve(resp);
+                return true;
             };
             const onError = (error) => {
                 cleanup();
@@ -113,12 +106,15 @@ export class HL7Socket extends AsyncEventEmitter {
             };
             const cleanup = () => {
                 clearTimeout(responseTimer);
-                this.removeListener('message', onMessage);
+                this._messageHooks.delete(messageHook);
                 this.socket.removeListener('error', onError);
             };
-            const controlId = message.header.field(MSHSegment.MessageControlID).value;
+            const controlId = message.header
+                .field(MSHSegment.MessageControlID)
+                .getValue();
             this.socket.once('error', reject);
-            this.on('message', onMessage);
+            this._messageHooks.add(messageHook);
+            // this.on('message', messageHook);
             if (responseTimeout) {
                 responseTimer = setTimeout(() => {
                     onError(new Error('Response timeout'));
@@ -140,6 +136,10 @@ export class HL7Socket extends AsyncEventEmitter {
         try {
             const message = new HL7Message();
             message.parse(data);
+            for (const hook of this._messageHooks) {
+                if (hook(message))
+                    break;
+            }
             this.emit('message', message);
         }
         catch (err) {

package/esm/index.js

@@ -1,7 +1,6 @@
+export * from './h-l7-request-context.js';
 export * from './helpers/hl7-exchange-error.js';
 export * from './hl7-client.js';
-export * from './hl7-request.js';
-export * from './hl7-response.js';
 export * from './hl7-router.js';
 export * from './hl7-server.js';
 export * from './hl7-socket.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hl7v2-net",
   "description": "HL7 v2 server/client for NodeJS",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
@@ -15,7 +15,8 @@
     "uid": "^2.0.2"
   },
   "peerDependencies": {
-    "hl7v2": "^1.0.2"
+    "hl7v2": "^1.1.0",
+    "hl7v2-dictionary": "^1.1.0"
   },
   "type": "module",
   "exports": {

package/types/h-l7-request-context.d.ts

@@ -0,0 +1,12 @@
+import { HL7Message } from 'hl7v2';
+import { AsyncEventEmitter } from 'node-events-async';
+import { HL7Socket } from './hl7-socket.js';
+export declare class HL7RequestContext extends AsyncEventEmitter {
+    protected _finished: boolean;
+    readonly socket: HL7Socket;
+    readonly request: HL7Message;
+    error?: Error;
+    constructor(socket: HL7Socket, message: HL7Message);
+    get finished(): boolean;
+    end(message?: HL7Message): void;
+}

package/types/hl7-client.d.ts

@@ -5,7 +5,7 @@ import { AsyncEventEmitter } from 'node-events-async';
 import { StrictOmit } from 'ts-gems';
 import { HL7Router } from './hl7-router.js';
 import { HL7Socket } from './hl7-socket.js';
-import { HL7ErrorMiddleware, HL7Middleware } from './types.js';
+import { HL7Middleware } from './types.js';
 export declare class Hl7Client extends AsyncEventEmitter {
     protected _router: HL7Router;
     protected _socket?: HL7Socket;
@@ -24,7 +24,7 @@ export declare class Hl7Client extends AsyncEventEmitter {
     sendMessage(message: HL7Message): Promise<void>;
     sendMessageWaitAck(request: HL7Message): Promise<HL7Message>;
     setKeepAlive(enable?: boolean, initialDelay?: number): void;
-    use(handler: HL7Middleware | HL7ErrorMiddleware, priority?: number): void;
+    use(handler: HL7Middleware, priority?: number): void;
     protected _onMessage(message: HL7Message): void;
 }
 export declare namespace Hl7Client {

package/types/hl7-router.d.ts

@@ -1,12 +1,10 @@
-import type { HL7Request } from './hl7-request.js';
-import { HL7Response } from './hl7-response.js';
-import { HL7ErrorMiddleware, HL7Middleware } from './types.js';
+import type { HL7RequestContext } from './h-l7-request-context.js';
+import { HL7Middleware } from './types.js';
 export declare class HL7Router {
-    protected _allHandlers: Record<number, (HL7Middleware | HL7ErrorMiddleware)[]>;
-    protected _needPrepare?: boolean;
+    protected _handlerStack: Map<number, (HL7Router | HL7Middleware)[]>;
+    protected _needPrepare: boolean;
     protected _handlers: HL7Middleware[];
-    protected _errorHandlers: HL7ErrorMiddleware[];
-    use(handler: HL7Middleware | HL7ErrorMiddleware | HL7Router, priority?: number): void;
-    handle(error: Error | undefined, req: HL7Request, res: HL7Response, callback: (err?: Error) => void): void;
-    protected _prepareStack(): void;
+    use(handler: HL7Middleware | HL7Router, priority?: number): void;
+    handle(context: HL7RequestContext, callback: () => void): void;
+    protected _prepareStack(final?: boolean): void;
 }

package/types/hl7-server.d.ts

@@ -5,7 +5,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 { HL7ErrorMiddleware, HL7Middleware } from './types.js';
+import { HL7Middleware } from './types.js';
 export declare class HL7Server extends AsyncEventEmitter<HL7Server.Events> {
     protected _server: net.Server | tls.Server;
     protected _sockets: Set<HL7Socket>;
@@ -76,7 +76,7 @@ export declare class HL7Server extends AsyncEventEmitter<HL7Server.Events> {
      * connections.
      */
     close(waitRunningHandlers?: number): Promise<void>;
-    use(handler: HL7Middleware | HL7ErrorMiddleware, priority?: number): void;
+    use(handler: HL7Middleware, priority?: number): void;
     /**
      * Asynchronously get the number of concurrent connections on the server. Works
      * when sockets were sent to forks.

package/types/hl7-socket.d.ts

@@ -5,6 +5,7 @@ import { AsyncEventEmitter } from 'node-events-async';
 import { FrameStream } from './helpers/frame-stream.js';
 export declare class HL7Socket extends AsyncEventEmitter {
     readonly socket: Socket;
+    protected _messageHooks: Set<(resp: HL7Message) => boolean>;
     protected _frameStream: FrameStream;
     protected _waitPromises: Set<Promise<any>>;
     protected _options: HL7Socket.Options;

package/types/index.d.cts

@@ -1,7 +1,6 @@
+export * from './h-l7-request-context.js';
 export * from './helpers/hl7-exchange-error.js';
 export * from './hl7-client.js';
-export * from './hl7-request.js';
-export * from './hl7-response.js';
 export * from './hl7-router.js';
 export * from './hl7-server.js';
 export * from './hl7-socket.js';

package/types/index.d.ts

@@ -1,7 +1,6 @@
+export * from './h-l7-request-context.js';
 export * from './helpers/hl7-exchange-error.js';
 export * from './hl7-client.js';
-export * from './hl7-request.js';
-export * from './hl7-response.js';
 export * from './hl7-router.js';
 export * from './hl7-server.js';
 export * from './hl7-socket.js';

package/types/types.d.ts

@@ -1,5 +1,3 @@
-import type { HL7Request } from './hl7-request.js';
-import type { HL7Response } from './hl7-response.js';
+import type { HL7RequestContext } from './h-l7-request-context.js';
 export type NextFunction = (error?: Error) => void;
-export type HL7Middleware = (req: HL7Request, res: HL7Response, next: NextFunction) => void;
-export type HL7ErrorMiddleware = (error: Error, req: HL7Request, res: HL7Response, next: NextFunction) => void;
+export type HL7Middleware = (context: HL7RequestContext, next: NextFunction) => void;

package/cjs/hl7-request.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HL7Request = void 0;
-class HL7Request {
-    constructor(socket, message) {
-        this.socket = socket;
-        this.message = message;
-    }
-}
-exports.HL7Request = HL7Request;

package/cjs/hl7-response.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HL7Response = void 0;
-const node_events_async_1 = require("node-events-async");
-class HL7Response extends node_events_async_1.AsyncEventEmitter {
-    constructor(req) {
-        super();
-        this._finished = false;
-        this._req = req;
-    }
-    get socket() {
-        return this._req.socket;
-    }
-    get request() {
-        return this._req;
-    }
-    get finished() {
-        return this._finished || !this.socket.connected;
-    }
-    send(message) {
-        if (this.finished || !this.socket.connected)
-            return;
-        this.socket.sendMessage(message);
-        this._finished = true;
-        this.emit('finish', message);
-    }
-}
-exports.HL7Response = HL7Response;

package/esm/hl7-request.js

@@ -1,6 +0,0 @@
-export class HL7Request {
-    constructor(socket, message) {
-        this.socket = socket;
-        this.message = message;
-    }
-}

package/esm/hl7-response.js

@@ -1,24 +0,0 @@
-import { AsyncEventEmitter } from 'node-events-async';
-export class HL7Response extends AsyncEventEmitter {
-    constructor(req) {
-        super();
-        this._finished = false;
-        this._req = req;
-    }
-    get socket() {
-        return this._req.socket;
-    }
-    get request() {
-        return this._req;
-    }
-    get finished() {
-        return this._finished || !this.socket.connected;
-    }
-    send(message) {
-        if (this.finished || !this.socket.connected)
-            return;
-        this.socket.sendMessage(message);
-        this._finished = true;
-        this.emit('finish', message);
-    }
-}

package/types/hl7-request.d.ts

@@ -1,7 +0,0 @@
-import { HL7Message } from 'hl7v2';
-import { HL7Socket } from './hl7-socket.js';
-export declare class HL7Request {
-    readonly socket: HL7Socket;
-    readonly message: HL7Message;
-    constructor(socket: HL7Socket, message: HL7Message);
-}

package/types/hl7-response.d.ts

@@ -1,13 +0,0 @@
-import { HL7Message } from 'hl7v2';
-import { AsyncEventEmitter } from 'node-events-async';
-import { HL7Request } from './hl7-request.js';
-import { HL7Socket } from './hl7-socket.js';
-export declare class HL7Response extends AsyncEventEmitter {
-    protected _req: HL7Request;
-    protected _finished: boolean;
-    constructor(req: HL7Request);
-    get socket(): HL7Socket;
-    get request(): HL7Request;
-    get finished(): boolean;
-    send(message: HL7Message): void;
-}