hl7v2-net 1.1.2 → 1.1.3

package/cjs/hl7-client.js

@@ -3,11 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hl7Client = void 0;
 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 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 {
+    /**
+     * Creates an HL7 TCP client
+     * @static
+     */
+    static createClient(options) {
+        const client = new Hl7Client(options);
+        client._tls = false;
+        return client;
+    }
+    /**
+     * Creates a secure HL7 TCP client
+     * @static
+     */
+    static createTlsClient(options) {
+        const client = new Hl7Client(options);
+        client._tls = true;
+        return client;
+    }
+    /**
+     *
+     * @constructor
+     * @protected
+     */
     constructor(options) {
         super();
         this._router = new hl7_router_js_1.HL7Router();
@@ -46,7 +70,9 @@ class Hl7Client extends node_events_async_1.AsyncEventEmitter {
                 return;
             }
             let timeoutTimer;
-            const tcpSocket = node_net_1.default.connect(this._options);
+            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'));
@@ -56,10 +82,17 @@ class Hl7Client extends node_events_async_1.AsyncEventEmitter {
                 this.emit('close');
             });
             socket.on('error', err => this.emit('error', err));
-            socket.on('message', message => this._onMessage(message));
+            socket.on('message', message => {
+                this.emit('message', message, socket);
+                this._onMessage(message);
+            });
+            socket.on('send', message => this.emit('send', message, socket));
             const onReady = () => {
                 clearTimeout(timeoutTimer);
                 tcpSocket.removeListener('error', onError);
+                if (this._options.keepAlive) {
+                    tcpSocket.setKeepAlive(this._options.keepAlive, this._options.keepAliveInitialDelay);
+                }
                 resolve();
             };
             const onError = (error) => {

package/cjs/hl7-server.js

@@ -182,15 +182,19 @@ class HL7Server extends node_events_async_1.AsyncEventEmitter {
             maxBufferSize: this.maxBufferPerSocket,
         });
         this._sockets.add(socket);
-        socket.on('message', message => this._onMessage(socket, message));
         socket.on('close', () => {
             this._sockets.delete(socket);
             this.emit('disconnect', socket);
         });
         socket.on('error', error => this.emit('error', error, socket));
+        socket.on('message', message => {
+            this.emit('message', message, socket);
+            this._onMessage(message, socket);
+        });
+        socket.on('send', message => this.emit('send', message, socket));
         this.emit('connection', socket);
     }
