fastify-hl7 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Shane
+
+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/README.md

@@ -0,0 +1,122 @@
+# Fastify HL7
+
+A Fastify Hl7 Plugin Developed in Pure TypeScript.
+It uses the [node-hl7-client](https://github.com/Bugs5382/node-hl7-client) and [node-hl7-server](https://github.com/Bugs5382/node-hl7-server) plugin as a wrapper.
+
+The build exports this to valid ESM and CJS for ease of cross-compatibility.
+
+If you are using this NPM package, please consider giving it a :star: star.
+This will increase its visibility and solicit more contribution from the outside.
+
+This documentation is how to use this plugin, not on how to use the libraries above.
+Head [here](#external-libraries) if you need help with those.
+
+## Table of Contents
+
+1. [Install](#install)
+2. [Basic Usage](#basic-usage)
+   1. [Server Quick Start](#server-quick-start)
+   2. [Client Quick Start](#client-quick-start)
+3. [Full Documentation](#full-documentation)
+   1. [This Library Options](#this-library-options)
+   2. [External Libraries](#external-libraries)
+4. [Acknowledgements](#acknowledgements)
+5. [License](#license)
+
+## Install
+
+```
+npm install fastify-hl7
+```
+
+## Basic Usage
+
+Register this as a plugin.
+
+```ts
+await fastify.register(fastifyHL7)
+```
+
+### Server Quick Start
+
+```ts
+const listener = fastify.hl7.createInbound(
+  'ib_adt',
+  {port: 3001},
+  async (req, res) => {
+    const messageReq = req.getMessage()
+    const messageType = req.getType()
+    // your logic here
+    await res.sendResponse('AA')
+})
+```
+This will create a inbound connection. You can optionally return it to a variable to attach advanced listeners. 
+
+### Client Quick Start
+
+```ts
+import fastify from "fastify";
+
+fastify.hl7.createClient('localhost', {host: '0.0.0.0'})
+```
+
+This will create a "client" class that will then allow you to attach different outbound connections.
+The name ```localhost``` in a unique identifier to this host, so it can be used to attach different outbound connections to this server/broker.
+
+There might be times when your HL7 messages need to cross-over to different hosts/server/inbound endpoints and this is how you would get them.
+
+Within your code now you can use the fastify context and access the ```hl7``` decorator,
+and create an outbound connection.
+
+```ts
+const client = fastify.hl7.createOutbound(
+  'ob_adt',
+  {port: 3001},
+  async (res) => {
+    const messageRes = res.getMessage()
+    // Your code here. Either a failure or a success, but still do your work here.
+})
+
+// building a HL7 Message Segment
+const message = app.hl7.buildMessage({
+  messageHeader: {
+    msh_9_1: "ADT",
+    msh_9_2: "A01",
+    msh_11_1: "D",
+  }
+})
+
+await client.sendMessage(message)
+```
+
+## Full Documentation
+
+### This Library Options
+
+### `enableServer`
+
+If this is not set, enableServer will be set to ```true```. You need to set this to ```false``` will turn off the server capabilities.
+
+
+### ```serverOptions```
+
+Set this using the options from the [node-hl7-serer](https://github.com/Bugs5382/node-hl7-server/blob/main/README.md) library ServerOptions values to override server creation.
+This could be enabling IPv4 or IPv6 and other server options including TLS. SInce you can not set this after run time, it has to be set during registration.
+
+
+
+### External Libraries
+
+* [node-hl7-client](https://github.com/Bugs5382/node-hl7-client/blob/main/README.md) - For the Client, Parser, and Builder to review their options that can be passed as props.
+* [node-hl7-server](https://github.com/Bugs5382/node-hl7-server/blob/main/README.md) - For the Server to the options that can be passed as props.
+
+Please review the library for more complete documentation.
+A far as this plugin for Fastify, there are no options to pass.
+
+## Acknowledgements
+
+- My Wife and Baby Girl.
+
+## License
+
+Licensed under [MIT](./LICENSE).

package/lib/cjs/api.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HL7Server = exports.HL7Client = exports.fastifyHL7 = void 0;
+var _1 = __importDefault(require("."));
+exports.fastifyHL7 = _1.default;
+var hL7Client_js_1 = require("./class/hL7Client.js");
+Object.defineProperty(exports, "HL7Client", { enumerable: true, get: function () { return hL7Client_js_1.HL7Client; } });
+var hL7Server_js_1 = require("./class/hL7Server.js");
+Object.defineProperty(exports, "HL7Server", { enumerable: true, get: function () { return hL7Server_js_1.HL7Server; } });
+exports.default = _1.default;

package/lib/cjs/class/hL7Client.js

@@ -0,0 +1,244 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HL7Client = void 0;
+var node_hl7_client_1 = __importStar(require("node-hl7-client"));
+var errors_1 = require("../errors");
+var HL7Client = /** @class */ (function () {
+    function HL7Client() {
+        this._clientConnections = [];
+    }
+    /**
+     * Close All Connections for this Client
+     * @since 1.0.0
+     */
+    HL7Client.prototype.closeAll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                this._clientConnections.forEach(function (outbound) {
+                    outbound.ports.map(function (port) { return __awaiter(_this, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, port.connection.close()];
+                                case 1:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                });
+                return [2 /*return*/, true];
+            });
+        });
+    };
+    /**
+     * Build a HL7 Batch
+     * @description Create a properly formatted HL7 Batch.
+     * @since 1.0.0
+     * @param props
+     */
+    HL7Client.prototype.buildBatch = function (props) {
+        if (typeof props !== 'undefined' && typeof props.text !== 'undefined') {
+            throw new errors_1.errors.FASTIFY_HL7_ERR_USAGE('Use processMessage method. This is for building.');
+        }
+        return new node_hl7_client_1.Batch(__assign({}, props));
+    };
+    /**
+     * Build a HL7 File Batch
+     * @description Create a properly formatted HL7 File Batch.
+     * @since 1.0.0
+     * @param props
+     */
+    HL7Client.prototype.buildFileBatch = function (props) {
+        if (typeof props !== 'undefined' && (typeof props.fullFilePath !== 'undefined' || typeof props.fileBuffer !== 'undefined')) {
+            throw new errors_1.errors.FASTIFY_HL7_ERR_USAGE('Use readFile or readFileBuffer method. This is for building.');
+        }
+        return new node_hl7_client_1.FileBatch(__assign({}, props));
+    };
+    /**
+     * Build a HL7 Message
+     * @description Create a properly formatted HL7 message.
+     * @since 1.0.0
+     * @param props
+     */
+    HL7Client.prototype.buildMessage = function (props) {
+        if (typeof props !== 'undefined' && typeof props.text !== 'undefined') {
+            throw new errors_1.errors.FASTIFY_HL7_ERR_USAGE('Use processMessage method. This is for building.');
+        }
+        return new node_hl7_client_1.Message(__assign({}, props));
+    };
+    /**
+     *
+     * @param name
+     * @param props
+     */
+    HL7Client.prototype.createClient = function (name, props) {
+        var nameFormat = /[ `!@#$%^&*()+\-=\[\]{};':"\\|,.<>\/?~]/; //eslint-disable-line
+        if (nameFormat.test(name)) {
+            throw new errors_1.errors.FASTIFY_HL7_ERR_USAGE('name must not contain certain characters: `!@#$%^&*()+\\-=\\[\\]{};\':"\\\\|,.<>\\/?~.');
+        }
+        // make sure that this does not exist already...
+        this._clientConnections.forEach(function (connections) {
+            if (connections.name === name) {
+                throw new errors_1.errors.FASTIFY_HL7_ERR_USAGE('name must be unique.');
+            }
+            // nto in the Client class yet
+            // if (client.getHost() === props.host) {
+            //   throw new errors.FASTIFY_HL7_ERR_USAGE(`host is already a pointer. Name is: ${connections.name}`)
+            // }
+        });
+        // new client
+        var client = new node_hl7_client_1.default(props);
+        // add it to the collection
+        this._clientConnections.push({
+            name: name,
+            client: client,
+            ports: []
+        });
+    };
+    /**
+     * Create an HL7 Outbound Connection
+     * @description Connect to an HL7 Server/Broker
+     * @since 1.0.0
+     * @param name The name stored within created client connections.
+     * @param props
+     * @param handler
+     */
+    HL7Client.prototype.createOutbound = function (name, props, handler) {
+        var nameFormat = /[ `!@#$%^&*()+\-=\[\]{};':"\\|,.<>\/?~]/; //eslint-disable-line
+        if (nameFormat.test(name)) {
+            throw new errors_1.errors.FASTIFY_HL7_ERR_USAGE('name must not contain certain characters: `!@#$%^&*()+\\-=\\[\\]{};\':"\\\\|,.<>\\/?~.');
+        }
+        var getConnection = this._clientConnections.find(function (client) { return client.name === name; });
+        if (typeof getConnection !== 'undefined') {
+            // make sure port is not used all ready
+            getConnection.ports.forEach(function (outbound) {
+                if (outbound.port === props.port.toString()) {
+                    throw new errors_1.errors.FASTIFY_HL7_ERR_USAGE("port ".concat(props.port, " is already used with this client. Choose a new outgoing port."));
+                }
+            });
+            // create outbound port to the server in getConnection.client
+            var outbound = new node_hl7_client_1.HL7Outbound(getConnection.client, props, handler);
+            // add it to the array of known ports. need to know this, so we can get it later if needed.
+            getConnection.ports.push({ port: props.port.toString(), connection: outbound });
+            // return it right away. the user might do something with it.
+            return outbound;
+        }
+        throw new errors_1.errors.FASTIFY_HL7_ERR_USAGE('No valid client. Improper setup of a outbound connection.');
+    };
+    /**
+     * Process a HL7
+     * @description A HL7 message that could either be a Message (MSH) or Batch (BHS)
+     * @since 1.0.0
+     * @param text Raw HL& String
+     */
+    HL7Client.prototype.processHL7 = function (text) {
+        if ((0, node_hl7_client_1.isBatch)(text)) {
+            return new node_hl7_client_1.Batch({ text: text });
+        }
+        else {
+            return new node_hl7_client_1.Message({ text: text });
+        }
+    };
+    /**
+     * Read File
+     * @description Pass the correct path of the file you want to read.
+     * @since 1.0.0
+     * @param fullFilePath
+     * @returns FileBatch
+     * @example
+     *
+     * fastify.hl7.readFile( path.join('temp/', 'hl7.readTestBHS.20231208.hl7') )
+     *
+     */
+    HL7Client.prototype.readFile = function (fullFilePath) {
+        return new node_hl7_client_1.FileBatch({ fullFilePath: fullFilePath });
+    };
+    /**
+     * Read a File Buffer
+     * @description Translate an already Buffered HL7 FHS segment to decode it.
+     * @since 1.0.0
+     * @param fileBuffer
+     * @returns FileBatch
+     * @example
+     *
+     * const fileBuffer = fs.readFileSync(path.join('temp/', 'hl7.readTestBHS.20231208.hl7'))
+     * fastify.hl7.readFileBuffer(fileBuffer)
+     *
+     */
+    HL7Client.prototype.readFileBuffer = function (fileBuffer) {
+        return new node_hl7_client_1.FileBatch({ fileBuffer: fileBuffer });
+    };
+    return HL7Client;
+}());
+exports.HL7Client = HL7Client;

package/lib/cjs/class/hL7Server.js

@@ -0,0 +1,111 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HL7Server = void 0;
+var node_hl7_server_1 = require("node-hl7-server");
+var errors_1 = require("../errors");
+var HL7Server = /** @class */ (function () {
+    function HL7Server(server) {
+        this._server = server;
+        this._serverInboundConnections = [];
+    }
+    /**
+     * Close Inbound connection.
+     * @since 1.0.0
+     * @param port
+     */
+    HL7Server.prototype.close = function (port) {
+        return __awaiter(this, void 0, void 0, function () {
+            var inbound;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        inbound = this._serverInboundConnections.find(function (server) { return server.port === port; });
+                        if (!(typeof inbound !== 'undefined')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, inbound.server.close()]; // close the server for all inbound connections
+                    case 1: return [2 /*return*/, _a.sent()]; // close the server for all inbound connections
+                    case 2: throw new errors_1.errors.FASTIFY_HL7_ERR_USAGE("No inbound server listening on port: ".concat(port));
+                }
+            });
+        });
+    };
+    /**
+     * Close all Inbound connections.
+     * @since 1.0.0
+     */
+    HL7Server.prototype.closeAll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                this._serverInboundConnections.map(function (inbound) { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, inbound.server.close()];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                return [2 /*return*/, true];
+            });
+        });
+    };
+    /**
+     * Create Inbound connection.
+     * @since 1.0.0
+     * @param name
+     * @param props
+     * @param handler
+     */
+    HL7Server.prototype.createInbound = function (name, props, handler) {
+        var nameFormat = /[ `!@#$%^&*()+\-=\[\]{};':"\\|,.<>\/?~]/; //eslint-disable-line
+        if (nameFormat.test(name)) {
+            throw new errors_1.errors.FASTIFY_HL7_ERR_USAGE('name must not contain certain characters: `!@#$%^&*()+\\-=\\[\\]{};\':"\\\\|,.<>\\/?~.');
+        }
+        var inbound = new node_hl7_server_1.HL7Inbound(this._server, props, handler);
+        this._serverInboundConnections.push({
+            name: name,
+            port: props.port.toString(),
+            server: inbound
+        });
+        return inbound;
+    };
+    return HL7Server;
+}());
+exports.HL7Server = HL7Server;

package/lib/cjs/decorate.js

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

package/lib/cjs/errors.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errors = void 0;
+var error_1 = __importDefault(require("@fastify/error"));
+exports.errors = {
+    /** Error if there is an setup error of the plugin itself. */
+    FASTIFY_HL7_ERR_SETUP_ERRORS: (0, error_1.default)('FASTIFY_HL7_ERR_SETUP_ERRORS', 'Setup error: %s'),
+    /** If an invalid usage error was done, this error would pop up. */
+    FASTIFY_HL7_ERR_USAGE: (0, error_1.default)('FASTIFY_HL7_ERR_USAGE', 'Usage error: %s')
+};