@devmoods/express-extras 0.63.1 → 0.65.0

package/README.md

@@ -1,112 +1 @@
 # @devmoods/express-extras
-
-> Express evolved: Type-safe routing, elegant transactions, and production-ready patterns for modern Node.js
-
-## ⚠️ Express v5 ⚠️
-
-Due to [internal changes in the router](https://github.com/pillarjs/router/issues/122) used in Express v5 that breaks the ability to generate a full set of routes using the `routes` management command and to generate the OpenAPI spec, this library doesn't officially support Express v5. But in most cases if will work just fine as long as you don't rely on these features.
-
-## Get ready
-
-_Extremely opinionated_ set of utilities for cranking out production-ready Node.js apps in a timely manner. We assume you are using PostgreSQL as the main database, Redis for data you don't want in Postgres and [Faktory](https://contribsys.com/faktory/) for background jobs.
-
-- Only works with [ECMAScript Modules (ESM)](https://nodejs.org/api/esm.html)
-- Thin layer on top of [Express](https://expressjs.com) with better support for `async`/`await` and type safety.
-
-```typescript
-const router = createRouter();
-
-router.put(
-  '/posts/:id',
-  {
-    request: type({ title: 'string' }),
-    response: type({ id: 'number', title: 'string' }),
-  },
-  async (req) => {
-    await delay(1000);
-    return {
-      id: req.params.id,
-      ...req.body,
-    };
-  },
-);
-```
-
-- Clean graceful shutdown procedures and built-in health checks. Runs perfectly in Kubernetes.
-- PostgreSQL with transactions and migrations
-
-```bash
-bin/dx manage migrate up
-```
-
-```typescript
-await postgres.transaction(() => {
-  const post = await postgres.get<{ title: string }>(
-    sql`SELECT title FROM posts WHERE id = ${id} FOR UPDATE`,
-  );
-
-  await postgres.query(
-    sql`UPDATE posts SET ${sql.spreadUpdate({ title: post.title.split('').reverse().join('') })} WHERE id = ${id}`,
-  );
-
-  try {
-    // Nested transactions with savepoints
-    await postgres.transaction(() => {
-    })
-  } catch () {
-  }
-
-  throw new Error('please rollback');
-});
-```
-
-- CSRF protection
-- Built in auth backends! Email+password, passwordless, easy to extend with more
-- OpenAPI v3 generator
-- Redis
-- Slack/Discord client for sending operational notifications
-- CLI commands inspired by Django's management commands
-
-```bash
-bin/dx manage --help
-```
-
-```typescript
-registerManagementCommand((command, cli) => {
-  command('hello').action(() => {
-    cli.writeLine('Hello World');
-  });
-});
-```
-
-- Delayed/async jobs with [Faktory](https://contribsys.com/faktory/)
-- Validation of HTTP requests using [Standard Schema](https://github.com/standard-schema/standard-schema), including [`jsonSchema()`](https://json-schema.org/) and [arktype](https://arktype.io/).
-- Logging helpers to write well-formatted contextual JSON logs to `stdout`
-
-```typescript
-const logger = getLogger();
-
-logger.info('hello world', { foo: 'bar', baz: 10 });
-// {"level":"info","hostname":"machine.local","pid":43149,"name":"default","message":"hello world","foo":"bar","baz":10,"time":"2024-01-02T17:25:28.610Z","v":1}
-```
-
-- Request local context using [AsyncLocalStorage](https://nodejs.org/api/async_context.html) (e.g. request ids)
-- [RFC 7807 Problem Details for HTTP APIs](https://tools.ietf.org/html/rfc7807) by default
-- Uses [Sentry](https://sentry.io/) for external error monitoring
-- [The Twelve-Factor App](https://12factor.net/)
-
-## Goals
-
-- Time-to-market and top-notch developer experience.
-
-## Non-goals
-
-- Support for multiple different database vendors and job processing systems.
-
-## Example
-
-> See the [example/](./example) folder for a complete example.
-
-## Configure
-
-Put environment variables in `.env` at the application will automatically read those on startup. For test configuration in unit and integrations tests, use `.env.test`.

package/dist/auth/emailAndPassword.js

@@ -1,3 +1,4 @@
+import { startTimer } from '@devmoods/observability';
 import argon2 from 'argon2';
 import bcrypt from 'bcrypt';
 import {} from 'express';
@@ -5,7 +6,6 @@ import { createTokenResponse, tokenSchema } from './token.js';
 import {} from './types.js';
 import { Unauthorized } from '../errors.js';
 import { getLogger } from '../logger.js';
-import { startTimer } from '../utils.js';
 import { jsonSchema } from '../validate.js';
 const passwordSchema = { type: 'string', minLength: 4 };
 const emailSchema = { type: 'string', minLength: 4 };
@@ -57,6 +57,7 @@ export function EmailAndPasswordAuthProvider(options) {
                 }
                 context.setCurrentUser(user);
                 await options.onPasswordChanged?.(user, await hashPassword(password), {
+                    /* c8 ignore next 2 */
                     ip: req.ip ?? '',
                     userAgent: req.headers['user-agent'] ?? '',
                 });

package/dist/auth/google.d.ts

@@ -4,10 +4,10 @@ interface GoogleProfile {
     fullName: string;
 }
 interface GoogleAuthProviderOptions<UserModel = AnyUser> {
-    clientId: string;
-    clientSecret: string;
-    redirectUri: string;
+    clientId?: string;
+    clientSecret?: string;
+    redirectUri?: string;
     getOrCreateUserFromUserIdentifier(userIdentifier: string, profile: GoogleProfile): Promise<UserModel>;
 }
-export declare function GoogleAuthProvider<UserModel extends AnyUser>(options: GoogleAuthProviderOptions<UserModel>): AuthProvider<UserModel>;
+export declare function GoogleAuthProvider<UserModel extends AnyUser>({ clientId, clientSecret, redirectUri, getOrCreateUserFromUserIdentifier, }: GoogleAuthProviderOptions<UserModel>): AuthProvider<UserModel>;
 export {};

package/dist/auth/google.js

@@ -1,3 +1,4 @@
+import { config } from '@devmoods/config';
 import { type } from 'arktype';
 import {} from 'express';
 import { OAuth2Client } from 'google-auth-library';
@@ -6,11 +7,11 @@ import { getLogger } from '../logger.js';
 import { createTokenResponse } from './token.js';
 import {} from './types.js';
 const logger = getLogger('auth');
-export function GoogleAuthProvider(options) {
+export function GoogleAuthProvider({ clientId = config.GOOGLE_AUTH_CLIENT_ID, clientSecret = config.GOOGLE_AUTH_CLIENT_SECRET, redirectUri = `${config.PUBLIC_URL}/api/v1/auth/google/callback`, getOrCreateUserFromUserIdentifier, }) {
     const client = new OAuth2Client({
-        clientId: options.clientId,
-        clientSecret: options.clientSecret,
-        redirectUri: options.redirectUri,
+        clientId,
+        clientSecret,
+        redirectUri,
     });
     const verifyAuthorizationCode = async (inputCode) => {
         try {
@@ -25,7 +26,7 @@ export function GoogleAuthProvider(options) {
     const verifyIdToken = async (token) => {
         const ticket = await client.verifyIdToken({
             idToken: token,
-            audience: options.clientId,
+            audience: clientId,
         });
         const payload = ticket.getPayload();
         if (!payload) {
@@ -36,12 +37,11 @@ export function GoogleAuthProvider(options) {
     const requiredScopes = ['openid', 'email', 'profile'];
     return {
         setupRoutes(router, context) {
-            const googleUser = { id: 'google' };
             router.get('/google/login', {}, async (req, res) => {
-                const state = await context.createTemporaryToken(googleUser);
+                const state = await context.createTemporaryToken(null);
                 const params = new URLSearchParams();
-                params.set('client_id', options.clientId);
-                params.set('redirect_uri', options.redirectUri);
+                params.set('client_id', clientId);
+                params.set('redirect_uri', redirectUri);
                 params.set('response_type', 'code');
                 params.set('scope', requiredScopes.join(' '));
                 params.set('access_type', 'offline');
@@ -69,7 +69,7 @@ export function GoogleAuthProvider(options) {
                     throw BadRequest(`Missing required scopes: ${requiredScopes.join(', ')}`);
                 }
                 try {
-                    await context.verifyTemporaryToken(state, googleUser, true);
+                    await context.verifyTemporaryToken(state, null, true);
                 }
                 catch (e) {
                     logger.error(e);
@@ -81,7 +81,10 @@ export function GoogleAuthProvider(options) {
                 }
                 const payload = await verifyIdToken(idToken);
                 logger.info('google payload', { payload });
-                const user = await options.getOrCreateUserFromUserIdentifier(payload?.sub, { email: payload.email, fullName: payload.name });
+                const user = await getOrCreateUserFromUserIdentifier(payload?.sub, {
+                    email: payload.email,
+                    fullName: payload.name,
+                });
                 const accessToken = await context.login(req, res, user);
                 logger.info('google-login', { email: user.email });
                 if (req.accepts('html')) {

package/dist/auth/passwordless.js

@@ -1,8 +1,8 @@
+import { DoesNotExistError } from '@devmoods/postgres';
 import {} from 'express';
 import { createTokenResponse } from './token.js';
 import {} from './types.js';
 import { getLogger } from '../logger.js';
-import { DoesNotExistError } from '../postgres.js';
 import { jsonSchema } from '../validate.js';
 const logger = getLogger('auth');
 export function PasswordlessAuthProvider(options) {
@@ -13,6 +13,7 @@ export function PasswordlessAuthProvider(options) {
         catch (error) {
             if (error instanceof DoesNotExistError) {
                 return null;
+                /* c8 ignore next 3 */
             }
             throw error;
         }

package/dist/auth/token.js

@@ -1,8 +1,8 @@
+import { config } from '@devmoods/config';
 import {} from 'express';
 import jwt from 'jsonwebtoken';
 import { v4 } from 'uuid';
 import { InvalidToken } from './errors.js';
-import { config } from '../config.js';
 import {} from '../validate.js';
 const ACCESS_TOKEN_COOKIE_NAME = 'access_token';
 export const tokenSchema = {
@@ -24,8 +24,8 @@ export function createTokenResponse(accessToken) {
 /**
  * Returns a signed JWT token.
  */
-export function createAccessToken(payload, version = '1', secret = config.value.AUTH_SECRET) {
-    const expiresIn = config.value.AUTH_TOKEN_EXPIRES_IN;
+export function createAccessToken(payload, version = '1', secret = config.AUTH_JWT_SECRET) {
+    const expiresIn = config.AUTH_TOKEN_EXPIRES;
     const token = jwt.sign({ v: version, ...payload }, secret, {
         expiresIn,
     });
@@ -34,7 +34,7 @@ export function createAccessToken(payload, version = '1', secret = config.value.
 /**
  * Decode the given JWT token.
  */
-export function decodeAccessToken(token, secret = config.value.AUTH_SECRET) {
+export function decodeAccessToken(token, secret = config.AUTH_JWT_SECRET) {
     try {
         const decoded = jwt.verify(token.trim(), secret);
         /* c8 ignore next 3 */
@@ -95,7 +95,7 @@ export function extractAccessTokenFromRequest(req) {
  * If the provided token is `null` the cookie will be cleared.
  */
 export function setAccessTokenCookie(res, token) {
-    const sameSite = (config.value.AUTH_COOKIE_SAME_SITE || 'strict');
+    const sameSite = config.AUTH_COOKIE_SAME_SITE;
     if (token == null) {
         res.cookie(ACCESS_TOKEN_COOKIE_NAME, v4(), {
             expires: new Date(1970, 0, 1),
@@ -105,7 +105,7 @@ export function setAccessTokenCookie(res, token) {
     }
     else {
         res.cookie(ACCESS_TOKEN_COOKIE_NAME, token, {
-            expires: new Date(Date.now() + config.value.AUTH_TOKEN_EXPIRES_IN * 1000),
+            expires: new Date(Date.now() + config.AUTH_TOKEN_EXPIRES * 1000),
             httpOnly: true,
             sameSite,
             secure: process.env.NODE_ENV === 'production',

package/dist/auth/types.d.ts

@@ -35,7 +35,7 @@ export interface AuthProviderContext<UserModel extends AnyUser> {
     filterUser: AuthOptions<UserModel>['filterUser'];
     tokenStorage: AuthOptions<UserModel>['tokenStorage'];
     setCurrentUser: (user: UserModel) => void;
-    createTemporaryToken(user: UserModel): Promise<string>;
+    createTemporaryToken(user: UserModel | null): Promise<string>;
     verifyTemporaryToken(token: string, user: UserModel | null, consume?: boolean): Promise<string>;
     decodeTemporaryToken(token: string): DecodedTemporaryToken;
     createOtp(user: UserModel): Promise<string>;

package/dist/auth.d.ts

@@ -13,7 +13,7 @@ export interface CreateAuth<UserModel extends AnyUser> {
     before: () => RequestHandler;
     allow: (fn?: AuthIsAllowedFn<UserModel>) => RequestHandler;
     isAuthorized: (fn?: (user: UserModel) => boolean) => RequestHandler;
-    createTemporaryToken(user: UserModel): Promise<string>;
+    createTemporaryToken(user: UserModel | null): Promise<string>;
     verifyTemporaryToken(token: string, user: UserModel | null): Promise<string>;
     decodeTemporaryToken(token: string): DecodedTemporaryToken;
     createOtp(user: UserModel): Promise<string>;

package/dist/auth.js

@@ -1,10 +1,10 @@
 import * as crypto from 'node:crypto';
+import { config } from '@devmoods/config';
 import {} from 'express';
 import { InvalidToken, PermissionDenied } from './auth/errors.js';
 import { createAccessToken, decodeAccessToken, extractAccessTokenFromRequest, setAccessTokenCookie, tokenSchema, } from './auth/token.js';
 import { TokenStorage, } from './auth/types.js';
-import { config } from './config.js';
-import { setContext, useContext } from './context.js';
+import { setRequestContext, useRequestContext } from './context.js';
 import { Forbidden, NotFound, Unauthorized } from './errors.js';
 import { getLogger } from './logger.js';
 import {} from './redis.js';
@@ -19,7 +19,7 @@ export * from './auth/google.js';
 export class RedisTokenStorage extends TokenStorage {
     redis;
     keyPrefix;
-    constructor(redis, keyPrefix = `${config.value.REDIS_KEY_PREFIX}auth:`) {
+    constructor(redis, keyPrefix = `${config.REDIS_KEY_PREFIX}auth:`) {
         super();
         this.redis = redis;
         this.keyPrefix = keyPrefix;
@@ -38,8 +38,8 @@ export class RedisTokenStorage extends TokenStorage {
 }
 const sha256 = (value) => crypto.createHash('sha256').update(value).digest('hex');
 export function createAuth({ getUserById, filterUser, tokenStorage, providers, loginUrl = '/', onUserLoggedIn, sessionTokenVersion = '1', }) {
-    const useCurrentUser = () => useContext('currentUser');
-    const setCurrentUser = (user) => setContext('currentUser', user);
+    const useCurrentUser = () => useRequestContext('currentUser');
+    const setCurrentUser = (user) => setRequestContext('currentUser', user);
     const login = async (req, res, user, isRefresh = false) => {
         const accessToken = createAccessToken({ uid: user.id }, sessionTokenVersion);
         const sessionId = sha256(accessToken.token);
@@ -63,7 +63,12 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
         }
     };
     // Make timing attacks harder
-    const jitter = (duration = 0) => new Promise((resolve) => void setTimeout(resolve, Math.max((0.5 - duration) * 1000, 200)));
+    const jitter = (duration = 0) => {
+        if (process.env.NODE_ENV === 'test') {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => void setTimeout(resolve, Math.max((0.5 - duration) * 1000, 200)));
+    };
     /**
      * API for auth providers to use
      */
@@ -224,7 +229,7 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
     }
     async function createOtp(user) {
         const otp = crypto.randomInt(100000, 999999).toString();
-        await tokenStorage.set(otp, String(user.id), config.value.AUTH_OTP_EXPIRES_IN);
+        await tokenStorage.set(otp, String(user.id), config.AUTH_OTP_EXPIRES);
         return otp;
     }
     async function verifyOtp(otp, user, consume = true) {
@@ -232,6 +237,7 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
         if (!storedUid) {
             throw new InvalidToken('Invalid OTP');
         }
+        /* c8 ignore next 3 */
         if (user && storedUid !== user.id) {
             throw new InvalidToken('Invalid OTP');
         }
@@ -250,7 +256,7 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
             const randomBytes = crypto.randomBytes(32).toString('hex');
             const payload = { v: '1', uid: uid, r: randomBytes };
             const signature = crypto
-                .createHmac('sha256', config.value.AUTH_SECRET)
+                .createHmac('sha256', config.AUTH_JWT_SECRET)
                 .update(JSON.stringify(payload))
                 .digest('base64')
                 .slice(0, 12);
@@ -258,7 +264,7 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
                 throw new Error('User ID is required to create a token');
             }
             const temporaryToken = Buffer.from(JSON.stringify({ payload, signature })).toString('base64url');
-            await tokenStorage.set(temporaryToken, String(uid), config.value.AUTH_TEMP_TOKEN_EXPIRES_IN);
+            await tokenStorage.set(temporaryToken, String(uid), config.AUTH_TEMP_TOKEN_EXPIRES);
             return temporaryToken;
         }
         catch (error) {
@@ -272,10 +278,11 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
     async function verifyTemporaryToken(token, user, consume = true) {
         const decoded = decodeTemporaryToken(token);
         const expectedSignature = crypto
-            .createHmac('sha256', config.value.AUTH_SECRET)
+            .createHmac('sha256', config.AUTH_JWT_SECRET)
             .update(JSON.stringify(decoded.payload))
             .digest('base64')
             .slice(0, 12);
+        /* c8 ignore next 3 */
         if (expectedSignature !== decoded.signature) {
             throw new InvalidToken('Invalid signature');
         }

package/dist/cache.d.ts

@@ -23,4 +23,7 @@ export declare function createCache(adapter: CacheAdapter): {
         (...args: Arguments): Promise<T>;
         clear(...args: Arguments): Promise<void>;
     };
+    hashKey: typeof hashKey;
 };
+declare function hashKey(obj: unknown): string;
+export {};

package/dist/cache.js

@@ -1,7 +1,7 @@
-import { config } from './config.js';
+import { config } from '@devmoods/config';
 import {} from './redis.js';
 export function createRedisCacheAdapter(redis, options = {}) {
-    const { keyPrefix = `${config.value.REDIS_KEY_PREFIX}cache:` } = options;
+    const { keyPrefix = `${config.REDIS_KEY_PREFIX}cache:` } = options;
     const withKeyPrefix = (key) => `${keyPrefix}${key}`;
     return {
         async get(key) {
@@ -97,6 +97,7 @@ export function createCache(adapter) {
         clear: adapter.clear.bind(adapter),
         wrap: cached,
         decorate: cachedFn,
+        hashKey,
     };
 }
 function hashKey(obj) {

package/dist/channels.d.ts

@@ -1,9 +1,13 @@
+import { type StandardSchemaV1 } from '@standard-schema/spec';
 import { type Request } from 'express';
 import { type RedisClient } from './redis.js';
 import { type ExtractParams, type TypedRequestHandler } from './router.js';
-export declare function createEventStream<Channels extends string>(redis: RedisClient): {
-    sse: <Path extends string>({ channels, }: {
-        channels: (req: Request) => string[] | Promise<string[]>;
-    }) => TypedRequestHandler<ExtractParams<Path>, any, any, any>;
-    publish: (channel: Channels, message: unknown) => Promise<number>;
+export interface EventStreamSseOptions<Schema extends StandardSchemaV1> {
+    channels: (req: Request) => string[] | Promise<string[]>;
+    getIdFromMessage?: (message: StandardSchemaV1.InferOutput<Schema>) => string | undefined;
+}
+export declare function createEventStream<Channels extends string, Schema extends StandardSchemaV1>(redis: RedisClient, schema: Schema): {
+    sse: <const Path extends string>({ channels, getIdFromMessage, }: EventStreamSseOptions<Schema>) => TypedRequestHandler<ExtractParams<Path>, any, any, any>;
+    publish: (channel: Channels, message: StandardSchemaV1.InferOutput<Schema>) => Promise<number>;
+    close: () => Promise<void>;
 };

package/dist/channels.js

@@ -1,63 +1,149 @@
+import { config } from '@devmoods/config';
+import {} from '@standard-schema/spec';
 import {} from 'express';
-import { config } from './config.js';
 import { requestContext } from './context.js';
 import { getLogger } from './logger.js';
 import {} from './redis.js';
 import {} from './router.js';
 const logger = getLogger();
-export function createEventStream(redis) {
-    const keyPrefix = `${config.value.REDIS_KEY_PREFIX}events:`;
+const defaultGetIdFromMessage = (message) => {
+    if (typeof message === 'object' && message !== null && 'id' in message) {
+        return `${message.id}`;
+    }
+    return undefined;
+};
+function writeChunk(res, chunk, state) {
+    // If we're already draining, just enqueue.
+    if (state.draining) {
+        if (state.queue.length >= state.maxQueue) {
+            // Drop the oldest chunk to keep memory bounded.
+            state.queue.shift();
+        }
+        state.queue.push(chunk);
+        return;
+    }
+    if (res.write(chunk)) {
+        return;
+    }
+    // Buffer is full — start draining
+    state.draining = true;
+    const flush = () => {
+        while (state.queue.length) {
+            const next = state.queue.shift();
+            if (!res.write(next)) {
+                state.draining = true;
+                res.once('drain', flush);
+                return;
+            }
+        }
+        state.draining = false;
+    };
+    res.once('drain', flush);
+}
+export function createEventStream(redis, schema) {
+    const keyPrefix = `${config.REDIS_KEY_PREFIX}events:`;
     const withKeyPrefix = (key) => `${keyPrefix}${key}`;
-    const sse = ({ channels, }) => {
+    const subscribers = new Set();
+    const sse = ({ channels, getIdFromMessage = defaultGetIdFromMessage, }) => {
         return async (req, res, next) => {
             try {
-                const headers = {
-                    'Content-Type': 'text/event-stream',
-                    'Cache-Control': 'no-cache',
-                    Connection: 'keep-alive',
-                };
-                res.writeHead(200, headers);
-                res.write('retry: 15000\n');
+                const subscriber = redis.duplicate();
+                /* c8 ignore next 3 */
+                subscriber.on('error', (error) => {
+                    logger.error(error);
+                });
+                await subscriber.connect();
                 const heartbeat = setInterval(() => {
                     try {
                         if (!res.writableEnded) {
-                            res.write('event: heartbeat\n');
-                            res.write('data: ping\n\n');
+                            writeChunk(res, 'event: heartbeat\n', state);
+                            writeChunk(res, 'data: ping\n\n', state);
                         }
                     }
                     catch (error) {
                         logger.error(error);
                     }
                 }, 15000);
+                const state = {
+                    draining: false,
+                    queue: [],
+                    maxQueue: 1000,
+                };
                 const store = requestContext.getStore();
                 const listener = (value) => {
                     try {
                         requestContext.run(store, () => {
                             if (!res.writableEnded) {
-                                res.write('event: data\n');
-                                res.write(`data: ${JSON.stringify(value)}\n\n`);
+                                const id = getIdFromMessage?.(value);
+                                if (id) {
+                                    writeChunk(res, `id: ${id}\n`, state);
+                                }
+                                writeChunk(res, 'event: data\n', state);
+                                writeChunk(res, `data: ${JSON.stringify(value)}\n\n`, state);
                             }
                         });
+                        /* c8 ignore next 3 */
                     }
                     catch (error) {
                         logger.error(error);
                     }
                 };
-                const subscriber = redis.duplicate();
-                await subscriber.connect();
                 const _channels = await channels(req);
                 await subscriber.subscribe(_channels.map(withKeyPrefix), (message) => {
-                    listener(JSON.parse(message));
+                    let parsedMessage;
+                    try {
+                        parsedMessage = JSON.parse(message);
+                        /* c8 ignore next 3 */
+                    }
+                    catch (error) {
+                        logger.error(error);
+                    }
+                    if (parsedMessage) {
+                        listener(parsedMessage);
+                    }
                 });
                 logger.info('event stream subscribe', { channels: _channels });
-                res.on('close', () => {
+                const headers = {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    Connection: 'keep-alive',
+                    'x-accel-buffering': 'no',
+                };
+                res.writeHead(200, headers);
+                writeChunk(res, 'retry: 10000\n', state);
+                let closed = false;
+                const close = () => {
+                    if (closed) {
+                        return;
+                    }
+                    closed = true;
                     requestContext.run(store, () => {
                         logger.info('event stream close');
                         clearInterval(heartbeat);
-                        subscriber.quit();
-                        res.end();
+                        subscriber.close();
                     });
-                });
+                };
+                const gracefulClose = () => {
+                    if (closed) {
+                        return;
+                    }
+                    if (!res.writableEnded) {
+                        writeChunk(res, 'event: close\n', state);
+                        writeChunk(res, 'data: shutdown\n\n', state);
+                        res.end();
+                    }
+                    close();
+                };
+                subscribers.add(gracefulClose);
+                const cleanup = () => {
+                    subscribers.delete(gracefulClose);
+                    close();
+                };
+                res.on('close', cleanup);
+                res.on('finish', cleanup);
+                req.on('aborted', cleanup);
+                req.socket.on('error', cleanup);
+                /* c8 ignore next 3 */
             }
             catch (error) {
                 next(error);
@@ -67,5 +153,11 @@ export function createEventStream(redis) {
     const publish = (channel, message) => {
         return redis.publish(withKeyPrefix(channel), JSON.stringify(message));
     };
-    return { sse, publish };
+    const close = async () => {
+        for (const closeSubscriber of subscribers) {
+            closeSubscriber();
+        }
+        subscribers.clear();
+    };
+    return { sse, publish, close };
 }

package/dist/cli.js

@@ -1,8 +1,8 @@
 import { stdin, stdout, stderr } from 'node:process';
 import * as readline from 'node:readline';
 import {} from 'node:tty';
+import { startTimer } from '@devmoods/observability';
 import chalk from 'chalk';
-import { startTimer } from './utils.js';
 export class CLI {
     options;
     constructor(options = {}) {