@chidchanun/bcp 0.1.19 → 0.1.21

package/packages/client/src/http-error.ts

@@ -0,0 +1,516 @@
+export interface HttpErrorOptions {
+    code?: string;
+    message?: string;
+    details?: unknown;
+    headers?: HeadersInit;
+}
+
+export interface HttpErrorPayload {
+    error: {
+        status: number;
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+}
+
+export interface HttpErrorLike {
+    name: string;
+    status: number;
+    code: string;
+    message: string;
+    details?: unknown;
+    headers?: unknown;
+}
+
+export class HttpError
+    extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details: unknown;
+    readonly headers: Headers;
+
+    constructor(
+        status: number,
+        options: HttpErrorOptions = {}
+    ) {
+        assertHttpErrorStatus(
+            status
+        );
+
+        const defaults =
+            getHttpErrorDefaults(
+                status
+            );
+
+        super(
+            options.message ??
+            defaults.message
+        );
+
+        this.name =
+            "HttpError";
+        this.status =
+            status;
+        this.code =
+            normalizeErrorCode(
+                options.code ??
+                defaults.code
+            );
+        this.details =
+            options.details;
+        this.headers =
+            new Headers(
+                options.headers
+            );
+    }
+}
+
+export function createHttpError(
+    status: number,
+    options: HttpErrorOptions = {}
+): HttpError {
+    return new HttpError(
+        status,
+        options
+    );
+}
+
+export function throwHttpError(
+    status: number,
+    options: HttpErrorOptions = {}
+): never {
+    throw createHttpError(
+        status,
+        options
+    );
+}
+
+export function isHttpError(
+    error: unknown
+): error is HttpErrorLike {
+    return (
+        error instanceof
+            HttpError ||
+        (
+            typeof error ===
+                "object" &&
+            error !== null &&
+            "name" in error &&
+            error.name ===
+                "HttpError" &&
+            "status" in error &&
+            typeof error.status ===
+                "number" &&
+            Number.isInteger(
+                error.status
+            ) &&
+            error.status >= 400 &&
+            error.status <= 599 &&
+            "code" in error &&
+            typeof error.code ===
+                "string" &&
+            "message" in error &&
+            typeof error.message ===
+                "string"
+        )
+    );
+}
+
+export function toErrorResponse(
+    error: unknown,
+    fallback: HttpErrorOptions = {}
+): Response {
+    const httpError =
+        isHttpError(
+            error
+        )
+            ? normalizeHttpError(
+                error
+            )
+            : createHttpError(
+                500,
+                fallback
+            );
+
+    return createHttpErrorResponse(
+        httpError
+    );
+}
+
+export function errorResponse(
+    status: number,
+    options: HttpErrorOptions = {}
+): Response {
+    return createHttpErrorResponse(
+        createHttpError(
+            status,
+            options
+        )
+    );
+}
+
+export function badRequest(
+    message = "Bad Request",
+    details?: unknown
+): Response {
+    return errorResponse(
+        400,
+        {
+            code:
+                "bad_request",
+            message,
+            details,
+        }
+    );
+}
+
+export function unauthorized(
+    message = "Unauthorized",
+    details?: unknown
+): Response {
+    return errorResponse(
+        401,
+        {
+            code:
+                "unauthorized",
+            message,
+            details,
+        }
+    );
+}
+
+export function forbidden(
+    message = "Forbidden",
+    details?: unknown
+): Response {
+    return errorResponse(
+        403,
+        {
+            code:
+                "forbidden",
+            message,
+            details,
+        }
+    );
+}
+
+export function notFoundResponse(
+    message = "Not Found",
+    details?: unknown
+): Response {
+    return errorResponse(
+        404,
+        {
+            code:
+                "not_found",
+            message,
+            details,
+        }
+    );
+}
+
+export function conflict(
+    message = "Conflict",
+    details?: unknown
+): Response {
+    return errorResponse(
+        409,
+        {
+            code:
+                "conflict",
+            message,
+            details,
+        }
+    );
+}
+
+export function unprocessableEntity(
+    message = "Unprocessable Entity",
+    details?: unknown
+): Response {
+    return errorResponse(
+        422,
+        {
+            code:
+                "unprocessable_entity",
+            message,
+            details,
+        }
+    );
+}
+
+export function tooManyRequests(
+    message = "Too Many Requests",
+    options: {
+        details?: unknown;
+        retryAfter?:
+            | number
+            | string;
+    } = {}
+): Response {
+    const headers =
+        new Headers();
+
+    if (
+        options.retryAfter !==
+        undefined
+    ) {
+        headers.set(
+            "Retry-After",
+            String(
+                options.retryAfter
+            )
+        );
+    }
+
+    return errorResponse(
+        429,
+        {
+            code:
+                "too_many_requests",
+            message,
+            details:
+                options.details,
+            headers,
+        }
+    );
+}
+
+export function internalServerError(
+    message = "Internal Server Error"
+): Response {
+    return errorResponse(
+        500,
+        {
+            code:
+                "internal_server_error",
+            message,
+        }
+    );
+}
+
+export function serviceUnavailable(
+    message = "Service Unavailable",
+    details?: unknown
+): Response {
+    return errorResponse(
+        503,
+        {
+            code:
+                "service_unavailable",
+            message,
+            details,
+        }
+    );
+}
+
+function createHttpErrorResponse(
+    error: HttpError
+): Response {
+    const payload:
+        HttpErrorPayload = {
+        error: {
+            status:
+                error.status,
+            code:
+                error.code,
+            message:
+                error.message,
+        },
+    };
+
+    if (
+        error.details !==
+        undefined
+    ) {
+        payload.error.details =
+            error.details;
+    }
+
+    const headers =
+        new Headers(
+            error.headers
+        );
+
+    if (
+        !headers.has(
+            "Cache-Control"
+        )
+    ) {
+        headers.set(
+            "Cache-Control",
+            "no-store"
+        );
+    }
+
+    return Response.json(
+        payload,
+        {
+            status:
+                error.status,
+            headers,
+        }
+    );
+}
+
+function normalizeHttpError(
+    error: HttpErrorLike
+): HttpError {
+    if (
+        error instanceof
+        HttpError
+    ) {
+        return error;
+    }
+
+    return createHttpError(
+        error.status,
+        {
+            code:
+                error.code,
+            message:
+                error.message,
+            details:
+                error.details,
+            headers:
+                error.headers instanceof
+                    Headers
+                    ? error.headers
+                    : undefined,
+        }
+    );
+}
+
+function assertHttpErrorStatus(
+    status: number
+): void {
+    if (
+        !Number.isInteger(
+            status
+        ) ||
+        status < 400 ||
+        status > 599
+    ) {
+        throw new RangeError(
+            `BCP Framework: HTTP error status must be an integer from 400 to 599, received ${status}.`
+        );
+    }
+}
+
+function normalizeErrorCode(
+    value: string
+): string {
+    const normalized =
+        value
+            .trim()
+            .toLowerCase()
+            .replace(
+                /[^a-z0-9]+/g,
+                "_"
+            )
+            .replace(
+                /^_+|_+$/g,
+                ""
+            );
+
+    if (!normalized) {
+        throw new Error(
+            "BCP Framework: HTTP error code must not be empty."
+        );
+    }
+
+    return normalized;
+}
+
+function getHttpErrorDefaults(
+    status: number
+): {
+    code: string;
+    message: string;
+} {
+    switch (status) {
+        case 400:
+            return {
+                code: "bad_request",
+                message: "Bad Request",
+            };
+        case 401:
+            return {
+                code: "unauthorized",
+                message: "Unauthorized",
+            };
+        case 403:
+            return {
+                code: "forbidden",
+                message: "Forbidden",
+            };
+        case 404:
+            return {
+                code: "not_found",
+                message: "Not Found",
+            };
+        case 405:
+            return {
+                code: "method_not_allowed",
+                message: "Method Not Allowed",
+            };
+        case 409:
+            return {
+                code: "conflict",
+                message: "Conflict",
+            };
+        case 413:
+            return {
+                code: "payload_too_large",
+                message: "Payload Too Large",
+            };
+        case 415:
+            return {
+                code: "unsupported_media_type",
+                message: "Unsupported Media Type",
+            };
+        case 422:
+            return {
+                code: "unprocessable_entity",
+                message: "Unprocessable Entity",
+            };
+        case 429:
+            return {
+                code: "too_many_requests",
+                message: "Too Many Requests",
+            };
+        case 500:
+            return {
+                code: "internal_server_error",
+                message: "Internal Server Error",
+            };
+        case 501:
+            return {
+                code: "not_implemented",
+                message: "Not Implemented",
+            };
+        case 502:
+            return {
+                code: "bad_gateway",
+                message: "Bad Gateway",
+            };
+        case 503:
+            return {
+                code: "service_unavailable",
+                message: "Service Unavailable",
+            };
+        case 504:
+            return {
+                code: "gateway_timeout",
+                message: "Gateway Timeout",
+            };
+        default:
+            return {
+                code:
+                    `http_${status}`,
+                message:
+                    `HTTP ${status}`,
+            };
+    }
+}

package/packages/client/src/server.ts

@@ -22,6 +22,28 @@ export {
     type RedirectStatus,
 } from "../../server/src/server-response.js";
 
+export {
+    badRequest,
+    conflict,
+    createHttpError,
+    errorResponse,
+    forbidden,
+    HttpError,
+    internalServerError,
+    isHttpError,
+    notFoundResponse,
+    serviceUnavailable,
+    throwHttpError,
+    tooManyRequests,
+    toErrorResponse,
+    unauthorized,
+    unprocessableEntity,
+
+    type HttpErrorLike,
+    type HttpErrorOptions,
+    type HttpErrorPayload,
+} from "./http-error.js";
+
 export {
     createSession,
     createSessionToken,