Newts Parading Majestically

    TypeScript icon, indicating that this package has built-in type declarations

    1.0.7 • Public • Published

    trmi-redis npm

    This is a Redis Pub/Sub RMI implementation with a horizontal scaling support.


    yarn add trmi-redis
    npm i trmi-redis

    Getting started

    You can find a more detailed example here.

    Define and implement a remote service

    type HelloResponse = {
        message: string;
    interface HelloWorldSpecification {
        hello(world: string): Promise<HelloResponse>;
        bye(): Promise<void>;
    import { RemoteService, RemoteMethod } from 'trmi-redis';
    class HelloWorld implements HelloWorldSpecification {
        async hello(world: string): Promise<HelloResponse> {
            return {
                message: `Hello ${world}!`,
        async bye(): Promise<void> {
            throw new Error('"bye" method is not implemented');

    Start a remote service server

    import { RedisRemoteServer } from 'trmi-redis';
            handshake: true,
            settings: {
                host: '',
                port: 6379,
        .from(HelloWorld) // it is possible to pass varargs here
        .catch(e => console.error('Failed to start a server', e));

    Start a remote client

    import { RedisRemoteClient } from 'trmi-redis';
    const client = await RedisRemoteClient.create({
            handshake: 15000,
            settings: {
                host: '',
                port: 6379,
    const helloWorld = client.getService<HelloWorldSpecification>('HelloWorld');
    const response = await helloWorld.hello('world');


    Remote service name

    By default, the remote service name defaults to the class name. You can override this behaviour by passing a name property. Characters .~ are restricted as they are used in internal key generation.

    @RemoteService({ name: 'MyServer_HelloWorld' })
    class HelloWorld implements HelloWorldSpecification


    Default response timeout is 30000 ms (30 seconds).

    RedisRemoteClient.create({ timeout: 25000, ... });

    This implementation also supports a handshake. It is similar to an ack-response in Redisson Remote Services. Before calling the remote service method, the server sends a handshake informing the client that it received a request. Because of this, it is possible to define 2 different timeouts: handshake and response timeout.

    By default, handshakes are disabled. To enable them, you should pass a handshake property to both remote client and server.

    RedisRemoteServer.create({ handshake: true, ... });
    RedisRemoteClient.create({ handshake: 5000, ... });


    Keep in mind that method params and return values are serialized/deserialized using JSON.stringify/JSON.parse functions and represented as objects. If you pass a class instance on one side, it will not become an instance of that class on the other side.

    Each client and server creates 2 connections to the Redis. One is used for subscriptions and the other one is used for publishing the messages. Server is using locks to ensure that a remote call will only be called once, therefore horizontal scaling is possible.


    npm i trmi-redis

    DownloadsWeekly Downloads






    Unpacked Size

    28.4 kB

    Total Files


    Last publish


    • alexnzarov