@syncbridge/hl7 0.4.1

package/LICENSE

@@ -0,0 +1,15 @@
+Copyright (c) 2025 Panates (Panates Teknoloji Yatirim A.S.). All rights reserved.
+
+This software and associated documentation files (the "Software") are
+the proprietary property of Panates and are protected by copyright laws
+and international copyright treaties.
+
+Unauthorized copying, distribution, modification, reverse engineering,
+or use of this software, in whole or in part, is strictly prohibited
+without the express written permission of Panates.
+
+This Software is provided solely for use in accordance with the terms
+of a valid license agreement. Any unauthorized use may result in
+civil and/or criminal penalties.
+
+For licensing inquiries, please contact: info@panates.com

package/README.md

@@ -0,0 +1 @@
+# SyncBridge Ngrok Connectors

package/components/hl7-client.component.d.ts

@@ -0,0 +1,37 @@
+import { Buffer } from 'node:buffer';
+import { AddressInfo } from 'node:net';
+import { TransmitLogger } from '@syncbridge/builtins';
+import { ComponentBase } from '@syncbridge/common';
+import { HL7Message } from 'hl7v2';
+import { Hl7Client, HL7Middleware } from 'hl7v2-net';
+import { HL7ClientVariables } from './hl7-client.variables.js';
+/**
+ * HL7Client component
+ */
+export declare class HL7ClientComponent<TEvents extends HL7ClientComponent.Events = HL7ClientComponent.Events> extends ComponentBase<TEvents> {
+    protected _stopping?: boolean;
+    protected _address?: any;
+    client: Hl7Client;
+    transmitLogger?: TransmitLogger;
+    values: HL7ClientVariables;
+    protected _init(): Promise<void>;
+    protected _start(abortSignal: AbortSignal): Promise<void>;
+    protected _stop(): Promise<void>;
+    use(handler: HL7Middleware, priority?: number): void;
+}
+/**
+ * @namespace
+ */
+export declare namespace HL7ClientComponent {
+    interface Events extends ComponentBase.Events {
+        connect: [info: AddressInfo];
+        ready: [info: AddressInfo];
+        close: [info: AddressInfo];
+        error: [error: Error, info: AddressInfo];
+        message: [message: HL7Message, info: AddressInfo];
+        data: [data: Buffer, info: AddressInfo];
+        transmit: [data: Buffer, info: AddressInfo];
+    }
+    const Variables: typeof HL7ClientVariables;
+    type Variables = HL7ClientVariables;
+}

package/components/hl7-client.component.js

