hl7v2-net 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/cjs/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FS = exports.VT = exports.LF = exports.CR = void 0;
+exports.CR = '\x0D';
+exports.LF = '\x0A';
+exports.VT = '\x0B';
+exports.FS = '\x1C';

package/cjs/helpers/frame-stream.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 {
+    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;
+        if (opts?.frameStart) {
+            this._frameStart = node_buffer_1.Buffer.isBuffer(opts.frameStart)
+                ? opts.frameStart
+                : node_buffer_1.Buffer.from(opts.frameStart);
+        }
+        if (opts?.frameEnd) {
+            this._frameEnd = node_buffer_1.Buffer.isBuffer(opts.frameEnd)
+                ? opts.frameEnd
+                : node_buffer_1.Buffer.from(opts.frameEnd);
+        }
+    }
+    _transform(chunk, _encoding, callback) {
+        // Reset flush timer
+        if (this._flushTimeout) {
+            clearTimeout(this._flushTimeout);
+        }
+        try {
+            // console.log(chunk);
+            if (!node_buffer_1.Buffer.isBuffer(chunk))
+                chunk = node_buffer_1.Buffer.from(chunk);
+            if (this._chunkBuffer) {
+                this._assertMaxBuffer(chunk.length);
+                chunk = node_buffer_1.Buffer.concat([this._chunkBuffer, chunk]);
+                this._chunkBuffer = undefined;
+            }
+            const frameStart = this._frameStart;
+            const frameEnd = this._frameEnd;
+            if (frameStart || frameEnd) {
+                const stxLen = frameStart?.length || 0;
+                const etxLen = frameEnd?.length || 0;
+                let stxPos = 0;
+                let etxPos = 0;
+                while (etxPos < chunk.length) {
+                    /** Find the next stx position */
+                    stxPos = etxPos;
+                    if (frameStart) {
+                        stxPos = chunk.indexOf(frameStart, etxPos);
+                        if (stxPos < 0) {
+                            this._chunkBuffer = chunk.subarray(etxPos);
+                            return;
+                        }
+                    }
+                    if (stxPos < 0)
+                        stxPos = 0;
+                    etxPos = frameEnd
+                        ? /** Find the next etx position if frameEnd defined */
+                            chunk.indexOf(frameEnd, stxPos + stxLen)
+                        : frameStart
+                            ? /** Find the next stx if frameStart not defined */
+                                chunk.indexOf(frameStart, stxPos + stxLen)
+                            : -1;
+                    if (etxPos < 0) {
+                        this._chunkBuffer = chunk.subarray(stxPos);
+                        return;
+                    }
+                    etxPos += etxLen;
+                    this._pushChunk(chunk.subarray(stxPos, etxPos));
+                    this.flushBuffer();
+                }
+                return;
+            }
+            this._pushChunk(chunk);
+        }
+        finally {
+            if (this._chunks.length && this._frameDelayMs)
+                this._flushTimeout = setTimeout(() => this.flushBuffer(), this._frameDelayMs).unref();
+            callback();
+        }
+    }
+    _pushChunk(chunk) {
+        this._assertMaxBuffer(chunk.length);
+        this._chunks.push(chunk);
+        this._bufferSize += chunk.length;
+    }
+    _assertMaxBuffer(newChunkLen = 0) {
+        if (this.maxBufferSize &&
+            this._bufferSize + newChunkLen + (this._chunkBuffer?.length || 0) >
+                this.maxBufferSize) {
+            this.emit('error', new Error('Max buffer size exceeded'));
+        }
+    }
+    _flush(callback) {
+        if (this._flushTimeout) {
+            clearTimeout(this._flushTimeout);
+        }
+        this.flushBuffer();
+        callback();
+    }
+    reset() {
+        this._chunks = [];
+        this._chunkBuffer = undefined;
+        if (this._flushTimeout) {
+            clearTimeout(this._flushTimeout);
+            this._flushTimeout = undefined;
+        }
+    }
+    flushBuffer() {
+        if (this._chunkBuffer) {
+            this._chunks.push(this._chunkBuffer);
+            this._chunkBuffer = undefined;
+        }
+        /* c8 ignore next */
+        if (this._chunks.length === 0)
+            return;
+        const combined = this._chunks.length === 1 ? this._chunks[0] : node_buffer_1.Buffer.concat(this._chunks);
+        this._chunks = [];
+        this._bufferSize = 0;
+        if (this._customTransform) {
+            this._customTransform(combined, 'buffer', (err, data) => {
+                if (err)
+                    this.emit('error', err);
+                else
+                    this.push(data);
+            });
+            return;
+        }
+        this.push(combined);
+    }
+}
+exports.FrameStream = FrameStream;

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

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

package/cjs/hl7-client.js

