@devmoods/express-extras 0.65.1 → 0.66.1

package/dist/errors.js

@@ -1,24 +1,24 @@
 import { STATUS_CODES } from 'node:http';
 import { DoesNotExistError, IntegrityError } from '@devmoods/postgres';
 import * as Sentry from '@sentry/node';
-import { errors } from 'compose-middleware';
 import {} from 'express';
 import { InvalidToken } from './auth/errors.js';
+import { errors } from './composeMiddleware.js';
 import { getLogger } from './logger.js';
 export class ApiError extends Error {
     status;
     payload;
 }
-export const BadRequest = (reason) => makeError(400, 'Invalid Params', { reason });
-export const Forbidden = (detail = '') => makeError(403, detail);
-export const NotFound = (detail = 'Could not find resource') => makeError(404, detail);
-export const Unauthorized = (detail = 'Unauthorized') => makeError(401, detail);
-export const Conflict = (detail = '') => makeError(409, detail);
+export const BadRequest = (reason, options) => makeError(400, 'Invalid Params', { reason }, options);
+export const Forbidden = (detail = '', options) => makeError(403, detail, {}, options);
+export const NotFound = (detail = 'Could not find resource', options) => makeError(404, detail, {}, options);
+export const Unauthorized = (detail = 'Unauthorized', options) => makeError(401, detail, {}, options);
+export const Conflict = (detail = '', options) => makeError(409, detail, {}, options);
 /**
  * Create a new ApiError instance
  */