@@ -0,0 +1,137 @@
+import { __decorate, __metadata } from "tslib";
+import path from 'node:path';
+import { TransmitLogger } from '@syncbridge/builtins';
+import { Component, ComponentBase, ServiceStatus } from '@syncbridge/common';
+import { Hl7Client } from 'hl7v2-net';
+import { noOp, panatesAuthor } from '../constants.js';
+import { HL7ClientVariables } from './hl7-client.variables.js';
+/**
+ * HL7Client component
+ */
+let HL7ClientComponent = class HL7ClientComponent extends ComponentBase {
+    _stopping;
+    _address;
+    transmitLogger;
+    async _init() {
+        await super._init();
+        this.values.reconnect = this.values.reconnect || {};
+        try {
+            if (this.values.tls) {
+                this.client = Hl7Client.createTlsClient({
+                    host: this.values.host,
+                    port: this.values.port,
+                    connectTimeout: this.values.connectTimeout,
+                    responseTimeout: this.values.responseTimeout,
+                    keepAlive: this.values.keepAlive,
+                    reconnect: this.values.reconnect,
+                    ...this.values.tls,
+                });
+            }
+            else {
+                this.client = Hl7Client.createClient({
+                    host: this.values.host,
+                    port: this.values.port,
+                    connectTimeout: this.values.connectTimeout,
+                    responseTimeout: this.values.responseTimeout,
+                    keepAlive: this.values.keepAlive,
+                    reconnect: {
+                        // @ts-ignore
+                        strategy: 'exponential',
+                        ...this.values.reconnect,
+                    },
+                });
+            }
+            this.client.on('connect', () => {
+                this._address = { ...this.client.address() };
+                this._address.toString = function () {
+                    return `${this.address}:${this.port}`;
+                }.bind(this._address);
+                if (this.transmitLogger)
+                    this.transmitLogger.info('Connected', `${this._address}`);
+                this.logger?.trace(`Connected to ${this._address}`);
+                this.emit('connect', this._address);
+            });
+            this.client.on('ready', () => this.emit('ready', this._address));
+            this.client.on('close', () => {
+                if (this.transmitLogger)
+                    this.transmitLogger.info('Disconnected', this._address);
+                this.logger?.trace(`Disconnected from ${this._address}`);
+                this.emit('close', this._address);
+            });
+            this.client.on('error', error => {
+                error = error instanceof AggregateError ? error.errors[0] : error;
+                if (error.code === 'ECONNREFUSED')
+                    error.message = `Connection refused to ${error.address}:${error.port}`;
+                this.logger?.error(error);
+                this.emit('error', error, this._address);
+            });
+            this.client.on('message', message => {
+                this.logger?.trace(`HL7 message (${message.messageType}) received from ${this.client.uri}`);
+                this.emit('message', message, this._address);
+            });
+            this.client.on('send', message => {
+                this.logger?.trace(`HL7 message (${message.messageType}) sent to ${this.client.uri}`);
+                this.emit('send', message, this._address);
+            });
+            this.client.on('data', data => {
+                this.emit('data', data, this._address);
+            });
+            const { communicationLogs } = this.values;
+            const { dataDirectory } = this.processor;
+            if (communicationLogs) {
+                const transmitLogger = (this.transmitLogger = new TransmitLogger({
+                    ...communicationLogs,
+                    logDirectory: dataDirectory
+                        ? path.join(dataDirectory, 'comm-logs')
+                        : undefined,
+                    name: this.path.replace(/\//g, '-'),
+                    maxFiles: communicationLogs?.maxFiles,
+                    maxFileSize: communicationLogs?.maxFileSize,
+                }));
+                this.on('data', (data, info) => {
+                    transmitLogger.received(data, info);
+                });
+                this.on('transmit', (data, info) => {
+                    transmitLogger.transmitted(data, info);
+                });
+            }
+        }
+        catch (err) {
+            this.logger?.error(err);
+            this.setStatus(ServiceStatus.unhealthy, err.message);
+        }
+    }
+    async _start(abortSignal) {
+        this._stopping = false;
+        this.client.connect().catch(noOp);
+        await super._start(abortSignal);
+    }
+    async _stop() {
+        this._stopping = true;
+        await this.client.close(30000);
+        return super._stop();
+    }
+    use(handler, priority) {
+        return this.client.use(handler, priority);
+    }
+};
+__decorate([
+    Component.UseVariables(),
+    __metadata("design:type", HL7ClientVariables)
+], HL7ClientComponent.prototype, "values", void 0);
+HL7ClientComponent = __decorate([
+    Component({
+        className: 'HL7Client',
+        displayName: 'HL7 Client',
+        description: 'HL7 Client component',
+        author: panatesAuthor,
+        tags: ['hl7', 'client'],
+    })
+], HL7ClientComponent);
+export { HL7ClientComponent };
+/**
+ * @namespace
+ */
+(function (HL7ClientComponent) {
+    HL7ClientComponent.Variables = HL7ClientVariables;
+})(HL7ClientComponent || (HL7ClientComponent = {}));

package/components/hl7-client.variables.d.ts

@@ -0,0 +1,15 @@
+import { TransmitLogger } from '@syncbridge/builtins';
+import { TcpClientComponent } from '@syncbridge/net';
+/**
+ * Variables
+ */
+export declare class HL7ClientVariables {
+    host: string;
+    port: number;
+    keepAlive: boolean;
+    connectTimeout: number;
+    responseTimeout: number;
+    tls: TcpClientComponent.TlsVariables;
+    reconnect: TcpClientComponent.ReconnectVariables;
+    communicationLogs?: TransmitLogger.Variables;
+}

package/components/hl7-client.variables.js

@@ -0,0 +1,72 @@
+import { __decorate, __metadata } from "tslib";
+import { TransmitLogger } from '@syncbridge/builtins';
+import { DefineVariable } from '@syncbridge/common';
+import { TcpClientComponent } from '@syncbridge/net';
+/**
+ * Variables
+ */
+export class HL7ClientVariables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Host',
+        description: 'Hostname or IP address to be connected to',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], HL7ClientVariables.prototype, "host", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Port',
+        description: 'Port number of target listener',
+        required: true,
+        minValue: 1,
+        maxValue: 65535,
+    }),
+    __metadata("design:type", Number)
+], HL7ClientVariables.prototype, "port", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Keep alive',
+        description: 'Enables keep-alive on the TCP socket',
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], HL7ClientVariables.prototype, "keepAlive", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Connect timeout',
+        description: 'Connection timeout in milliseconds',
+        default: 10000,
+    }),
+    __metadata("design:type", Number)
+], HL7ClientVariables.prototype, "connectTimeout", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Response timeout',
+        description: 'Response timeout in milliseconds',
+        default: 30000,
+    }),
+    __metadata("design:type", Number)
+], HL7ClientVariables.prototype, "responseTimeout", void 0);
+__decorate([
+    DefineVariable({
+        label: 'TLS',
+        description: 'TLS options',
+    }),
+    __metadata("design:type", TcpClientComponent.TlsVariables)
+], HL7ClientVariables.prototype, "tls", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Reconnect',
+        description: 'Reconnect options',
+    }),
+    __metadata("design:type", TcpClientComponent.ReconnectVariables)
+], HL7ClientVariables.prototype, "reconnect", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Communication Logs',
+        description: 'Stores communication logs if enabled',
+    }),
+    __metadata("design:type", TransmitLogger.Variables)
+], HL7ClientVariables.prototype, "communicationLogs", void 0);

