@devmoods/express-extras 0.27.0 → 0.28.0

package/bin/migrate

@@ -2,4 +2,4 @@
 
 set -e
 
-node_modules/.bin/ts-node --esm node_modules/@devmoods/express-extras/dist/cli.js ${*:1}
+node_modules/.bin/ts-node --esm node_modules/@devmoods/express-extras/dist/cli/migrate.js ${*:1}

package/bin/routes

@@ -0,0 +1,5 @@
+#/bin/bash 
+
+set -e
+
+node_modules/.bin/ts-node --esm node_modules/@devmoods/express-extras/dist/cli/routes.js ${*:1}

package/dist/auth.js

@@ -142,7 +142,7 @@ export function EmailAndPasswordAuthProvider(options) {
         },
     };
 }
-export function createAuth({ getUserByToken, filterUser = (x) => x, redis, providers, }) {
+export function createAuth({ getUserByToken, filterUser, redis, providers, }) {
     const useCurrentUser = () => useContext('currentUser');
     const setCurrentUser = (user) => setContext('currentUser', user);
     const providerContext = {
@@ -272,6 +272,7 @@ export function parseAuthorizationHeader(req) {
     if (!token) {
         if (type) {
             return type;
+            /* c8 ignore next 3 */
         }
         return null;
     }

package/dist/cache.d.ts

@@ -4,7 +4,10 @@ export interface CacheAdapter {
     set(key: string, value: any, expires?: number | null | undefined): Promise<void>;
     clear(key?: string): Promise<void>;
 }
-export declare function createRedisCacheAdapter(redis: RedisClient): CacheAdapter;
+export interface RedisCacheAdapterOptions {
+    keyPrefix?: string;
+}
+export declare function createRedisCacheAdapter(redis: RedisClient, options?: RedisCacheAdapterOptions): CacheAdapter;
 export declare function createMemoryCacheAdapter(): CacheAdapter;
 export declare function createCache(adapter: CacheAdapter): {
     set: (key: string, value: any, expires?: number | null | undefined) => Promise<void>;

package/dist/cache.js

@@ -1,18 +1,24 @@
 import {} from './redis.js';
-export function createRedisCacheAdapter(redis) {
+export function createRedisCacheAdapter(redis, options = {}) {
+    const { keyPrefix = 'cache:' } = options;
+    const createKey = (key) => `${keyPrefix}${key}`;
     return {
         async get(key) {
-            const value = await redis.get(key);
+            const value = await redis.get(createKey(key));
             if (value == null) {
                 return null;
             }
             return JSON.parse(value);
         },
         async set(key, value, expires) {
-            await redis.set(key, JSON.stringify(value), { PX: expires });
+            await redis.set(createKey(key), JSON.stringify(value), { PX: expires });
         },
         async clear(key) {
             if (key) {
+                await redis.del(createKey(key));
+            }
+            const keys = await redis.keys(`${keyPrefix}*`);
+            for (const key of keys) {
                 await redis.del(key);
             }
         },

package/dist/cli/migrate.js

@@ -0,0 +1,3 @@
+import 'dotenv/config';
+import { cli } from '../migrate.js';
+cli();

package/dist/cli/routes.d.ts

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

package/dist/cli/routes.js

@@ -0,0 +1,10 @@
+import { createFetch } from '@devmoods/fetch';
+const port = process.env.PORT ?? 3000;
+const fetch = createFetch({
+    getRootUrl: () => `http://localhost:${port}`,
+    getRequestId: () => 'routes',
+});
+const response = await fetch('/docs');
+for (const route of response.jsonData.routes) {
+    process.stdout.write(`${route.method.toLocaleUpperCase().padEnd(5)} ${route.path}\n`);
+}

package/dist/listen.d.ts

@@ -1,11 +1,19 @@
 /// <reference types="node" resolution-mode="require"/>
-import type * as http from 'node:http';
-/**
- * Listen on the given port and setup proper signal
- * handlers for terminating the process gracefully.
- */
-export declare function listen(server: http.Server, options: {
-    port: number;
-    onShutdown?: () => void | Promise<void>;
-    healthCheck?: () => Promise<unknown>;
-}): void;
+import type { Application } from 'express';
+import type { Server } from 'node:http';
+interface StoppableServer extends Server {
+    inspect(): Record<string, any>;
+    stop(): Promise<boolean>;
+}
+export declare function stoppable(server: Server, grace?: number): StoppableServer;
+interface ExpressServerOptions {
+    onShutdown?(): Promise<void> | void;
+    healthCheck?(): Promise<unknown>;
+}
+export declare function createExpressServer(app: Application, options?: ExpressServerOptions): {
+    start(): void;
+    stop(): Promise<boolean>;
+    terminate(): Promise<void>;
+    readonly port: number;
+};
+export {};

package/dist/listen.js

@@ -1,54 +1,126 @@
-import { createTerminus } from '@godaddy/terminus';
+import { delay } from '@devmoods/fetch';
+import * as http from 'node:http';
 import { getLogger } from './logger.js';
-import { readEnv } from './utils.js';
+import { route } from './middleware.js';
+import { envPort, readEnv } from './utils.js';
 const logger = getLogger('http');
 const READINESS_PERIOD_MS = readEnv.number('READINESS_PERIOD_MS', 0);
 const FORCE_EXIT_TIMEOUT = readEnv.number('FORCE_EXIT_TIMEOUT', 5000);
-/**
- * Listen on the given port and setup proper signal
- * handlers for terminating the process gracefully.
- */
-export function listen(server, options) {
-    createTerminus(server, {
-        timeout: FORCE_EXIT_TIMEOUT,
-        signals: ['SIGTERM', 'SIGINT'],
-        async onShutdown() {
-            logger.info('app shutting down');
-        },
-        beforeShutdown() {
-            return new Promise((resolve) => {
-                setTimeout(resolve, READINESS_PERIOD_MS + 1000);
+export function stoppable(server, grace = Infinity) {
+    let stopped = false;
+    let gracefully = true;
+    const requestsPerSocket = new Map();
+    const onConnection = (socket) => {
+        requestsPerSocket.set(socket, 0);
+        socket.once('close', () => requestsPerSocket.delete(socket));
+    };
+    const onRequest = (req, res) => {
+        requestsPerSocket.set(req.socket, requestsPerSocket.get(req.socket) + 1);
+        res.once('finish', () => {
+            const pending = requestsPerSocket.get(req.socket) - 1;
+            requestsPerSocket.set(req.socket, pending);
+            if (stopped && pending === 0) {
+                req.socket.end();
+            }
+        });
+    };
+    function stop() {
+        return new Promise((resolve, reject) => {
+            setImmediate(() => {
+                stopped = true;
+                if (grace < Infinity) {
+                    setTimeout(destroyAll, grace).unref();
+                }
+                server.close((e) => {
+                    if (e) {
+                        return reject(e);
+                    }
+                    resolve(gracefully);
+                });
+                for (const [socket, requests] of requestsPerSocket) {
+                    if (requests === 0) {
+                        socket.end();
+                    }
+                }
+            });
+        });
+    }
+    function destroyAll() {
+        gracefully = false;
+        for (const socket of requestsPerSocket.keys()) {
+            socket.end();
+        }
+        setImmediate(() => {
+            for (const socket of requestsPerSocket.keys()) {
+                socket.destroy();
+            }
+        });
+    }
+    server.on('connection', onConnection);
+    server.on('request', onRequest);
+    // @ts-ignore
+    server.stop = stop;
+    // @ts-ignore
+    server.inspect = () => {
+        return {
+            sockets: requestsPerSocket.size,
+        };
+    };
+    return server;
+}
+export function createExpressServer(app, options = {}) {
+    const server = stoppable(http.createServer(app), FORCE_EXIT_TIMEOUT);
+    let stopping = false;
+    async function onSignal(signal) {
+        if (stopping) {
+            return;
+        }
+        stopping = true;
+        try {
+            logger.info(`app shutting down due to ${signal}`);
+            await delay(READINESS_PERIOD_MS + 1000);
+            await server.stop();
+            await options.onShutdown?.();
+            logger.info('app shut down');
+            process.exit(0);
+        }
+        catch (error) {
+            logger.error(error, 'error during shutdown');
+            process.exit(1);
+        }
+    }
+    for (const signal of ['SIGTERM', 'SIGINT']) {
+        process.on(signal, onSignal);
+    }
+    app.get('/health', route(async () => {
+        const timestamp = new Date().toISOString();
+        try {
+            if (stopping) {
+                throw new Error();
+            }
+            const meta = await options.healthCheck?.();
+            return { status: 'ok', meta, timestamp };
+        }
+        catch (error) {
+            return [503, { status: 'error', timestamp }];
+        }
+    }));
+    return {
+        start() {
+            const port = app.get('port') ?? envPort(0);
+            server.listen(port, () => {
+                logger.info('app listening', { port: this.port });
             });
         },
-        async onSignal() {
-            logger.info('app received shutdown signal');
-            await options?.onShutdown?.();
+        stop() {
+            return server.stop();
         },
-        async onSendFailureDuringShutdown() {
-            logger.info('app sent service not available message to client');
+        terminate() {
+            return onSignal('SIGTERM');
         },
-        healthChecks: {
-            '/health': async ({ state }) => {
-                if (state.isShuttingDown) {
-                    return false;
-                }
-                try {
-                    const meta = await options?.healthCheck?.();
-                    return {
-                        meta,
-                        timestamp: new Date().toISOString(),
-                    };
-                }
-                catch (error) {
-                    logger.error(error, 'health check failed');
-                    throw error;
-                }
-            },
-            verbatim: true,
+        get port() {
+            // @ts-ignore
+            return server.address().port;
         },
-    });
-    const port = options.port;
-    server.listen(port, () => {
-        logger.info('app listening', { port });
-    });
+    };
 }

package/dist/logger.d.ts

@@ -11,16 +11,13 @@ export interface LoggerOptions {
      * Context to attach to each log line
      */
     getContext?: () => LoggerContext;
-    /**
-     * Defaults to `process.env.NODE_ENV === 'test'`
-     */
-    silent?: () => boolean;
+    level?: string;
     output?: Duplex;
 }
 export declare function attachSentryClientToLoggers(sentryClient: CreateSentry['client']): void;
 export declare function setGlobalLoggerContext(getContext: () => LoggerContext): void;
 export type Logger = ReturnType<typeof createLogger>;
-export declare function createLogger({ name, getContext, silent, output, }: LoggerOptions): {
+export declare function createLogger({ name, getContext, level, output, }: LoggerOptions): {
     debug(message: string, context?: LoggerContext): void;
     info(message: string, context?: LoggerContext): void;
     warn(message: string, context?: LoggerContext): void;

package/dist/logger.js

@@ -1,5 +1,6 @@
 import * as os from 'node:os';
 import { useRequestId } from './context.js';
+import { readEnv } from './utils.js';
 const LEVELS = {
     TRACE: 10,
     DEBUG: 20,
@@ -24,14 +25,17 @@ function defaultGetContext() {
         ..._globalGetContext?.(),
     };
 }
-export function createLogger({ name, getContext, silent = () => false, output = process.stdout, }) {
+export function createLogger({ name, getContext, level = readEnv('LOG_LEVEL', 'INFO'), output = process.stdout, }) {
     if (_loggers.has(name)) {
         throw new Error(`A logger named ${name} already exists`);
     }
     const hostname = os.hostname();
     const pid = process.pid;
     const env = process.env.NODE_ENV;
-    const logLevel = silent() ? LEVELS.FATAL + 1 : LEVELS.INFO;
+    const logLevelName = level.toUpperCase();
+    const logLevel = logLevelName in LEVELS
+        ? LEVELS[logLevelName]
+        : LEVELS.INFO;
     function getFinalContext(context) {
         return {
             ...defaultGetContext(),

package/dist/migrate.js

@@ -16,7 +16,9 @@ Usage
     });
     let exitCode = 0;
     try {
-        exitCode = await runCli(cli.input, cli.flags, () => cli.showHelp());
+        exitCode = await runCli(cli.input, cli.flags, 
+        /* c8 ignore next 2 */
+        () => cli.showHelp());
     }
     catch (error) {
         if (error instanceof CliError) {

package/dist/setupTests.js

@@ -1,9 +1,4 @@
 import 'dotenv/config';
 import * as crypto from 'node:crypto';
 // @ts-ignore
-import createFetchMock from 'vitest-fetch-mock';
-import { vi } from 'vitest';
-const fetchMocker = createFetchMock(vi);
-fetchMocker.enableMocks();
-// @ts-ignore
 globalThis.crypto = crypto;

package/dist/utils.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { EventEmitter } from 'node:events';
 /**
  * Start a high resolution timer
  *
@@ -14,4 +16,5 @@ export declare namespace readEnv {
 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

@@ -25,3 +25,10 @@ function readEnvBoolean(key, defaultValue) {
     return ['true', '1', 't'].includes(readEnv(key, `${defaultValue}`).toLowerCase());
 }
 export const envPort = (defaultPort = 3000) => readEnv.number('PORT', defaultPort);
+export async function waitForEvent(emitter, event) {
+    return new Promise((resolve) => {
+        emitter.once(event, (...args) => {
+            resolve([args]);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -24,17 +24,14 @@
   "license": "ISC",
   "devDependencies": {
     "@devmoods/eslint-config": "^1.2.0",
-    "@sentry/types": "^7.64.0",
-    "@types/express-serve-static-core": "^4.17.36",
-    "@types/node": "20.5.3",
+    "@types/koa-compose": "^3.2.5",
+    "@types/node": "20.5.9",
     "@types/supertest": "^2.0.12",
-    "@typescript-eslint/eslint-plugin": "^6.4.1",
-    "@typescript-eslint/parser": "^6.4.1",
-    "@vitest/coverage-v8": "^0.34.2",
-    "@vitest/expect": "^0.34.2",
-    "@vitest/runner": "^0.34.3",
+    "@typescript-eslint/eslint-plugin": "^6.5.0",
+    "@typescript-eslint/parser": "^6.5.0",
+    "@vitest/coverage-v8": "^0.34.3",
     "chalk": "^5.3.0",
-    "eslint": "^8.47.0",
+    "eslint": "^8.48.0",
     "eslint-plugin-jsx-a11y": "^6.7.1",
     "eslint-plugin-prettier": "^5.0.0",
     "eslint-plugin-react": "^7.33.2",
@@ -42,27 +39,24 @@
     "faktory-worker": "^4.5.1",
     "import-sort-cli": "6.0.0",
     "import-sort-style-module": "6.0.0",
-    "prettier": "3.0.2",
+    "prettier": "3.0.3",
     "supertest": "6.3.3",
     "ts-node": "10.9.1",
-    "typescript": "5.1.6",
-    "vitest": "^0.34.2",
-    "vitest-fetch-mock": "^0.2.2"
+    "typescript": "5.2.2",
+    "vitest": "^0.34.3"
   },
   "dependencies": {
     "@devmoods/fetch": "^3.3.0",
-    "@godaddy/terminus": "^4.12.1",
-    "@sentry/node": "^7.64.0",
+    "@sentry/node": "^7.66.0",
     "@types/bcrypt": "^5.0.0",
     "@types/body-parser": "^1.19.2",
     "@types/cookie-parser": "^1.4.3",
     "@types/express": "^4.17.17",
     "@types/jsonwebtoken": "^9.0.2",
-    "@types/koa-compose": "^3.2.5",
     "@types/nodemailer": "^6.4.9",
     "@types/pg": "^8.10.2",
     "@types/superagent": "^4.1.18",
-    "@types/uuid": "^9.0.2",
+    "@types/uuid": "^9.0.3",
     "ajv": "^8.12.0",
     "bcrypt": "^5.1.1",
     "body-parser": "^1.20.2",
@@ -72,11 +66,11 @@
     "express": "^4.18.2",
     "express-route-parser": "^1.0.5",
     "helmet": "^7.0.0",
-    "jsonwebtoken": "^9.0.1",
-    "meow": "^12.1.0",
+    "jsonwebtoken": "^9.0.2",
+    "meow": "^12.1.1",
     "nodemailer": "^6.9.4",
     "pg": "^8.11.3",
-    "redis": "^4.6.7",
+    "redis": "^4.6.8",
     "sql-template-strings": "^2.2.2",
     "uuid": "^9.0.0"
   },
@@ -104,7 +98,7 @@
     "start:worker": "ts-node --esm example/worker.ts",
     "clean": "rm -rf dist",
     "lint": "eslint src",
-    "test": "NODE_ENV=test DOTENV_CONFIG_PATH=.env.test vitest",
+    "test": "./test.sh src",
     "build": "pnpm run clean && tsc --project tsconfig.build.json",
     "prettier": "prettier --write '**/*.{js,css,md,ts,tsx}'",
     "import-sort": "import-sort --write '**/*.{js,jsx,ts,tsx}'",

package/dist/cli.js

@@ -1,3 +0,0 @@
-import 'dotenv/config';
-import { cli } from './migrate.js';
-cli();