@fishka/express 0.9.23 → 0.9.25

package/README.md

@@ -1,6 +1,6 @@
 # Express API
 
-Type-safe Express.js routing with clean, minimal API.
+Functional utilities for Express.js with type-safe validation and error handling.
 
 ## Installation
 
@@ -8,65 +8,165 @@ Type-safe Express.js routing with clean, minimal API.
 npm install @fishka/express
 ```
 
+## Overview
+
+This package provides standalone utility functions that work directly with Express. Each feature can be used independently - mix and match what you need.
+
 ## Quick Start
 
 ```typescript
 import express from 'express';
-import { RouteTable, transform, toInt } from '@fishka/express';
+import { addErrorHandling, body, patchExpressAsyncErrors, pathParam, queryParam } from '@fishka/express';
 import { assertString } from '@fishka/assertions';
 
 const app = express();
 app.use(express.json());
 
-const routes = new RouteTable(app);
+// Enable automatic async error catching (call once at startup)
+patchExpressAsyncErrors();
 
 // GET /users/:id - with typed path params
-routes.get('users/:id', async ctx => ({
-  id: ctx.path('id', transform(toInt())), // number - validated inline
-  name: 'John',
-}));
+app.get('/users/:id', async (req, res) => {
+  const id = pathParam(req, 'id'); // string - validated inline
+  res.json({ id, name: 'John' });
+});
 
-// GET /users - list all users
-routes.get('users', async () => [
-  { id: 1, name: 'John' },
-  { id: 2, name: 'Jane' },
-]);
+// GET /users - with query params
+app.get('/users', async (req, res) => {
+  const page = queryParam(req, 'page'); // string - throws 400 if missing
+  res.json({ page, users: [] });
+});
 
 // POST /users - with body validation
-routes.post('users', async ctx => ({
-  id: 1,
-  name: ctx.body({ name: v => assertString(v, 'name required') }).name,
-}));
+app.post('/users', async (req, res) => {
+  const data = body(req, { name: assertString });
+  res.json({ id: 1, name: data.name }); // validators infer a type for the data!
+});
 
-// DELETE /users/:id
-routes.delete('users/:id', async () => {});
+// Add error handling middleware (must be last)
+addErrorHandling(app);
 
 app.listen(3000);
 ```
 
-## URL Parameter Validation
+## Utilities
+
+### `pathParam(req, name, validator?)`
 
-Use `transform()` to validate and transform path/query parameters. All operators are composable:
+Get and validate a path parameter from Express request.
 
 ```typescript
-import { transform, toInt, minLength, matches, min, range, oneOf } from '@fishka/express';
+import { pathParam, transform, toInt, minLength } from '@fishka/express';
 
