@mxweb/core 1.0.0

package/dist/error.d.ts

@@ -0,0 +1,301 @@
+/**
+ * @fileoverview HTTP error classes for standardized error handling.
+ *
+ * This module provides a hierarchy of HTTP error classes that can be thrown
+ * in handlers, services, or guards. The framework automatically converts
+ * these errors into appropriate HTTP responses.
+ *
+ * @module error
+ */
+/**
+ * Base HTTP error class that all specific HTTP errors extend.
+ * Throw this directly when you need a custom status code, or use
+ * one of the predefined error classes for common HTTP errors.
+ *
+ * @example
+ * ```ts
+ * // Throw with custom status code
+ * throw new HttpError(418, "I'm a teapot");
+ *
+ * // With additional error details
+ * throw new HttpError(400, "Validation failed", { field: "email", reason: "invalid format" });
+ * ```
+ */
+export declare class HttpError extends Error {
+    readonly statusCode: number;
+    readonly message: string;
+    readonly error?: unknown | undefined;
+    /**
+     * Creates a new HttpError instance.
+     *
+     * @param statusCode - HTTP status code (e.g., 400, 404, 500)
+     * @param message - Human-readable error message (overrides Error.message)
+     * @param error - Optional additional error details or original error
+     */
+    constructor(statusCode: number, message: string, error?: unknown | undefined);
+}
+/**
+ * HTTP 400 Bad Request error.
+ * Use when the request is malformed or contains invalid data.
+ *
+ * @example
+ * ```ts
+ * if (!request.body) {
+ *   throw new BadRequestError("Request body is required");
+ * }
+ * ```
+ */
+export declare class BadRequestError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 401 Unauthorized error.
+ * Use when authentication is required but not provided or invalid.
+ *
+ * @example
+ * ```ts
+ * if (!token) {
+ *   throw new UnauthorizedError("Authentication token required");
+ * }
+ * ```
+ */
+export declare class UnauthorizedError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 403 Forbidden error.
+ * Use when the user is authenticated but lacks permission.
+ *
+ * @example
+ * ```ts
+ * if (!user.isAdmin) {
+ *   throw new ForbiddenError("Admin access required");
+ * }
+ * ```
+ */
+export declare class ForbiddenError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 404 Not Found error.
+ * Use when the requested resource does not exist.
+ *
+ * @example
+ * ```ts
+ * const product = await this.productService.findById(id);
+ * if (!product) {
+ *   throw new NotFoundError(`Product with id ${id} not found`);
+ * }
+ * ```
+ */
+export declare class NotFoundError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 405 Method Not Allowed error.
+ * Use when the HTTP method is not supported for the resource.
+ *
+ * @example
+ * ```ts
+ * throw new MethodNotAllowedError("DELETE is not allowed for this resource");
+ * ```
+ */
+export declare class MethodNotAllowedError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 406 Not Acceptable error.
+ * Use when the server cannot produce a response matching the Accept headers.
+ *
+ * @example
+ * ```ts
+ * if (acceptHeader !== "application/json") {
+ *   throw new NotAcceptableError("Only application/json is supported");
+ * }
+ * ```
+ */
+export declare class NotAcceptableError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 408 Request Timeout error.
+ * Use when the server timed out waiting for the request.
+ *
+ * @example
+ * ```ts
+ * throw new RequestTimeoutError("Request took too long to complete");
+ * ```
+ */
+export declare class RequestTimeoutError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 409 Conflict error.
+ * Use when the request conflicts with the current state of the resource.
+ *
+ * @example
+ * ```ts
+ * const existing = await this.userService.findByEmail(email);
+ * if (existing) {
+ *   throw new ConflictError("User with this email already exists");
+ * }
+ * ```
+ */
+export declare class ConflictError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 410 Gone error.
+ * Use when the resource existed but has been permanently deleted.
+ *
+ * @example
+ * ```ts
+ * if (resource.deletedAt) {
+ *   throw new GoneError("This resource has been permanently removed");
+ * }
+ * ```
+ */
+export declare class GoneError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 413 Payload Too Large error.
+ * Use when the request body exceeds the server's size limit.
+ *
+ * @example
+ * ```ts
+ * if (fileSize > MAX_FILE_SIZE) {
+ *   throw new PayloadTooLargeError(`File size exceeds ${MAX_FILE_SIZE} bytes`);
+ * }
+ * ```
+ */
+export declare class PayloadTooLargeError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 415 Unsupported Media Type error.
+ * Use when the request content type is not supported.
+ *
+ * @example
+ * ```ts
+ * if (contentType !== "application/json") {
+ *   throw new UnsupportedMediaTypeError("Only JSON content type is accepted");
+ * }
+ * ```
+ */
+export declare class UnsupportedMediaTypeError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 422 Unprocessable Entity error.
+ * Use when the request is well-formed but semantically invalid.
+ *
+ * @example
+ * ```ts
+ * if (startDate > endDate) {
+ *   throw new UnprocessableEntityError("Start date cannot be after end date");
+ * }
+ * ```
+ */
+export declare class UnprocessableEntityError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 429 Too Many Requests error.
+ * Use when the user has exceeded the rate limit.
+ *
+ * @example
+ * ```ts
+ * if (requestCount > RATE_LIMIT) {
+ *   throw new TooManyRequestsError("Rate limit exceeded. Please try again later.");
+ * }
+ * ```
+ */
+export declare class TooManyRequestsError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 500 Internal Server Error.
+ * Use for unexpected server errors that are not the client's fault.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await this.externalService.call();
+ * } catch (error) {
+ *   throw new InternalServerError("Failed to process request", error);
+ * }
+ * ```
+ */
+export declare class InternalServerError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 501 Not Implemented error.
+ * Use when the server does not support the functionality required.
+ *
+ * @example
+ * ```ts
+ * throw new NotImplementedError("This feature is not yet implemented");
+ * ```
+ */
+export declare class NotImplementedError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 502 Bad Gateway error.
+ * Use when the server received an invalid response from an upstream server.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await fetch(upstreamUrl);
+ * } catch (error) {
+ *   throw new BadGatewayError("Upstream service returned invalid response", error);
+ * }
+ * ```
+ */
+export declare class BadGatewayError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 503 Service Unavailable error.
+ * Use when the server is temporarily unable to handle the request.
+ *
+ * @example
+ * ```ts
+ * if (isMaintenanceMode) {
+ *   throw new ServiceUnavailableError("Service is under maintenance");
+ * }
+ * ```
+ */
+export declare class ServiceUnavailableError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * HTTP 504 Gateway Timeout error.
+ * Use when an upstream server timed out.
+ *
+ * @example
+ * ```ts
+ * throw new GatewayTimeoutError("Upstream service did not respond in time");
+ * ```
+ */
+export declare class GatewayTimeoutError extends HttpError {
+    constructor(message?: string, error?: unknown);
+}
+/**
+ * Validation error (extends BadRequestError - HTTP 400).
+ * Use specifically for input validation failures.
+ *
+ * @example
+ * ```ts
+ * const errors = validate(dto);
+ * if (errors.length) {
+ *   throw new ValidateError("Validation failed", errors);
+ * }
+ * ```
+ */
+export declare class ValidateError extends BadRequestError {
+    constructor(message?: string, error?: unknown);
+}

