Your Toolkit for Smooth Healthcare Interoperability - Simple, Reliable, and Fast!
Intuitive Deployment
Experience the power of Gofer Engine, meticulously crafted for simplicity and speed. Elevate your interoperability journey with an engine designed from the ground up to make complexity disappear. Launch your interface channels swiftly, turning what used to take days into a matter of minutes. Gofer Engine isn't just easy to use; it's a breeze to learn. Dive into the world of seamless connectivity in just 5 minutes with our beginner-friendly tutorial. Your journey to smooth healthcare interoperability starts here, with a toolkit that prioritizes simplicity and rapid deployment.
Type-Safe Development
Gofer Engine is powered by TypeScript, bringing a robust and strongly- typed foundation to your development experience. When crafting filters and transformer steps, embrace the confidence that comes with robust type checking and code completion. Whether you're shaping a simple filter or intricately designing a complex transformer, Gofer Engine acts as your vigilant ally, ensuring errors are caught and resolved before they even have a chance to reach production. With strong typing at the core, code with assurance and elevate your development workflow.
Versatile Integration Options
Unlock the versatility of Gofer Engine, offering the flexibility to serve as a standalone interoperability engine or seamlessly integrate as a library into your application. In standalone mode, Gofer Engine excels at processing messages between diverse sources and destinations. As a library, it empowers you to seamlessly embed interoperability directly into your application, making it an integral part of your software ecosystem. Whether you're orchestrating interoperability independently or integrating within your app, Gofer Engine adapts to your needs with ease and efficiency.
Now with OOP support!
Introducing a new dimension to Gofer Engine, we've seamlessly integrated Object-Oriented Programming (OOP) style scripting capabilities. This enhancement empowers users to leverage the principles of OOP in crafting their interface channels. With this feature, you can organize and encapsulate your code in a more modular and structured manner, enhancing readability and maintainability. Dive into the world of OOP within Gofer Engine, bringing an added layer of flexibility and sophistication to your interoperability workflows.
In this concise example, we establish a basic HL7v2 TCP forwarder channel. The channel actively listens on localhost's port5000 and efficiently forwards all valid HL7v2 messages to the remote URL hl7.emr.example.com, utilizing port 5000.
import gofer from '@gofer-engine/engine';
gofer
.listen('tcp', 'localhost', 5500)
.ack()
.route((route) => route.send('tcp', 'hl7.emr.example.com', 5500))
.run();
Gofer Engine Standalone
Gofer Engine transcends the ordinary, evolving beyond a simple pass-through engine into a comprehensive standalone interface powerhouse. Elevate your interoperability experience with built-in support for filtering, transforming, queuing, events, routing, logging, and much more. This robust feature set is a testament to our commitment to simplicity, ensuring that even as a standalone engine, Gofer Engine seamlessly integrates advanced functionalities. Whether you're navigating intricate data transformations or orchestrating events with precision, Gofer Engine stands tall, reflecting our values of versatility and reliability in every interaction.
Message Types Supported
- HL7 v2
- JSON
- XML (Incomplete, WIP)
- Delimitted Text
Supported Connectors
- TCP (MLLP)
- HTTP
- HTTPS
- SFTP
Storage Methods/Databases Supported
| Database | Support | Notes |
|---|---|---|
 | ✔️ | |
 | ✔️ | |
 | ✔️ | |
 | ✔️ | Only supported for HL7 v2 type messages |
| File Systems | ✔️ | Supports Local and Network File Systems |
Gofer Engine Integrated
Are you in the process of crafting a Node.JS application, leveraging frameworks such as Express or Next.JS? Perhaps you're deep into developing a RestFUL API, GraphQL Server, or FHIR Server in Node.JS/TypeScript. In your quest for a versatile tool to seamlessly handle sending and receiving HL7, JSON, XML, delimited file types or FHIR resources, look no further. Gofer Engine, as an integrated library, becomes an invaluable asset, effortlessly weaving into your Node.JS environment. Whether you're navigating intricate healthcare standards or managing diverse data formats, Gofer Engine stands as your reliable companion in the world of seamless integration.
Messengers
Embedding Gofer Engine directly into your application is a seamless experience. With integrated messenger functions, creating, sending, receiving, and parsing healthcare messages becomes an effortless process. Gofer Engine empowers your application with the capability to interact with healthcare messages, streamlining the communication process and ensuring a smooth and efficient integration within your software ecosystem.
After creating a messenger service function, you can use it to pass values into the message builder and send the message.
Receivers
If your application operates as a server, Gofer Engine provides a powerful solution to set up a dedicated listener for messages. This listener seamlessly captures messages from remote endpoints, allowing you to effortlessly integrate the parsed data into your application. Gofer Engine empowers your server-side functionality, ensuring smooth communication and effective data integration to enhance the capabilities of your application.
Message Classes
Gofer Engine not only supports but also provides an array of tools designed to streamline the creation of a healthcare interoperability engine. From message parsing to validation and transformation, these tools simplify the intricate process. For instance, parsed messages offer robust interfaces, allowing seamless access and manipulation of message data. At the heart of these interfaces lies the foundation—the IMsg interface—a core element empowering developers to navigate and shape healthcare data effortlessly.
interface IMsg {
kind: string;
setMsg: (msg: any) => IMsg;
json: (normalized?: boolean) => any;
toString: () => string;
set: (path?: string | undefined, value?: any) => IMsg;
setJSON: (path: string | undefined, json: any) => IMsg;
get: (path: string | undefined) => any;
delete: (path: string) => IMsg;
copy: (path: string, toPath: string) => IMsg;
move: (fromPath: string, toPath: string) => IMsg;
}