-export function makeError(status, detail, payload) {
-    const error = new ApiError(detail || STATUS_CODES[status]);
+export function makeError(status, detail, payload, options) {
+    const error = new ApiError(detail || STATUS_CODES[status], options);
     error.status = status;
     error.payload = payload;
     return error;
@@ -46,13 +46,13 @@ export function mapToProblem(error) {
 }
 function convertToAPIError(error) {
     if (error instanceof IntegrityError) {
-        return Conflict(error.message);
+        return Conflict(error.message, { cause: error });
     }
     if (error instanceof DoesNotExistError) {
-        return NotFound(error.message);
+        return NotFound(error.message, { cause: error });
     }
     if (error instanceof InvalidToken) {
-        return Unauthorized(error.message);
+        return Unauthorized(error.message, { cause: error });
     }
     return error;
 }

package/dist/faktory.d.ts

@@ -1,33 +1,35 @@
 import { create, type WorkerOptions } from 'faktory-worker';
-export interface JobsOptions {
-    queueName: string;
+export interface JobsOptions<QueueName extends string> {
+    queues: QueueName[];
     faktory?: typeof create;
 }
 export type AnyJobContext = Record<string, any>;
-export interface JobOptions {
+export interface JobOptions<QueueName extends string> {
     retry?: number;
     priority?: number;
     at?: Date | string;
+    queue?: QueueName;
 }
-export declare function createJobs<GlobalContext extends AnyJobContext>({ queueName, faktory: createFactory, }: JobsOptions): {
-    job: <Arguments extends Record<string, any>, Fn extends (input: Arguments, ctx: GlobalContext) => undefined | Promise<any>>(optionsOrFn: JobOptions | Fn, fnOrUndefined?: Fn) => {
+type JobFn<Arguments, Context extends AnyJobContext> = (input: Arguments, ctx: Context) => undefined | Promise<any>;
+export declare function createJobs<QueueName extends string, GlobalContext extends AnyJobContext>({ queues, faktory: createFactory }: JobsOptions<QueueName>): {
+    job: <Arguments>(optionsOrFn: JobOptions<QueueName> | JobFn<Arguments, GlobalContext>, fnOrUndefined?: JobFn<Arguments, GlobalContext>) => {
         $job: boolean;
         jobName: string;
-        options: JobOptions;
-        delay(args?: Parameters<Fn>[0]): Promise<`${string}-${string}-${string}-${string}-${string}`>;
-        execute(args: Parameters<Fn>[0], context: GlobalContext): Promise<any>;
+        options: JobOptions<QueueName>;
+        delay(args?: Parameters<JobFn<Arguments, GlobalContext>>[0]): Promise<`${string}-${string}-${string}-${string}-${string}`>;
+        execute(args: Parameters<JobFn<Arguments, GlobalContext>>[0], context: GlobalContext): Promise<any>;
     };
-    queueName: string;
+    queues: QueueName[];
 };
 export type Job = ReturnType<ReturnType<typeof createJobs>['job']>;
 export interface FaktoryWorkerOptions<GlobalContext> {
     jobs: unknown[];
-    queueName: string;
+    queues: string[];
     faktory?: typeof create;
     jobContext?: GlobalContext;
 }
 export { createFaktoryWorker as createJobWorker };
-export declare function createFaktoryWorker<GlobalContext>({ queueName, jobs, faktory: createFactory, jobContext, }: FaktoryWorkerOptions<GlobalContext>): Promise<{
+export declare function createFaktoryWorker<GlobalContext>({ queues, jobs, faktory: createFactory, jobContext, }: FaktoryWorkerOptions<GlobalContext>): Promise<{
     start(workerOptions?: WorkerOptions): Promise<void>;
     stop(): Promise<void>;
 }>;

package/dist/faktory.js

@@ -4,7 +4,7 @@ import { create } from 'faktory-worker';
 import { JOB_ID_CONTEXT_KEY, requestContext, setRequestContext, } from './context.js';
 import { getLogger } from './logger.js';
 const logger = getLogger('faktory');
-export function createJobs({ queueName, faktory: createFactory = create, }) {
+export function createJobs({ queues, faktory: createFactory = create }) {
     const faktory = createFactory();
     function job(optionsOrFn, fnOrUndefined) {
         const fn = typeof optionsOrFn === 'function' ? optionsOrFn : fnOrUndefined;
@@ -26,7 +26,7 @@ export function createJobs({ queueName, faktory: createFactory = create, }) {
                     const client = await faktory.connect();
                     const j = client.job(jobName, args);
                     j.jid = jid;
-                    j.queue = queueName;
+                    j.queue = options.queue || queues[0];
                     Object.assign(j, options);
                     await j.push();
                     await client.close();
@@ -53,10 +53,10 @@ export function createJobs({ queueName, faktory: createFactory = create, }) {
             },
         };
     }
-    return { job, queueName };
+    return { job, queues };
 }
 export { createFaktoryWorker as createJobWorker };
-export async function createFaktoryWorker({ queueName, jobs, faktory: createFactory = create, jobContext, }) {
+export async function createFaktoryWorker({ queues, jobs, faktory: createFactory = create, jobContext, }) {
     const faktory = createFactory();
     const filter = (j) => !!Object.prototype.hasOwnProperty.call(j, '$job');
     const availableJobs = jobs.filter(filter);
@@ -69,7 +69,7 @@ export async function createFaktoryWorker({ queueName, jobs, faktory: createFact
         async start(workerOptions = {}) {
             try {
                 logger.info('faktory started', {
-                    queueName,
+                    queues,
                     availableJobs: availableJobs.map((j) => j.jobName),
                 });
                 faktory.use(async (ctx, next) => {
@@ -91,7 +91,7 @@ export async function createFaktoryWorker({ queueName, jobs, faktory: createFact
                     });
                 });
                 await faktory.work({
-                    queues: [queueName],
+                    queues,
                     ...workerOptions,
                 });
             }

package/dist/listen.d.ts

@@ -1,19 +1,28 @@
 import { type Server } from 'node:http';
 import { type Application } from 'express';
-interface StoppableServer extends Server {
-    inspect(): Record<string, any>;
-    stop(): Promise<boolean>;
-}
-export declare function stoppable(server: Server, grace?: number): StoppableServer;
-interface ExpressServerOptions {
+export declare function stoppable(server: Server, gracePeriodMs?: number): {
+    start: (port?: number) => Promise<void>;
+    stop: () => Promise<boolean>;
+    inspect: () => {
+        sockets: number;
+        requests: number;
+    };
+    readonly port: number;
+};
+export interface ExpressServerOptions {
+    trustProxy?: boolean | number | string;
+    onStart?(): Promise<void> | void;
     onShutdown?(): Promise<void> | void;
     beforeShutdown?(): Promise<void> | void;
     healthCheck?(type?: 'live' | 'ready'): Promise<unknown>;
+    gracePeriodMs?: number;
 }
-interface ExpressServer extends StoppableServer {
+export interface EnhancedApplication extends Application {
     start(): Promise<void>;
+    stop(): Promise<boolean>;
     port: number;
     terminate(): Promise<void>;
+    server: Server;
 }
-export declare function createExpressServer(app: Application, options?: ExpressServerOptions): ExpressServer;
-export {};
+export declare const impress: (options?: ExpressServerOptions) => EnhancedApplication;
+export declare function createExpressServer(app: Application, options?: ExpressServerOptions): EnhancedApplication;

package/dist/listen.js

@@ -4,14 +4,14 @@ import {} from 'node:net';
 import { config } from '@devmoods/config';
 import { delay } from '@devmoods/fetch';
 import { startTimer } from '@devmoods/observability';
-import {} from 'express';
+import express, {} from 'express';
 import { BadRequest } from './errors.js';
 import { getLogger } from './logger.js';
-import { route } from './middleware.js';
+import { before, route } from './middleware.js';
 import { envPort } from './utils.js';
 const logger = getLogger('http');
 const appTimer = startTimer();
-export function stoppable(server, grace = Infinity) {
+export function stoppable(server, gracePeriodMs = Infinity) {
     let stopped = false;
     let gracefully = true;
     const requestsPerSocket = new Map();
@@ -20,9 +20,12 @@ export function stoppable(server, grace = Infinity) {
         socket.once('close', () => requestsPerSocket.delete(socket));
     };
     const onRequest = (req, res) => {
-        requestsPerSocket.set(req.socket, requestsPerSocket.get(req.socket) + 1);
+        requestsPerSocket.set(req.socket, 
+        /* c8 ignore next 1 */
+        (requestsPerSocket.get(req.socket) ?? 0) + 1);
         res.once('finish', () => {
-            const pending = requestsPerSocket.get(req.socket) - 1;
+            /* c8 ignore next 1 */
+            const pending = Math.max(0, (requestsPerSocket.get(req.socket) ?? 0) - 1);
             requestsPerSocket.set(req.socket, pending);
             if (stopped && pending === 0) {
                 req.socket.end();
@@ -33,8 +36,8 @@ export function stoppable(server, grace = Infinity) {
         return new Promise((resolve, reject) => {
             setImmediate(() => {
                 stopped = true;
-                if (grace < Infinity) {
-                    setTimeout(destroyAll, grace).unref();
+                if (gracePeriodMs < Infinity) {
+                    setTimeout(destroyAll, gracePeriodMs).unref();
                 }
                 server.close((e) => {
                     if (e) {
@@ -63,18 +66,49 @@ export function stoppable(server, grace = Infinity) {
     }
     server.on('connection', onConnection);
     server.on('request', onRequest);
-    // @ts-expect-error attach stop
-    server.stop = stop;
-    // @ts-expect-error attach inspect
-    server.inspect = () => {
+    const getPort = () => {
+        const address = server.address();
+        if (address == null) {
+            throw new Error('address is null, server not listening?');
+        }
+        /* c8 ignore next 3 */
+        if (typeof address === 'string') {
+            throw new Error('address was a string, should not happen');
+        }
+        return address.port;
+    };
+    const start = (port = 0) => {
+        return new Promise((resolve) => {
+            server.listen(port, () => {
+                resolve();
+            });
+        });
+    };
+    const inspect = () => {
         return {
             sockets: requestsPerSocket.size,
+            requests: Array.from(requestsPerSocket.values()).reduce((acc, curr) => acc + curr, 0),
         };
     };
-    return server;
+    return {
+        start,
+        stop,
+        inspect,
+        get port() {
+            return getPort();
+        },
+    };
 }
+export const impress = (options = {}) => {
+    return createExpressServer(express(), options);
+};
 export function createExpressServer(app, options = {}) {
-    const server = stoppable(http.createServer(app), config.GRACE_PERIOD_MS);
+    const server = http.createServer(app);
+    const ctl = stoppable(server, options.gracePeriodMs ?? config.GRACE_PERIOD_MS);
+    const trustProxy = options.trustProxy ?? true;
+    if (trustProxy) {
+        app.set('trust proxy', trustProxy);
+    }
     let stopping = false;
     async function onSignal(signal) {
         if (stopping) {
@@ -86,7 +120,7 @@ export function createExpressServer(app, options = {}) {
             logger.info(`app shutting down due to ${signal}`);
             await delay(config.READINESS_PERIOD_MS + 1000);
             await options.beforeShutdown?.();
-            const gracefully = await server.stop();
+            const gracefully = await ctl.stop();
             await options.onShutdown?.();
             logger.info('app shut down', {
                 duration: timer.getDuration(),
@@ -106,7 +140,7 @@ export function createExpressServer(app, options = {}) {
     }
     const healthTypes = ['live', 'ready'];
     if (!app.get('__healthAttached')) {
-        app.get('/health/:type?', route(async (req) => {
+        app.get('/health/:type?', before(), route(async (req) => {
             const timestamp = new Date().toISOString();
             const validateType = (type) => {
                 return healthTypes.includes(type);
@@ -116,7 +150,7 @@ export function createExpressServer(app, options = {}) {
                 throw BadRequest('Invalid health type');
             }
             try {
-                if (stopping) {
+                if (stopping && type === 'ready') {
                     throw new Error('The server is shutting down');
                 }
                 const meta = await options.healthCheck?.(type);
@@ -129,36 +163,29 @@ export function createExpressServer(app, options = {}) {
         }));
         app.set('__healthAttached', true);
     }
-    const expressServer = server;
-    Object.defineProperty(expressServer, 'port', {
+    const enhanced = app;
+    enhanced.server = server;
+    Object.defineProperty(enhanced, 'port', {
         get() {
-            const address = this.address();
-            if (address == null) {
-                throw new Error('address is null, server not listening?');
-            }
-            /* c8 ignore next 3 */
-            if (typeof address === 'string') {
-                throw new Error('address was a string, should not happen');
-            }
-            return address.port;
+            return ctl.port;
         },
         enumerable: true,
         configurable: true,
     });
-    expressServer.start = function start() {
+    enhanced.start = async function start() {
         const port = app.get('port') ?? envPort(0);
-        return new Promise((resolve) => {
-            server.listen(port, () => {
-                logger.info('app listening', {
-                    port: expressServer.port,
-                    duration: appTimer.getDuration(),
-                });
-                resolve();
-            });
+        await options.onStart?.();
+        await ctl.start(port);
+        logger.info('app listening', {
+            port: ctl.port,
+            duration: appTimer.getDuration(),
         });
     };
-    expressServer.terminate = function terminate() {
+    enhanced.stop = () => {
+        return ctl.stop();
+    };
+    enhanced.terminate = function terminate() {
         return onSignal('SIGTERM');
     };
-    return expressServer;
+    return enhanced;
 }

package/dist/logger.d.ts

@@ -1,6 +1,19 @@
+import { type Writable } from 'node:stream';
 export type LoggerContext = Record<string, any>;
-export interface LoggerOutputWriter {
-    write(chunk: any): boolean;
+export interface LoggerAdapter {
+    captureError(error: Error | null, attributes?: Record<string, any>): void;
+    write(chunk: Record<string, any>): boolean;
+}
+export declare class JsonStreamAdapter implements LoggerAdapter {
+    #private;
+    constructor(stream: Writable);
+    captureError(error: Error, attributes?: Record<string, any>): void;
+    write(log: Record<string, any>): boolean;
+}
+export declare class SentryLoggerAdapter implements LoggerAdapter {
+    constructor();
+    captureError(error: Error | null, attributes?: Record<string, any>): void;
+    write(log: Record<string, any>): boolean;
 }
 export interface LoggerOptions {
     /**
@@ -11,13 +24,19 @@ export interface LoggerOptions {
      * Context to attach to each log line
      */
     getContext?: () => LoggerContext;
+    /**
+     * Default log level. Log lines below this level will be ignored.
+     */
     level?: string;
-    output?: LoggerOutputWriter;
+    /**
+     * Adapters to write logs to. By default it logs JSON to stdout.
+     */
+    outputs?: LoggerAdapter[];
 }
 export declare function setGlobalLoggerContext(getContext: () => LoggerContext): void;
 export declare function clearGlobalLoggerContext(): void;
 export type Logger = ReturnType<typeof createLogger>;
-export declare function createLogger({ name, getContext, level, output, }: LoggerOptions): {
+export declare function createLogger({ name, getContext, level, outputs, }: LoggerOptions): {
     debug(message: string, context?: LoggerContext): void;
     info(message: string, context?: LoggerContext): void;
     warn(message: string, context?: LoggerContext): void;

package/dist/logger.js

@@ -1,7 +1,44 @@
 import * as os from 'node:os';
+import {} from 'node:stream';
 import { config } from '@devmoods/config';
 import * as Sentry from '@sentry/node';
-import { useAnonymousSession, useRequestId } from './context.js';
+export class JsonStreamAdapter {
+    #stream;
+    constructor(stream) {
+        this.#stream = stream;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    captureError(error, attributes) { }
+    write(log) {
+        const chunk = `${JSON.stringify(log)}\n`;
+        return this.#stream.write(chunk);
+    }
+}
+export class SentryLoggerAdapter {
+    constructor() { }
+    captureError(error, attributes) {
+        /* c8 ignore start */
+        if (error == null) {
+            return;
+        }
+        if (Sentry.isInitialized()) {
+            Sentry.captureException(error, {
+                tags: attributes,
+            });
+        }
+        /* c8 ignore end */
+    }
+    write(log) {
+        const { message, ...attributes } = log;
+        /* c8 ignore start */
+        if (Sentry.isInitialized()) {
+            const fn = log.level;
+            Sentry.logger[fn](message, attributes);
+        }
+        /* c8 ignore end */
+        return true;
+    }
+}
 const LEVELS = {
     TRACE: 10,
     DEBUG: 20,
@@ -19,62 +56,49 @@ export function setGlobalLoggerContext(getContext) {
 export function clearGlobalLoggerContext() {
     _getGlobalContextFns.length = 0;
 }
-function defaultGetContext() {
-    const nameArgIndex = process.argv.indexOf('--name');
-    const globalContext = _getGlobalContextFns.reduce((acc, fn) => {
-        return Object.assign(acc, fn());
-    }, {});
-    return {
-        app: nameArgIndex > -1 ? process.argv.at(nameArgIndex + 1) : undefined,
-        requestId: useRequestId(),
-        sessionId: useAnonymousSession(),
-        ...globalContext,
+const nameArgIndex = process.argv.indexOf('--name');
+/* c8 ignore next 1 */
+const app = nameArgIndex > -1 ? process.argv.at(nameArgIndex + 1) : undefined;
+const hostname = os.hostname();
+const pid = process.pid;
+const env = process.env.NODE_ENV;
+function baseContext() {
+    const globalContext = {
+        app,
+        hostname,
+        pid,
+        env,
     };
+    for (const fn of _getGlobalContextFns) {
+        Object.assign(globalContext, fn());
+    }
+    return globalContext;
 }
-export function createLogger({ name, getContext, level = config.LOG_LEVEL, output = process.stdout, }) {
+export function createLogger({ name, getContext, level = config.LOG_LEVEL, outputs = [new JsonStreamAdapter(process.stdout), new SentryLoggerAdapter()], }) {
     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 logLevelName = level.toUpperCase();
     const logLevel = logLevelName in LEVELS
         ? LEVELS[logLevelName]
         : LEVELS.INFO;
     function getFinalContext(context) {
-        return {
-            ...defaultGetContext(),
-            ...getContext?.(),
-            ...context,
-        };
+        return Object.assign(baseContext(), getContext?.(), context);
     }
-    const sentryMapping = {
-        [LEVELS.TRACE]: 'trace',
-        [LEVELS.DEBUG]: 'debug',
-        [LEVELS.INFO]: 'info',
-        [LEVELS.WARN]: 'warn',
-        [LEVELS.ERROR]: 'error',
-        [LEVELS.FATAL]: 'fatal',
-    };
     // eslint-disable-next-line @typescript-eslint/no-shadow
     function log(level, message, context) {
+        if (level < logLevel) {
+            return;
+        }
         const attributes = {
             level: LEVELS_TO_NAME[level],
-            env,
-            hostname,
-            pid,
             name,
             ...context,
             time: new Date().toISOString(),
             v: 1,
         };
-        if (level >= logLevel) {
-            output.write(`${JSON.stringify({ message, ...attributes })}\n`);
-            if (Sentry.isInitialized()) {
-                const fn = sentryMapping[level];
-                Sentry.logger[fn](message, attributes);
-            }
+        for (const output of outputs) {
+            output.write({ message, ...attributes });
         }
     }
     const api = {
@@ -89,10 +113,8 @@ export function createLogger({ name, getContext, level = config.LOG_LEVEL, outpu
         },
         error(error, message, context = {}) {
             const finalContext = getFinalContext(context);
-            if (Sentry.isInitialized()) {
-                Sentry.captureException(error, {
-                    tags: finalContext,
-                });
+            for (const output of outputs) {
+                output.captureError(error, finalContext);
             }
             return log(LEVELS.ERROR, message || error?.message || '', {
                 ...finalContext,
@@ -101,10 +123,8 @@ export function createLogger({ name, getContext, level = config.LOG_LEVEL, outpu
         },
         fatal(error, message, context = {}) {
             const finalContext = getFinalContext(context);
-            if (Sentry.isInitialized()) {
-                Sentry.captureException(error, {
-                    tags: finalContext,
-                });
+            for (const output of outputs) {
+                output.captureError(error, finalContext);
             }
             return log(LEVELS.FATAL, message || error?.message || '', {
                 ...finalContext,

package/dist/manage.d.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
-import { type Express } from 'express';
+import { type Application } from 'express';
 import { CLI } from './cli.js';
 export declare function registerManagementCommand(register: (command: Command['command'], cli: CLI) => void, program?: Command): void;
 export declare function runManagementCommands(program?: Command): Promise<void>;
-export declare function registerDefaultCommands(app: Express | null, program?: Command): void;
+export declare function registerDefaultCommands(app: Application | null, program?: Command): void;

package/dist/manage.js

@@ -33,11 +33,13 @@ export function registerDefaultCommands(app, program = defaultProgram) {
             }
             if (options.openapi) {
                 const routes = toOpenAPISpec(app);
+                // eslint-disable-next-line no-console
                 console.log(JSON.stringify(routes, null, 2));
                 return;
             }
             const routes = parseRoutes(app);
             if (options.json) {
+                // eslint-disable-next-line no-console
                 console.log(JSON.stringify(routes, null, 2));
                 return;
             }
@@ -58,6 +60,7 @@ export function registerDefaultCommands(app, program = defaultProgram) {
             .option('--json', 'Output JSON')
             .action(cli.wrap(async (options) => {
             if (options.json) {
+                // eslint-disable-next-line no-console
                 console.log(JSON.stringify(config, null, 2));
                 return;
             }
@@ -76,10 +79,11 @@ export function registerDefaultCommands(app, program = defaultProgram) {
                     path: openApiFile,
                 },
                 output: {
-                    format: false,
+                    format: null,
                     path: options.output,
-                    lint: false,
+                    lint: null,
                     tsConfigPath: resolve('./tsconfig.json'),
+                    importFileExtension: '.js',
                 },
                 plugins: [
                     {
@@ -89,6 +93,7 @@ export function registerDefaultCommands(app, program = defaultProgram) {
                     {
                         asClass: true,
                         classStructure: 'off',
+                        /* c8 ignore next 1 */
                         classNameBuilder: (name) => `${name}Service`,
                         name: '@hey-api/sdk',
                     },
@@ -101,16 +106,11 @@ export function registerDefaultCommands(app, program = defaultProgram) {
             .option('--output <string>', 'Output file path', 'src/types/db.gen.ts')
             .option('--connection <string>', 'Database connection string')
             .action(cli.wrap(async (options) => {
-            try {
-                await generateDatabaseTypes({
-                    outputPath: options.output,
-                    connectionString: options.connection || config.POSTGRES_URL,
-                });
-                cli.writeLine(`✅ Database types generated successfully at: ${options.output}\n`);
-            }
-            catch (error) {
-                cli.writeLine(`❌ Failed to generate database types: ${error}\n`);
-            }
+            await generateDatabaseTypes({
+                outputPath: options.output,
+                connectionString: options.connection || config.POSTGRES_URL,
+            });
+            cli.writeLine(`Database types generated successfully at: ${options.output}\n`);
         }));
     }, program);
 }

package/dist/middleware.d.ts

@@ -1,7 +1,7 @@
 import { type ServerResponse, type IncomingMessage } from 'node:http';
-import { compose } from 'compose-middleware';
 import { type NextFunction, type RequestHandler, type Request, type Response, json as jsonParser, urlencoded as urlencodedParser } from 'express';
 import { type createAuth } from './auth.js';
+import { compose } from './composeMiddleware.js';
 import { type CsrfMiddlewareOptions } from './csrf.js';
 export { urlencodedParser, jsonParser };
 export { asyncMiddleware as route };
@@ -50,10 +50,12 @@ export interface BeforeMiddlewareOptions {
     auth?: ReturnType<typeof createAuth>;
 }
 export declare function useCspNonce(): string;
+export interface BeforeMiddleware extends RequestHandler {
+}
 /**
  * Register middleware that must come before the app routes.
  */
-export declare function before({ cookies, helmet: useHelmet, json: useJson, csrf: useCsrf, urlencoded: useUrlencoded, allowUnsafeInlineScripts, cspDirectives, auth, }?: BeforeMiddlewareOptions): import("compose-middleware").RequestHandler<any, any, void>;
+export declare function before({ cookies, helmet: useHelmet, json: useJson, csrf: useCsrf, urlencoded: useUrlencoded, allowUnsafeInlineScripts, cspDirectives, auth, }?: BeforeMiddlewareOptions): BeforeMiddleware;
 /**
  * Middleware that sends a 404
  *