package/dist/error.js

@@ -0,0 +1 @@
+"use strict";class r extends Error{constructor(r,e,s){super(e),this.statusCode=r,this.message=e,this.error=s,this.name=this.constructor.name}}class e extends r{constructor(r="Bad Request",e){super(400,r,e)}}exports.BadGatewayError=class extends r{constructor(r="Bad Gateway",e){super(502,r,e)}},exports.BadRequestError=e,exports.ConflictError=class extends r{constructor(r="Conflict",e){super(409,r,e)}},exports.ForbiddenError=class extends r{constructor(r="Forbidden",e){super(403,r,e)}},exports.GatewayTimeoutError=class extends r{constructor(r="Gateway Timeout",e){super(504,r,e)}},exports.GoneError=class extends r{constructor(r="Gone",e){super(410,r,e)}},exports.HttpError=r,exports.InternalServerError=class extends r{constructor(r="Internal Server Error",e){super(500,r,e)}},exports.MethodNotAllowedError=class extends r{constructor(r="Method Not Allowed",e){super(405,r,e)}},exports.NotAcceptableError=class extends r{constructor(r="Not Acceptable",e){super(406,r,e)}},exports.NotFoundError=class extends r{constructor(r="Not Found",e){super(404,r,e)}},exports.NotImplementedError=class extends r{constructor(r="Not Implemented",e){super(501,r,e)}},exports.PayloadTooLargeError=class extends r{constructor(r="Payload Too Large",e){super(413,r,e)}},exports.RequestTimeoutError=class extends r{constructor(r="Request Timeout",e){super(408,r,e)}},exports.ServiceUnavailableError=class extends r{constructor(r="Service Unavailable",e){super(503,r,e)}},exports.TooManyRequestsError=class extends r{constructor(r="Too Many Requests",e){super(429,r,e)}},exports.UnauthorizedError=class extends r{constructor(r="Unauthorized",e){super(401,r,e)}},exports.UnprocessableEntityError=class extends r{constructor(r="Unprocessable Entity",e){super(422,r,e)}},exports.UnsupportedMediaTypeError=class extends r{constructor(r="Unsupported Media Type",e){super(415,r,e)}},exports.ValidateError=class extends e{constructor(r="Validation Error",e){super(r,e)}};