package/components/hl7-server.component.d.ts

@@ -0,0 +1,44 @@
+import net, { AddressInfo } from 'node:net';
+import { TransmitLogger } from '@syncbridge/builtins';
+import { ComponentBase } from '@syncbridge/common';
+import { TcpServerComponent } from '@syncbridge/net';
+import { HL7Message } from 'hl7v2';
+import { HL7Middleware, HL7Server, HL7Socket } from 'hl7v2-net';
+import { HL7ServerVariables } from './hl7-server.variables.js';
+/**
+ * HL7Server component
+ */
+export declare class HL7ServerComponent<TEvents extends HL7ServerComponent.Events = HL7ServerComponent.Events> extends ComponentBase<TEvents> {
+    protected _stopping?: boolean;
+    server: HL7Server;
+    transmitLogger?: TransmitLogger;
+    values: HL7ServerVariables;
+    protected _init(): Promise<void>;
+    protected _start(abortSignal: AbortSignal): Promise<void>;
+    protected _stop(): Promise<void>;
+    use(handler: HL7Middleware, priority?: number): void;
+}
+/**
+ * @namespace
+ */
+export declare namespace HL7ServerComponent {
+    interface Events extends ComponentBase.Events {
+        listening: [];
+        close: [];
+        connection: [info: AddressInfo, socket: HL7Socket];
+        disconnect: [info: AddressInfo, socket: HL7Socket];
+        drop: [data?: net.DropArgument];
+        error: [error: Error, info?: AddressInfo, socket?: HL7Socket | undefined];
+        warning: [
+            error: Error | string,
+            info: AddressInfo,
+            socket: HL7Socket | undefined
+        ];
+        message: [message: HL7Message, info: AddressInfo, socket: HL7Socket];
+        transmit: [message: HL7Message, info: AddressInfo, socket: HL7Socket];
+    }
+    const Variables: typeof HL7ServerVariables;
+    type Variables = HL7ServerVariables;
+    const TlsVariables: typeof import("packages-ext/net/build/components/tcp-server.variables.js").TcpServerTlsVariables;
+    type TlsVariables = TcpServerComponent.TlsVariables;
+}

