@devmoods/express-extras 0.63.0 → 0.64.0

package/dist/auth.js

@@ -197,7 +197,7 @@ export function createAuth({ getUserById, filterUser, tokenStorage, providers, l
             try {
                 const user = useCurrentUser();
                 if (!user) {
-                    throw new PermissionDenied('User not logged in');
+                    throw new InvalidToken('User not logged in');
                 }
                 if (isAuthorized && !(await isAuthorized(user))) {
                     throw new PermissionDenied('Permission denied');

package/dist/channels.d.ts

@@ -1,9 +1,12 @@
 import { type Request } from 'express';
 import { type RedisClient } from './redis.js';
 import { type ExtractParams, type TypedRequestHandler } from './router.js';
+export interface EventStreamSseOptions {
+    channels: (req: Request) => string[] | Promise<string[]>;
+    getIdFromMessage?: (message: unknown) => string | undefined;
+}
 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>;
+    sse: <Path extends string>({ channels, getIdFromMessage, }: EventStreamSseOptions) => TypedRequestHandler<ExtractParams<Path>, any, any, any>;
     publish: (channel: Channels, message: unknown) => Promise<number>;
+    close: () => Promise<void>;
 };

package/dist/channels.js

@@ -5,37 +5,79 @@ import { getLogger } from './logger.js';
 import {} from './redis.js';
 import {} from './router.js';
 const logger = getLogger();
+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) {
     const keyPrefix = `${config.value.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();
+                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);
                             }
                         });
                     }
@@ -43,21 +85,60 @@ export function createEventStream(redis) {
                         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);
+                    }
+                    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, no-transform',
+                    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);
             }
             catch (error) {
                 next(error);
@@ -67,5 +148,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/listen.d.ts

@@ -7,6 +7,7 @@ interface StoppableServer extends Server {
 export declare function stoppable(server: Server, grace?: number): StoppableServer;
 interface ExpressServerOptions {
     onShutdown?(): Promise<void> | void;
+    beforeShutdown?(): Promise<void> | void;
     healthCheck?(type?: 'live' | 'ready'): Promise<unknown>;
 }
 export declare function createExpressServer(app: Application, options?: ExpressServerOptions): {

package/dist/listen.js

@@ -87,9 +87,13 @@ export function createExpressServer(app, options = {}) {
         try {
             logger.info(`app shutting down due to ${signal}`);
             await delay(READINESS_PERIOD + 1000);
-            await server.stop();
+            await options.beforeShutdown?.();
+            const gracefully = await server.stop();
             await options.onShutdown?.();
-            logger.info('app shut down', { duration: timer.getDuration() });
+            logger.info('app shut down', {
+                duration: timer.getDuration(),
+                gracefully,
+            });
             process.exit(0);
         }
         catch (error) {

package/dist/redis.d.ts

@@ -5,3 +5,6 @@ export interface RedisOptions {
 }
 export type RedisClient = ReturnType<typeof createClient>;
 export declare function createRedis({ url, onError, }?: RedisOptions): RedisClient;
+export declare function connectRedis(redis: RedisClient, shouldContinue?: boolean): Promise<void>;
+export declare function stopRedis(redis: RedisClient, timeout?: number): Promise<void>;
+export declare function pingRedis(redis: RedisClient): Promise<string>;

package/dist/redis.js

@@ -1,5 +1,6 @@
 import { createClient } from 'redis';
 import { config } from './config.js';
+import { withTimeout } from './utils.js';
 export function createRedis({ url = config.value.REDIS_URL, onError, } = {}) {
     const client = createClient({ url });
     // Always attach a listener even if
@@ -9,3 +10,25 @@ export function createRedis({ url = config.value.REDIS_URL, onError, } = {}) {
     });
     return client;
 }
+export async function connectRedis(redis, shouldContinue = true) {
+    try {
+        await withTimeout(redis.connect(), 10000);
+    }
+    catch (error) {
+        if (shouldContinue) {
+            return;
+        }
+        throw new Error('Failed to connect to Redis', { cause: error });
+    }
+}
+export async function stopRedis(redis, timeout = 10000) {
+    try {
+        return await withTimeout(redis.close(), timeout);
+    }
+    catch {
+        return redis.destroy();
+    }
+}
+export function pingRedis(redis) {
+    return withTimeout(redis.ping(), 1000);
+}

package/dist/setupTests.js

@@ -1,5 +1,6 @@
 import 'dotenv/config';
 import EventEmitter from 'node:events';
-import failOnConsole from 'vitest-fail-on-console';
+import { extendMatchers, failOnConsole } from './vitest/index.js';
 EventEmitter.setMaxListeners(20);
 failOnConsole();
+extendMatchers(expect);

package/dist/utils.d.ts

@@ -1,4 +1,6 @@
 import { type EventEmitter } from 'node:events';
+import { withTimeout, TimeoutError, delay } from '@devmoods/fetch';
+export { withTimeout, TimeoutError, delay };
 /**
  * Start a high resolution timer
  */
@@ -22,4 +24,3 @@ declare function readEnvNumber(key: string, defaultValue: number): number;
 declare function readEnvBoolean(key: string, defaultValue: boolean): boolean;
 export declare const envPort: (defaultPort?: number) => number;
 export declare function waitForEvent(emitter: EventEmitter, event: string): Promise<unknown>;
-export {};

package/dist/utils.js

@@ -1,4 +1,6 @@
 import {} from 'node:events';
+import { withTimeout, TimeoutError, delay } from '@devmoods/fetch';
+export { withTimeout, TimeoutError, delay };
 /**
  * Start a high resolution timer
  */

package/dist/vitest/index.d.ts

@@ -0,0 +1 @@
+export * from './matchers.js';

package/dist/vitest/index.js

@@ -0,0 +1 @@
+export * from './matchers.js';

package/dist/vitest/matchers.d.ts

@@ -0,0 +1,11 @@
+import { type ExpectStatic } from 'vitest';
+import failOnConsole from 'vitest-fail-on-console';
+interface CustomMatchers<R = unknown> {
+    toMatchResponse: (statusCode: number, body: unknown) => R;
+}
+declare module 'vitest' {
+    interface Matchers<T = any> extends CustomMatchers<T> {
+    }
+}
+export { failOnConsole };
+export declare function extendMatchers(expect: ExpectStatic): void;

package/dist/vitest/matchers.js

@@ -0,0 +1,61 @@
+import {} from 'vitest';
+import failOnConsole from 'vitest-fail-on-console';
+export { failOnConsole };
+export function extendMatchers(expect) {
+    expect.extend({
+        toMatchResponse(received, expectedStatusCode, expectedBody) {
+            const { isNot } = this;
+            // Check if received is a proper response object
+            if (!received ||
+                typeof received !== 'object' ||
+                !('status' in received)) {
+                return {
+                    pass: false,
+                    message: () => `Expected response object with status property, but received: ${this.utils.printReceived(received)}`,
+                };
+            }
+            const { status, body } = received;
+            // Check status code
+            const statusMatches = status === expectedStatusCode;
+            // Check body (if provided)
+            let bodyMatches = true;
+            let bodyMessage = '';
+            if (expectedBody !== undefined) {
+                if (typeof expectedBody === 'object' && expectedBody !== null) {
+                    // For objects, do a deep equality check
+                    bodyMatches = this.equals(body, expectedBody);
+                    if (!bodyMatches) {
+                        bodyMessage = `\n\nExpected body:\n${this.utils.printExpected(expectedBody)}\nReceived body:\n${this.utils.printReceived(body)}`;
+                    }
+                }
+                else {
+                    // For primitives, do a simple equality check
+                    bodyMatches = body === expectedBody;
+                    if (!bodyMatches) {
+                        bodyMessage = `\n\nExpected body: ${this.utils.printExpected(expectedBody)}\nReceived body: ${this.utils.printReceived(body)}`;
+                    }
+                }
+            }
+            const pass = statusMatches && bodyMatches;
+            let message = '';
+            if (!statusMatches) {
+                message += `Expected status: ${this.utils.printExpected(expectedStatusCode)}\nReceived status: ${this.utils.printReceived(status)}`;
+            }
+            if (!bodyMatches) {
+                message += bodyMessage;
+            }
+            return {
+                pass,
+                message: () => {
+                    if (pass && isNot) {
+                        return `Expected response not to match status ${expectedStatusCode}${expectedBody !== undefined ? ` with body ${this.utils.printExpected(expectedBody)}` : ''}`;
+                    }
+                    if (!pass && !isNot) {
+                        return `Expected response to match status ${expectedStatusCode}${expectedBody !== undefined ? ` with body ${this.utils.printExpected(expectedBody)}` : ''}\n\n${message}`;
+                    }
+                    return message;
+                },
+            };
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.63.0",
+  "version": "0.64.0",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -29,6 +29,12 @@
         "types": "./dist/vite/types.d.ts",
         "default": "./dist/vite/types.js"
       }
+    },
+    "./vitest": {
+      "import": {
+        "types": "./dist/vitest/index.d.ts",
+        "default": "./dist/vitest/index.js"
+      }
     }
   },
   "author": {
@@ -65,9 +71,9 @@
   },
   "dependencies": {
     "@devmoods/fetch": "^4.2.0",
-    "@hey-api/openapi-ts": "^0.82.5",
-    "@sentry/node": "^10.10.0",
-    "@sentry/profiling-node": "^10.10.0",
+    "@hey-api/openapi-ts": "^0.83.1",
+    "@sentry/node": "^10.11.0",
+    "@sentry/profiling-node": "^10.11.0",
     "@standard-schema/spec": "^1.0.0",
     "@types/bcrypt": "^6.0.0",
     "@types/cookie-parser": "^1.4.9",
@@ -82,7 +88,7 @@
     "argon2": "^0.44.0",
     "bcrypt": "^6.0.0",
     "chalk": "^5.6.2",
-    "commander": "^14.0.0",
+    "commander": "^14.0.1",
     "compose-middleware": "^5.0.1",
     "cookie-parser": "^1.4.7",
     "dotenv": "^17.2.2",
@@ -95,8 +101,8 @@
     "pg-structure": "^7.15.3",
     "redis": "^5.8.2",
     "sonda": "^0.9.0",
-    "sql-formatter": "^15.6.8",
-    "uuid": "^12.0.0"
+    "sql-formatter": "^15.6.9",
+    "uuid": "^13.0.0"
   },
   "prettier": {
     "singleQuote": true

package/dist/vite/vitest.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/vite/vitest.js

@@ -1 +0,0 @@
-export {};