sentri 1.1.0 → 1.1.2

package/README.md

@@ -17,6 +17,7 @@ Auth and authorization library for Express + PostgreSQL. Provides JWT-based auth
 - [Programmatic API](#programmatic-api)
 - [Types](#types)
 - [Error Handling](#error-handling)
+- [Migration from 1.0.x](#migration-from-10x)
 
 ---
 
@@ -55,7 +56,7 @@ prisma/
   schema.prisma          ← Prisma models (Prisma only, created or appended)
 ```
 
-### 2. Mount the router
+### 2. Mount the router and error handler
 
 ```typescript
 import express from 'express';
@@ -64,6 +65,12 @@ import { auth } from './lib/sentri/auth.js';
 const app = express();
 app.use(express.json());
 app.use('/auth', auth.router());
+
+// ... your routes ...
+
+// Must be last — catches SentriError from sentri and your own subclasses
+app.use(auth.errorHandler());
+app.listen(3000);
 ```
 
 Done. All endpoints are available at `/auth/*`.
@@ -189,7 +196,7 @@ The `router` field in config lets you replace the built-in service logic for ind
 Each key is optional — only override what you need. Any key you omit falls back to the built-in behaviour.
 
 ```typescript
-import { createAuth, AuthError } from 'sentri';
+import { createAuth, SentriError } from 'sentri';
 import type { AuthResult } from 'sentri';
 
 export const auth = createAuth({
@@ -202,7 +209,7 @@ export const auth = createAuth({
     login: async (input): Promise<AuthResult> => {
       const otpVerified = await redis.get(`otp:${input.identifier}`);
       if (!otpVerified) {
-        return { success: false, error: new AuthError('INVALID_CREDENTIALS', 'OTP required') };
+        return { success: false, error: new SentriError('INVALID_CREDENTIALS', 'OTP required') };
       }
       return defaultLogin(input);
     },
@@ -232,7 +239,7 @@ export const auth = createAuth({
 
 | Key | Signature | Must return |
 |---|---|---|
-| `register` | `(input: SignupInput) => Promise<SignupResult>` | `SignupResult` |
+| `register` | `(input: RegisterInput) => Promise<RegisterResult>` | `RegisterResult` |
 | `login` | `(input: LoginInput) => Promise<AuthResult>` | `AuthResult` |
 | `refresh` | `(refreshToken: string) => Promise<RefreshResult>` | `RefreshResult` |
 | `logout` | `(refreshToken: string \| undefined) => Promise<void>` | `void` |
@@ -287,7 +294,7 @@ import { createAdapter } from './adapter.js';
 export const adapter = createAdapter(db);
 ```
 
-`createAdapter` throws `AuthError` with code `CONFIGURATION_ERROR` at runtime if called without a `db` argument.
+`createAdapter` throws `SentriError` with code `CONFIGURATION_ERROR` at runtime if called without a `db` argument.
 
 ---
 
@@ -473,8 +480,8 @@ Token and password utilities are available on the auth client for use outside th
 ```typescript
 // Token utilities
 const accessToken = auth.signAccessToken({ id, identifier, roles });
-const user = auth.verifyAccessToken(accessToken);         // throws AuthError if invalid
-const { sessionId } = auth.verifyRefreshToken(token);    // throws AuthError if invalid
+const user = auth.verifyAccessToken(accessToken);         // throws SentriError if invalid
+const { sessionId } = auth.verifyRefreshToken(token);    // throws SentriError if invalid
 const refreshToken = auth.signRefreshToken(sessionId);
 
 // Password utilities
@@ -482,7 +489,26 @@ const hash = await auth.hashPassword('secret123');
 const valid = await auth.verifyPassword('secret123', hash);
 ```
 
-`verifyAccessToken` and `verifyRefreshToken` throw `AuthError` with code `TOKEN_EXPIRED` or `TOKEN_INVALID` — wrap them in a try/catch or use the router which handles this automatically.
+`verifyAccessToken` and `verifyRefreshToken` throw `SentriError` with code `TOKEN_EXPIRED` or `TOKEN_INVALID` — wrap them in a try/catch or use the router which handles this automatically.
+
+### `register` — standalone service function
+
+The `register` function is also exported directly so you can call it outside the built-in router (e.g. in tests, scripts, or admin tools):
+
+```typescript
+import { register } from 'sentri';
+
+const result = await register(
+  { identifier: 'alice@example.com', password: 'hunter2', roles: ['user'] },
+  config,
+);
+
+if (result.success) {
+  console.log(result.user.id);
+} else {
+  console.error(result.error.code); // 'USER_ALREADY_EXISTS' | 'INVALID_ROLE'
+}
+```
 
 ---
 
@@ -495,11 +521,11 @@ import type {
   AuthAdapter,
   AuthUser,
   AuthResult,
-  SignupResult,
+  RegisterResult,
   AssignRolesResult,
   RefreshResult,
   ApiResponse,
-  SignupInput,
+  RegisterInput,
   LoginInput,
   RouterHandlers,
   UserRecord,
@@ -508,17 +534,17 @@ import type {
   CookieConfig,
   PermitCheck,
   PermitOptions,
-  AuthErrorCode,
+  SentriErrorCode,
 } from 'sentri';
 
-import { AuthError, createAuth } from 'sentri';
+import { SentriError, AUTH_ERROR_STATUS, createAuth, register } from 'sentri';
 ```
 
 ---
 
 ## Error Handling
 
-All errors thrown by the library are instances of `AuthError` with a machine-readable `code`:
+All errors thrown by the library are instances of `SentriError` with a machine-readable `code` and an HTTP `statusCode`:
 
 | Code | HTTP | Meaning |
 |---|---|---|
@@ -533,44 +559,70 @@ All errors thrown by the library are instances of `AuthError` with a machine-rea
 | `VALIDATION_ERROR` | 400 | Missing or invalid input field |
 | `CONFIGURATION_ERROR` | 500 | Invalid `createAuth` configuration |
 
-The built-in router converts all `AuthError` instances to the standard envelope automatically. For custom routes:
+### `auth.errorHandler()`
+
+Mount `auth.errorHandler()` **after all your routes** to automatically format every `SentriError` (and any subclass) into the standard envelope:
 
 ```typescript
-import { AuthError } from 'sentri';
-
-const AUTH_ERROR_STATUS: Record<string, number> = {
-  UNAUTHORIZED: 401,
-  TOKEN_EXPIRED: 401,
-  TOKEN_INVALID: 401,
-  INVALID_CREDENTIALS: 401,
-  FORBIDDEN: 403,
-  USER_NOT_FOUND: 404,
-  USER_ALREADY_EXISTS: 409,
-  INVALID_ROLE: 400,
-  VALIDATION_ERROR: 400,
-  CONFIGURATION_ERROR: 500,
-};
+app.use('/auth', auth.router());
+app.use('/api', apiRouter);
+
+// Must be last
+app.use(auth.errorHandler());
+```
+
+Optional logger for unexpected errors:
+
+```typescript
+app.use(auth.errorHandler({
+  onUnhandled: (err) => logger.error('Unexpected error', { err }),
+}));
+```
+
+### Extending `SentriError`
+
+Define application-specific errors by extending `SentriError`. They are caught automatically by `auth.errorHandler()` via `instanceof`:
+
+```typescript
+import { SentriError } from 'sentri';
+
+export class NotFoundError extends SentriError {
+  constructor(resource: string) {
+    super('NOT_FOUND', `${resource} not found`, 404);
+  }
+}
 
-app.use((error, _request, response, next) => {
-  if (error instanceof AuthError) {
-    const statusCode = AUTH_ERROR_STATUS[error.code] ?? 500;
-    return response.status(statusCode).json({
-      error: true,
-      statusCode,
-      code: error.code,
-      message: error.message,
-      data: null,
-    });
+export class PaymentError extends SentriError {
+  constructor(message: string) {
+    super('PAYMENT_FAILED', message, 402);
   }
-  next(error);
+}
+
+// Throw anywhere in your routes — auth.errorHandler() catches them all
+app.get('/items/:id', auth.protect(), async (req, res) => {
+  const item = await db.items.findById(req.params['id']);
+  if (!item) throw new NotFoundError('Item');
+  res.json(item);
 });
 ```
 
+Response shape for any `SentriError` (built-in or custom):
+
+```json
+{
+  "error": true,
+  "statusCode": 404,
+  "code": "NOT_FOUND",
+  "message": "Item not found",
+  "data": null
+}
+```
+
 ---
 
 ## Migration from 1.0.x
 
-### Breaking changes
+### Breaking changes in 1.1.0
 
 | What changed | Action required |
 |---|---|
@@ -578,7 +630,19 @@ app.use((error, _request, response, next) => {
 | `RouterHandlers.signup` renamed to `RouterHandlers.register` | Update config if you used a custom signup handler |
 | `protect()` now performs one DB read per request | Ensure your adapter's `session.findById` is indexed on session ID |
 
-### New features
+### Breaking changes in 1.2.0
 
-- **Session-bound tokens** — access tokens are immediately invalidated after logout without waiting for expiry.
-- **`apiKey` config** — lock `POST /register` to trusted callers via `X-Api-Key` header.
+| What changed | Action required |
+|---|---|
+| `AuthError` renamed to `SentriError` | Replace all `import { AuthError }` with `import { SentriError }` |
+| `AuthErrorCode` renamed to `SentriErrorCode` | Replace all `AuthErrorCode` type references |
+| `SignupResult` renamed to `RegisterResult` | Replace type references |
+| `SignupInput` renamed to `RegisterInput` | Replace type references |
+| `signup` service renamed to `register` | Replace `import { signup }` with `import { register }` |
+
+### New features in 1.2.0
+
+- **`auth.errorHandler()`** — built-in Express error handler mounted like `auth.router()`.
+- **`SentriError.statusCode`** — each error carries its own HTTP status; no need for a manual status map.
+- **Extensible errors** — subclass `SentriError` with a custom `code` and `statusCode`; `auth.errorHandler()` catches all subclasses automatically.
+- **`register` exported** — the registration service function is now a named export for use outside the built-in router.

package/dist/client.d.ts

@@ -1,6 +1,7 @@
 import type { PermitCheck, PermitOptions } from './middleware/permit.js';
+import type { ErrorHandlerOptions } from './middleware/errorHandler.js';
 import type { AuthConfig, AuthUser } from './types/auth.js';
-import type { RequestHandler, Router } from 'express';
+import type { ErrorRequestHandler, RequestHandler, Router } from 'express';
 /**
  * The bound auth client returned by {@link createAuth}.
  *
@@ -15,7 +16,8 @@ export interface AuthClient<TRole extends string = string> {
      * Express middleware factory that enforces authentication.
      *
      * Reads the `Authorization: Bearer <token>` header, verifies the access token,
-     * and injects the decoded payload as `request.user`. Calls `next(AuthError)` on failure.
+     * confirms the session is still active in the database, and injects the decoded
+     * payload as `request.user`. Calls `next(SentriError)` on any failure.
      *
      * @example
      * router.get('/me', auth.protect(), (request, response) => {
@@ -27,7 +29,7 @@ export interface AuthClient<TRole extends string = string> {
      * Express middleware factory that enforces role-based access.
      *
      * Must be used **after** `protect()`. Passes if the authenticated user has
-     * at least one of the specified roles; otherwise calls `next(AuthError)` with
+     * at least one of the specified roles; otherwise calls `next(SentriError)` with
      * code `FORBIDDEN`.
      *
      * @example
@@ -38,7 +40,7 @@ export interface AuthClient<TRole extends string = string> {
      * Express middleware factory for resource-level permission checks.
      *
      * Must be used **after** `protect()`. Evaluates a check function against the
-     * current request and calls `next(AuthError)` with `FORBIDDEN` if it returns `false`.
+     * current request and calls `next(SentriError)` with `FORBIDDEN` if it returns `false`.
      *
      * Accepts either a bare check function or an options object with an optional
      * `roles` list whose members bypass the check entirely.
@@ -75,32 +77,65 @@ export interface AuthClient<TRole extends string = string> {
     signAccessToken(payload: AuthUser<TRole>): string;
     /** Sign a refresh token bound to a session ID. */
     signRefreshToken(sessionId: string): string;
-    /** Verify and decode an access token. Throws `AuthError` if invalid or expired. */
+    /** Verify and decode an access token. Throws `SentriError` if invalid or expired. */
     verifyAccessToken(token: string): AuthUser<TRole>;
-    /** Verify and decode a refresh token. Throws `AuthError` if invalid or expired. */
+    /** Verify and decode a refresh token. Throws `SentriError` if invalid or expired. */
     verifyRefreshToken(token: string): {
         sessionId: string;
     };
     /**
-     * Returns a pre-built Express Router with all standard auth endpoints mounted:
+     * Returns a pre-built Express Router with all standard auth endpoints mounted.
      *
-     * - `POST /register` — register a new user, returns `{ user }`.
-     *   Requires `X-Api-Key` header when `config.apiKey` is set.
+     * Endpoints:
+     * - `POST /register` — register a new user. Requires `X-Api-Key` header when `config.apiKey` is set.
      * - `POST /login` — authenticate, sets refresh token cookie, returns `{ accessToken, user }`
-     * - `POST /refresh` — reads refresh token from cookie, returns `{ accessToken }`
-     * - `POST /logout` — invalidate the current session; any access token bound to
-     *   this session is immediately rejected by `protect()`.
-     * - `POST /logout-all` — invalidate all sessions for the user (requires valid access token)
+     * - `POST /refresh` — rotate refresh token, returns new `{ accessToken }`
+     * - `POST /logout` — delete the current session; the bound access token is immediately rejected by `protect()`
+     * - `POST /logout-all` — delete all sessions for the user (requires valid access token)
      * - `GET  /me` — return the authenticated user
      * - `POST /users/:userId/roles` — assign roles (requires admin)
      *
-     * Requires `express.json()` to be applied before the router.
+     * Requires `express.json()` before the router.
      *
      * @example
      * app.use(express.json());
      * app.use('/auth', auth.router());
      */
     router(): Router;
+    /**
+     * Returns an Express error-handling middleware that formats every `SentriError`
+     * (and any subclass) into the standard sentri response envelope:
+     *
+     * ```json
+     * { "error": true, "statusCode": 401, "code": "UNAUTHORIZED", "message": "...", "data": null }
+     * ```
+     *
+     * Mount it **after all your routes** so it acts as the global catch-all for
+     * both sentri errors and your own `SentriError` subclasses.
+     *
+     * @example
+     * import { SentriError } from 'sentri';
+     *
+     * // Define app-specific errors by extending SentriError
+     * class NotFoundError extends SentriError {
+     *   constructor(resource: string) {
+     *     super('NOT_FOUND', `${resource} not found`, 404);
+     *   }
+     * }
+     *
+     * app.use('/auth', auth.router());
+     * app.use('/api', apiRouter);
+     *
+     * // Catches errors from sentri AND your own subclasses
+     * app.use(auth.errorHandler());
+     *
+     * @example
+     * // With optional unhandled-error logger
+     * app.use(auth.errorHandler({
+     *   onUnhandled: (err) => logger.error('Unexpected error', { err }),
+     * }));
+     */
+    errorHandler(options?: ErrorHandlerOptions): ErrorRequestHandler;
 }
 /**
  * Create a fully configured auth client for your application.

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtD;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM;IACvD;;;;;;;;;;OAUG;IACH,OAAO,IAAI,cAAc,CAAC;IAE1B;;;;;;;;;OASG;IACH,SAAS,CAAC,GAAG,KAAK,EAAE,KAAK,EAAE,GAAG,cAAc,CAAC;IAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,cAAc,CAAC;IAC3C,MAAM,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,cAAc,CAAC;IAEtD,oEAAoE;IACpE,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE7C,kEAAkE;IAClE,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE9D,uDAAuD;IACvD,eAAe,CAAC,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC;IAElD,kDAAkD;IAClD,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAE5C,mFAAmF;IACnF,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAElD,mFAAmF;IACnF,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAEzD;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,IAAI,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EACtD,MAAM,EAAE,UAAU,CAAC,KAAK,CAAC,GACxB,UAAU,CAAC,KAAK,CAAC,CAgBnB"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE3E;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM;IACvD;;;;;;;;;;;OAWG;IACH,OAAO,IAAI,cAAc,CAAC;IAE1B;;;;;;;;;OASG;IACH,SAAS,CAAC,GAAG,KAAK,EAAE,KAAK,EAAE,GAAG,cAAc,CAAC;IAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,cAAc,CAAC;IAC3C,MAAM,CAAC,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,cAAc,CAAC;IAEtD,oEAAoE;IACpE,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE7C,kEAAkE;IAClE,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE9D,uDAAuD;IACvD,eAAe,CAAC,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC;IAElD,kDAAkD;IAClD,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAE5C,qFAAqF;IACrF,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAElD,qFAAqF;IACrF,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAEzD;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,IAAI,MAAM,CAAC;IAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,YAAY,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,mBAAmB,CAAC;CAClE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EACtD,MAAM,EAAE,UAAU,CAAC,KAAK,CAAC,GACxB,UAAU,CAAC,KAAK,CAAC,CAiBnB"}

package/dist/client.js

@@ -5,6 +5,7 @@ import { protect } from './middleware/protect.js';
 import { authorize } from './middleware/authorize.js';
 import { permit } from './middleware/permit.js';
 import { createAuthRouter } from './middleware/router.js';
+import { createErrorHandler } from './middleware/errorHandler.js';
 /**
  * Create a fully configured auth client for your application.
  *
@@ -30,6 +31,7 @@ export function createAuth(config) {
     return {
         protect: () => protect(config),
         authorize: (...roles) => authorize(...roles),
+        permit: (optionsOrCheck) => permit(optionsOrCheck),
         hashPassword: (plain) => hashPassword(plain, resolved.saltRounds),
         verifyPassword: (plain, hash) => verifyPassword(plain, hash),
         signAccessToken: (payload) => signAccessToken(payload, config),
@@ -37,7 +39,7 @@ export function createAuth(config) {
         verifyAccessToken: (token) => verifyAccessToken(token, config),
         verifyRefreshToken: (token) => verifyRefreshToken(token, config),
         router: () => createAuthRouter(config),
-        permit: (optionsOrCheck) => permit(optionsOrCheck),
+        errorHandler: (options) => createErrorHandler(options),
     };
 }
 //# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC3G,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAkH1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,UAAU,CACxB,MAAyB;IAEzB,cAAc,CAAC,MAAoB,CAAC,CAAC;IACrC,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAoB,CAAC,CAAC;IAErD,OAAO;QACL,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAoB,CAAC;QAC5C,SAAS,EAAE,CAAC,GAAG,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC;QAC5C,YAAY,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC;QACjE,cAAc,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC;QAC5D,eAAe,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,eAAe,CAAC,OAAmB,EAAE,MAAoB,CAAC;QACxF,gBAAgB,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,CAAC,SAAS,EAAE,MAAoB,CAAC;QAClF,iBAAiB,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,iBAAiB,CAAC,KAAK,EAAE,MAAoB,CAAoB;QAC/F,kBAAkB,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAoB,CAAC;QAC9E,MAAM,EAAE,GAAG,EAAE,CAAC,gBAAgB,CAAC,MAAM,CAAC;QACtC,MAAM,EAAE,CAAC,cAAkD,EAAE,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC;KACvF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC3G,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAsJlE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,UAAU,CACxB,MAAyB;IAEzB,cAAc,CAAC,MAAoB,CAAC,CAAC;IACrC,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAoB,CAAC,CAAC;IAErD,OAAO;QACL,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAoB,CAAC;QAC5C,SAAS,EAAE,CAAC,GAAG,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC;QAC5C,MAAM,EAAE,CAAC,cAAkD,EAAE,EAAE,CAAC,MAAM,CAAC,cAAc,CAAC;QACtF,YAAY,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC;QACjE,cAAc,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC;QAC5D,eAAe,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,eAAe,CAAC,OAAmB,EAAE,MAAoB,CAAC;QACxF,gBAAgB,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,CAAC,SAAS,EAAE,MAAoB,CAAC;QAClF,iBAAiB,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,iBAAiB,CAAC,KAAK,EAAE,MAAoB,CAAoB;QAC/F,kBAAkB,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAoB,CAAC;QAC9E,MAAM,EAAE,GAAG,EAAE,CAAC,gBAAgB,CAAC,MAAM,CAAC;QACtC,YAAY,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,kBAAkB,CAAC,OAAO,CAAC;KACvD,CAAC;AACJ,CAAC"}

package/dist/errors/AuthError.d.ts

@@ -1,41 +1,99 @@
 /**
- * Discriminant codes for {@link AuthError}.
+ * Discriminant codes for built-in {@link SentriError} instances.
  *
  * - `INVALID_CREDENTIALS` — identifier or password did not match (intentionally vague to prevent user enumeration)
  * - `USER_NOT_FOUND` — an operation required a user that does not exist
- * - `USER_ALREADY_EXISTS` — signup was attempted with an identifier already in the database
+ * - `USER_ALREADY_EXISTS` — registration was attempted with an identifier already in the database
  * - `TOKEN_EXPIRED` — the JWT was valid but its `exp` claim is in the past
  * - `TOKEN_INVALID` — the JWT could not be verified (bad signature, malformed, wrong type)
  * - `FORBIDDEN` — the user is authenticated but lacks the required role
- * - `UNAUTHORIZED` — no valid access token was present on the request
+ * - `UNAUTHORIZED` — no valid access token was present on the request, or the session was revoked
  * - `INVALID_ROLE` — a role name was used that is not in `validRoles`
  * - `VALIDATION_ERROR` — a required field was missing or had an invalid value
  * - `CONFIGURATION_ERROR` — `createAuth` was called with an invalid configuration
+ *
+ * When you extend {@link SentriError} for your own error types you can use any
+ * string as `code` — it does not need to be one of these built-in values.
+ */
+export type SentriErrorCode = 'INVALID_CREDENTIALS' | 'USER_NOT_FOUND' | 'USER_ALREADY_EXISTS' | 'TOKEN_EXPIRED' | 'TOKEN_INVALID' | 'FORBIDDEN' | 'UNAUTHORIZED' | 'INVALID_ROLE' | 'VALIDATION_ERROR' | 'CONFIGURATION_ERROR';
+/**
+ * Default HTTP status codes for built-in error codes.
+ * Custom codes that are not in this map default to 500.
+ *
+ * @internal
  */
-export type AuthErrorCode = 'INVALID_CREDENTIALS' | 'USER_NOT_FOUND' | 'USER_ALREADY_EXISTS' | 'TOKEN_EXPIRED' | 'TOKEN_INVALID' | 'FORBIDDEN' | 'UNAUTHORIZED' | 'INVALID_ROLE' | 'VALIDATION_ERROR' | 'CONFIGURATION_ERROR';
+export declare const AUTH_ERROR_STATUS: Record<string, number>;
 /**
- * Error class thrown by the library for all authentication and authorization failures.
- *
- * Carries a machine-readable `code` that lets you distinguish error types without
- * string-matching on the message.
- *
- * @example
- * import { AuthError } from 'sentri';
- *
- * app.use((error, _request, response, next) => {
- *   if (error instanceof AuthError) {
- *     const status =
- *       error.code === 'UNAUTHORIZED' ? 401
- *       : error.code === 'FORBIDDEN' ? 403
- *       : 400;
- *     response.status(status).json({ error: error.code, message: error.message });
- *   } else {
- *     next(error);
+ * Base error class for all authentication and authorization failures in sentri.
+ *
+ * Every error thrown by sentri is an instance of `SentriError`. The `code`
+ * property is a machine-readable string that lets you distinguish error
+ * types without string-matching on the message. Built-in codes are listed
+ * in {@link SentriErrorCode}; custom subclasses may use any string.
+ *
+ * The `statusCode` property holds the HTTP status that the built-in router
+ * and `auth.errorHandler()` will use in the response. For built-in codes
+ * it is derived automatically. Pass it explicitly when subclassing with a
+ * custom code.
+ *
+ * ---
+ *
+ * **Extending SentriError**
+ *
+ * You can create application-specific error classes by extending `SentriError`.
+ * Any subclass will be caught automatically by `auth.errorHandler()` because
+ * `instanceof SentriError` is `true` for all subclasses.
+ *
+ * ```typescript
+ * import { SentriError } from 'sentri';
+ *
+ * // Domain error with a custom code and explicit HTTP status
+ * export class PaymentError extends SentriError {
+ *   constructor(message: string) {
+ *     super('PAYMENT_FAILED', message, 402);
  *   }
+ * }
+ *
+ * // Throw it anywhere in your routes — auth.errorHandler() catches it
+ * router.post('/checkout', auth.protect(), async (req, res) => {
+ *   const ok = await chargeCard(req.body.cardToken);
+ *   if (!ok) throw new PaymentError('Card declined');
+ *   res.json({ success: true });
  * });
+ * ```
+ *
+ * ---
+ *
+ * **Error handling in custom routes**
+ *
+ * ```typescript
+ * app.use('/auth', auth.router());
+ * app.use('/api', apiRouter);
+ *
+ * // Mount after all routes — catches SentriError from sentri AND your subclasses
+ * app.use(auth.errorHandler());
+ * ```
  */
-export declare class AuthError extends Error {
-    readonly code: AuthErrorCode;
-    constructor(code: AuthErrorCode, message: string);
+export declare class SentriError extends Error {
+    /**
+     * Machine-readable error code.
+     * Built-in codes are defined by {@link SentriErrorCode}.
+     * Custom subclasses may use any string.
+     */
+    readonly code: string;
+    /**
+     * HTTP status code associated with this error.
+     * Derived automatically for built-in codes; pass it explicitly when
+     * subclassing with a custom `code`.
+     */
+    readonly statusCode: number;
+    /**
+     * @param code - Machine-readable error code. Use a built-in {@link SentriErrorCode}
+     *   or any string for custom subclasses.
+     * @param message - Human-readable description of the error.
+     * @param statusCode - HTTP status to use in the response. For built-in codes
+     *   this is derived automatically; for custom codes it defaults to `500`.
+     */
+    constructor(code: SentriErrorCode | (string & {}), message: string, statusCode?: number);
 }
 //# sourceMappingURL=AuthError.d.ts.map

package/dist/errors/AuthError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AuthError.d.ts","sourceRoot":"","sources":["../../src/errors/AuthError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,aAAa,GACrB,qBAAqB,GACrB,gBAAgB,GAChB,qBAAqB,GACrB,eAAe,GACf,eAAe,GACf,WAAW,GACX,cAAc,GACd,cAAc,GACd,kBAAkB,GAClB,qBAAqB,CAAC;AAE1B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,SAAU,SAAQ,KAAK;IAClC,SAAgB,IAAI,EAAE,aAAa,CAAC;gBAExB,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM;CAKjD"}
+{"version":3,"file":"AuthError.d.ts","sourceRoot":"","sources":["../../src/errors/AuthError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,eAAe,GACvB,qBAAqB,GACrB,gBAAgB,GAChB,qBAAqB,GACrB,eAAe,GACf,eAAe,GACf,WAAW,GACX,cAAc,GACd,cAAc,GACd,kBAAkB,GAClB,qBAAqB,CAAC;AAE1B;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAWpD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC;;;;OAIG;IACH,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B;;;;OAIG;IACH,SAAgB,UAAU,EAAE,MAAM,CAAC;IAEnC;;;;;;OAMG;gBAED,IAAI,EAAE,eAAe,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,EACrC,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM;CAOtB"}

package/dist/errors/AuthError.js

@@ -1,30 +1,97 @@
 /**
- * Error class thrown by the library for all authentication and authorization failures.
- *
- * Carries a machine-readable `code` that lets you distinguish error types without
- * string-matching on the message.
- *
- * @example
- * import { AuthError } from 'sentri';
- *
- * app.use((error, _request, response, next) => {
- *   if (error instanceof AuthError) {
- *     const status =
- *       error.code === 'UNAUTHORIZED' ? 401
- *       : error.code === 'FORBIDDEN' ? 403
- *       : 400;
- *     response.status(status).json({ error: error.code, message: error.message });
- *   } else {
- *     next(error);
+ * Default HTTP status codes for built-in error codes.
+ * Custom codes that are not in this map default to 500.
+ *
+ * @internal
+ */
+export const AUTH_ERROR_STATUS = {
+    UNAUTHORIZED: 401,
+    TOKEN_EXPIRED: 401,
+    TOKEN_INVALID: 401,
+    INVALID_CREDENTIALS: 401,
+    FORBIDDEN: 403,
+    USER_NOT_FOUND: 404,
+    USER_ALREADY_EXISTS: 409,
+    INVALID_ROLE: 400,
+    VALIDATION_ERROR: 400,
+    CONFIGURATION_ERROR: 500,
+};
+/**
+ * Base error class for all authentication and authorization failures in sentri.
+ *
+ * Every error thrown by sentri is an instance of `SentriError`. The `code`
+ * property is a machine-readable string that lets you distinguish error
+ * types without string-matching on the message. Built-in codes are listed
+ * in {@link SentriErrorCode}; custom subclasses may use any string.
+ *
+ * The `statusCode` property holds the HTTP status that the built-in router
+ * and `auth.errorHandler()` will use in the response. For built-in codes
+ * it is derived automatically. Pass it explicitly when subclassing with a
+ * custom code.
+ *
+ * ---
+ *
+ * **Extending SentriError**
+ *
+ * You can create application-specific error classes by extending `SentriError`.
+ * Any subclass will be caught automatically by `auth.errorHandler()` because
+ * `instanceof SentriError` is `true` for all subclasses.
+ *
+ * ```typescript
+ * import { SentriError } from 'sentri';
+ *
+ * // Domain error with a custom code and explicit HTTP status
+ * export class PaymentError extends SentriError {
+ *   constructor(message: string) {
+ *     super('PAYMENT_FAILED', message, 402);
  *   }
+ * }
+ *
+ * // Throw it anywhere in your routes — auth.errorHandler() catches it
+ * router.post('/checkout', auth.protect(), async (req, res) => {
+ *   const ok = await chargeCard(req.body.cardToken);
+ *   if (!ok) throw new PaymentError('Card declined');
+ *   res.json({ success: true });
  * });
+ * ```
+ *
+ * ---
+ *
+ * **Error handling in custom routes**
+ *
+ * ```typescript
+ * app.use('/auth', auth.router());
+ * app.use('/api', apiRouter);
+ *
+ * // Mount after all routes — catches SentriError from sentri AND your subclasses
+ * app.use(auth.errorHandler());
+ * ```
  */
-export class AuthError extends Error {
+export class SentriError extends Error {
+    /**
+     * Machine-readable error code.
+     * Built-in codes are defined by {@link SentriErrorCode}.
+     * Custom subclasses may use any string.
+     */
     code;
-    constructor(code, message) {
+    /**
+     * HTTP status code associated with this error.
+     * Derived automatically for built-in codes; pass it explicitly when
+     * subclassing with a custom `code`.
+     */
+    statusCode;
+    /**
+     * @param code - Machine-readable error code. Use a built-in {@link SentriErrorCode}
+     *   or any string for custom subclasses.
+     * @param message - Human-readable description of the error.
+     * @param statusCode - HTTP status to use in the response. For built-in codes
+     *   this is derived automatically; for custom codes it defaults to `500`.
+     */
+    constructor(code, message, statusCode) {
         super(message);
-        this.name = 'AuthError';
+        this.name = 'SentriError';
         this.code = code;
+        this.statusCode = statusCode ?? AUTH_ERROR_STATUS[code] ?? 500;
     }
 }
 //# sourceMappingURL=AuthError.js.map