@devmoods/express-extras 0.65.0 → 0.66.0

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
  *

package/dist/middleware.js

@@ -2,11 +2,11 @@ import * as crypto from 'node:crypto';
 import {} from 'node:http';
 import { config } from '@devmoods/config';
 import { startTimer } from '@devmoods/observability';
-import { compose } from 'compose-middleware';
 import cookieParser from 'cookie-parser';
 import { json as jsonParser, urlencoded as urlencodedParser, } from 'express';
 import helmet from 'helmet';
 import {} from './auth.js';
+import { compose } from './composeMiddleware.js';
 import { ANONYMOUS_SESSION_KEY, setRequestContext, useRequestContext, withRequestContext, } from './context.js';
 import { csrf, doubleCsrfProtection, } from './csrf.js';
 import { NotFound } from './errors.js';
@@ -17,6 +17,7 @@ export { asyncMiddleware as route };
 export { compose as composeMiddleware };
 const CSP_NONCE_KEY = 'csp-nonce';
 export function useCspNonce() {
+    /* c8 ignore next 1 */
     return useRequestContext(CSP_NONCE_KEY) ?? '__CSP_NOT_SET__';
 }
 /**
@@ -32,7 +33,7 @@ export function before({ cookies = true, helmet: useHelmet = true, json: useJson
             : useCsrf
                 ? csrf()
                 : undefined,
-        auth && auth.before(),
+        auth && auth.middleware(false),
         logRequestDuration(),
         setCspNonce(),
         useHelmet &&
@@ -96,6 +97,7 @@ function logRequestDuration() {
             path: req.path,
             query: req.query,
             ip: req.ip,
+            /* c8 ignore next 5 */
             userAgent: req.headers['user-agent'] ?? 'unknown',
             accept: req.headers['accept'] ?? 'unknown',
             host: req.headers['host'] ?? 'unknown',
@@ -204,6 +206,11 @@ export function asyncMiddleware(fn) {
                 res.status(result).end();
             }
             else if (typeof result !== 'undefined') {
+                // @ts-expect-error custom value
+                const successStatus = req.__successStatus;
+                if (successStatus != null) {
+                    res.status(successStatus);
+                }
                 res.send(result);
             }
         })
@@ -221,10 +228,10 @@ export function withTransaction(wrapper) {
                     res.on('error', reject);
                     next();
                 });
+                /* c8 ignore next 5 */
             });
         }
         catch (error) {
-            /* c8 ignore next 2 */
             next(error);
         }
     };

package/dist/rate-limit.d.ts

@@ -1,5 +1,15 @@
 import { type RequestHandler, type Request } from 'express';
 import { type RedisClient } from './redis.js';
+export interface RateLimitMiddleware extends RequestHandler {
+    /**
+     * Clear the rate limit for a specific key
+     */
+    clear: (key: string) => Promise<void>;
+    /**
+     * Clear all rate limits
+     */
+    clearAll: () => Promise<number>;
+}
 export interface RateLimitOptions {
     /**
      * Maximum number of requests allowed within the window
@@ -17,7 +27,7 @@ export interface RateLimitOptions {
      */
     getKey?: (req: Request) => string;
 }
-export declare function rateLimit(redis: RedisClient, { max, windowSizeInSeconds, getKey, }?: RateLimitOptions): RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> & {
-    clear: (key: string) => Promise<void>;
-    clearAll: () => Promise<number>;
-};
+/**
+ * Returns a middleware for rate limiting requests.
+ */
+export declare function rateLimit(redis: RedisClient, { max, windowSizeInSeconds, getKey, }?: RateLimitOptions): RateLimitMiddleware;

package/dist/rate-limit.js

@@ -2,9 +2,14 @@ import { config } from '@devmoods/config';
 import {} from 'express';
 import { makeError } from './errors.js';
 import {} from './redis.js';