-routes.get('users/:id', async ctx => ({
-  id: ctx.path('id', transform(toInt())), // string → number (required)
-  page: ctx.query('page', transform(toInt(), min(1))), // number >= 1, required (throws 400 if missing)
-  limit: ctx.query('limit', transform(toInt(), range(1, 100))), // number 1-100, required (throws 400 if missing)
-  sort: ctx.query('sort', transform(oneOf('asc', 'desc'))), // enum, required (throws 400 if missing)
-  search: ctx.query('search', transform(minLength(3))), // string min 3 chars, required (throws 400 if missing)
-}));
+app.get('/users/:id', async (req, res) => {
+  // Simple - returns string, throws 400 if missing
+  const id1 = pathParam(req, 'id');
+
+  // With validation - transform to number
+  const id2 = pathParam(req, 'id', transform(toInt()));
+
+  // Transform with validation - string min length
+  const slug = pathParam(req, 'slug', transform(minLength(3)));
+
+  res.json({ id: '...' });
+});
 ```
 
-### Parameter Requirements
+### `queryParam(req, name, validator?)`
 
-- `ctx.path('name')` - returns string (throws 400 if missing)
-- `ctx.query('name')` - returns string (throws 400 if missing/empty)
-- `ctx.query('name', validator)` - returns validated value (throws 400 if missing/empty/invalid)
-- All parameters are required - missing or empty values throw BAD_REQUEST
-- Validators receive raw values (including undefined/null/empty) and can enforce additional validation
+Get and validate a query parameter from Express request.
+
+```typescript
+import { queryParam, transform, toInt, min, range, oneOf } from '@fishka/express';
+
+app.get('/users', async (req, res) => {
+  // Simple - returns string, throws 400 if missing
+  const search = queryParam(req, 'search');
+
+  // With validation - transform to number with min value
+  const page = queryParam(req, 'page', transform(toInt(), min(1)));
+
+  // With validation - number range
+  const limit = queryParam(req, 'limit', transform(toInt(), range(1, 100)));
+
+  // With validation - enum
+  const sort = queryParam(req, 'sort', transform(oneOf('asc', 'desc')));
+
+  res.json({ page, limit, users: [] });
+});
+```
+
+### `body(req, validator)`
+
+Get and validate the request body.
+
+```typescript
+import { body } from '@fishka/express';
+import { assertString, assertNumber } from '@fishka/assertions';
+
+app.post('/users', async (req, res) => {
+  // Object assertion - validates and infers a type.
+  const data = body(req, {
+    name: assertString,
+    age: assertNumber,
+  });
+
+  res.json({ id: 1, name: data.name });
+});
+```
+
+### `patchExpressAsyncErrors()`
+
+Patches Express to automatically catch async errors. Call once at application startup.
+
+```typescript
+import { patchExpressAsyncErrors } from '@fishka/express';
+
+// Call before defining routes
+patchExpressAsyncErrors();
+
+// Now async route handlers don't need try/catch
+app.get('/users', async (req, res) => {
+  const users = await db.users.findAll(); // Errors are caught automatically
+  res.json(users);
+});
+```
+
+### `addErrorHandling(app)`
+
+Adds centralized error handling middleware. Must be called after all routes.
+
+```typescript
+import { addErrorHandling, HttpError } from '@fishka/express';
+
+// Define routes...
+app.get('/users/:id', async (req, res) => {
+  const user = await db.users.findById(req.params.id);
+  assertHttp(user, 404, 'User not found');
+  res.json(user);
+});
+
+// Add error handling last
+addErrorHandling(app);
+```
+
+## Parameter Validation
+
+Use `transform()` to validate and transform parameters. All operators are composable:
+
+```typescript
+import { transform, toInt, minLength, matches, min, range, oneOf } from '@fishka/express';
+
+app.get('/users/:id', async (req, res) => {
+  const id = pathParam(req, 'id', transform(toInt())); // string → number
+  const page = queryParam(req, 'page', transform(toInt(), min(1))); // number >= 1
+  const limit = queryParam(req, 'limit', transform(toInt(), range(1, 100))); // number 1-100
+  const sort = queryParam(req, 'sort', transform(oneOf('asc', 'desc'))); // enum
+  const search = queryParam(req, 'search', transform(minLength(3))); // string min 3 chars
+
+  res.json({ id, page, limit });
+});
+```
 
 ### Available Operators
 
@@ -98,26 +198,12 @@ routes.get('users/:id', async ctx => ({
 - `validator(fn)` - custom validator returning string|undefined
 - `map(fn)` - transform value
 
-### All Parameters Are Required
-
-- **Path parameters** are always required - `ctx.path()` throws 400 if missing
-- **Query parameters** are always required - `ctx.query()` throws 400 if missing/empty
-- **Validators** transform and validate parameter values
-
-For parameters that should have default values when missing, handle them at the application level or use the `optional()` wrapper:
-
-```typescript
-import { transform, toInt, optional } from '@fishka/express';
-
-routes.get('users', async ctx => {
-  // Using optional() wrapper for parameters with default values
-  const page = ctx.query('page', optional(transform(toInt()))) ?? 1;
-  // All parameters are required by default
-  const search = ctx.query('search');
+### Parameter Requirements
 
-  return { page: page ?? 1, search };
-});
-```
+- `pathParam(req, 'name')` - returns string (throws 400 if missing)
+- `queryParam(req, 'name')` - returns string (throws 400 if missing/empty)
+- `queryParam(req, 'name', validator)` - returns validated value (throws 400 if missing/empty/invalid)
+- All parameters are required - missing or empty values throw BAD_REQUEST
 
 ## Authentication
 
@@ -128,12 +214,9 @@ const auth = new BasicAuthStrategy(async (user, pass) =>
   user === 'admin' && pass === 'secret' ? { id: '1', role: 'admin' } : null,
 );
 
-routes.get('profile', {
-  middlewares: [createAuthMiddleware(auth)],
-  run: async ctx => {
-    const user = getAuthUser(ctx);
-    return { id: user.id };
-  },
+app.get('/profile', createAuthMiddleware(auth), async (req, res) => {
+  const user = getAuthUser(req);
+  res.json({ id: user.id });
 });
 ```
 
