import {
  HttpNotFound,
  HttpBadRequest,
} from "@httpx/exception";
 
const e = new HttpNotFound();
// 👉 e.message     -> 'Not found' (default message)
// 👉 e.statusCode  -> 404
// 👉 -> e instanceof HttpNotFound (and HttpClientException, HttpException and Error)
 
const e400 = new HttpBadRequest("Problems parsing JSON");
// 👉 e.message     -> 'Problems parsing JSON'
// ...

import { createHttpException } from "@httpx/exception";
 
const e404 = createHttpException(404); // e404 instanceof HttpClientException
const e500 = createHttpException(500); // e500 instanceof HttpServerException

import { createHttpException, HttpNotImplemented } from "@httpx/exception";
 
throw createHttpException(404, "The graal is yet to find !");
 
const e500 = createHttpException(500, {
  message: "Something really wrong happened.",
  url: "https://api.dev/gateway",
  cause: new HttpNotImplemented(), // or any Error...
});

import { HttpGatewayTimeout, HttpInternalServerError } from "@httpx/exception";
 
const e500 = new HttpInternalServerError({
  url: "https://api.dev/gateway",
  method: "GET",
  code: "ERR_UNREACHABLE_SERVICE",
  errorId: nanoid(),
  // 👉 nesting
  cause: new HttpGatewayTimeout({
    message: "This Serverless Function has timed out",
    errorId: "cdg1::h99k2-1664884491087-b41a2832f559",
  }),
});

import { HttpUnprocessableEntity } from "@httpx/exception";
 
const e422 = new HttpUnprocessableEntity({
  message: "Request validation failed",
  url: "https://acme.org/api/user/create",
  method: "POST",
  issues: [
    // typed as HttpValidationIssues[]
    {
      message: "Invalid address",
      path: ["addresses", 0, "line1"],
      code: "empty_string",
    },
  ],
});
 
// 👉 e422.issues
// 👉 e422.method === 'POST'
// ...

const e = new HttpBadRequest({
  // 👉 nesting
  cause: new TypeError({
    message: "Param validation failed",
    // 👉 nesting: multiple levels are supported
    cause: new NoSuchUser("User id is invalid"),
  }),
});

import { createHttpException, HttpMethodNotAllowed } from "@httpx/exception";
 
const { statusCode } = createHttpException(405);
switch (statusCode) {
  case HttpMethodNotAllowed.STATUS:
    console.log(statusCode); // 👉 405
    break;
}

import { createHttpException } from "@httpx/exception";
 
const e404 = createHttpException(404);
// 👉 e instanceof Error === true
// 👉 e instanceof HttpException === true
// 👉 e instanceof HttpClientException === true
// 👉 e instanceof HttpNotFound === true
// 👉 e instanceof HttpServerException === false

import {
  isHttpException,
  isHttpClientException,
  isHttpServerException,
} from "@httpx/exception";
 
// True
isHttpException(new HttpNotFound());
isHttpClientException(new HttpNotFound());
isHttpServerException(new HttpInternalServerError());
 
// False
isHttpClientException(new HttpInternalServerError());
isHttpServerException(new HttpNotFound());
isHttpException(new Error());
isHttpServerException(
  new (class extends HttpServerException {
    constructor() {
      super(400); // 400 isn't a server exception
    }
  })()
);

import { isHttpErrorStatusCode } from "@httpx/exception";
 
// True
isHttpErrorStatusCode(404);
// False
isHttpErrorStatusCode(200);

import { fromJson, toJson } from "@httpx/exception/serializer";
 
const e = new HttpForbidden();
 
const json = toJson(e); // string
const deserialized = fromJson(json);
 
// e === deserialized

import {
  convertToSerializable,
  createFromSerializable,
} from "@httpx/exception/serializer";
 
const e = new HttpForbidden({
  cause: new Error("Token was revoked"),
});
 
const serializableObject = convertToSerializable(e);
const deserialized = createFromSerializable(serializableObject);
// e === deserialized

import { createHttpException, HttpServerException } from "@httpx/exception";
 
const nonOfficialStatusCodes = [
  [509, "Might refer to bandwidth limit"],
  [525, "Might refer to SSL Handshake Failed (ie: cloudflare)"],
  [526, "Might refer to Invalid SSL Certificate (ie: cloudflare)"],
  ["...", "..."],
];
 
const e = createHttpException(509, {
  message: "Bandwidth limit exceeded",
  // ... others properties
});
 
// e instanceof HttpServerException
 
// alternatively
const alternate = new HttpServerException({
  statusCode: 509,
  message: "Bandwidth limit exceeded",
  // ... others properties
});

import {
  isErrorWithErrorStatusCode,
  createHttpException,
  type isErrorWithErrorStatusCode
} from "@httpx/exception";
 
try {
  throw new (class extends Error {
    statusCode = 400; // <- by convention
  })();
} catch (e) {
  // will check if the value is an Error and that there's a statusCode is >=400 && <600
  if (isErrorWithErrorStatusCode(e)) {
    throw createHttpException(e.statusCode, e.message);
  }
}

import {
  isObjectWithErrorStatusCode,
  createHttpException,
  type ObjectWithErrorStatusCode,
} from "@httpx/exception";
 
const noSuchUser = {
  statusCode: 404,
} satisfies ObjectWithErrorStatusCode;
 
class NoSuchItem extends DomainError implements ObjectWithErrorStatusCode {
  statusCode = 404;
}
 
if (isObjectWithErrorStatusCode(noSuchUser)) {
  throw createHttpException(e.statusCode, "Nothing");
}