hl7v2-net 1.0.2

package/cjs/hl7-socket.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HL7Socket = void 0;
+const tslib_1 = require("tslib");
+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._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 => this.emit('error', err));
+        socket.pipe(frameStream);
+        socket.on('connect', () => this.emit('connect'));
+        socket.on('ready', () => this.emit('ready'));
+        socket.on('lookup', listener => this.emit('lookup', listener));
+        socket.on('timeout', () => socket.destroy());
+        socket.on('close', () => {
+            this.emit('close');
+        });
+        frameStream.on('data', data => this._parseMessage(data));
+    }
+    get connected() {
+        return !this.socket.closed;
+    }
+    get closed() {
+        return this.socket.closed;
+    }
+    get readyState() {
+        return this.socket.readyState;
+    }
+    get maxBufferSize() {
+        return this._frameStream.maxBufferSize || 0;
+    }
+    set maxBufferSize(value) {
+        this._frameStream.maxBufferSize = value;
+    }
+    address() {
+        return this.socket.address();
+    }
+    async close(waitRunningHandlers) {
+        if (this.closed)
+            return;
+        /** Stop receiving data */
+        this.socket.unpipe(this._frameStream);
+        /** Wait for running handlers to finish */
+        if (waitRunningHandlers && this._waitPromises.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._waitPromises)).then(() => {
+                    clearTimeout(timer);
+                    resolve();
+                });
+            });
+        }
+        return new Promise(resolve => {
+            this.socket.once('close', () => resolve());
+            this.socket.destroy();
+        });
+    }
+    sendMessage(message) {
+        if (!this.connected)
+            throw new Error('Socket is not connected');
+        let encoding = message.header.field(hl7v2_1.MSHSegment.CharacterSet).value;
+        if (!encoding) {
+            encoding = 'UTF-8';
+            message.header.field(hl7v2_1.MSHSegment.CharacterSet).value = encoding;
+        }
+        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.end(hl7v2_1.FS + hl7v2_1.CR);
+    }
+    async sendMessageWaitAck(message) {
+        this.sendMessage(message);
+        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;
+                if (msgType2 !== 'ACK')
+                    return;
+                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;
+                if (controlId2 !== controlId)
+                    return;
+                cleanup();
+                resolve(resp);
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const cleanup = () => {
+                clearTimeout(responseTimer);
+                this.removeListener('message', onMessage);
+                this.socket.removeListener('error', onError);
+            };
+            const controlId = message.header.field(hl7v2_1.MSHSegment.MessageControlID).value;
+            this.socket.once('error', reject);
+            this.on('message', onMessage);
+            if (responseTimeout) {
+                responseTimer = setTimeout(() => {
+                    onError(new Error('Response timeout'));
+                }, responseTimeout).unref();
+            }
+        });
+        this._waitPromises.add(waitPromise);
+        waitPromise.finally(() => {
+            this._waitPromises.delete(waitPromise);
+        });
+        return waitPromise;
+    }
+    setKeepAlive(enable, initialDelay) {
+        this._options.keepAlive = enable;
+        this._options.keepAliveInitialDelay = initialDelay;
+        this.socket.setKeepAlive(enable, initialDelay);
+    }
+    _parseMessage(data) {
+        try {
+            const message = new hl7v2_1.HL7Message();
+            message.parse(data);
+            this.emit('message', message);
+        }
+        catch (err) {
+            this.emit('error', err);
+        }
+    }
+}
+exports.HL7Socket = HL7Socket;

package/cjs/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+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);
+tslib_1.__exportStar(require("./types.js"), exports);

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/constants.js

@@ -0,0 +1,4 @@
+export const CR = '\x0D';
+export const LF = '\x0A';
+export const VT = '\x0B';
+export const FS = '\x1C';

package/esm/helpers/frame-stream.js

@@ -0,0 +1,133 @@
+import { Buffer } from 'node:buffer';
+import { Transform } from 'node:stream';
+export class FrameStream extends 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 = Buffer.isBuffer(opts.frameStart)
+                ? opts.frameStart
+                : Buffer.from(opts.frameStart);
+        }
+        if (opts?.frameEnd) {
+            this._frameEnd = Buffer.isBuffer(opts.frameEnd)
+                ? opts.frameEnd
+                : Buffer.from(opts.frameEnd);
+        }
+    }
+    _transform(chunk, _encoding, callback) {
+        // Reset flush timer
+        if (this._flushTimeout) {
+            clearTimeout(this._flushTimeout);
+        }
+        try {
+            // console.log(chunk);
+            if (!Buffer.isBuffer(chunk))
+                chunk = Buffer.from(chunk);
+            if (this._chunkBuffer) {
+                this._assertMaxBuffer(chunk.length);
+                chunk = 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] : 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);
+    }
+}

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

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

package/esm/hl7-client.js

@@ -0,0 +1,107 @@
+import net from 'node:net';
+import { AsyncEventEmitter } from 'node-events-async';
+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 {
+    constructor(options) {
+        super();
+        this._router = new 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 = 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', 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 HL7Request(this._socket, message);
+        const res = new HL7Response(req);
+        this._router.handle(undefined, req, res, error => {
+            if (error)
+                this.emit('error', error);
+        });
+    }
+}

package/esm/hl7-request.js

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

package/esm/hl7-response.js

@@ -0,0 +1,24 @@
+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/esm/hl7-router.js

@@ -0,0 +1,100 @@
+export 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);
+        });
+    }
+}