package/components/hl7-server.component.js

@@ -0,0 +1,147 @@
+import { __decorate, __metadata } from "tslib";
+import path from 'node:path';
+import { TransmitLogger } from '@syncbridge/builtins';
+import { Component, ComponentBase, ServiceStatus } from '@syncbridge/common';
+import { TcpServerComponent } from '@syncbridge/net';
+import { HL7Server } from 'hl7v2-net';
+import { panatesAuthor } from '../constants.js';
+import { HL7ServerVariables } from './hl7-server.variables.js';
+/**
+ * HL7Server component
+ */
+let HL7ServerComponent = class HL7ServerComponent extends ComponentBase {
+    _stopping;
+    transmitLogger;
+    async _init() {
+        await super._init();
+        try {
+            if (this.values.tls) {
+                this.server = HL7Server.createTlsServer(this.values.tls);
+            }
+            else {
+                this.server = HL7Server.createServer();
+            }
+            this.server.on('listening', () => this.emit('listening'));
+            this.server.on('close', () => this.emit('close'));
+            this.server.on('connection', socket => {
+                this.logger?.trace(`Connection from: ${socket.remoteAddress()}`);
+                const info = {
+                    address: socket.remoteAddress(),
+                    toString: () => socket.remoteAddress(),
+                };
+                this.emit('connection', info, socket);
+            });
+            this.server.on('disconnect', socket => {
+                this.logger?.trace(`Disconnected: ${socket.remoteAddress()}`);
+                const info = {
+                    address: socket.remoteAddress(),
+                    toString: () => socket.remoteAddress(),
+                };
+                this.emit('disconnect', info, socket);
+            });
+            this.server.on('error', (error, socket) => {
+                if (socket) {
+                    error.message = error.message + ` [${socket?.remoteAddress()}]`;
+                }
+                if (error.code === 'ECONNRESET')
+                    return;
+                this.logger?.error(error);
+                if (socket) {
+                    const info = {
+                        address: socket.remoteAddress(),
+                        toString: () => socket.remoteAddress(),
+                    };
+                    this.emit('error', error, info, socket);
+                }
+                else
+                    this.emit('error', error);
+            });
+            this.server.on('message', (message, socket) => {
+                this.logger?.trace(`HL7 message (${message.messageType}) received from ${socket.remoteAddress()}`);
+                const info = {
+                    address: socket.remoteAddress(),
+                    toString: () => socket.remoteAddress(),
+                };
+                this.emit('message', message, info, socket);
+            });
+            this.server.on('send', (message, socket) => {
+                this.logger?.trace(`HL7 message (${message.messageType}) sent to ${socket.remoteAddress()}`);
+                const info = {
+                    address: socket.remoteAddress(),
+                    toString: () => socket.remoteAddress(),
+                };
+                this.emit('send', message, info, socket);
+            });
+            this.server.on('data', (data, socket) => {
+                const info = {
+                    address: socket.remoteAddress(),
+                    toString: () => socket.remoteAddress(),
+                };
+                this.emit('data', data, info, socket);
+            });
+            this.server.on('write', (data, socket) => {
+                const info = {
+                    address: socket.remoteAddress(),
+                    toString: () => socket.remoteAddress(),
+                };
+                this.emit('transmit', data, info, socket);
+            });
+            const { communicationLogs } = this.values;
+            const { dataDirectory } = this.processor;
+            if (communicationLogs) {
+                const transmitLogger = (this.transmitLogger = new TransmitLogger({
+                    ...communicationLogs,
+                    logDirectory: dataDirectory
+                        ? path.join(dataDirectory, 'comm-logs')
+                        : undefined,
+                    name: this.path.replace(/\//g, '-'),
+                    maxFiles: communicationLogs?.maxFiles,
+                    maxFileSize: communicationLogs?.maxFileSize,
+                }));
+                this.on('data', (data, info) => {
+                    transmitLogger.received(data, info);
+                });
+                this.on('transmit', (data, info) => {
+                    transmitLogger.transmitted(data, info);
+                });
+            }
+        }
+        catch (err) {
+            this.logger?.error(err);
+            this.setStatus(ServiceStatus.unhealthy, err.message);
+        }
+    }
+    async _start(abortSignal) {
+        this._stopping = false;
+        await this.server.listen(this.values.port);
+        super._start(abortSignal);
+    }
+    async _stop() {
+        this._stopping = true;
+        await this.server.close(30000);
+    }
+    use(handler, priority) {
+        return this.server.use(handler, priority);
+    }
+};
+__decorate([
+    Component.UseVariables(),
+    __metadata("design:type", HL7ServerVariables)
+], HL7ServerComponent.prototype, "values", void 0);
+HL7ServerComponent = __decorate([
+    Component({
+        className: 'HL7Server',
+        displayName: 'HL7 Server',
+        description: 'HL7 server component',
+        author: panatesAuthor,
+        tags: ['hl7', 'server'],
+    })
+], HL7ServerComponent);
+export { HL7ServerComponent };
+/**
+ * @namespace
+ */
+(function (HL7ServerComponent) {
+    HL7ServerComponent.Variables = HL7ServerVariables;
+    HL7ServerComponent.TlsVariables = TcpServerComponent.TlsVariables;
+})(HL7ServerComponent || (HL7ServerComponent = {}));

package/components/hl7-server.variables.d.ts

@@ -0,0 +1,6 @@
+import { TcpServerComponent } from '@syncbridge/net';
+/**
+ * Variables
+ */
+export declare class HL7ServerVariables extends TcpServerComponent.Variables {
+}

package/components/hl7-server.variables.js

@@ -0,0 +1,6 @@
+import { TcpServerComponent } from '@syncbridge/net';
+/**
+ * Variables
+ */
+export class HL7ServerVariables extends TcpServerComponent.Variables {
+}

package/components.d.ts

@@ -0,0 +1,2 @@
+export * from './components/hl7-client.component.js';
+export * from './components/hl7-server.component.js';

package/components.js

@@ -0,0 +1,2 @@
+export * from './components/hl7-client.component.js';
+export * from './components/hl7-server.component.js';

package/constants.d.ts

@@ -0,0 +1,4 @@
+import { AuthorMetadata } from '@syncbridge/common';
+export declare const version = "1";
+export declare const noOp: () => undefined;
+export declare const panatesAuthor: AuthorMetadata;

package/constants.js

@@ -0,0 +1,7 @@
+export const version = '0.4.1';
+export const noOp = () => undefined;
+export const panatesAuthor = {
+    name: 'Panates Technology AS',
+    email: 'info@panates.com',
+    url: 'https://www.panates.com',
+};

package/index.d.ts

@@ -0,0 +1,5 @@
+import * as components from './components.js';
+export { components };
+export * from './components.js';
+declare const cfg: import("@syncbridge/common").IExtensionPackage;
+export default cfg;

package/index.js

@@ -0,0 +1,9 @@
+import { makeExtensionPackage } from '@syncbridge/common';
+import * as components from './components.js';
+export { components };
+export * from './components.js';
+const cfg = makeExtensionPackage({
+    processors: [],
+    components: Object.values(components),
+});
+export default cfg;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@syncbridge/hl7",
+  "version": "0.4.1",
+  "description": "SyncBridge HL7 connection components",
+  "author": "Panates Inc",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "ansi-colors": "^4.1.3",
+    "fast-tokenizer": "^1.9.0",
+    "hl7v2": "^1.7.0",
+    "hl7v2-net": "^1.7.0",
+    "node-events-async": "^1.5.0"
+  },
+  "peerDependencies": {
+    "@syncbridge/common": "^0.4.1",
+    "@syncbridge/builtins": "^0.4.1",
+    "@syncbridge/net": "^0.4.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "engines": {
+    "node": ">=20.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}