Introducing Threadosaurus: Simplify Worker Threads in Node.js with TypeScript

Gallifrey Rules — Tue, 01 Oct 2024 16:07:37 +0000

Managing worker threads in Node.js can be complex. That’s where Threadosaurus comes in — a simple, intuitive library that streamlines the process of creating and running worker threads in Node.js using TypeScript.

Why Threadosaurus?
Worker threads are an essential feature in Node.js for handling CPU-intensive tasks without blocking the main event loop. However, using them can introduce challenges like managing worker creation, handling communication between main process and worker thread, timeouts, and handling errors as expected.

Many other libraries rely on providing the worker thread a filename directly, which can lead to runtime errors if the path is incorrect or misconfigured. Threadosaurus simplifies this process by automatically handling the worker class and filename setup, reducing the chances of such errors and improving code reliability.

You have a single function called CreateThreadosaurus, you pass on your class and that’s it! You now have an instance you can call where every method is run in a worker thread!

There are some limitations which are discussed directly in the repo.

Let’s see how a simple typical setup looks like.

import { CreateThreadosaurus } from 'threadosaurus';
import SampleWorkerThreadClass from './SampleWorkerThreadClass';

const worker = CreateThreadosaurus(SampleWorkerThreadClass);
console.log(await worker.greet('LJ and NJ'));

Worker file example

import { Threadosaurus } from 'threadosaurus';

export default class SampleWorkerThreadClass implements Threadosaurus {
    async greet(name: string): Promise<string> {
        return Promise.resolve(`Hello ${name} from worker thread!`);
    }

    get__filename(): string {
        return __filename;
    }
}

And that’s it!

Head on to the repo to get started in no time!

Quick introduction to Gallifrey-Rules

Gallifrey Rules — Mon, 26 Aug 2024 14:58:12 +0000

Gallifrey-Rules is an innovative Node.js/TypeScript library that streamlines the development of event-driven services, offering a powerful, structured approach to managing complex event processing workflows.

Traditionally, when working with event streaming platforms like Kafka, developers often find themselves constructing multiple consumers, each tailored to connect with Kafka brokers and initiate message consumption from specific topics. Within these consumers, a core loop processes incoming messages, typically triggering a function — let’s call it consumeMessages—that acts as the entry point for handling each new message. The conventional structure requires separate entry points for different consumers, driven by the distinct message types associated with each topic.

However, these consumeMessages functions often operate as black boxes, encapsulating large blocks of code executed per message, with little transparency into the internal processing flow. The result is an accumulation of boilerplate code that, while essential, is not directly related to the core business logic. This includes handling testing, configuration data, metrics, error management, and logging. Additionally, developers frequently face the need for mechanisms that allow consumers to enqueue new events for future processing, further complicating the codebase.

As event-driven services scale alongside growing business logic, the maintenance and management of this boilerplate code can become increasingly burdensome. The complexity is further amplified when considering the requirements for properly containerizing the application.

Gallifrey-Rules addresses these challenges head-on. This production-ready library, with design principles refined over two years of use in real-world environments, is now available as an open-source port for Node.js and TypeScript.

At its core, Gallifrey-Rules enforces a streamlined and structured approach to event handling, simplifying the developer’s workflow. The library introduces three essential plugin types — Rules, DataObjects, and Actions — each serving a distinct purpose in shaping your business logic.

Rules: Focus solely on business logic, dictating the actions to be taken when a new event is received.
DataObjects: Handle data retrieval from external sources, separating data access concerns from the business logic.
Actions: Manage data mutation, including adding records, modifying states, and sending notifications or emails.
By adopting Gallifrey-Rules, developers gain several immediate benefits. The need for manually written consumers is eliminated, along with the requirement for separate entry points per topic. Gallifrey-Rules unifies all event messages into a standardized Event structure, encapsulating essential details such as EntityName (e.g., orders, akin to database table names), EventName (e.g., new-order or order-shipped), EventID (e.g., orderId), and a payload containing the event's metadata.

This structured visibility allows Gallifrey-Rules to offer deep insights into the event processing flow. The library can track and measure the performance of each plugin, providing a clear overview that simplifies the troubleshooting of performance bottlenecks.

Moreover, Gallifrey-Rules features centralized configuration management that abstracts underlying systems, enabling seamless transitions — such as switching from environment variables to feature flags — without the need to modify individual plugins.

In addition to these capabilities, Gallifrey-Rules offers extensive error handling, recovery, and logging options, ensuring robust and resilient event-driven services.

For those eager to get started, the quickest path is to explore the sample application and consult the accompanying documentation. Should you have any questions or require further clarification, feel free to reach out.

Forem: Gallifrey Rules

Introducing Threadosaurus: Simplify Worker Threads in Node.js with TypeScript

Quick introduction to Gallifrey-Rules