-    _onMessage(socket, message) {
+    _onMessage(message, socket) {
         const waitPromise = new Promise(resolve => {
             const context = new h_l7_request_context_js_1.HL7RequestContext(socket, message);
             const timeoutTimer = setTimeout(() => {

package/cjs/hl7-socket.js

@@ -28,7 +28,15 @@ class HL7Socket extends node_events_async_1.AsyncEventEmitter {
         socket.on('close', () => {
             this.emit('close');
         });
-        frameStream.on('data', data => this._parseMessage(data));
+        frameStream.on('data', data => {
+            try {
+                const message = this._parseMessage(data);
+                this.emit('message', message);
+            }
+            catch (err) {
+                this.emit('error', err);
+            }
+        });
     }
     get connected() {
         return !this.socket.closed;
@@ -86,6 +94,7 @@ class HL7Socket extends node_events_async_1.AsyncEventEmitter {
         this.socket.write(hl7v2_1.VT);
         this.socket.write(buf);
         this.socket.end(hl7v2_1.FS + hl7v2_1.CR);
+        this.emit('send', message, this.socket);
     }
     async sendMessageWaitAck(message) {
         this.sendMessage(message);
@@ -137,18 +146,13 @@ class HL7Socket extends node_events_async_1.AsyncEventEmitter {
         this.socket.setKeepAlive(enable, initialDelay);
     }
     _parseMessage(data) {
-        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) {
-            this.emit('error', err);
+        const message = new hl7v2_1.HL7Message();
+        message.parse(data);
+        for (const hook of this._messageHooks) {
+            if (hook(message))
+                break;
         }
+        return message;
     }
 }
 exports.HL7Socket = HL7Socket;

package/esm/hl7-client.js

@@ -1,9 +1,33 @@
 import net from 'node:net';
+import tls from 'node:tls';
 import { AsyncEventEmitter } from 'node-events-async';
 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 {
+    /**
+     * Creates an HL7 TCP client
+     * @static
+     */
+    static createClient(options) {
+        const client = new Hl7Client(options);
+        client._tls = false;
+        return client;
+    }
+    /**
+     * Creates a secure HL7 TCP client
+     * @static
+     */
+    static createTlsClient(options) {
+        const client = new Hl7Client(options);
+        client._tls = true;
+        return client;
+    }
+    /**
+     *
+     * @constructor
+     * @protected
+     */
     constructor(options) {
         super();
         this._router = new HL7Router();
@@ -42,7 +66,9 @@ export class Hl7Client extends AsyncEventEmitter {
                 return;
             }
             let timeoutTimer;
-            const tcpSocket = net.connect(this._options);
+            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'));
@@ -52,10 +78,17 @@ export class Hl7Client extends AsyncEventEmitter {
                 this.emit('close');
             });
             socket.on('error', err => this.emit('error', err));
-            socket.on('message', message => this._onMessage(message));
+            socket.on('message', message => {
+                this.emit('message', message, socket);
+                this._onMessage(message);
+            });
+            socket.on('send', message => this.emit('send', message, socket));
             const onReady = () => {
                 clearTimeout(timeoutTimer);
                 tcpSocket.removeListener('error', onError);
+                if (this._options.keepAlive) {
+                    tcpSocket.setKeepAlive(this._options.keepAlive, this._options.keepAliveInitialDelay);
+                }
                 resolve();
             };
             const onError = (error) => {

package/esm/hl7-server.js

@@ -178,15 +178,19 @@ export class HL7Server extends AsyncEventEmitter {
             maxBufferSize: this.maxBufferPerSocket,
         });
         this._sockets.add(socket);
-        socket.on('message', message => this._onMessage(socket, message));
         socket.on('close', () => {
             this._sockets.delete(socket);
             this.emit('disconnect', socket);
         });
         socket.on('error', error => this.emit('error', error, socket));
+        socket.on('message', message => {
+            this.emit('message', message, socket);
+            this._onMessage(message, socket);
+        });
+        socket.on('send', message => this.emit('send', message, socket));
         this.emit('connection', socket);
     }
-    _onMessage(socket, message) {
+    _onMessage(message, socket) {
         const waitPromise = new Promise(resolve => {
             const context = new HL7RequestContext(socket, message);
             const timeoutTimer = setTimeout(() => {

package/esm/hl7-socket.js

@@ -24,7 +24,15 @@ export class HL7Socket extends AsyncEventEmitter {
         socket.on('close', () => {
             this.emit('close');
         });
-        frameStream.on('data', data => this._parseMessage(data));
+        frameStream.on('data', data => {
+            try {
+                const message = this._parseMessage(data);
+                this.emit('message', message);
+            }
+            catch (err) {
+                this.emit('error', err);
+            }
+        });
     }
     get connected() {
         return !this.socket.closed;
@@ -82,6 +90,7 @@ export class HL7Socket extends AsyncEventEmitter {
         this.socket.write(VT);
         this.socket.write(buf);
         this.socket.end(FS + CR);
+        this.emit('send', message, this.socket);
     }
     async sendMessageWaitAck(message) {
         this.sendMessage(message);
@@ -133,17 +142,12 @@ export class HL7Socket extends AsyncEventEmitter {
         this.socket.setKeepAlive(enable, initialDelay);
     }
     _parseMessage(data) {
-        try {
-            const message = new HL7Message();
-            message.parse(data);
-            for (const hook of this._messageHooks) {
-                if (hook(message))
-                    break;
-            }
-            this.emit('message', message);
-        }
-        catch (err) {
-            this.emit('error', err);
+        const message = new HL7Message();
+        message.parse(data);
+        for (const hook of this._messageHooks) {
+            if (hook(message))
+                break;
         }
+        return message;
     }
 }

package/package.json

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

package/types/hl7-client.d.ts

@@ -1,16 +1,32 @@
 import net from 'node:net';
+import tls from 'node:tls';
 import { HL7Message } from 'hl7v2';
-import { TcpNetConnectOpts } from 'net';
 import { AsyncEventEmitter } from 'node-events-async';
 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 {
+export declare class Hl7Client extends AsyncEventEmitter<Hl7Client.Events> {
     protected _router: HL7Router;
     protected _socket?: HL7Socket;
-    protected _options: Hl7Client.ConnectOptions;
-    constructor(options: Hl7Client.ConnectOptions);
+    protected _tls?: boolean;
+    protected _options: Hl7Client.NetConnectOptions | Hl7Client.TlsConnectOptions;
+    /**
+     * Creates an HL7 TCP client
+     * @static
+     */
+    static createClient(options: Hl7Client.NetConnectOptions): Hl7Client;
+    /**
+     * Creates a secure HL7 TCP client
+     * @static
+     */
+    static createTlsClient(options: Hl7Client.TlsConnectOptions): Hl7Client;
+    /**
+     *
+     * @constructor
+     * @protected
+     */
+    protected constructor(options: Hl7Client.NetConnectOptions | Hl7Client.TlsConnectOptions);
     get connected(): boolean;
     get readyState(): net.SocketReadyState;
     get connectTimeout(): number | undefined;
@@ -28,10 +44,16 @@ export declare class Hl7Client extends AsyncEventEmitter {
     protected _onMessage(message: HL7Message): void;
 }
 export declare namespace Hl7Client {
-    interface ConnectOptions extends StrictOmit<TcpNetConnectOpts, 'onread' | 'readable' | 'writable'>, HL7Socket.Options {
+    interface CommonConnectOptions {
         connectTimeout?: number;
         maxBufferSize?: number;
+        responseTimeout?: number;
+        keepAlive?: boolean;
+        keepAliveInitialDelay?: number;
     }
-    interface Events extends StrictOmit<HL7Socket.Events, 'message'> {
+    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 {};
 }

package/types/hl7-server.d.ts

@@ -94,7 +94,7 @@ export declare class HL7Server extends AsyncEventEmitter<HL7Server.Events> {
      */
     unref(): this;
     protected _connectionListener(tcpSocket: Socket): void;
-    protected _onMessage(socket: HL7Socket, message: HL7Message): void;
+    protected _onMessage(message: HL7Message, socket: HL7Socket): void;
 }
 export declare namespace HL7Server {
     interface Events {
@@ -104,7 +104,8 @@ export declare namespace HL7Server {
         disconnect: [socket: HL7Socket];
         drop: [data?: net.DropArgument];
         error: [error: Error, HL7Socket | undefined];
-        message: [message: HL7Message];
+        message: [message: HL7Message, socket: HL7Socket];
+        send: [message: HL7Message, socket: HL7Socket];
     }
     interface Options {
         applicationName?: string;

package/types/hl7-socket.d.ts

@@ -26,7 +26,7 @@ export declare class HL7Socket extends AsyncEventEmitter {
     sendMessage(message: HL7Message): void;
     sendMessageWaitAck(message: HL7Message): Promise<HL7Message>;
     setKeepAlive(enable?: boolean, initialDelay?: number): void;
-    protected _parseMessage(data: Buffer): void;
+    protected _parseMessage(data: Buffer): HL7Message;
 }
 export declare namespace HL7Socket {
     interface Events {
@@ -37,7 +37,8 @@ export declare namespace HL7Socket {
         lookup: [
             listener: (err: Error, address: string, family: string | number, host: string) => void
         ];
-        message: [message: HL7Message];
+        message: [message: HL7Message, socket: HL7Socket];
+        send: [message: HL7Message, socket: HL7Socket];
     }
     interface Options {
         responseTimeout?: number;