@devmoods/express-extras 0.26.2 → 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/__tests__/__migrations__/1_a.js

@@ -1,3 +1,4 @@
+import {} from '../../postgres.js';
 export async function up(query) {
     await query('CREATE TABLE baz (id serial primary key)');
     await query('CREATE TABLE foo (id serial primary key)');

package/dist/auth.d.ts

@@ -7,7 +7,7 @@ export declare function createAuthToken(payload: any, secret?: string): string;
 /**
  * Decode the given JWT token.
  */
-export declare function decodeAuthToken(token: string): {
+export declare function decodeAuthToken(token: string, secret?: string): {
     [x: string]: any;
     iss?: string | undefined;
     sub?: string | undefined;

package/dist/auth.js

@@ -29,9 +29,10 @@ export function createAuthToken(payload, secret = AUTH_SECRET) {
 /**
  * Decode the given JWT token.
  */
-export function decodeAuthToken(token) {
+export function decodeAuthToken(token, secret = AUTH_SECRET) {
     try {
-        const decoded = jwt.verify(token.trim(), AUTH_SECRET);
+        const decoded = jwt.verify(token.trim(), secret);
+        /* c8 ignore next 3 */
         if (typeof decoded === 'string') {
             throw new Error('decoded value not an object');
         }
@@ -141,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 = {
@@ -271,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,17 +1,24 @@
-export function createRedisCacheAdapter(redis) {
+import {} from './redis.js';
+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/context.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
+import {} from 'express';
 import { v4 as uuid } from 'uuid';
 const requestContext = new AsyncLocalStorage();
 const REQUEST_ID = 'requestId';

package/dist/email.d.ts

@@ -13,4 +13,5 @@ export interface SendEmailOptions extends nodemailer.SendMailOptions {
 export declare function createEmail({ host, port, user, pass, senderName, senderAddress, }: EmailOptions): {
     send: ({ to, subject, message, ...rest }: SendEmailOptions) => Promise<void>;
     transporter: nodemailer.Transporter<import("nodemailer/lib/smtp-transport/index.js").SentMessageInfo>;
+    readonly outbox: Record<string, any>[];
 };

package/dist/email.js

@@ -1,5 +1,6 @@
 import * as nodemailer from 'nodemailer';
 import { getLogger } from './logger.js';
+const logger = getLogger('email');
 export function createEmail({ host, port, user, pass, senderName, senderAddress, }) {
     const transporter = nodemailer.createTransport({
         host,
@@ -7,15 +8,27 @@ export function createEmail({ host, port, user, pass, senderName, senderAddress,
         secure: false,
         auth: { user, pass },
     });
+    const outbox = [];
     const send = async ({ to, subject, message, ...rest }) => {
-        const result = await transporter.sendMail({
+        const payload = {
             from: `${senderName} <${senderAddress}>`,
             to,
             subject,
             text: message,
             ...rest,
-        });
-        getLogger('email').info('email-sent', { email: result });
+        };
+        const result = await transporter.sendMail(payload);
+        outbox.push(payload);
+        if (outbox.length > 5) {
+            outbox.shift();
+        }
+        logger.info('email-sent', { email: result });
+    };
+    return {
+        send,
+        transporter,
+        get outbox() {
+            return outbox;
+        },
     };
-    return { send, transporter };
 }

package/dist/errors.js

@@ -1,6 +1,6 @@
-import { STATUS_CODES } from 'node:http';
 import * as Sentry from '@sentry/node';
 import { errors } from 'compose-middleware';
+import { STATUS_CODES } from 'node:http';
 import { DoesNotExistError, IntegrityError } from './postgres.js';
 export class ApiError extends Error {
 }
@@ -20,14 +20,15 @@ export function makeError(status, detail, payload) {
 }
 export function mapToProblem(error) {
     if (error instanceof ApiError) {
-        const statusMessage = STATUS_CODES[error.status || '500'];
+        const status = error.status || 500;
+        const statusMessage = STATUS_CODES[status];
         return {
             type: `/api/problems/${statusMessage
                 .toLocaleLowerCase()
                 .replace(/ /g, '-')}`,
             title: statusMessage,
-            detail: error.message,
-            status: error.status,
+            detail: error.message || '',
+            status,
             ...error.payload,
         };
     }
@@ -35,6 +36,7 @@ export function mapToProblem(error) {
         type: 'internal-error',
         title: 'Internal Server Error',
         status: 500,
+        detail: '',
     };
 }
 function convertToAPIError(error) {
@@ -48,9 +50,6 @@ function convertToAPIError(error) {
 }
 function _errorHandler({ onError }) {
     return (err, req, res, next) => {
-        if (!err) {
-            err = makeError(500);
-        }
         onError?.(err);
         const apiError = convertToAPIError(err);
         const problem = mapToProblem(apiError);

package/dist/faktory.d.ts

@@ -1,12 +1,14 @@
+import { create } from 'faktory-worker';
 export interface JobsOptions {
     queueName: string;
+    faktory?: typeof create;
 }
-export declare function createJobs({ queueName }: JobsOptions): {
+export declare function createJobs({ queueName, faktory: createFactory, }: JobsOptions): {
     job: <K extends Record<string, any>, T extends (input: K) => void | Promise<any>>(fn: T) => {
         $job: boolean;
         jobName: string;
         readonly executionCount: number;
-        delay(args?: Parameters<T>[0] | undefined): Promise<void>;
+        delay(args?: Parameters<T>[0] | undefined): Promise<`${string}-${string}-${string}-${string}-${string}`>;
         execute(args: Parameters<T>[0]): Promise<any>;
     };
     queueName: string;
@@ -15,8 +17,10 @@ export type Job = ReturnType<ReturnType<typeof createJobs>['job']>;
 export interface FaktoryWorkerOptions {
     jobs: unknown[];
     queueName: string;
+    faktory?: typeof create;
 }
 export declare function useJobId(): string | undefined;
-export declare function createFaktoryWorker({ queueName, jobs, }: FaktoryWorkerOptions): Promise<{
+export declare function createFaktoryWorker({ queueName, jobs, faktory: createFactory, }: FaktoryWorkerOptions): Promise<{
     start(): Promise<void>;
+    stop(): Promise<void>;
 }>;

package/dist/faktory.js

@@ -5,12 +5,12 @@ import { getLogger } from './logger.js';
 import { startTimer } from './utils.js';
 const logger = getLogger('faktory');
 const JOB_ID = 'jobId';
-export function createJobs({ queueName }) {
-    const faktory = create();
+export function createJobs({ queueName, faktory: createFactory = create, }) {
+    const faktory = createFactory();
     function job(fn) {
         const jobName = fn.name;
         let executionCount = 0;
-        if (jobName == null) {
+        if (!jobName) {
             throw new Error('Can not create job without a name');
         }
         return {
@@ -35,7 +35,9 @@ export function createJobs({ queueName }) {
                         jobName,
                         args: JSON.stringify(args),
                     });
+                    throw error;
                 }
+                return jid;
             },
             async execute(args) {
                 try {
@@ -59,8 +61,8 @@ export function useJobId() {
         return store.get(JOB_ID);
     }
 }
-export async function createFaktoryWorker({ queueName, jobs, }) {
-    const faktory = create();
+export async function createFaktoryWorker({ queueName, jobs, faktory: createFactory = create, }) {
+    const faktory = createFactory();
     const filter = (j) => !!Object.prototype.hasOwnProperty.call(j, '$job');
     const availableJobs = jobs.filter(filter);
     for (const job of availableJobs) {
@@ -99,5 +101,8 @@ export async function createFaktoryWorker({ queueName, jobs, }) {
                 process.exit(1);
             }
         },
+        async stop() {
+            return faktory.stop();
+        },
     };
 }

package/dist/listen.d.ts

@@ -1,13 +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 properly.
- *
- * Kubernetes friendly.
- */
-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,56 +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 properly.
- *
- * Kubernetes friendly.
- */
-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

@@ -1,4 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
+import type { Duplex } from 'node:stream';
 import type { CreateSentry } from './sentry.js';
 export type LoggerContext = Record<string, any>;
 export interface LoggerOptions {
@@ -10,16 +11,13 @@ export interface LoggerOptions {
      * Context to attach to each log line
      */
     getContext?: () => LoggerContext;
-    /**
-     * Defaults to `process.env.NODE_ENV === 'test'`
-     */
-    silent?: () => boolean;
-    output?: NodeJS.WriteStream;
+    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 = () => process.env.NODE_ENV === 'test', 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.d.ts

@@ -10,6 +10,7 @@ interface MigrationFileAPI {
     down(fn: any): Promise<string> | Promise<void> | string | void;
 }
 export declare function cli(): Promise<void>;
+export declare function runCli(input: string[], flags: Record<string, any>, showHelp?: () => void): Promise<number>;
 export interface MigratorOptions {
     postgres?: ReturnType<typeof createPostgres>;
     migrationTableName?: string;

package/dist/migrate.js

@@ -14,8 +14,31 @@ Usage
         description: 'PostgreSQL migration tool',
         importMeta: import.meta,
     });
-    const verbose = !cli.flags.silent;
-    const args = cli.input.slice();
+    let exitCode = 0;
+    try {
+        exitCode = await runCli(cli.input, cli.flags, 
+        /* c8 ignore next 2 */
+        () => cli.showHelp());
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            exitCode = error.code;
+        }
+    }
+    finally {
+        process.exit(exitCode);
+    }
+}
+class CliError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.code = code;
+    }
+}
+export async function runCli(input, flags, showHelp) {
+    const verbose = !flags.silent;
+    const args = input.slice();
     const action = args.shift();
     function isValidAction(action) {
         return action != null && ['init', 'up', 'down', 'create'].includes(action);
@@ -24,8 +47,8 @@ Usage
     async function run(action, ...args) {
         try {
             if (!isValidAction(action)) {
-                cli.showHelp();
-                return;
+                showHelp?.();
+                throw new CliError(`Invalid action ${action}`, 2);
             }
             switch (action) {
                 case 'up':
@@ -43,20 +66,19 @@ Usage
                     break;
                 }
                 case 'create': {
-                    const createdMigration = await migrator.create(args[0], cli.flags.typescript ? 'ts' : 'sql');
+                    const createdMigration = await migrator.create(args[0], flags.typescript ? 'ts' : 'sql');
                     migrator.log(chalk.green('Created migration', createdMigration));
                     break;
                 }
             }
+            return 0;
         }
         catch (error) {
             console.error(chalk.red(error.message));
-        }
-        finally {
-            process.exit(0);
+            throw new CliError(error.message, 1);
         }
     }
-    run(action, ...args);
+    return run(action, ...args);
 }
 export class Migrator {
     constructor({ postgres = createPostgres(), pathToMigrations = path.resolve(process.cwd(), 'db', 'migrations'), migrationTableName = 'migrations', verbose = true, } = {}) {
@@ -136,9 +158,6 @@ export class Migrator {
             for (const migration of pendingMigrations) {
                 this.log('Running migration', migration.filename);
                 const migrator = await this.readMigrationFile(migration.filename);
-                if (!migrator.up || !migrator.down) {
-                    throw new Error('Migrations must export both an up() and a down() function.');
-                }
                 if (migrator.useTransaction !== false) {
                     await this.postgres.transaction(async (tx) => {
                         await this.migrate(tx, migrator, direction);
@@ -166,9 +185,6 @@ export class Migrator {
             }
             this.log('Rolling back migration', migrationToRollback.filename);
             const migrator = await this.readMigrationFile(migrationToRollback.filename);
-            if (!migrator.up || !migrator.down) {
-                throw new Error('Migrations must export both an up() and a down() function.');
-            }
             if (migrator.useTransaction !== false) {
                 await this.postgres.transaction(async (tx) => {
                     await this.migrate(tx, migrator, 'down');
@@ -182,6 +198,7 @@ export class Migrator {
                 });
             }
             return await this.getCurrentVersion();
+            /* c8 ignore next 2 */
         }
         throw new Error(`Invalid direction ${direction}`);
     }
@@ -216,6 +233,7 @@ export class Migrator {
             else {
                 await returnValue;
             }
+            /* c8 ignore next 3 */
         }
         catch (error) {
             throw new Error(`Migration failed: ${error.message}`);
@@ -230,7 +248,7 @@ export class Migrator {
     }
     async getMigrations() {
         const files = await fs.readdir(this.pathToMigrations);
-        return (files || [])
+        return files
             .map((filename) => filename.match(this.filenameRegExp))
             .filter(notNullOrUndefined)
             .map(([filename, version, name]) => ({

package/dist/postgres.js

@@ -1,4 +1,4 @@
-import pg from 'pg';
+import pg, {} from 'pg';
 import { SQL } from 'sql-template-strings';
 import { readEnv } from './utils.js';
 export class DoesNotExistError extends Error {
@@ -38,6 +38,7 @@ export class Connection {
         const result = await this.client.query(text, values);
         if (result.rows) {
             return result.rows;
+            /* c8 ignore next 2*/
         }
         return [];
     }
@@ -68,9 +69,11 @@ export class Transaction extends Connection {
  *
  * @param config
  */
-export function createPostgres({ onError = () => { }, url = readEnv('POSTGRES_URL'), ...config } = {}) {
+export function createPostgres({ onError, url = readEnv('POSTGRES_URL'), ...config } = {}) {
     const pool = new pg.Pool({ connectionString: url, ...config });
-    pool.on('error', onError);
+    if (onError) {
+        pool.on('error', onError);
+    }
     async function withConnection(callback) {
         const client = await pool.connect();
         try {
@@ -106,6 +109,7 @@ export function createPostgres({ onError = () => { }, url = readEnv('POSTGRES_UR
         catch (error) {
             await client.query('ROLLBACK');
             throw error;
+            /* c8 ignore next 3 */
         }
         finally {
             client.release();

package/dist/redis.d.ts

@@ -1,7 +1,7 @@
 import { createClient } from 'redis';
 export interface RedisOptions {
     url?: string;
-    onError: (error: Error) => void;
+    onError?: (error: Error) => void;
 }
 export type RedisClient = ReturnType<typeof createClient>;
-export declare function createRedis({ url, onError, }: RedisOptions): RedisClient;
+export declare function createRedis({ url, onError, }?: RedisOptions): RedisClient;

package/dist/redis.js

@@ -1,7 +1,9 @@
 import { createClient } from 'redis';
 import { readEnv } from './utils.js';
-export function createRedis({ url = readEnv('REDIS_URL', ''), onError, }) {
+export function createRedis({ url = readEnv('REDIS_URL', ''), onError, } = {}) {
     const client = createClient({ url });
-    client.on('error', onError);
+    if (onError) {
+        client.on('error', onError);
+    }
     return client;
 }

package/dist/sentry.js

@@ -1,4 +1,5 @@
 import * as Sentry from '@sentry/node';
+import {} from 'express';
 import { attachSentryClientToLoggers } from './logger.js';
 import { readEnv } from './utils.js';
 /**

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/dist/validate.js

@@ -1,4 +1,5 @@
-import _Ajv from 'ajv';
+import _Ajv, {} from 'ajv';
+import {} from 'express';
 import { BadRequest } from './errors.js';
 const Ajv = _Ajv;
 export function validateBody(schema) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.26.2",
+  "version": "0.28.0",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -24,16 +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",
+    "@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",
@@ -41,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",
@@ -71,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"
   },
@@ -103,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();