hl7v2-net 1.4.4 → 1.6.0

package/cjs/helpers/frame-stream.js

@@ -4,14 +4,21 @@ exports.FrameStream = void 0;
 const node_buffer_1 = require("node:buffer");
 const node_stream_1 = require("node:stream");
 class FrameStream extends node_stream_1.Transform {
+    _chunks = [];
+    _chunkBuffer;
+    _flushTimeout;
+    _frameDelayMs;
+    _frameStart;
+    _frameEnd;
+    _bufferSize = 0;
+    _customTransform;
+    maxBufferSize;
     constructor(opts) {
         super({
             ...opts,
             objectMode: true,
             transform: undefined,
         });
-        this._chunks = [];
-        this._bufferSize = 0;
         this._customTransform = opts?.transform;
         this._frameDelayMs = opts?.frameDelayMs || (opts?.frameEnd ? 0 : 500);
         this.maxBufferSize = opts?.maxBufferSize;

package/cjs/helpers/hl7-exchange-error.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HL7ExchangeError = void 0;
 const hl7v2_1 = require("hl7v2");
 class HL7ExchangeError extends hl7v2_1.HL7Error {
+    request;
+    response;
     constructor(message, args) {
         super(message, args);
         if (args?.request)

package/cjs/hl7-client.js

@@ -5,11 +5,17 @@ const tslib_1 = require("tslib");
 const node_net_1 = tslib_1.__importDefault(require("node:net"));
 const node_tls_1 = tslib_1.__importDefault(require("node:tls"));
 const node_events_async_1 = require("node-events-async");
+const reconnect_core_1 = tslib_1.__importDefault(require("reconnect-core"));
 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 Hl7Client extends node_events_async_1.AsyncEventEmitter {
+    _connectionManager;
+    _router = new hl7_router_js_1.HL7Router();
+    _socket;
+    _tls;
+    _options;
     /**
      * Creates an HL7 TCP client
      * @static
@@ -35,8 +41,60 @@ class Hl7Client extends node_events_async_1.AsyncEventEmitter {
      */
     constructor(options) {
         super();
-        this._router = new hl7_router_js_1.HL7Router();
         this._options = options;
+        let reconnecting = false;
+        const connectionManager = (this._connectionManager = socketReconnect({
+            ...this._options.reconnect,
+            timeout: this._options.connectTimeout,
+        })
+            .on('error', err => {
+            if (!connectionManager.reconnect)
+                return;
+            this.emit('error', err);
+        })
+            .on('connect', (tcpSocket) => {
+            if (!this._socket) {
+                const socket = (this._socket = new hl7_socket_js_1.HL7Socket(tcpSocket, this._options));
+                socket.on('connect', () => this.emit('connect'));
+                socket.on('ready', () => this.emit('ready'));
+                socket.on('lookup', (err, address, family, host) => this.emit('lookup', err, address, family, host));
+                socket.on('close', () => {
+                    this._socket = undefined;
+                    this.emit('close');
+                });
+                socket.on('error', err => this.emit('error', err));
+                socket.on('message', message => {
+                    this.emit('message', message);
+                    this._onMessage(message);
+                });
+                socket.on('send', message => this.emit('send', message));
+                socket.on('data', data => this.emit('data', data));
+            }
+            else
+                this._socket._bindSocket(tcpSocket);
+            if (reconnecting)
+                this.emit('reconnect', tcpSocket);
+            reconnecting = false;
+            this.emit('connect');
+        })
+            .on('reconnect', (n, delay) => {
+            if (n === 0 && delay === 0)
+                return;
+            reconnecting = true;
+            this.emit('reconnecting', n, delay);
+        })
+            .on('disconnect', err => {
+            this._socket = undefined;
+            if (connectionManager.reconnect) {
+                if (err)
+                    err.message = `TCP socket connection lost: ${err.message}`;
+                else
+                    err = new Error('TCP socket connection lost');
+                this.emit('disconnect', err);
+            }
+            else
+                this.emit('disconnect');
+        }));
     }
     get connected() {
         return this._socket?.connected ?? false;
@@ -81,57 +139,32 @@ class Hl7Client extends node_events_async_1.AsyncEventEmitter {
         if (this._socket)
             this._socket.maxBufferSize = value;
     }
-    connect() {
+    async connect() {
+        if (this.connected)
+            return;
         return new Promise((resolve, reject) => {
-            if (this.connected) {
-                resolve();
-                return;
-            }
-            let timeoutTimer;
-            const tcpSocket = this._tls
-                ? node_tls_1.default.connect(this._options)
-                : node_net_1.default.connect(this._options);
-            const socket = (this._socket = new hl7_socket_js_1.HL7Socket(tcpSocket, this._options));
-            socket.on('connect', () => this.emit('connect'));
-            socket.on('ready', () => this.emit('ready'));
-            socket.on('lookup', (err, address, family, host) => this.emit('lookup', err, address, family, host));
-            socket.on('close', () => {
-                this._socket = undefined;
-                this.emit('close');
-            });
-            socket.on('error', err => this.emit('error', err));
-            socket.on('message', message => {
-                this.emit('message', message);
-                this._onMessage(message);
-            });
-            socket.on('send', message => this.emit('send', message));
-            socket.on('data', data => this.emit('data', data));
             const onReady = () => {
-                clearTimeout(timeoutTimer);
-                tcpSocket.removeListener('error', onError);
-                if (this._options.keepAlive) {
-                    tcpSocket.setKeepAlive(this._options.keepAlive, this._options.keepAliveInitialDelay);
-                }
+                this.removeListener('error', onError);
                 resolve();
             };
             const onError = (error) => {
-                clearTimeout(timeoutTimer);
-                tcpSocket.removeListener('ready', onReady);
-                tcpSocket.destroy();
+                this.removeListener('ready', onReady);
                 reject(error);
             };
-            tcpSocket.once('ready', onReady);
-            tcpSocket.once('error', onError);
-            if (this.connectTimeout) {
-                timeoutTimer = setTimeout(() => {
-                    this.emit('error', new Error('Connection timeout'));
-                    tcpSocket.destroy();
-                }, this._options.connectTimeout).unref();
-            }
+            this.once('ready', onReady);
+            this.once('error', onError);
+            this._connectionManager.reconnect = true;
+            this._connectionManager.connect({
+                tls: this._tls,
+                options: this._options,
+            });
         });
     }
     async close(waitRunningHandlers) {
+        this._connectionManager.reconnect = false;
         await this._socket?.close(waitRunningHandlers);
+        this._connectionManager.disconnect();
+        this._connectionManager.reset();
     }
     async sendMessage(message) {
         if (!this.connected)
@@ -161,3 +194,37 @@ class Hl7Client extends node_events_async_1.AsyncEventEmitter {
     }
 }
 exports.Hl7Client = Hl7Client;
+const socketReconnect = (0, reconnect_core_1.default)((args) => {
+    const tcpSocket = args.tls
+        ? node_tls_1.default.connect({
+            ...args.options,
+            timeout: undefined,
+        })
+        : node_net_1.default.connect({
+            ...args.options,
+            timeout: undefined,
+        });
+    if (args.options.timeout) {
+        const timer = setTimeout(() => {
+            tcpSocket.destroy(new Error('Connection timed out'));
+        }, args.options.timeout).unref();
+        const onConnect = () => {
+            clearTimeout(timer);
+            tcpSocket.removeListener('error', onError);
+        };
+        const onError = () => {
+            clearTimeout(timer);
+            tcpSocket.removeListener('connect', onConnect);
+            tcpSocket.removeListener('ready', onReady);
+        };
+        const onReady = () => {
+            if (args.options.keepAlive) {
+                tcpSocket.setKeepAlive(args.options.keepAlive, args.options.keepAliveInitialDelay);
+            }
+        };
+        tcpSocket.once('connect', onConnect);
+        tcpSocket.once('error', onError);
+        tcpSocket.once('ready', onReady);
+    }
+    return tcpSocket;
+});

package/cjs/hl7-request.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HL7Request = void 0;
 class HL7Request {
+    socket;
+    message;
     constructor(socket, message) {
         this.socket = socket;
         this.message = message;

package/cjs/hl7-response.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HL7Response = void 0;
 const hl7v2_1 = require("hl7v2");
 class HL7Response {
+    _finished = false;
+    request;
+    errors = [];
+    message;
     constructor(request) {
-        this._finished = false;
-        this.errors = [];
         this.request = request;
         this.message = request.message.createAck();
         request.socket.once('send', () => {

package/cjs/hl7-router.js

@@ -2,11 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HL7Router = void 0;
 class HL7Router {
-    constructor() {
-        this._handlerStack = new Map();
-        this._needPrepare = true;
-        this._handlers = [];
-    }
+    _handlerStack = new Map();
+    _needPrepare = true;
+    _handlers = [];
     use(handler, priority = 0) {
         let list = this._handlerStack[priority];
         if (!list) {

package/cjs/hl7-server.js

@@ -13,6 +13,14 @@ 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 {
+    _server;
+    _sockets = new Set();
+    _router = new hl7_router_js_1.HL7Router();
+    _runningHandlers = new Set();
+    _closing;
+    parseStrict;
+    maxBufferPerSocket;
+    responseTimeout;
     /**
      * Creates a HL7 TCP server
      * @static
@@ -34,9 +42,6 @@ class HL7Server extends node_events_async_1.AsyncEventEmitter {
      */
     constructor(server, options) {
         super();
-        this._sockets = new Set();
-        this._router = new hl7_router_js_1.HL7Router();
-        this._runningHandlers = new Set();
         this.maxBufferPerSocket = options?.maxBufferPerSocket;
         this.responseTimeout = options?.responseTimeout;
         this.parseStrict = options?.parseStrict;
@@ -197,7 +202,8 @@ class HL7Server extends node_events_async_1.AsyncEventEmitter {
             this._onMessage(message, socket);
         });
         socket.on('send', message => this.emit('send', message, socket));
-        socket.on('data', data => this.emit('data', data));
+        socket.on('data', data => this.emit('data', data, socket));
+        socket.on('write', data => this.emit('write', data, socket));
         this.emit('connection', socket);
     }
     _onMessage(message, socket) {

package/cjs/hl7-socket.js

@@ -2,41 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HL7Socket = void 0;
 const tslib_1 = require("tslib");
+const node_buffer_1 = require("node:buffer");
 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");
 class HL7Socket extends node_events_async_1.AsyncEventEmitter {
+    _messageHooks = new Set();
+    _frameStream;
+    _waitPromises = new Set();
+    _options;
+    responseTimeout;
+    /**
+     * User defined property
+     * @protected
+     */
+    user;
     constructor(socket, options) {
         super();
-        this._messageHooks = new Set();
-        this._waitPromises = new Set();
-        this.socket = socket;
         this._options = options;
         const frameStream = new frame_stream_js_1.FrameStream({
             frameStart: hl7v2_1.VT,
             frameEnd: hl7v2_1.FS + hl7v2_1.CR,
             maxBufferSize: options?.maxBufferSize,
         });
-        this._frameStream = frameStream;
-        socket.on('error', (err) => {
-            if (err.code === 'ECONNRESET') {
-                err.message = `Connection reset by peer`;
-            }
-            this.emit('error', err);
-        });
-        socket.pipe(frameStream);
-        socket.on('connect', () => this.emit('connect'));
-        socket.on('ready', () => this.emit('ready'));
-        socket.on('lookup', (err, address, family, host) => this.emit('lookup', err, address, family, host));
-        socket.on('timeout', () => socket.destroy());
-        socket.on('close', () => {
-            this.emit('close');
-        });
         frameStream.on('data', data => {
             this.emit('data', data);
             this._onData(data);
         });
+        this._frameStream = frameStream;
+        this._bindSocket(socket);
+    }
+    get socket() {
+        return this._socket;
     }
     get connected() {
         return !this.socket.closed;
@@ -45,7 +43,7 @@ class HL7Socket extends node_events_async_1.AsyncEventEmitter {
         return this.socket.closed;
     }
     get readyState() {
-        return this.socket.readyState;
+        return this.socket?.readyState || 'closed';
     }
     get maxBufferSize() {
         return this._frameStream.maxBufferSize || 0;
@@ -54,14 +52,14 @@ class HL7Socket extends node_events_async_1.AsyncEventEmitter {
         this._frameStream.maxBufferSize = value;
     }
     address() {
-        return this.socket.address();
+        return this.socket?.address() || {};
     }
     remoteAddress() {
-        const addr = this.socket.remoteAddress;
+        const addr = this.socket?.remoteAddress;
         return addr?.startsWith('::ffff:') ? addr.slice(7) : addr;
     }
     get writable() {
-        return this.connected && this.socket.writable;
+        return this.connected && this.socket?.writable;
     }
     async close(waitRunningHandlers) {
         if (this.closed)
@@ -106,10 +104,14 @@ class HL7Socket extends node_events_async_1.AsyncEventEmitter {
             }
             const str = message.toHL7String();
             const buf = iconv_lite_1.default.encode(str, encoding);
-            this.socket.write(hl7v2_1.VT);
-            this.socket.write(buf);
-            this.socket.write(hl7v2_1.FS + hl7v2_1.CR);
+            const outBuffer = node_buffer_1.Buffer.concat([
+                node_buffer_1.Buffer.from(hl7v2_1.VT),
+                buf,
+                node_buffer_1.Buffer.from(hl7v2_1.FS + hl7v2_1.CR),
+            ]);
+            this.socket.write(outBuffer);
             this.emit('send', message);
+            this.emit('write', outBuffer);
         }
         catch (err) {
             this.emit('error', err);
@@ -189,5 +191,44 @@ class HL7Socket extends node_events_async_1.AsyncEventEmitter {
             this.sendMessage(nak);
         }
     }
+    _bindSocket(socket) {
+        if (socket === this._socket)
+            return;
+        this._unBindSocket();
+        this._socket = socket;
+        const hl7EventListeners = (socket.__hl7EventListeners = {});
+        hl7EventListeners.onConnect = () => this.emit('connect');
+        hl7EventListeners.onReady = () => this.emit('ready');
+        hl7EventListeners.onLookup = (err, address, family, host) => this.emit('lookup', err, address, family, host);
+        hl7EventListeners.onTimeout = () => socket.destroy();
+        hl7EventListeners.onClose = () => this.emit('close');
+        hl7EventListeners.onError = (err) => {
+            if (err.code === 'ECONNRESET') {
+                err.message = `Connection reset by peer`;
+            }
+            this.emit('error', err);
+        };
+        socket.on('connect', hl7EventListeners.onConnect);
+        socket.on('ready', hl7EventListeners.onReady);
+        socket.on('lookup', hl7EventListeners.onLookup);
+        socket.on('timeout', hl7EventListeners.onTimeout);
+        socket.on('close', hl7EventListeners.onClose);
+        socket.on('error', hl7EventListeners.onError);
+        socket.pipe(this._frameStream);
+    }
+    _unBindSocket() {
+        if (!this.socket)
+            return;
+        this.socket.unpipe(this._frameStream);
+        const hl7EventListeners = this.socket.__hl7EventListeners;
+        if (hl7EventListeners) {
+            this.socket.removeListener('connect', hl7EventListeners.onConnect);
+            this.socket.removeListener('ready', hl7EventListeners.onReady);
+            this.socket.removeListener('lookup', hl7EventListeners.onLookup);
+            this.socket.removeListener('timeout', hl7EventListeners.onTimeout);
+            this.socket.removeListener('close', hl7EventListeners.onClose);
+            this.socket.removeListener('error', hl7EventListeners.onError);
+        }
+    }
 }
 exports.HL7Socket = HL7Socket;

package/esm/helpers/frame-stream.js

@@ -1,14 +1,21 @@
 import { Buffer } from 'node:buffer';
 import { Transform } from 'node:stream';
 export class FrameStream extends Transform {
+    _chunks = [];
+    _chunkBuffer;
+    _flushTimeout;
+    _frameDelayMs;
+    _frameStart;
+    _frameEnd;
+    _bufferSize = 0;
+    _customTransform;
+    maxBufferSize;
     constructor(opts) {
         super({
             ...opts,
             objectMode: true,
             transform: undefined,
         });
-        this._chunks = [];
-        this._bufferSize = 0;
         this._customTransform = opts?.transform;
         this._frameDelayMs = opts?.frameDelayMs || (opts?.frameEnd ? 0 : 500);
         this.maxBufferSize = opts?.maxBufferSize;

package/esm/helpers/hl7-exchange-error.js

@@ -1,5 +1,7 @@
 import { HL7Error } from 'hl7v2';
 export class HL7ExchangeError extends HL7Error {
+    request;
+    response;
     constructor(message, args) {
         super(message, args);
         if (args?.request)

package/esm/hl7-client.js

@@ -1,11 +1,17 @@
 import net from 'node:net';
 import tls from 'node:tls';
 import { AsyncEventEmitter } from 'node-events-async';
+import reconnectCore from 'reconnect-core';
 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 Hl7Client extends AsyncEventEmitter {
+    _connectionManager;
+    _router = new HL7Router();
+    _socket;
+    _tls;
+    _options;
     /**
      * Creates an HL7 TCP client
      * @static
@@ -31,8 +37,60 @@ export class Hl7Client extends AsyncEventEmitter {
      */
     constructor(options) {
         super();
-        this._router = new HL7Router();
         this._options = options;
+        let reconnecting = false;
+        const connectionManager = (this._connectionManager = socketReconnect({
+            ...this._options.reconnect,
+            timeout: this._options.connectTimeout,
+        })
+            .on('error', err => {
+            if (!connectionManager.reconnect)
+                return;
+            this.emit('error', err);
+        })
+            .on('connect', (tcpSocket) => {
+            if (!this._socket) {
+                const socket = (this._socket = new HL7Socket(tcpSocket, this._options));
+                socket.on('connect', () => this.emit('connect'));
+                socket.on('ready', () => this.emit('ready'));
+                socket.on('lookup', (err, address, family, host) => this.emit('lookup', err, address, family, host));
+                socket.on('close', () => {
+                    this._socket = undefined;
+                    this.emit('close');
+                });
+                socket.on('error', err => this.emit('error', err));
+                socket.on('message', message => {
+                    this.emit('message', message);
+                    this._onMessage(message);
+                });
+                socket.on('send', message => this.emit('send', message));
+                socket.on('data', data => this.emit('data', data));
+            }
+            else
+                this._socket._bindSocket(tcpSocket);
+            if (reconnecting)
+                this.emit('reconnect', tcpSocket);
+            reconnecting = false;
+            this.emit('connect');
+        })
+            .on('reconnect', (n, delay) => {
+            if (n === 0 && delay === 0)
+                return;
+            reconnecting = true;
+            this.emit('reconnecting', n, delay);
+        })
+            .on('disconnect', err => {
+            this._socket = undefined;
+            if (connectionManager.reconnect) {
+                if (err)
+                    err.message = `TCP socket connection lost: ${err.message}`;
+                else
+                    err = new Error('TCP socket connection lost');
+                this.emit('disconnect', err);
+            }
+            else
+                this.emit('disconnect');
+        }));
     }
     get connected() {
         return this._socket?.connected ?? false;
@@ -77,57 +135,32 @@ export class Hl7Client extends AsyncEventEmitter {
         if (this._socket)
             this._socket.maxBufferSize = value;
     }
-    connect() {
+    async connect() {
+        if (this.connected)
+            return;
         return new Promise((resolve, reject) => {
-            if (this.connected) {
-                resolve();
-                return;
-            }
-            let timeoutTimer;
-            const tcpSocket = this._tls
-                ? tls.connect(this._options)
-                : net.connect(this._options);
-            const socket = (this._socket = new HL7Socket(tcpSocket, this._options));
-            socket.on('connect', () => this.emit('connect'));
-            socket.on('ready', () => this.emit('ready'));
-            socket.on('lookup', (err, address, family, host) => this.emit('lookup', err, address, family, host));
-            socket.on('close', () => {
-                this._socket = undefined;
-                this.emit('close');
-            });
-            socket.on('error', err => this.emit('error', err));
-            socket.on('message', message => {
-                this.emit('message', message);
-                this._onMessage(message);
-            });
-            socket.on('send', message => this.emit('send', message));
-            socket.on('data', data => this.emit('data', data));
             const onReady = () => {
-                clearTimeout(timeoutTimer);
-                tcpSocket.removeListener('error', onError);
-                if (this._options.keepAlive) {
-                    tcpSocket.setKeepAlive(this._options.keepAlive, this._options.keepAliveInitialDelay);
-                }
+                this.removeListener('error', onError);
                 resolve();
             };
             const onError = (error) => {
-                clearTimeout(timeoutTimer);
-                tcpSocket.removeListener('ready', onReady);
-                tcpSocket.destroy();
+                this.removeListener('ready', onReady);
                 reject(error);
             };
-            tcpSocket.once('ready', onReady);
-            tcpSocket.once('error', onError);
-            if (this.connectTimeout) {
-                timeoutTimer = setTimeout(() => {
-                    this.emit('error', new Error('Connection timeout'));
-                    tcpSocket.destroy();
-                }, this._options.connectTimeout).unref();
-            }
+            this.once('ready', onReady);
+            this.once('error', onError);
+            this._connectionManager.reconnect = true;
+            this._connectionManager.connect({
+                tls: this._tls,
+                options: this._options,
+            });
         });
     }
     async close(waitRunningHandlers) {
+        this._connectionManager.reconnect = false;
         await this._socket?.close(waitRunningHandlers);
+        this._connectionManager.disconnect();
+        this._connectionManager.reset();
     }
     async sendMessage(message) {
         if (!this.connected)
@@ -156,3 +189,37 @@ export class Hl7Client extends AsyncEventEmitter {
         });
     }
 }
+const socketReconnect = reconnectCore((args) => {
+    const tcpSocket = args.tls
+        ? tls.connect({
+            ...args.options,
+            timeout: undefined,
+        })
+        : net.connect({
+            ...args.options,
+            timeout: undefined,
+        });
+    if (args.options.timeout) {
+        const timer = setTimeout(() => {
+            tcpSocket.destroy(new Error('Connection timed out'));
+        }, args.options.timeout).unref();
+        const onConnect = () => {
+            clearTimeout(timer);
+            tcpSocket.removeListener('error', onError);
+        };
+        const onError = () => {
+            clearTimeout(timer);
+            tcpSocket.removeListener('connect', onConnect);
+            tcpSocket.removeListener('ready', onReady);
+        };
+        const onReady = () => {
+            if (args.options.keepAlive) {
+                tcpSocket.setKeepAlive(args.options.keepAlive, args.options.keepAliveInitialDelay);
+            }
+        };
+        tcpSocket.once('connect', onConnect);
+        tcpSocket.once('error', onError);
+        tcpSocket.once('ready', onReady);
+    }
+    return tcpSocket;
+});

package/esm/hl7-request.js

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

package/esm/hl7-response.js

@@ -1,8 +1,10 @@
 import { MSASegment } from 'hl7v2';
 export class HL7Response {
+    _finished = false;
+    request;
+    errors = [];
+    message;
     constructor(request) {
-        this._finished = false;
-        this.errors = [];
         this.request = request;
         this.message = request.message.createAck();
         request.socket.once('send', () => {

package/esm/hl7-router.js

@@ -1,9 +1,7 @@
 export class HL7Router {
-    constructor() {
-        this._handlerStack = new Map();
-        this._needPrepare = true;
-        this._handlers = [];
-    }
+    _handlerStack = new Map();
+    _needPrepare = true;
+    _handlers = [];
     use(handler, priority = 0) {
         let list = this._handlerStack[priority];
         if (!list) {

package/esm/hl7-server.js

@@ -9,6 +9,14 @@ import { HL7Response } from './hl7-response.js';
 import { HL7Router } from './hl7-router.js';
 import { HL7Socket } from './hl7-socket.js';
 export class HL7Server extends AsyncEventEmitter {
+    _server;
+    _sockets = new Set();
+    _router = new HL7Router();
+    _runningHandlers = new Set();
+    _closing;
+    parseStrict;
+    maxBufferPerSocket;
+    responseTimeout;
     /**
      * Creates a HL7 TCP server
      * @static
@@ -30,9 +38,6 @@ export class HL7Server extends AsyncEventEmitter {
      */
     constructor(server, options) {
         super();
-        this._sockets = new Set();
-        this._router = new HL7Router();
-        this._runningHandlers = new Set();
         this.maxBufferPerSocket = options?.maxBufferPerSocket;
         this.responseTimeout = options?.responseTimeout;
         this.parseStrict = options?.parseStrict;
@@ -193,7 +198,8 @@ export class HL7Server extends AsyncEventEmitter {
             this._onMessage(message, socket);
         });
         socket.on('send', message => this.emit('send', message, socket));
-        socket.on('data', data => this.emit('data', data));
+        socket.on('data', data => this.emit('data', data, socket));
+        socket.on('write', data => this.emit('write', data, socket));
         this.emit('connection', socket);
     }
     _onMessage(message, socket) {

package/esm/hl7-socket.js

@@ -1,38 +1,36 @@
+import { Buffer } from 'node:buffer';
 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';
 export class HL7Socket extends AsyncEventEmitter {
+    _messageHooks = new Set();
+    _frameStream;
+    _waitPromises = new Set();
+    _options;
+    responseTimeout;
+    /**
+     * User defined property
+     * @protected
+     */
+    user;
     constructor(socket, options) {
         super();
-        this._messageHooks = new Set();
-        this._waitPromises = new Set();
-        this.socket = socket;
         this._options = options;
         const frameStream = new FrameStream({
             frameStart: VT,
             frameEnd: FS + CR,
             maxBufferSize: options?.maxBufferSize,
         });
-        this._frameStream = frameStream;
-        socket.on('error', (err) => {
-            if (err.code === 'ECONNRESET') {
-                err.message = `Connection reset by peer`;
-            }
-            this.emit('error', err);
-        });
-        socket.pipe(frameStream);
-        socket.on('connect', () => this.emit('connect'));
-        socket.on('ready', () => this.emit('ready'));
-        socket.on('lookup', (err, address, family, host) => this.emit('lookup', err, address, family, host));
-        socket.on('timeout', () => socket.destroy());
-        socket.on('close', () => {
-            this.emit('close');
-        });
         frameStream.on('data', data => {
             this.emit('data', data);
             this._onData(data);
         });
+        this._frameStream = frameStream;
+        this._bindSocket(socket);
+    }
+    get socket() {
+        return this._socket;
     }
     get connected() {
         return !this.socket.closed;
@@ -41,7 +39,7 @@ export class HL7Socket extends AsyncEventEmitter {
         return this.socket.closed;
     }
     get readyState() {
-        return this.socket.readyState;
+        return this.socket?.readyState || 'closed';
     }
     get maxBufferSize() {
         return this._frameStream.maxBufferSize || 0;
@@ -50,14 +48,14 @@ export class HL7Socket extends AsyncEventEmitter {
         this._frameStream.maxBufferSize = value;
     }
     address() {
-        return this.socket.address();
+        return this.socket?.address() || {};
     }
     remoteAddress() {
-        const addr = this.socket.remoteAddress;
+        const addr = this.socket?.remoteAddress;
         return addr?.startsWith('::ffff:') ? addr.slice(7) : addr;
     }
     get writable() {
-        return this.connected && this.socket.writable;
+        return this.connected && this.socket?.writable;
     }
     async close(waitRunningHandlers) {
         if (this.closed)
@@ -102,10 +100,14 @@ export class HL7Socket extends AsyncEventEmitter {
             }
             const str = message.toHL7String();
             const buf = iconv.encode(str, encoding);
-            this.socket.write(VT);
-            this.socket.write(buf);
-            this.socket.write(FS + CR);
+            const outBuffer = Buffer.concat([
+                Buffer.from(VT),
+                buf,
+                Buffer.from(FS + CR),
+            ]);
+            this.socket.write(outBuffer);
             this.emit('send', message);
+            this.emit('write', outBuffer);
         }
         catch (err) {
             this.emit('error', err);
@@ -185,4 +187,43 @@ export class HL7Socket extends AsyncEventEmitter {
             this.sendMessage(nak);
         }
     }
+    _bindSocket(socket) {
+        if (socket === this._socket)
+            return;
+        this._unBindSocket();
+        this._socket = socket;
+        const hl7EventListeners = (socket.__hl7EventListeners = {});
+        hl7EventListeners.onConnect = () => this.emit('connect');
+        hl7EventListeners.onReady = () => this.emit('ready');
+        hl7EventListeners.onLookup = (err, address, family, host) => this.emit('lookup', err, address, family, host);
+        hl7EventListeners.onTimeout = () => socket.destroy();
+        hl7EventListeners.onClose = () => this.emit('close');
+        hl7EventListeners.onError = (err) => {
+            if (err.code === 'ECONNRESET') {
+                err.message = `Connection reset by peer`;
+            }
+            this.emit('error', err);
+        };
+        socket.on('connect', hl7EventListeners.onConnect);
+        socket.on('ready', hl7EventListeners.onReady);
+        socket.on('lookup', hl7EventListeners.onLookup);
+        socket.on('timeout', hl7EventListeners.onTimeout);
+        socket.on('close', hl7EventListeners.onClose);
+        socket.on('error', hl7EventListeners.onError);
+        socket.pipe(this._frameStream);
+    }
+    _unBindSocket() {
+        if (!this.socket)
+            return;
+        this.socket.unpipe(this._frameStream);
+        const hl7EventListeners = this.socket.__hl7EventListeners;
+        if (hl7EventListeners) {
+            this.socket.removeListener('connect', hl7EventListeners.onConnect);
+            this.socket.removeListener('ready', hl7EventListeners.onReady);
+            this.socket.removeListener('lookup', hl7EventListeners.onLookup);
+            this.socket.removeListener('timeout', hl7EventListeners.onTimeout);
+            this.socket.removeListener('close', hl7EventListeners.onClose);
+            this.socket.removeListener('error', hl7EventListeners.onError);
+        }
+    }
 }

package/package.json

@@ -1,22 +1,24 @@
 {
   "name": "hl7v2-net",
   "description": "HL7 v2 server/client for NodeJS",
-  "version": "1.4.4",
+  "version": "1.6.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {
     "@jsopen/objects": "^2.0.2",
-    "iconv-lite": "^0.7.0",
+    "backoff": "^2.5.0",
+    "iconv-lite": "^0.7.1",
     "is-typedarray": "^1.0.0",
     "node-events-async": "^1.2.0",
+    "reconnect-core": "^1.3.0",
     "ts-gems": "^3.11.3",
     "tslib": "^2.8.1",
-    "valgen": "^5.17.1",
+    "valgen": "^5.18.2",
     "uid": "^2.0.2"
   },
   "peerDependencies": {
-    "hl7v2": "^1.4.4",
-    "hl7v2-dictionary": "^1.4.4"
+    "hl7v2": "^1.6.0",
+    "hl7v2-dictionary": "^1.6.0"
   },
   "type": "module",
   "exports": {

package/types/hl7-client.d.ts

@@ -1,13 +1,15 @@
 import net from 'node:net';
 import tls from 'node:tls';
+import { Backoff } from 'backoff';
 import { HL7Message } from 'hl7v2';
-import { AddressInfo } from 'net';
 import { AsyncEventEmitter } from 'node-events-async';
+import reconnectCore from 'reconnect-core';
 import { StrictOmit } from 'ts-gems';
 import { HL7Router } from './hl7-router.js';
 import { HL7Socket } from './hl7-socket.js';
 import { HL7Middleware } from './types.js';
 export declare class Hl7Client extends AsyncEventEmitter<Hl7Client.Events> {
+    protected _connectionManager: ReturnType<typeof socketReconnect>;
     protected _router: HL7Router;
     protected _socket?: HL7Socket;
     protected _tls?: boolean;
@@ -32,7 +34,7 @@ export declare class Hl7Client extends AsyncEventEmitter<Hl7Client.Events> {
     get closed(): boolean;
     get readyState(): net.SocketReadyState;
     get uri(): string;
-    address(): AddressInfo;
+    address(): net.AddressInfo;
     get connectTimeout(): number | undefined;
     set connectTimeout(value: number | null);
     get responseTimeout(): number | undefined;
@@ -48,6 +50,10 @@ export declare class Hl7Client extends AsyncEventEmitter<Hl7Client.Events> {
     protected _onMessage(message: HL7Message): void;
 }
 export declare namespace Hl7Client {
+    export interface Events extends HL7Socket.Events {
+        reconnecting: [n: number, delay: number];
+        reconnect: [socket: net.Socket];
+    }
     interface CommonConnectOptions {
         connectTimeout?: number;
         maxBufferSize?: number;
@@ -55,10 +61,22 @@ export declare namespace Hl7Client {
         keepAlive?: boolean;
         keepAliveInitialDelay?: number;
         parseStrict?: boolean;
+        reconnect?: ReconnectOptions;
     }
     export type NetConnectOptions = StrictOmit<net.TcpNetConnectOpts, 'onread' | 'readable' | 'writable'> & CommonConnectOptions;
     export type TlsConnectOptions = StrictOmit<tls.ConnectionOptions, 'socket'> & CommonConnectOptions;
-    export interface Events extends HL7Socket.Events {
+    export interface ReconnectOptions {
+        strategy?: 'fibonacci' | 'exponential' | Backoff;
+        immediate?: boolean | undefined;
+        failAfter?: number | undefined;
+        randomisationFactor?: number | undefined;
+        initialDelay?: number | undefined;
+        maxDelay?: number | undefined;
     }
     export {};
 }
+declare const socketReconnect: reconnectCore.CustomModule<{
+    tls?: boolean;
+    options: Hl7Client.NetConnectOptions | Hl7Client.TlsConnectOptions;
+}, net.Socket>;
+export {};

package/types/hl7-server.d.ts

@@ -108,7 +108,8 @@ export declare namespace HL7Server {
         error: [error: Error, HL7Socket | undefined];
         message: [message: HL7Message, socket: HL7Socket];
         send: [message: HL7Message, socket: HL7Socket];
-        data: [Buffer];
+        data: [Buffer, socket: HL7Socket];
+        write: [buffer: Buffer, socket: HL7Socket];
     }
     interface Options {
         applicationName?: string;

package/types/hl7-socket.d.ts

@@ -4,7 +4,7 @@ import { Socket } from 'net';
 import { AsyncEventEmitter } from 'node-events-async';
 import { FrameStream } from './helpers/frame-stream.js';
 export declare class HL7Socket extends AsyncEventEmitter<HL7Socket.Events> {
-    readonly socket: Socket;
+    protected _socket: Socket;
     protected _messageHooks: Set<(resp: HL7Message) => boolean>;
     protected _frameStream: FrameStream;
     protected _waitPromises: Set<Promise<any>>;
@@ -16,12 +16,13 @@ export declare class HL7Socket extends AsyncEventEmitter<HL7Socket.Events> {
      */
     protected user?: any;
     constructor(socket: Socket, options: HL7Socket.Options);
+    get socket(): Socket;
     get connected(): boolean;
     get closed(): boolean;
-    get readyState(): import("net").SocketReadyState;
+    get readyState(): import("node:net").SocketReadyState;
     get maxBufferSize(): number;
     set maxBufferSize(value: number);
-    address(): {} | import("net").AddressInfo;
+    address(): {};
     remoteAddress(): string | undefined;
     get writable(): boolean;
     close(waitRunningHandlers?: number): Promise<void>;
@@ -29,6 +30,8 @@ export declare class HL7Socket extends AsyncEventEmitter<HL7Socket.Events> {
     sendMessageWaitAck(message: HL7Message): Promise<HL7Message>;
     setKeepAlive(enable?: boolean, initialDelay?: number): void;
     protected _onData(data: Buffer): void;
+    _bindSocket(socket: Socket): void;
+    protected _unBindSocket(): void;
 }
 export declare namespace HL7Socket {
     interface Events {
@@ -37,14 +40,15 @@ export declare namespace HL7Socket {
         close: [];
         error: [error: Error];
         lookup: [
-            err: Error,
+            err: Error | null,
             address: string,
-            family: string | number,
+            family: number | null,
             host: string
         ];
         message: [message: HL7Message];
         send: [message: HL7Message];
-        data: [Buffer];
+        data: [buffer: Buffer];
+        write: [buffer: Buffer];
     }
     interface Options {
         responseTimeout?: number;