@@ -150,91 +233,129 @@ app.use(
 );
 ```
 
-## HTTP Status Code in Validation
+## HTTP Errors
 
-For cases where you need specific HTTP status codes (like 401 for authentication, 404 for not found), use `assertHttp`:
+Use `HttpError` for specific status codes:
 
 ```typescript
-import { assertHttp, HTTP_UNAUTHORIZED, HTTP_NOT_FOUND } from '@fishka/express';
+import { HttpError, HTTP_UNAUTHORIZED, HTTP_NOT_FOUND } from '@fishka/express';
 
-// In a validator or route handler
-assertHttp(req.headers.authorization, HTTP_UNAUTHORIZED, 'Authorization required');
-assertHttp(user, HTTP_NOT_FOUND, 'User not found');
-assertHttp(user.isAdmin, HTTP_FORBIDDEN, 'Admin access required');
-```
+app.get('/users/:id', async (req, res) => {
+  const user = await db.users.findById(req.params.id);
 
-## Complete Example
-
-Full initialization with TLS context, validation, and error handling:
+  if (!req.headers.authorization) {
+    throw new HttpError(HTTP_UNAUTHORIZED, 'Authorization required');
+  }
 
-```typescript
-import express from 'express';
-import { RouteTable, createTlsMiddleware, catchAllMiddleware, transform, toInt } from '@fishka/express';
+  if (!user) {
+    throw new HttpError(HTTP_NOT_FOUND, 'User not found');
+  }
 
-const app = express();
-
-// 1. Basic express middleware
-app.use(express.json());
-
-// 2. Initialize TLS context (Request IDs, etc.)
-// Note: Request ID functionality is disabled by default.
-// To enable it, call configureExpressApi({ requestIdHeader: 'x-request-id' }) first.
-app.use(createTlsMiddleware());
+  res.json(user);
+});
+```
 
-// 3. Define routes with typed parameters
-const routes = new RouteTable(app);
+Use `assertHttp` for inline assertions:
 
-routes.get('health', async () => ({ status: 'UP' }));
+```typescript
+import { assertHttp, HTTP_UNAUTHORIZED, HTTP_NOT_FOUND } from '@fishka/express';
 
-routes.get('users/:id', async ctx => ({
-  id: ctx.path('id', transform(toInt())),
-}));
+app.get('/admin', async (req, res) => {
+  assertHttp(req.headers.authorization, HTTP_UNAUTHORIZED, 'Authorization required');
 
-// 4. Error handler - catches middleware/parsing errors
-app.use(catchAllMiddleware);
+  const user = await db.users.findById(req.params.id);
+  assertHttp(user, HTTP_NOT_FOUND, 'User not found');
+  assertHttp(user.isAdmin, HTTP_FORBIDDEN, 'Admin access required');
 
-app.listen(3000);
+  res.json({ admin: true });
+});
 ```
 
 ## Configuration
 
-You can configure global settings using `configureExpressApi`:
+### Request ID
 
 ```typescript
-import { configureExpressApi } from '@fishka/express';
+import { configureExpressApi, createTlsMiddleware } from '@fishka/express';
 
-// Request ID configuration (disabled by default)
+// Enable request ID with custom header name
 configureExpressApi({
-  // Enable request ID with custom header name
   requestIdHeader: 'x-request-id', // or 'x-correlation-id', 'trace-id', etc.
-
-  // Whether to trust request ID from client headers
-  trustRequestIdHeader: true, // default: true
+  trustRequestIdHeader: true, // default: true, if we trust and propagate request ID passed by client.
 });
 
