fastify-hl7 1.0.0-beta.1

package/lib/cjs/index.js

@@ -0,0 +1,192 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+var node_hl7_server_1 = __importDefault(require("node-hl7-server"));
+var hL7Server_js_1 = require("./class/hL7Server.js");
+var hL7Client_js_1 = require("./class/hL7Client.js");
+var errors_js_1 = require("./errors.js");
+var validation_js_1 = require("./validation.js");
+__exportStar(require("./types.js"), exports);
+/**
+ * @since 1.0.0
+ * @param fastify
+ * @param _opts
+ * @param connection
+ */
+var decorateFastifyInstance = function (fastify, _opts, connection) {
+    if (typeof fastify.hl7 !== 'undefined') {
+        throw new errors_js_1.errors.FASTIFY_HL7_ERR_SETUP_ERRORS('Already registered.');
+    }
+    if (typeof fastify.hl7 === 'undefined') {
+        fastify.log.trace('[fastify-hl7] Decorate Fastify');
+        fastify.decorate('hl7', connection);
+    }
+};
+var fastifyHL7 = (0, fastify_plugin_1.default)(function (fastify, opts) { return __awaiter(void 0, void 0, void 0, function () {
+    var generatedOpts, serverInstance, server, client;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, validation_js_1.validateOpts)(opts)];
+            case 1:
+                generatedOpts = _a.sent();
+                opts = __assign(__assign({}, opts), generatedOpts);
+                serverInstance = (typeof opts.enableServer !== 'undefined' && opts.enableServer) ? new node_hl7_server_1.default(opts.serverOptions) : undefined;
+                if (typeof serverInstance !== 'undefined') {
+                    // Server Functions
+                    server = new hL7Server_js_1.HL7Server(serverInstance);
+                    // before we close fastify, make sure all server instances are closed
+                    fastify.addHook('preClose', function () { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    if (!(typeof server !== 'undefined')) return [3 /*break*/, 2];
+                                    return [4 /*yield*/, server.closeAll()];
+                                case 1:
+                                    _a.sent();
+                                    _a.label = 2;
+                                case 2: return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                }
+                client = new hL7Client_js_1.HL7Client();
+                // run these before fastify closes
+                fastify.addHook('preClose', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (!(typeof client !== 'undefined')) return [3 /*break*/, 2];
+                                return [4 /*yield*/, client.closeAll()];
+                            case 1:
+                                _a.sent();
+                                _a.label = 2;
+                            case 2: return [2 /*return*/];
+                        }
+                    });
+                }); });
+                decorateFastifyInstance(fastify, opts, {
+                    _serverInstance: serverInstance,
+                    buildBatch: function (props) {
+                        return client.buildBatch(props);
+                    },
+                    buildFileBatch: function (props) {
+                        return client.buildFileBatch(props);
+                    },
+                    buildMessage: function (props) {
+                        return client.buildMessage(props);
+                    },
+                    closeServer: function (port) {
+                        return __awaiter(this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!(typeof server !== 'undefined')) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, server.close(port)];
+                                    case 1: return [2 /*return*/, _a.sent()];
+                                    case 2: throw new errors_js_1.errors.FASTIFY_HL7_ERR_USAGE('server was not started. re-register plugin with enableServer set to true.');
+                                }
+                            });
+                        });
+                    },
+                    closeServerAll: function () { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    if (!(typeof server !== 'undefined')) return [3 /*break*/, 2];
+                                    return [4 /*yield*/, server.closeAll()];
+                                case 1: return [2 /*return*/, _a.sent()];
+                                case 2: throw new errors_js_1.errors.FASTIFY_HL7_ERR_USAGE('server was not started. re-register plugin with enableServer set to true.');
+                            }
+                        });
+                    }); },
+                    createClient: function (name, props) {
+                        client.createClient(name, props);
+                    },
+                    createInbound: function (name, props, handler) {
+                        if (typeof server !== 'undefined') {
+                            return server.createInbound(name, props, handler);
+                        }
+                        throw new errors_js_1.errors.FASTIFY_HL7_ERR_USAGE('server was not started. re-register plugin with enableServer set to true.');
+                    },
+                    createOutbound: function (name, props, handler) {
+                        return client.createOutbound(name, props, handler);
+                    },
+                    processHL7: function (text) {
+                        return client.processHL7(text);
+                    },
+                    readFile: function (fullFilePath) {
+                        return client.readFile(fullFilePath);
+                    },
+                    readFileBuffer: function (fileBuffer) {
+                        return client.readFileBuffer(fileBuffer);
+                    }
+                });
+                return [2 /*return*/];
+        }
+    });
+}); });
+exports.default = fastifyHL7;