package/dist/error.mjs

@@ -0,0 +1 @@
+class s extends Error{constructor(s,e,t){super(e),this.statusCode=s,this.message=e,this.error=t,this.name=this.constructor.name}}class e extends s{constructor(s="Bad Request",e){super(400,s,e)}}class t extends s{constructor(s="Unauthorized",e){super(401,s,e)}}class r extends s{constructor(s="Forbidden",e){super(403,s,e)}}class o extends s{constructor(s="Not Found",e){super(404,s,e)}}class c extends s{constructor(s="Method Not Allowed",e){super(405,s,e)}}class n extends s{constructor(s="Not Acceptable",e){super(406,s,e)}}class u extends s{constructor(s="Request Timeout",e){super(408,s,e)}}class a extends s{constructor(s="Conflict",e){super(409,s,e)}}class d extends s{constructor(s="Gone",e){super(410,s,e)}}class l extends s{constructor(s="Payload Too Large",e){super(413,s,e)}}class p extends s{constructor(s="Unsupported Media Type",e){super(415,s,e)}}class x extends s{constructor(s="Unprocessable Entity",e){super(422,s,e)}}class i extends s{constructor(s="Too Many Requests",e){super(429,s,e)}}class h extends s{constructor(s="Internal Server Error",e){super(500,s,e)}}class m extends s{constructor(s="Not Implemented",e){super(501,s,e)}}class y extends s{constructor(s="Bad Gateway",e){super(502,s,e)}}class T extends s{constructor(s="Service Unavailable",e){super(503,s,e)}}class b extends s{constructor(s="Gateway Timeout",e){super(504,s,e)}}class E extends e{constructor(s="Validation Error",e){super(s,e)}}export{y as BadGatewayError,e as BadRequestError,a as ConflictError,r as ForbiddenError,b as GatewayTimeoutError,d as GoneError,s as HttpError,h as InternalServerError,c as MethodNotAllowedError,n as NotAcceptableError,o as NotFoundError,m as NotImplementedError,l as PayloadTooLargeError,u as RequestTimeoutError,T as ServiceUnavailableError,i as TooManyRequestsError,t as UnauthorizedError,x as UnprocessableEntityError,p as UnsupportedMediaTypeError,E as ValidateError};