-// By default, request ID functionality is disabled.
-// To enable it, you must set requestIdHeader.
+// Add TLS middleware to track request context
+app.use(createTlsMiddleware());
 ```
 
-## Process Handlers
+### Process Handlers
 
-Handle uncaught errors and graceful shutdown in one place:
+Handle uncaught errors and graceful shutdown:
 
 ```typescript
 import { installProcessHandlers } from '@fishka/express';
 
 installProcessHandlers({
-  // Error handlers
   onUncaughtException: err => sendToMonitoring(err),
   onUnhandledRejection: reason => sendToMonitoring(reason),
-
-  // Graceful shutdown
   onShutdown: async () => {
     await database.close();
     await server.close();
   },
-  shutdownTimeout: 15000, // Force exit after 15s (default: 10s)
+  shutdownTimeout: 15000,
+});
+```
+
+## Complete Example
+
+```typescript
+import express from 'express';
+import {
+  addErrorHandling,
+  body,
+  min,
+  patchExpressAsyncErrors,
+  pathParam,
+  queryParam,
+  range,
+  toInt,
+  transform,
+} from '@fishka/express';
+import { assertString } from '@fishka/assertions';
+import { assertHttp } from './api.types';
+
+const app = express();
+app.use(express.json());
+
+// Enable automatic async error catching
+patchExpressAsyncErrors();
+
+// Routes
+app.get('/users/:id', async (req, res) => {
+  const id = pathParam(req, 'id', transform(toInt()));
+  const user = await db.users.findById(id);
+  assertHttp(user, 404, 'User not found');
+  res.json(user);
 });
