@authup/errors

Authup's error classes, error codes and code-to-HTTP-status mapping, with guards that survive JSON.
One error vocabulary for the server, the HTTP client and the consoles, so a caller branches on a code, not a message.

Installation · Usage · API · Documentation

Where it fits

Every Authup workspace that throws or inspects an error imports this package: the server throws its classes, the HTTP error middleware maps their code to a status, and @authup/core-http-kit and the consoles read the same codes back out of response bodies. Install it directly when your own code calls the Authup API and wants to branch on what went wrong (isEntityNotFoundError(error), error.code === ErrorCode.JWT_EXPIRED), or when you build a service on Authup's server packages and want to throw errors the same middleware understands.

Installation

npm install @authup/errors

ESM only. Node.js >=26.0.0. It has one runtime dependency, @ebec/core, and no Node-specific APIs.

Usage

Throw and map to a status

import { EntityNotFoundError, ErrorCode, httpStatusFromCode } from '@authup/errors';

const error = new EntityNotFoundError({ entity: 'user' });

error.message; // 'The user was not found.'
error.code === ErrorCode.ENTITY_NOT_FOUND; // true
httpStatusFromCode(error.code); // 404
httpStatusFromCode(ErrorCode.REGISTRATION_DISABLED); // 400, the fallback

• Every class extends AuthupError and sets its own code and default message. Pass a string to replace the message, or an options object (message, code, data, cause, and entity on the entity classes).
• data is merged into the JSON form, which is how LoginThrottledError, MfaThrottledError and DeviceVerificationThrottledError carry retryAfter (seconds) to the client.
• httpStatusFromCode(code, fallback = 400) answers from ERROR_CODE_TO_STATUS; any code not listed there gets the fallback. codeFromHttpStatus goes the other way for errors from a foreign source.

Recognize an error that crossed the wire

import { isAuthupError, isEntityNotFoundError, serializeError } from '@authup/errors';

declare const error: Error;

const body = JSON.parse(JSON.stringify(serializeError(error)));

if (isEntityNotFoundError(body)) {
    // body.code === 'entity_not_found'
}

if (isAuthupError(body)) {
    console.log(body.code, body.message);
}

• serializeError calls toJSON() when the error has one and otherwise spreads its own properties plus name and message. Use it wherever an error becomes a response body.
• The guards do not need instanceof. Each class stamps a Symbol.for(...) marker, and toJSON() writes the marker chain as strings under the same key, so a guard recognizes the live error and the parsed JSON alike.
• normalizeError(value) turns anything thrown (a string, a number, an object) into a real Error.

API

Each class also exports its marker symbol (ENTITY_NOT_FOUND_ERROR_INSTANCE, ...).

Notes

• isAuthupError needs the marker chain. An object without the @instanceof list (a hand-built { code, message }, or a body from an older server) is not an AuthupError, even when it carries an Authup code. Read body.code directly in that case.
• A class guard also accepts the plain code. isEntityNotFoundError is true for any AuthupError whose code is entity_not_found, not only for instances of that class. ValidationError and BadRequestError share bad_request, so isValidationError and isBadRequestError are both true for either class.
• The status lives in the mapping, not on the error. No class carries an HTTP status; codes not in ERROR_CODE_TO_STATUS map to 400 by default.

License

Made with 💚

Published under the Apache 2.0 License.