Singleton class across multiple requests in route handlers

[danieljee]

Environment:
node.js: v18.15.0
nextjs: 13.4.13

Problem

I'm trying to enable Server Sent Event so that I can push messages to the clients.
To do this, I'm using instrumentation to initialize required modules:

instrumentation.ts:

export async function register() {
  if (process.env.NEXT_RUNTIME === 'nodejs') {
    const { rmq } = await import('./server/rmq');
    await import('./server/server-sent-event');

    if (!rmq.isInitialized) {
      await rmq.init();
    }
  }
}

server-sent-event.ts:

import { Notification } from "@prisma/client";

class _SSEManager {
  private connections: Map<string, WritableStreamDefaultWriter>  = new Map();

  constructor() {
    console.log('SSEManager constructor')
  }

  public addUser(userId: string, stream: WritableStreamDefaultWriter) {
    console.log(`Number of connections = ${this.connections.keys.length}`);
    this.connections.set(userId, stream);

    stream.closed
      .then(() => {
        console.log(`SSE connection for user ${userId} closed.`)
        this.connections.delete(userId);
      }, () => {
        console.log(`SSE connection for user ${userId} closed.`)
        this.connections.delete(userId);
      })
  }

  public async sendNotification(userId: string, data: Notification) {
    const stream = this.connections.get(userId);

    if (!stream) return;

    const encoder = new TextEncoder();
    stream.write(encoder.encode(JSON.stringify(data)))
  }
}

export const SSEManager = new _SSEManager();

As you can see, my intention is that I want to use SSEManager as a singleton to ensure I keep the record of the connections across requests.

In /api/sse route handler I'm importing the SSEManager class:

import { NodeHelpers } from "@/server/server-helpers";
import { SSEManager } from "@/server/server-sent-event";
import { NextRequest, NextResponse } from "next/server";

export const runtime = 'nodejs';
export const dynamic = 'force-dynamic';

export async function GET(req: NextRequest) {
  const authSession = await NodeHelpers.getAuthSession()

  if (!authSession) return NextResponse.rewrite('/api/auth/401', { status: 401 })

  let responseStream = new TransformStream();
  const writer = responseStream.writable.getWriter();

  SSEManager.addUser(authSession.userId, writer);
  
  var resp = new Response(responseStream.readable, {
    headers: {
      'Content-Type': 'text/event-stream',
      Connection: 'keep-alive',
      'Cache-Control': 'no-cache, no-transform',
    },
  });

  return resp;
}

When send a request using different user accounts to the same route handler
output:

Number of connections = 0
Number of connections = 0
SSEManager constructor
Number of connections = 0
Number of connections = 0
SSEManager constructor

expected:

Number of connections = 0
Number of connections = 1
Number of connections = 2
Number of connections = 3

In every request the SSEManager reinitialized.

Is there way to use a module as a singleton just like in a normal node.js application?

Thank you

[midan888]

@danieljee I have the same issue, did you resolved it ?

[fryck]

NodeJS already have a internal cache module resolution, so singleton is easy to implement, for example:

@/lib/Api.ts:

import https from "https";

import HttpClient, { HttpClientOptions } from "./httpClient";

class Api extends HttpClient {
  constructor() {
    let httpClientOptions: HttpClientOptions = {
      baseURL: "/api",
    };

    if (process.env.NODE_ENV === "development") {
      httpClientOptions = {
        ...httpClientOptions,
        httpsAgent: new https.Agent({
          rejectUnauthorized: false,
        }),
      };
    }

    super(httpClientOptions);
  }

  async internalAuthenticate(topic: string, subscription: string) {
    const { data } = await this.instance.post<any>(
      `/pubsub/subscription`,
      {
        topic,
        subscription,
      },
      {
        headers: {
          "Content-Type": "application/json",
        },
      }
    );

    return data;
  }

  async getAuthorizationBearerToken() {
    return null;
  }
}

const api = new Api();

export default api;

This way, event if I import X times @/lib/Api in several route handler, I will get only one instance of Api :)

[naycho334]

Here's the approach I'm using: The issue you're seeing is indeed related to how Next.js works, particularly in development mode.
Here's an example. It's a different code, but with the same logic.

// Use a global variable to store the instance
declare global {
  var socketManager: SocketManager | undefined
}

const socketManager = global.socketManager || SocketManager.getInstance();

if (process.env.NODE_ENV !== 'production') global.socketManager = socketManager

export default socketManager;

[npyl]

This seems to work on client side but not on the server! I am searching for a server-side singleton solution but I haven't found anything!

[jmsandiegoo]

@npyl Have you found the solution?