+
+app.get('/users', async (req, res) => {
+  const page = queryParam(req, 'page', transform(toInt(), min(1)));
+  const limit = queryParam(req, 'limit', transform(toInt(), range(1, 100)));
+
+  const users = await db.users.findAll({ page, limit });
+  res.json({ users, page, limit });
+});
+
+app.post('/users', async (req, res) => {
+  const data = body(req, { name: assertString });
+  const user = await db.users.create(data);
+  res.status(201).json(user);
+});
+
+// Error handling (must be last)
+addErrorHandling(app);
+
+app.listen(3000);
 ```
 
 ## License

package/dist/cjs/auth/auth.utils.d.ts

@@ -1,31 +1,39 @@
-import { EndpointMiddleware, RequestContext } from '../router';
+import { ExpressRequest } from '../utils/express.utils';
 import { AuthStrategy, AuthUser } from './auth.types';
+declare const AUTH_USER_KEY: unique symbol;
+declare module 'express-serve-static-core' {
+    interface Request {
+        [AUTH_USER_KEY]?: AuthUser;
+    }
+}
 /**
- * Creates a middleware that enforces authentication using the provided strategy.
- * The authenticated user is stored in the context under the 'authUser' key.
+ * Creates an Express middleware that enforces authentication using the provided strategy.
+ * The authenticated user is stored in the request object.
  *
+ * @template Credentials - Type of the extracted credentials
  * @template User - Type of the authenticated user
  * @param strategy - Authentication strategy to use
  * @param onSuccess - Optional callback to process authenticated user
- * @returns a middleware that enforces authentication
+ * @returns Express middleware that enforces authentication
  */
-export declare function createAuthMiddleware<User extends AuthUser = AuthUser>(strategy: AuthStrategy<unknown, User>, onSuccess?: (user: User, context: RequestContext) => void): EndpointMiddleware;
+export declare function createAuthMiddleware<Credentials = unknown, User extends AuthUser = AuthUser>(strategy: AuthStrategy<Credentials, User>, onSuccess?: (user: User, req: ExpressRequest) => void): (req: ExpressRequest, res: unknown, next: (err?: unknown) => void) => Promise<void>;
 /**
- * Extracts the authenticated user from the request context.
+ * Extracts the authenticated user from the request.
  * Throws if the user is not present (i.e., authentication was not performed).
  *
  * @template User - Type of the authenticated user
- * @param context - Request context
+ * @param req - Express Request object
  * @returns The authenticated user
- * @throws Error if user is not found in context
+ * @throws Error if user is not found in request
  */
-export declare function getAuthUser<User extends AuthUser = AuthUser>(context: RequestContext): User;
+export declare function getAuthUser<User extends AuthUser = AuthUser>(req: ExpressRequest): User;
 /**
- * Safely extracts the authenticated user from the request context.
+ * Safely extracts the authenticated user from the request.
  * Returns undefined if the user is not present.
  *
  * @template User - Type of the authenticated user
- * @param context - Request context
+ * @param req - Express Request object
  * @returns The authenticated user, or undefined if not found
  */
-export declare function tryGetAuthUser<User extends AuthUser = AuthUser>(context: RequestContext): User | undefined;
+export declare function tryGetAuthUser<User extends AuthUser = AuthUser>(req: ExpressRequest): User | undefined;
+export {};

package/dist/cjs/auth/auth.utils.js

@@ -5,61 +5,67 @@ exports.getAuthUser = getAuthUser;
 exports.tryGetAuthUser = tryGetAuthUser;
 const api_types_1 = require("../api.types");
 const http_status_codes_1 = require("../http-status-codes");
+// Symbol key for storing auth user in request
+const AUTH_USER_KEY = Symbol('authUser');
 /**
- * Creates a middleware that enforces authentication using the provided strategy.
- * The authenticated user is stored in the context under the 'authUser' key.
+ * Creates an Express middleware that enforces authentication using the provided strategy.
+ * The authenticated user is stored in the request object.
  *
+ * @template Credentials - Type of the extracted credentials
  * @template User - Type of the authenticated user
  * @param strategy - Authentication strategy to use
  * @param onSuccess - Optional callback to process authenticated user
- * @returns a middleware that enforces authentication
+ * @returns Express middleware that enforces authentication
  */
 function createAuthMiddleware(strategy, onSuccess) {
-    return async (handler, context) => {
-        // Extract credentials from request
-        const credentials = strategy.extractCredentials(context.req);
-        // If no credentials found (and strategy returned undefined), we must deny access here.
-        // In a composite strategy scenario, we might want to try the next strategy, but this helper is for a single strategy enforcement.
-        if (!credentials) {
-            throw new api_types_1.HttpError(http_status_codes_1.HTTP_UNAUTHORIZED, 'No credentials provided or invalid format');
+    return async (req, _res, next) => {
+        try {
+            // Extract credentials from request
+            const credentials = strategy.extractCredentials(req);
+            // If no credentials found (and strategy returned undefined), we must deny access here.
+            if (!credentials) {
+                throw new api_types_1.HttpError(http_status_codes_1.HTTP_UNAUTHORIZED, 'No credentials provided or invalid format');
+            }
+            // Validate credentials and get authenticated user
+            const user = await strategy.validateCredentials(credentials);
+            // Store authenticated user in request for the handler to access
+            req[AUTH_USER_KEY] = user;
+            // Optional: Call success callback
+            if (onSuccess) {
+                onSuccess(user, req);
+            }
+            next();
         }
-        // Validate credentials and get authenticated user
-        const user = await strategy.validateCredentials(credentials);
-        // Store authenticated user in state for the handler to access
-        context.authUser = user;
-        // Optional: Call success callback
-        if (onSuccess) {
-            onSuccess(user, context);
+        catch (error) {
+            next(error);
         }
-        // Execute the actual handler
-        return handler();
     };
 }
 /**
- * Extracts the authenticated user from the request context.
+ * Extracts the authenticated user from the request.
  * Throws if the user is not present (i.e., authentication was not performed).
  *
  * @template User - Type of the authenticated user
- * @param context - Request context
+ * @param req - Express Request object
  * @returns The authenticated user
- * @throws Error if user is not found in context
+ * @throws Error if user is not found in request
  */
-function getAuthUser(context) {
-    const user = context.authUser;
+function getAuthUser(req) {
+    const user = req[AUTH_USER_KEY];
     if (!user) {
-        throw new api_types_1.HttpError(http_status_codes_1.HTTP_UNAUTHORIZED, 'User not found in context. Did you add auth middleware?');
+        throw new api_types_1.HttpError(http_status_codes_1.HTTP_UNAUTHORIZED, 'User not found in request. Did you add auth middleware?');
     }
     return user;
 }
 /**
- * Safely extracts the authenticated user from the request context.
+ * Safely extracts the authenticated user from the request.
  * Returns undefined if the user is not present.
  *
  * @template User - Type of the authenticated user
- * @param context - Request context
+ * @param req - Express Request object
  * @returns The authenticated user, or undefined if not found
  */
-function tryGetAuthUser(context) {
-    return context.authUser;
+function tryGetAuthUser(req) {
+    return req[AUTH_USER_KEY];
 }
 //# sourceMappingURL=auth.utils.js.map

package/dist/cjs/auth/auth.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"auth.utils.js","sourceRoot":"","sources":["../../../src/auth/auth.utils.ts"],"names":[],"mappings":";;AAcA,oDA4BC;AAWD,kCAMC;AAUD,wCAEC;AAvED,4CAAyC;AACzC,4DAAyD;AAIzD;;;;;;;;GAQG;AACH,SAAgB,oBAAoB,CAClC,QAAqC,EACrC,SAAyD;IAEzD,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE;QAChC,mCAAmC;QACnC,MAAM,WAAW,GAAG,QAAQ,CAAC,kBAAkB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAE7D,uFAAuF;QACvF,kIAAkI;QAClI,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,qBAAS,CAAC,qCAAiB,EAAE,2CAA2C,CAAC,CAAC;QACtF,CAAC;QAED,kDAAkD;QAClD,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;QAE7D,8DAA8D;QAC9D,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;QAExB,kCAAkC;QAClC,IAAI,SAAS,EAAE,CAAC;YACd,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC3B,CAAC;QAED,6BAA6B;QAC7B,OAAO,OAAO,EAAE,CAAC;IACnB,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,WAAW,CAAmC,OAAuB;IACnF,MAAM,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC;IAC9B,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,qBAAS,CAAC,qCAAiB,EAAE,yDAAyD,CAAC,CAAC;IACpG,CAAC;IACD,OAAO,IAAY,CAAC;AACtB,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,cAAc,CAAmC,OAAuB;IACtF,OAAO,OAAO,CAAC,QAA4B,CAAC;AAC9C,CAAC"}
+{"version":3,"file":"auth.utils.js","sourceRoot":"","sources":["../../../src/auth/auth.utils.ts"],"names":[],"mappings":";;AA0BA,oDA8BC;AAWD,kCAMC;AAUD,wCAEC;AArFD,4CAAyC;AACzC,4DAAyD;AAIzD,8CAA8C;AAC9C,MAAM,aAAa,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;AAUzC;;;;;;;;;GASG;AACH,SAAgB,oBAAoB,CAClC,QAAyC,EACzC,SAAqD;IAErD,OAAO,KAAK,EAAE,GAAmB,EAAE,IAAa,EAAE,IAA6B,EAAE,EAAE;QACjF,IAAI,CAAC;YACH,mCAAmC;YACnC,MAAM,WAAW,GAAG,QAAQ,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;YAErD,uFAAuF;YACvF,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,MAAM,IAAI,qBAAS,CAAC,qCAAiB,EAAE,2CAA2C,CAAC,CAAC;YACtF,CAAC;YAED,kDAAkD;YAClD,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,mBAAmB,CAAC,WAA0B,CAAC,CAAC;YAE5E,gEAAgE;YAC/D,GAAmD,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;YAE3E,kCAAkC;YAClC,IAAI,SAAS,EAAE,CAAC;gBACd,SAAS,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;YACvB,CAAC;YAED,IAAI,EAAE,CAAC;QACT,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,KAAK,CAAC,CAAC;QACd,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,WAAW,CAAmC,GAAmB;IAC/E,MAAM,IAAI,GAAI,GAAmD,CAAC,aAAa,CAAC,CAAC;IACjF,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,qBAAS,CAAC,qCAAiB,EAAE,yDAAyD,CAAC,CAAC;IACpG,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,cAAc,CAAmC,GAAmB;IAClF,OAAQ,GAAmD,CAAC,aAAa,CAAC,CAAC;AAC7E,CAAC"}

package/dist/cjs/error-handling.d.ts

@@ -37,6 +37,27 @@ export declare function catchRouteErrors(fn: ExpressFunction): ExpressFunction;
  * so this middleware primarily catches middleware and parsing errors.
  */
 export declare function catchAllMiddleware(error: unknown, _: ExpressRequest, res: ExpressResponse, next: NextFunction): Promise<void>;
+/**
+ * Patches Express to automatically catch errors from async route handlers.
+ * Call this once at application startup, before defining routes.
+ *
+ * After patching, you can use async handlers without try/catch:
+ * @example
+ * patchExpressAsyncErrors();
+ *
+ * const app = express();
+ *
+ * app.get('/users', async (req, res) => {
+ *   const user = await getUser(); // если упадёт - catchAllMiddleware поймает
+ *   res.json(user);
+ * });
+ *
+ * app.use(catchAllMiddleware);
+ *
+ * Note: This patches Express internal API. Works with Express 4.x and 5.x.
+ * Safe to call multiple times - patch applies only once.
+ */
+export declare function patchExpressAsyncErrors(): void;
 /** Options for installProcessHandlers(). */
 export interface ProcessHandlersOptions {
     /** Custom handler for uncaught exceptions. Called before default logging. */