@@ -0,0 +1,112 @@
+"use strict";
+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_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 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 {
+    constructor(options) {
+        super();
+        this._router = new hl7_router_js_1.HL7Router();
+        this._options = options;
+    }
+    get connected() {
+        return this._socket?.connected ?? false;
+    }
+    get readyState() {
+        return this._socket?.readyState || 'closed';
+    }
+    get connectTimeout() {
+        return this._options.connectTimeout;
+    }
+    set connectTimeout(value) {
+        this._options.connectTimeout = value ?? undefined;
+    }
+    get responseTimeout() {
+        return this._options.responseTimeout;
+    }
+    set responseTimeout(value) {
+        this._options.responseTimeout = value ?? undefined;
+    }
+    get maxBufferSize() {
+        return this._options.maxBufferSize || 0;
+    }
+    set maxBufferSize(value) {
+        this._options.maxBufferSize = value;
+        if (this._socket)
+            this._socket.maxBufferSize = value;
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            if (this.connected) {
+                resolve();
+                return;
+            }
+            let timeoutTimer;
+            const tcpSocket = 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', listener => this.emit('lookup', listener));
+            socket.on('close', () => {
+                this._socket = undefined;
+                this.emit('close');
+            });
+            socket.on('error', err => this.emit('error', err));
+            socket.on('message', message => this._onMessage(message));
+            const onReady = () => {
+                clearTimeout(timeoutTimer);
+                tcpSocket.removeListener('error', onError);
+                resolve();
+            };
+            const onError = (error) => {
+                clearTimeout(timeoutTimer);
+                tcpSocket.removeListener('ready', onReady);
+                tcpSocket.destroy();
+                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();
+            }
+        });
+    }
+    async close(waitRunningHandlers) {
+        await this._socket?.close(waitRunningHandlers);
+    }
+    async sendMessage(message) {
+        if (!this.connected)
+            await this.connect();
+        this._socket.sendMessage(message);
+    }
+    async sendMessageWaitAck(request) {
+        if (!this.connected)
+            await this.connect();
+        return this._socket.sendMessageWaitAck(request);
+    }
+    setKeepAlive(enable, initialDelay) {
+        this._options.keepAlive = enable;
+        this._options.keepAliveInitialDelay = initialDelay;
+        this._socket?.setKeepAlive(enable, initialDelay);
+    }
+    use(handler, priority = 0) {
+        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);
+        });
+    }
+}
+exports.Hl7Client = Hl7Client;

package/cjs/hl7-request.js

@@ -0,0 +1,10 @@
+"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

@@ -0,0 +1,28 @@
+"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/cjs/hl7-router.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HL7Router = void 0;
+class HL7Router {
+    constructor() {
+        this._allHandlers = {};
+        this._handlers = [];
+        this._errorHandlers = [];
+    }
+    use(handler, priority = 0) {
+        let list = this._allHandlers[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._needPrepare = true;
+    }
+    handle(error, req, res, callback) {
+        this._prepareStack();
+        let errIdx = -1;
+        let handlerIdx = -1;
+        let lastErr;
+        let callbackCalled = false;
+        const doCallback = (err) => {
+            if (callbackCalled)
+                return;
+            callbackCalled = true;
+            res.removeListener('finish', onFinish);
+            callback(err);
+        };
+        const onFinish = () => doCallback();
+        res.once('finish', onFinish);
+        const next = (err) => {
+            lastErr = err || lastErr;
+            if (res.finished) {
+                doCallback();
+                return;
+            }
+            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);
+                    return;
+                }
+            }
+            catch (e) {
+                next(e);
+            }
+        };
+        next(error);
+    }
+    _prepareStack() {
+        if (!this._needPrepare)
+            return;
+        delete this._needPrepare;
+        this._errorHandlers = [];
+        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);
+        });
+    }
+}
+exports.HL7Router = HL7Router;

package/cjs/hl7-server.js

