Mesh Lib (Node.js)

Node.js implementation of the Mesh communication library.

Installation

Install via NPM:

npm install @marketrix.ai/mesh

Usage

1. Configuration

Define your Redis connection and service details.

import { Mesh, MeshConfig } from '@marketrix.ai/mesh';

const config: MeshConfig = {
    redis: { host: 'localhost', port: 6379 }, // Shared Redis Config
    service_discovery: {
        heartbeat_interval: 2,
        heartbeat_threshold: 3
    },
    // host: '127.0.0.1', // Optional: Auto-detected if omitted
    port: 0 // 0 for random available port
};

2. Start Mesh

Initialize and start the mesh node.

const mesh = new Mesh(config);
await mesh.start();

3. Register a Service (Server)

Register a service name to handle incoming connections.

mesh.registerService('my-service-name')
    // 1. Streaming Handler
    .onRequestChannel(async (channel, metadata) => {
        console.log(`Accepted connection from session: ${metadata?.['x-session-id']}`);
        try {
            await channel.onData(async (msg) => {
                console.log('Received:', msg.payload);
                await channel.send({ function_name: 'reply', payload: 'Got it!' });
            });
        } catch (e) {
            console.error(e);
        }
    })
    // 2. Unary Handler (Request/Reply)
    .onRequestReply(async (msg, metadata) => {
        console.log('Received Unary:', msg.payload);
        console.log('Metadata:', metadata);
        return { function_name: 'reply', payload: 'Got Unary!' };
    });

4. Connect to a Peer (Client)

Discover and connect to another service.

const channel = await mesh.service('target-service-name').requestChannel('session-id-123');

await channel.send({ 
    function_name: 'greet', 
    payload: 'Hello World' 
});

// Reading messages (Callback handles backpressure)
await channel.onData(async (msg) => {
    console.log('Reply:', msg.payload);
    // To stop receiving, you can close the channel from within handler or check explicitly
    if (msg.payload === 'Hello World') {
        // channel.close(); // If needed to stop locally early
    }
});

await channel.close();

5. Graceful Shutdown

Remember to close the mesh connection when your application exits.

await mesh.close();

6. Callback-based Backpressure

Mesh supports onData(handler) for consumers who prefer callbacks but need backpressure. The method returns a Promise that resolves when the stream is closed, allowing you to await the entire processing session.

```typescript
await channel.onData(async (msg) => {
    await processMessage(msg);
    // The next message is only requested after this line completes
});