-export function rateLimit(redis, { max = 100, windowSizeInSeconds = 60, getKey = (req) => req.ip || 'unknown', } = {}) {
+/**
+ * Returns a middleware for rate limiting requests.
+ */
+export function rateLimit(redis, { max = 100, windowSizeInSeconds = 60, 
+/* c8 ignore next 1 */
+getKey = (req) => req.ip || 'unknown', } = {}) {
     const keyPrefix = `${config.REDIS_KEY_PREFIX}rate-limit:`;
-    const handler = async (req, res, next) => {
+    const middleware = async (req, res, next) => {
         try {
             const key = `${keyPrefix}${getKey(req)}`;
             // Use Redis to track requests
@@ -51,7 +56,7 @@ export function rateLimit(redis, { max = 100, windowSizeInSeconds = 60, getKey =
         } while (cursor !== '0');
         return deletedCount;
     };
-    handler.clear = clear;
-    handler.clearAll = clearAll;
-    return handler;
+    middleware.clear = clear;
+    middleware.clearAll = clearAll;
+    return middleware;
 }

package/dist/redis.d.ts

@@ -5,6 +5,3 @@ 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, timeout?: number): Promise<string>;

package/dist/redis.js

@@ -1,6 +1,5 @@
 import { config } from '@devmoods/config';
 import { createClient } from 'redis';
-import { withTimeout } from './utils.js';
 export function createRedis({ url = config.REDIS_URL, onError, } = {}) {
     const client = createClient({ url });
     // Always attach a listener even if
@@ -10,25 +9,3 @@ export function createRedis({ url = config.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, timeout = 1000) {
-    return withTimeout(redis.ping(), timeout);
-}

package/dist/router.js

@@ -22,7 +22,7 @@ export class TypedRouter {
             body: validation.request,
             query: validation.query,
             response: validation.response,
-        }), ...middleware, asyncMiddleware(handler));
+        }, { successStatus: validation.successStatus }), ...middleware, asyncMiddleware(handler));
         return this;
     }
     use(...middleware) {

package/dist/routes.d.ts

@@ -1,6 +1,6 @@
-import { type Express, type RequestHandler } from 'express';
-export declare function createDocsRouter(app: Express, extras?: Record<string, any>): RequestHandler;
-export declare function parseRoutes(app: Express): {
+import { type Application, type RequestHandler } from 'express';
+export declare function createDocsRouter(app: Application, extras?: Record<string, any>): RequestHandler;
+export declare function parseRoutes(app: Application): {
     method: string;
     path: string;
     params: {
@@ -15,6 +15,7 @@ export declare function parseRoutes(app: Express): {
     query: {} | null;
     body: {} | null;
     response: {} | null;
+    successStatus: {} | null;
 }[];
 export interface Key {
     name: string;
@@ -23,7 +24,7 @@ export interface Key {
 }
 export declare function extractTagsFromPath(path: string): string[];
 export declare function convertPathToOperationId(method: string, path: string): string;
-export declare function toOpenAPISpec(app: Express, info?: {
+export declare function toOpenAPISpec(app: Application, info?: {
     title: string;
     version: string;
     description?: string;

package/dist/routes.js

@@ -28,6 +28,9 @@ export function parseRoutes(app) {
             response: metadata
                 ?.filter((m) => typeof m === 'object' && m != null && 'responseSchema' in m)
                 .at(-1)?.responseSchema ?? null,
+            successStatus: metadata
+                ?.filter((m) => typeof m === 'object' && m != null && 'successStatus' in m)
+                .at(-1)?.successStatus ?? null,
         };
     });
 }
@@ -35,6 +38,7 @@ const buildPathParamsSchema = (pathParams) => {
     const required = [];
     const params = [];
     for (const param of pathParams) {
+        /* c8 ignore next 3 */
         if (param.in !== 'path') {
             continue;
         }
@@ -54,12 +58,12 @@ const buildPathParamsSchema = (pathParams) => {
 };
 // Fork of express-route-parser
 class ExpressPathParser {
-    _appPaths;
+    #appPaths;
     getPaths() {
-        return this._appPaths;
+        return this.#appPaths;
     }
     constructor(app) {
-        this._appPaths = [];
+        this.#appPaths = [];
         const router = app._router;
         if (router) {
             for (const layer of router.stack) {
@@ -77,7 +81,7 @@ class ExpressPathParser {
         if (!layer.route || !layer.route.stack.length) {
             return;
         }
-        this._appPaths.push(this.parseRouteLayer(layer, keys, path));
+        this.#appPaths.push(this.parseRouteLayer(layer, keys, path));
     };
     parseRouteLayer = (layer, keys, basePath) => {
         const lastRequestHandler = layer.route.stack[layer.route.stack.length - 1];
@@ -98,19 +102,18 @@ class ExpressPathParser {
     };
 }
 const pathRegexParser = (layerRegexPath, keys) => {
+    /* c8 ignore next 3 */
     if (typeof layerRegexPath === 'string') {
         return layerRegexPath;
     }
     if (layerRegexPath.fast_slash) {
         return '';
     }
+    /* c8 ignore next 3 */
     if (layerRegexPath.fast_star) {
         return '*';
     }
-    let mappedPath = '';
-    if (keys && keys.length) {
-        mappedPath = mapKeysToPath(layerRegexPath, keys);
-    }
+    const mappedPath = mapKeysToPath(layerRegexPath, keys);
     const match = layerRegexPath
         .toString()
         .replace('\\/?', '')
@@ -121,12 +124,13 @@ const pathRegexParser = (layerRegexPath, keys) => {
     }
     if (mappedPath) {
         return mappedPath.slice(1);
+        /* c8 ignore next 3 */
     }
     return layerRegexPath.toString();
 };
 const mapKeysToPath = (layerRegexPath, keys) => {
     if (!keys || keys.length === 0) {
-        throw Error('must include atleast one key to map');
+        return '';
     }
     let convertedSubPath = layerRegexPath.toString();
     for (const key of keys) {
@@ -183,7 +187,7 @@ export function toOpenAPISpec(app, info = {
     const paths = {};
     const allTags = new Set();
     for (const routeInfo of routes) {
-        const { method, path, params, query, body, response } = routeInfo;
+        const { method, path, params, query, body, response, successStatus } = routeInfo;
         if (!path.startsWith('/api/')) {
             continue;
         }
@@ -202,6 +206,7 @@ export function toOpenAPISpec(app, info = {
             parameters.push(...Object.keys(params.properties).map((name) => ({
                 name,
                 in: 'path',
+                /* c8 ignore next 1 */
                 required: params.required?.includes(name) ?? true,
                 schema: params.properties[name],
             })));
@@ -209,12 +214,14 @@ export function toOpenAPISpec(app, info = {
         // Add query parameters
         if (query && typeof query === 'object' && 'properties' in query) {
             const querySchema = query;
-            parameters.push(...Object.keys(querySchema.properties || {}).map((name) => ({
+            /* c8 ignore next 1 */
+            const properties = querySchema.properties || {};
+            parameters.push(...Object.keys(properties).map((name) => ({
                 name,
                 in: 'query',
                 required: Array.isArray(querySchema.required) &&
                     querySchema.required.includes(name),
-                schema: (querySchema.properties || {})[name],
+                schema: properties[name],
             })));
         }
         paths[openApiPath][method.toLowerCase()] = {
@@ -231,22 +238,26 @@ export function toOpenAPISpec(app, info = {
                 },
             }),
             responses: {
-                ...(response
-                    ? {
-                        '200': {
-                            description: 'Successful response',
-                            content: {
-                                'application/json': {
-                                    schema: response,
+                ...(() => {
+                    const code = String(successStatus ?? 200);
+                    if (response) {
+                        return {
+                            [code]: {
+                                description: 'Successful response',
+                                content: {
+                                    'application/json': {
+                                        schema: response,
+                                    },
                                 },
                             },
-                        },
+                        };
                     }
-                    : {
-                        '200': {
+                    return {
+                        [code]: {
                             description: 'Successful response',
                         },
-                    }),
+                    };
+                })(),
                 '400': {
                     description: 'Bad Request',
                     content: {

package/dist/sentry.js

@@ -4,11 +4,13 @@ import { nodeProfilingIntegration } from '@sentry/profiling-node';
 export function sentryOptions(options = {}) {
     return {
         dsn: config.SENTRY_DSN,
-        tracesSampleRate: 1.0,
-        profilesSampleRate: 1.0,
+        tracesSampleRate: config.SENTRY_TRACES_SAMPLE_RATE,
+        profilesSampleRate: config.SENTRY_PROFILES_SAMPLE_RATE,
         integrations: [
             nodeProfilingIntegration(),
-            eventLoopBlockIntegration({ threshold: 300 }),
+            eventLoopBlockIntegration({
+                threshold: config.SENTRY_EVENT_LOOP_THRESHOLD,
+            }),
         ],
         enableLogs: true,
         ...options,

package/dist/streams.d.ts

@@ -0,0 +1,7 @@
+import { type Writable } from 'node:stream';
+export interface ClientState {
+    draining: boolean;
+    queue: string[];
+    maxQueue: number;
+}
+export declare function writeChunk(writable: Writable, chunk: string, state: ClientState): void;

package/dist/streams.js

@@ -0,0 +1,29 @@
+import {} from 'node:stream';
+export function writeChunk(writable, 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 (writable.write(chunk)) {
+        return;
+    }
+    // Buffer is full — start draining
+    state.draining = true;
+    const flush = () => {
+        while (state.queue.length) {
+            const next = state.queue.shift();
+            if (!writable.write(next)) {
+                state.draining = true;
+                writable.once('drain', flush);
+                return;
+            }
+        }
+        state.draining = false;
+    };
+    writable.once('drain', flush);
+}

package/dist/utils.d.ts

@@ -1,4 +1,3 @@
-import { type EventEmitter } from 'node:events';
 import { withTimeout, TimeoutError, delay } from '@devmoods/fetch';
 export { withTimeout, TimeoutError, delay };
 export declare function readEnv(key: string): string | undefined;
@@ -10,4 +9,3 @@ 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>;

package/dist/utils.js

@@ -1,4 +1,3 @@
-import {} from 'node:events';
 import { withTimeout, TimeoutError, delay } from '@devmoods/fetch';
 export { withTimeout, TimeoutError, delay };
 export function readEnv(key, defaultValue) {
@@ -15,10 +14,3 @@ 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.d.ts

@@ -1,5 +1,5 @@
 import { type StandardSchemaV1 } from '@standard-schema/spec';
-import { type NextFunction, type RequestHandler, type Request, type Response } from 'express';
+import { type RequestHandler } from 'express';
 export type ValidationSchema = {
     type?: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'null';
     format?: string;
@@ -39,29 +39,50 @@ export type ValidationResult = {
     isValid: false;
     errors: ValidationErrors;
 };
-export interface ValidationSpec<RequestBodySchema extends StandardSchemaV1<any> | undefined = undefined, ResponseBodySchema extends StandardSchemaV1<any> | undefined = undefined, RequestQuerySchema extends StandardSchemaV1<any> | undefined = undefined, RequestParamsSchema extends StandardSchemaV1<any> | undefined = undefined> {
+export interface ValidationSpec<RequestBodySchema extends StandardSchemaV1 | undefined = undefined, ResponseBodySchema extends StandardSchemaV1 | undefined = undefined, RequestQuerySchema extends StandardSchemaV1 | undefined = undefined, RequestParamsSchema extends StandardSchemaV1 | undefined = undefined> {
+    /**
+     * Standard schema describing the HTTP request body.
+     */
     request?: RequestBodySchema;
+    /**
+     * Standard schema describing the return HTTP response body.
+     */
     response?: ResponseBodySchema;
+    /**
+     * Schema describing the shape of the `query` parameters.
+     * All values should be strings.
+     */
     query?: RequestQuerySchema;
+    /**
+     * Schema describing the shape of the `params` parameters.
+     */
     params?: RequestParamsSchema;
+    /**
+     * Expected success HTTP status code for this route (e.g., 200, 201, 204).
+     * Used by documentation generators to infer correct response code.
+     */
+    successStatus?: number;
 }
-export declare function validateSchema(data: unknown, schema: StandardSchemaV1<any>): Promise<ValidationResult>;
-export declare function validateStandardSchema(schemas: {
-    query?: StandardSchemaV1<any>;
-    body?: StandardSchemaV1<any>;
-    params?: StandardSchemaV1<any>;
-    response?: StandardSchemaV1<any>;
-}): {
-    (req: Request, res: Response, next: NextFunction): Promise<void>;
+export declare function validateSchema(data: unknown, schema: StandardSchemaV1): Promise<ValidationResult>;
+export interface ValidateStandardSchemaMiddleware extends RequestHandler {
     metadata: {
         bodySchema?: ValidationSchema;
         querySchema?: ValidationSchema;
         paramsSchema?: ValidationSchema;
         responseSchema?: ValidationSchema;
+        successStatus?: number;
     };
-};
+}
+export declare function validateStandardSchema(schemas: {
+    query?: StandardSchemaV1;
+    body?: StandardSchemaV1;
+    params?: StandardSchemaV1;
+    response?: StandardSchemaV1;
+}, extraMetadata?: {
+    successStatus?: number;
+}): ValidateStandardSchemaMiddleware;
 type WithJsonSchema<T> = T & {
     toJsonSchema: () => ValidationSchema;
 };
-export declare function jsonSchema(schema: ValidationSchema): WithJsonSchema<StandardSchemaV1<Record<string, any>>>;
+export declare function jsonSchema<Input>(schema: ValidationSchema): WithJsonSchema<StandardSchemaV1<Input>>;
 export {};

package/dist/validate.js

@@ -47,9 +47,13 @@ export async function validateSchema(data, schema) {
     }
     return { isValid: true, errors: null };
 }
-export function validateStandardSchema(schemas) {
+export function validateStandardSchema(schemas, extraMetadata) {
     const middleware = async (req, res, next) => {
         try {
+            if (extraMetadata?.successStatus != null) {
+                // @ts-expect-error custom value
+                req.__successStatus = extraMetadata.successStatus;
+            }
             for (const [key, schema] of Object.entries(schemas)) {
                 if (key === 'response') {
                     continue;
@@ -81,6 +85,7 @@ export function validateStandardSchema(schemas) {
     if (schemas.response) {
         metadata.responseSchema = toJsonSchema(schemas.response);
     }
+    Object.assign(metadata, extraMetadata);
     middleware.metadata = metadata;
     Object.defineProperty(middleware, 'name', {
         value: validateStandardSchema.name,

package/dist/vite/defineViteConfig.js

@@ -82,6 +82,7 @@ export function defineViteConfig({ base = '', reactCompiler = false, ssr = false
             globalSetup,
             include: ['src/**/*.{test,spec}.?(c|m)[jt]s?(x)'],
             globals: true,
+            restoreMocks: true,
         },
     });
 }

package/dist/vite/ssr.d.ts

@@ -1,7 +1,26 @@
+import { type RequestHandler } from 'express';
 export interface SsrMiddlewareOptions<InitialData = unknown> {
+    /**
+     * Root directory where Vite will look up files.
+     */
     root?: string;
+    /**
+     * Function to get the server side data for the request.
+     */
     getInitialData?: (req: Request) => Promise<InitialData>;
+    /**
+     * Whether or not to use the dev server.
+     *
+     * Uses `config.VITE_USE_DEV_SERVER` if not provided.
+     */
     useDevServer?: boolean;
 }
-export declare function createSsrMiddleware<InitialData = unknown>({ root, getInitialData, useDevServer, }?: SsrMiddlewareOptions<InitialData>): Promise<import("compose-middleware").RequestHandler<any, any, void>>;
+export interface SsrMiddleware extends RequestHandler {
+}
+/**
+ * Returns a middleware for setting up SSR using Vite middleware mode.
+ *
+ * See more: https://vite.dev/guide/ssr
+ */
+export declare function createSsrMiddleware<InitialData = unknown>({ root, getInitialData, useDevServer, }?: SsrMiddlewareOptions<InitialData>): Promise<SsrMiddleware>;
 export declare function replaceSsrPlaceholders(template: string, values: Record<string, unknown>): string;