@@ -0,0 +1,241 @@
+"use strict";
+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 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 {
+    /**
+     * Creates a HL7 TCP server
+     * @static
+     */
+    static createServer(listenerOptions, options) {
+        return new HL7Server(node_net_1.default.createServer(listenerOptions), options);
+    }
+    /**
+     * Creates a secure HL7 TCP server
+     * @static
+     */
+    static createTlsServer(listenerOptions, options) {
+        return new HL7Server(node_tls_1.default.createServer(listenerOptions), options);
+    }
+    /**
+     *
+     * @constructor
+     * @protected
+     */
+    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._server = server;
+        this._server.on('connection', socket => this._connectionListener(socket));
+        this._server.on('listening', () => this.emit('listening'));
+        this._server.on('close', () => this.emit('close'));
+        this._server.on('drop', data => this.emit('drop', data));
+        this._server.on('error', error => this.emit('error', error, undefined));
+    }
+    /**
+     *
+     */
+    get listening() {
+        return this._server.listening;
+    }
+    /**
+     *
+     */
+    get connections() {
+        return this._server.connections;
+    }
+    /**
+     * Set this property to reject connections when the server's connection count gets high.
+     * It is not recommended to use this option once a socket has been sent to a child with child_process.fork().
+     */
+    get maxConnections() {
+        return this._server.maxConnections;
+    }
+    set maxConnections(value) {
+        this._server.maxConnections = value;
+    }
+    /**
+     * Set this property to true to begin closing connections once the number of
+     * connections reaches the maxConnections threshold.
+     * This setting is only effective in cluster mode.
+     */
+    get dropMaxConnection() {
+        // Added in: NodeJS v23.1.0, v22.12.0
+        return this._server.dropMaxConnection;
+    }
+    set dropMaxConnection(value) {
+        // Added in: NodeJS v23.1.0, v22.12.0
+        this._server.dropMaxConnection = value;
+    }
+    listen(...args) {
+        return new Promise((resolve, reject) => {
+            const onListening = () => {
+                this._server.removeListener('error', onListening);
+                resolve();
+            };
+            const onError = (error) => {
+                this._server.removeListener('listening', onListening);
+                reject(error);
+            };
+            this._server.once('listening', onListening);
+            this._server.once('error', onError);
+            // @ts-ignore
+            this._server.listen.call(this._server, ...args);
+        });
+    }
+    /**
+     * Returns the bound `address`, the address `family` name, and `port` of the server
+     * as reported by the operating system if listening on an IP socket
+     * (useful to find which port was assigned when getting an OS-assigned address):
+     * `{ port: 12346, family: 'IPv4', address: '127.0.0.1' }`.
+     *
+     * For a server listening on a pipe or Unix domain socket, the name is returned
+     * as a string.
+     *
+     * `server.address()` returns `null` before the `'listening'` event has been
+     * emitted or after calling `server.close()`.
+     */
+    address() {
+        return this._server.address();
+    }
+    /**
+     * Stops the server from accepting new connections and keeps existing
+     * connections.
+     */
+    async close(waitRunningHandlers) {
+        if (!this.listening)
+            return;
+        this._closing = true;
+        /** Wait for running handlers to finish */
+        if (waitRunningHandlers && this._runningHandlers.size > 0) {
+            await new Promise(resolve => {
+                /** Timeout timer will resolve this promise to stop waiting */
+                const timer = setTimeout(() => {
+                    resolve();
+                }, waitRunningHandlers).unref();
+                Promise.allSettled(Array.from(this._runningHandlers)).then(() => {
+                    clearTimeout(timer);
+                    resolve();
+                });
+            });
+        }
+        await Promise.allSettled(Array.from(this._sockets.values()).map(socket => socket.close(waitRunningHandlers)));
+        return new Promise(resolve => {
+            this._server.close(() => resolve());
+        }).then(() => {
+            delete this._closing;
+            this.emit('close');
+        });
+    }
+    use(handler, priority = 0) {
+        this._router.use(handler, priority);
+    }
+    /**
+     * Asynchronously get the number of concurrent connections on the server. Works
+     * when sockets were sent to forks.
+     */
+    async getConnections() {
+        return new Promise((resolve, reject) => {
+            try {
+                this._server.getConnections((error, count) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(count);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Opposite of `unref()`, calling `ref()` on a previously `unref`ed server will _not_ let
+     * the program exit if it's the only server left (the default behavior).
+     * If the server is `ref`ed calling `ref()` again will have no effect.
+     */
+    ref() {
+        this._server.ref();
+        return this;
+    }
+    /**
+     * Calling `unref()` on a server will allow the program to exit if this is the only
+     * active server in the event system. If the server is already `unref`ed calling`unref()` again will have no effect.
+     */
+    unref() {
+        this._server.unref();
+        return this;
+    }
+    _connectionListener(tcpSocket) {
+        const socket = new hl7_socket_js_1.HL7Socket(tcpSocket, {
+            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);
+        });
+        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 timeoutTimer = setTimeout(() => {
+                try {
+                    const error = new hl7_exchange_error_js_1.HL7ExchangeError('Response timeout');
+                    const ack = req.message.createAck('AE', error);
+                    res.send(ack);
+                }
+                finally {
+                    resolve();
+                }
+            }, this.responseTimeout || 30000).unref();
+            this._router.handle(undefined, req, res, error => {
+                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();
+                }
+            });
+        });
+        this._runningHandlers.add(waitPromise);
+        waitPromise.finally(() => {
+            this._runningHandlers.delete(waitPromise);
+        });
+    }
+}
+exports.HL7Server = HL7Server;