Transports

Transports are the communication layer that moves messages between publishers and subscribers.

What is a Transport?

A transport handles:

• Connection management - Connecting, disconnecting, reconnecting
• Message delivery - Sending messages from publishers to subscribers
• Channel subscriptions - Managing which channels a subscriber listens to

Available Transports

Transport	Use Case	Direction
WebSocket	Real-time browser apps	Bidirectional
Redis	Distributed systems	Bidirectional
SSE	Server-to-client streaming	Server → Client

Transport Interface

All transports implement the Transport interface:

interface Transport {
  readonly id: string;
  readonly state: ConnectionState;
  readonly capabilities: TransportCapabilities;

  connect(): Promise<void>;
  disconnect(): Promise<void>;

  publish(channel: string, payload: unknown, options?: TransportPublishOptions): Promise<void>;
  subscribe(channel: string, handler: TransportMessageHandler): Promise<UnsubscribeFn>;

  on(event: TransportEvent, handler: TransportEventHandler): void;
  off(event: TransportEvent, handler: TransportEventHandler): void;
}

Transport Capabilities

Each transport declares its capabilities:

interface TransportCapabilities {
  canPublish: boolean;      // Can send messages
  canSubscribe: boolean;    // Can receive messages
  bidirectional: boolean;   // Both publish and subscribe
  supportsTargeting: boolean; // Can target specific connections
  supportsChannels: boolean;  // Supports channel-based routing
}

Connection States

Transports have four possible states:

type ConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting";

Using Transports

Direct Usage

import { WebSocketServerTransport } from "@pubsubjs/transport-websocket";

const transport = new WebSocketServerTransport({ port: 8080 });

// Connect
await transport.connect();

// Publish directly (without Publisher)
await transport.publish("my-channel", { data: "hello" });

// Subscribe directly (without Subscriber)
const unsubscribe = await transport.subscribe("my-channel", (message) => {
  console.log("Received:", message.payload);
});

// Clean up
unsubscribe();
await transport.disconnect();

With Publisher/Subscriber

import { Publisher, Subscriber } from "@pubsubjs/core";
import { WebSocketServerTransport } from "@pubsubjs/transport-websocket";

const transport = new WebSocketServerTransport({ port: 8080 });

// Publisher and Subscriber manage the transport
const publisher = new Publisher({ events, transport });
const subscriber = new Subscriber({ events, transport });

Sharing Transports

A single transport can be shared between publishers and subscribers:

const transport = new WebSocketServerTransport({ port: 8080 });

// Both use the same transport instance
const publisher = new Publisher({ events, transport });
const subscriber = new Subscriber({ events, transport });

Transport Events

Listen to transport events:

transport.on("connected", () => {
  console.log("Transport connected");
});

transport.on("disconnected", () => {
  console.log("Transport disconnected");
});

transport.on("error", (error) => {
  console.error("Transport error:", error);
});

transport.on("reconnecting", () => {
  console.log("Transport reconnecting...");
});

Auto-Reconnection

Configure automatic reconnection:

const publisher = new Publisher({
  events,
  transport,
  autoReconnect: true,
  reconnectInterval: 1000,    // Wait 1s between attempts
  maxReconnectAttempts: 10,   // Give up after 10 attempts
});

Choosing a Transport

Scenario	Recommended Transport
Browser real-time app	WebSocket
Microservices	Redis
Mobile push notifications	SSE
IoT devices	WebSocket or MQTT (custom)
Serverless functions	Redis

Next Steps

• WebSocket Transport - Real-time browser apps
• Redis Transport - Distributed systems
• SSE Transport - Server-to-client streaming
• Custom Transports - Build your own