package/lib/cjs/package.json

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

package/lib/cjs/types.js

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

package/lib/cjs/validation.js

@@ -0,0 +1,53 @@
+"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.validateOpts = void 0;
+/**
+ * @since 1.0.0
+ * @param opts
+ */
+var validateOpts = function (opts) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        // Mandatory, Defaulted
+        if (typeof opts.enableServer === 'undefined') {
+            opts.enableServer = true;
+        }
+        return [2 /*return*/, opts];
+    });
+}); };
+exports.validateOpts = validateOpts;

package/lib/esm/api.js

@@ -0,0 +1,5 @@
+import fastifyHL7 from '.';
+import { HL7Client } from './class/hL7Client.js';
+import { HL7Server } from './class/hL7Server.js';
+export default fastifyHL7;
+export { fastifyHL7, HL7Client, HL7Server };

package/lib/esm/class/hL7Client.js

@@ -0,0 +1,159 @@
+import Client, { Batch, FileBatch, HL7Outbound, isBatch, Message } from 'node-hl7-client';
+import { errors } from '../errors';
+export class HL7Client {
+    /** @internal */
+    _clientConnections;
+    constructor() {
+        this._clientConnections = [];
+    }
+    /**
+     * Close All Connections for this Client
+     * @since 1.0.0
+     */
+    async closeAll() {
+        this._clientConnections.forEach(outbound => {
+            outbound.ports.map(async (port) => {
+                await port.connection.close();
+            });
+        });
+        return true;
+    }
+    /**
+     * Build a HL7 Batch
+     * @description Create a properly formatted HL7 Batch.
+     * @since 1.0.0
+     * @param props
+     */
+    buildBatch(props) {
+        if (typeof props !== 'undefined' && typeof props.text !== 'undefined') {
+            throw new errors.FASTIFY_HL7_ERR_USAGE('Use processMessage method. This is for building.');
+        }
+        return new Batch({ ...props });
+    }
+    /**
+     * Build a HL7 File Batch
+     * @description Create a properly formatted HL7 File Batch.
+     * @since 1.0.0
+     * @param props
+     */
+    buildFileBatch(props) {
+        if (typeof props !== 'undefined' && (typeof props.fullFilePath !== 'undefined' || typeof props.fileBuffer !== 'undefined')) {
+            throw new errors.FASTIFY_HL7_ERR_USAGE('Use readFile or readFileBuffer method. This is for building.');
+        }
+        return new FileBatch({ ...props });
+    }
+    /**
+     * Build a HL7 Message
+     * @description Create a properly formatted HL7 message.
+     * @since 1.0.0
+     * @param props
+     */
+    buildMessage(props) {
+        if (typeof props !== 'undefined' && typeof props.text !== 'undefined') {
+            throw new errors.FASTIFY_HL7_ERR_USAGE('Use processMessage method. This is for building.');
+        }
+        return new Message({ ...props });
+    }
+    /**
+     *
+     * @param name
+     * @param props
+     */
+    createClient(name, props) {
+        const nameFormat = /[ `!@#$%^&*()+\-=\[\]{};':"\\|,.<>\/?~]/; //eslint-disable-line
+        if (nameFormat.test(name)) {
+            throw new errors.FASTIFY_HL7_ERR_USAGE('name must not contain certain characters: `!@#$%^&*()+\\-=\\[\\]{};\':"\\\\|,.<>\\/?~.');
+        }
+        // make sure that this does not exist already...
+        this._clientConnections.forEach((connections) => {
+            if (connections.name === name) {
+                throw new 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
+        const client = new Client(props);
+        // add it to the collection
+        this._clientConnections.push({
+            name,
+            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
+     */
+    createOutbound(name, props, handler) {
+        const nameFormat = /[ `!@#$%^&*()+\-=\[\]{};':"\\|,.<>\/?~]/; //eslint-disable-line
+        if (nameFormat.test(name)) {
+            throw new errors.FASTIFY_HL7_ERR_USAGE('name must not contain certain characters: `!@#$%^&*()+\\-=\\[\\]{};\':"\\\\|,.<>\\/?~.');
+        }
+        const getConnection = this._clientConnections.find(client => client.name === name);
+        if (typeof getConnection !== 'undefined') {
+            // make sure port is not used all ready
+            getConnection.ports.forEach((outbound) => {
+                if (outbound.port === props.port.toString()) {
+                    throw new errors.FASTIFY_HL7_ERR_USAGE(`port ${props.port} is already used with this client. Choose a new outgoing port.`);
+                }
+            });
+            // create outbound port to the server in getConnection.client
+            const outbound = new 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.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
+     */
+    processHL7(text) {
+        if (isBatch(text)) {
+            return new Batch({ text });
+        }
+        else {
+            return new Message({ 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') )
+     *
+     */
+    readFile(fullFilePath) {
+        return new FileBatch({ 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)
+     *
+     */
+    readFileBuffer(fileBuffer) {
+        return new FileBatch({ fileBuffer });
+    }
+}

package/lib/esm/class/hL7Server.js

@@ -0,0 +1,52 @@
+import { HL7Inbound } from 'node-hl7-server';
+import { errors } from '../errors';
+export class HL7Server {
+    _server;
+    _serverInboundConnections;
+    constructor(server) {
+        this._server = server;
+        this._serverInboundConnections = [];
+    }
+    /**
+     * Close Inbound connection.
+     * @since 1.0.0
+     * @param port
+     */
+    async close(port) {
+        const inbound = this._serverInboundConnections.find(server => server.port === port);
+        if (typeof inbound !== 'undefined') {
+            return await inbound.server.close(); // close the server for all inbound connections
+        }
+        throw new errors.FASTIFY_HL7_ERR_USAGE(`No inbound server listening on port: ${port}`);
+    }
+    /**
+     * Close all Inbound connections.
+     * @since 1.0.0
+     */
+    async closeAll() {
+        this._serverInboundConnections.map(async (inbound) => {
+            await inbound.server.close();
+        });
+        return true;
+    }
+    /**
+     * Create Inbound connection.
+     * @since 1.0.0
+     * @param name
+     * @param props
+     * @param handler
+     */
+    createInbound(name, props, handler) {
+        const nameFormat = /[ `!@#$%^&*()+\-=\[\]{};':"\\|,.<>\/?~]/; //eslint-disable-line
+        if (nameFormat.test(name)) {
+            throw new errors.FASTIFY_HL7_ERR_USAGE('name must not contain certain characters: `!@#$%^&*()+\\-=\\[\\]{};\':"\\\\|,.<>\\/?~.');
+        }
+        const inbound = new HL7Inbound(this._server, props, handler);
+        this._serverInboundConnections.push({
+            name,
+            port: props.port.toString(),
+            server: inbound
+        });
+        return inbound;
+    }
+}

package/lib/esm/decorate.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/errors.js

@@ -0,0 +1,7 @@
+import createError from '@fastify/error';
+export const errors = {
+    /** Error if there is an setup error of the plugin itself. */
+    FASTIFY_HL7_ERR_SETUP_ERRORS: createError('FASTIFY_HL7_ERR_SETUP_ERRORS', 'Setup error: %s'),
+    /** If an invalid usage error was done, this error would pop up. */
+    FASTIFY_HL7_ERR_USAGE: createError('FASTIFY_HL7_ERR_USAGE', 'Usage error: %s')
+};

package/lib/esm/index.js

@@ -0,0 +1,99 @@
+import fp from 'fastify-plugin';
+import Server from 'node-hl7-server';
+import { HL7Server } from './class/hL7Server.js';
+import { HL7Client } from './class/hL7Client.js';
+import { errors } from './errors.js';
+import { validateOpts } from './validation.js';
+export * from './types.js';
+/**
+ * @since 1.0.0
+ * @param fastify
+ * @param _opts
+ * @param connection
+ */
+const decorateFastifyInstance = (fastify, _opts, connection) => {
+    if (typeof fastify.hl7 !== 'undefined') {
+        throw new errors.FASTIFY_HL7_ERR_SETUP_ERRORS('Already registered.');
+    }
+    if (typeof fastify.hl7 === 'undefined') {
+        fastify.log.trace('[fastify-hl7] Decorate Fastify');
+        fastify.decorate('hl7', connection);
+    }
+};
+const fastifyHL7 = fp(async (fastify, opts) => {
+    const generatedOpts = await validateOpts(opts);
+    opts = { ...opts, ...generatedOpts };
+    // Create server.
+    // Since there can only be one server per IP address
+    // (i.e., the host this is running on.) There can only be more than one.
+    // A server can host many HL7 Inbound connections via different ports, this is fine.
+    // Clients are different as a app could talk to different servers, on many ports.
+    // So we need to do something different.
+    const serverInstance = (typeof opts.enableServer !== 'undefined' && opts.enableServer) ? new Server(opts.serverOptions) : undefined;
+    // Server Functions
+    let server;
+    if (typeof serverInstance !== 'undefined') {
+        // Server Functions
+        server = new HL7Server(serverInstance);
+        // before we close fastify, make sure all server instances are closed
+        fastify.addHook('preClose', async () => {
+            if (typeof server !== 'undefined') {
+                await server.closeAll();
+            }
+        });
+    }
+    // Client Functions
+    const client = new HL7Client();
+    // run these before fastify closes
+    fastify.addHook('preClose', async () => {
+        if (typeof client !== 'undefined') {
+            await client.closeAll();
+        }
+    });
+    decorateFastifyInstance(fastify, opts, {
+        _serverInstance: serverInstance,
+        buildBatch: function (props) {
+            return client.buildBatch(props);
+        },
+        buildFileBatch: function (props) {
+            return client.buildFileBatch(props);
+        },
+        buildMessage: function (props) {
+            return client.buildMessage(props);
+        },
+        closeServer: async function (port) {
+            if (typeof server !== 'undefined') {
+                return await server.close(port);
+            }
+            throw new errors.FASTIFY_HL7_ERR_USAGE('server was not started. re-register plugin with enableServer set to true.');
+        },
+        closeServerAll: async () => {
+            if (typeof server !== 'undefined') {
+                return await server.closeAll();
+            }
+            throw new errors.FASTIFY_HL7_ERR_USAGE('server was not started. re-register plugin with enableServer set to true.');
+        },
+        createClient: function (name, props) {
+            client.createClient(name, props);
+        },
+        createInbound: function (name, props, handler) {
+            if (typeof server !== 'undefined') {
+                return server.createInbound(name, props, handler);
+            }
+            throw new errors.FASTIFY_HL7_ERR_USAGE('server was not started. re-register plugin with enableServer set to true.');
+        },
+        createOutbound: function (name, props, handler) {
+            return client.createOutbound(name, props, handler);
+        },
+        processHL7: function (text) {
+            return client.processHL7(text);
+        },
+        readFile: function (fullFilePath) {
+            return client.readFile(fullFilePath);
+        },
+        readFileBuffer: function (fileBuffer) {
+            return client.readFileBuffer(fileBuffer);
+        }
+    });
+});
+export default fastifyHL7;

package/lib/esm/package.json

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

package/lib/esm/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/validation.js

@@ -0,0 +1,11 @@
+/**
+ * @since 1.0.0
+ * @param opts
+ */
+export const validateOpts = async (opts) => {
+    // Mandatory, Defaulted
+    if (typeof opts.enableServer === 'undefined') {
+        opts.enableServer = true;
+    }
+    return opts;
+};

package/lib/types/api.d.ts

@@ -0,0 +1,7 @@
+import { HL7 } from 'fastify';
+import fastifyHL7 from '.';
+import { AServers, FastifyHL7Options } from './decorate.js';
+import { HL7Client } from './class/hL7Client.js';
+import { HL7Server } from './class/hL7Server.js';
+export default fastifyHL7;
+export { fastifyHL7, HL7, FastifyHL7Options, HL7Client, HL7Server, AServers };