@vertz/errors 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,51 +1,3 @@
-// src/result.ts
-var ok = (data) => ({ ok: true, data });
-var err = (error) => ({ ok: false, error });
-function unwrap(result) {
-  if (result.ok) {
-    return result.data;
-  }
-  throw result.error;
-}
-function unwrapOr(result, defaultValue) {
-  if (result.ok) {
-    return result.data;
-  }
-  return defaultValue;
-}
-function map(result, fn) {
-  if (result.ok) {
-    return { ok: true, data: fn(result.data) };
-  }
-  return result;
-}
-function flatMap(result, fn) {
-  if (result.ok) {
-    return fn(result.data);
-  }
-  return result;
-}
-function match(result, handlers) {
-  return result.ok ? handlers.ok(result.data) : handlers.err(result.error);
-}
-function matchErr(result, handlers) {
-  if (result.ok) {
-    return handlers.ok(result.data);
-  }
-  const errorCode = result.error.code;
-  const handlersRecord = handlers;
-  const handler = handlersRecord[errorCode];
-  if (!handler) {
-    throw new Error(`Unhandled error code: ${errorCode}`);
-  }
-  return handler(result.error);
-}
-function isOk(result) {
-  return result.ok === true;
-}
-function isErr(result) {
-  return result.ok === false;
-}
 // src/app-error.ts
 class AppError extends Error {
   code;
@@ -61,70 +13,6 @@ class AppError extends Error {
     };
   }
 }
-// src/domain/schema.ts
-function createValidationError(message, issues) {
-  return {
-    code: "VALIDATION_FAILED",
-    message,
-    issues
-  };
-}
-function isValidationError(error) {
-  return error.code === "VALIDATION_FAILED";
-}
-// src/domain/db.ts
-function createNotFoundError(table, key) {
-  const keyStr = key ? JSON.stringify(key) : "";
-  return {
-    code: "NOT_FOUND",
-    message: `Record not found in ${table}${keyStr ? `: ${keyStr}` : ""}`,
-    table,
-    key
-  };
-}
-function isNotFoundError(error) {
-  return error.code === "NOT_FOUND";
-}
-function createUniqueViolation(message, options) {
-  return {
-    code: "UNIQUE_VIOLATION",
-    message,
-    ...options
-  };
-}
-function isUniqueViolation(error) {
-  return error.code === "UNIQUE_VIOLATION";
-}
-function createFKViolation(message, options) {
-  return {
-    code: "FK_VIOLATION",
-    message,
-    ...options
-  };
-}
-function isFKViolation(error) {
-  return error.code === "FK_VIOLATION";
-}
-function createNotNullViolation(message, options) {
-  return {
-    code: "NOT_NULL_VIOLATION",
-    message,
-    ...options
-  };
-}
-function isNotNullViolation(error) {
-  return error.code === "NOT_NULL_VIOLATION";
-}
-function createCheckViolation(message, options) {
-  return {
-    code: "CHECK_VIOLATION",
-    message,
-    ...options
-  };
-}
-function isCheckViolation(error) {
-  return error.code === "CHECK_VIOLATION";
-}
 // src/domain/auth.ts
 function createInvalidCredentialsError(message = "Invalid email or password") {
   return {
@@ -174,54 +62,65 @@ function createRateLimitedError(message = "Too many attempts, please try again l
 function isRateLimitedError(error) {
   return error.code === "RATE_LIMITED";
 }
+function createAuthValidationError(message, field, constraint) {
+  return {
+    code: "AUTH_VALIDATION_ERROR",
+    message,
+    field,
+    ...constraint !== undefined ? { constraint } : {}
+  };
+}
+function isAuthValidationError(error) {
+  return error.code === "AUTH_VALIDATION_ERROR";
+}
 // src/domain/client.ts
-function createValidationError2(message, issues) {
+function createValidationError(message, issues) {
   return {
-    code: "VALIDATION_ERROR",
+    code: "ValidationError",
     message,
     issues
   };
 }
-function isValidationError2(error) {
-  return error.code === "VALIDATION_ERROR";
+function isValidationError(error) {
+  return error.code === "ValidationError";
 }
-function createNotFoundError2(message = "Resource not found", resource) {
+function createNotFoundError(message = "Resource not found", resource) {
   return {
-    code: "NOT_FOUND",
+    code: "NotFound",
     message,
     resource
   };
 }
-function isNotFoundError2(error) {
-  return error.code === "NOT_FOUND";
+function isNotFoundError(error) {
+  return error.code === "NotFound";
 }
 function createConflictError(message = "Resource conflict", field) {
   return {
-    code: "CONFLICT",
+    code: "Conflict",
     message,
     field
   };
 }
 function isConflictError(error) {
-  return error.code === "CONFLICT";
+  return error.code === "Conflict";
 }
 function createUnauthorizedError(message = "Authentication required") {
   return {
-    code: "UNAUTHORIZED",
+    code: "Unauthorized",
     message
   };
 }
 function isUnauthorizedError(error) {
-  return error.code === "UNAUTHORIZED";
+  return error.code === "Unauthorized";
 }
 function createForbiddenError(message = "Access denied") {
   return {
-    code: "FORBIDDEN",
+    code: "Forbidden",
     message
   };
 }
 function isForbiddenError(error) {
-  return error.code === "FORBIDDEN";
+  return error.code === "Forbidden";
 }
 function createRateLimitedError2(message = "Too many requests", retryAfter) {
   return {
@@ -233,6 +132,102 @@ function createRateLimitedError2(message = "Too many requests", retryAfter) {
 function isRateLimitedError2(error) {
   return error.code === "RATE_LIMITED";
 }
+// src/domain/db.ts
+function createNotFoundError2(table, key) {
+  const keyStr = key ? JSON.stringify(key) : "";
+  return {
+    code: "NotFound",
+    message: `Record not found in ${table}${keyStr ? `: ${keyStr}` : ""}`,
+    table,
+    key
+  };
+}
+function isNotFoundError2(error) {
+  return error.code === "NotFound";
+}
+function createUniqueViolation(message, options) {
+  return {
+    code: "UNIQUE_VIOLATION",
+    message,
+    ...options
+  };
+}
+function isUniqueViolation(error) {
+  return error.code === "UNIQUE_VIOLATION";
+}
+function createFKViolation(message, options) {
+  return {
+    code: "FK_VIOLATION",
+    message,
+    ...options
+  };
+}
+function isFKViolation(error) {
+  return error.code === "FK_VIOLATION";
+}
+function createNotNullViolation(message, options) {
+  return {
+    code: "NOT_NULL_VIOLATION",
+    message,
+    ...options
+  };
+}
+function isNotNullViolation(error) {
+  return error.code === "NOT_NULL_VIOLATION";
+}
+function createCheckViolation(message, options) {
+  return {
+    code: "CHECK_VIOLATION",
+    message,
+    ...options
+  };
+}
+function isCheckViolation(error) {
+  return error.code === "CHECK_VIOLATION";
+}
+// src/domain/migration.ts
+function createMigrationQueryError(message, options) {
+  return {
+    code: "MIGRATION_QUERY_ERROR",
+    message,
+    ...options
+  };
+}
+function isMigrationQueryError(error) {
+  return error.code === "MIGRATION_QUERY_ERROR";
+}
+function createMigrationChecksumMismatch(migrationName, expectedChecksum, actualChecksum) {
+  return {
+    code: "MIGRATION_CHECKSUM_MISMATCH",
+    message: `Migration ${migrationName} has been modified after being applied (expected: ${expectedChecksum}, actual: ${actualChecksum})`,
+    migrationName,
+    expectedChecksum,
+    actualChecksum
+  };
+}
+function isMigrationChecksumMismatch(error) {
+  return error.code === "MIGRATION_CHECKSUM_MISMATCH";
+}
+function createMigrationHistoryNotFound() {
+  return {
+    code: "MIGRATION_HISTORY_NOT_FOUND",
+    message: "Migration history table does not exist. Run createHistoryTable() first."
+  };
+}
+function isMigrationHistoryNotFound(error) {
+  return error.code === "MIGRATION_HISTORY_NOT_FOUND";
+}
+// src/domain/schema.ts
+function createValidationError2(message, issues) {
+  return {
+    code: "VALIDATION_FAILED",
+    message,
+    issues
+  };
+}
+function isValidationError2(error) {
+  return error.code === "VALIDATION_FAILED";
+}
 // src/infra/index.ts
 class InfraError extends Error {
   constructor(message) {
@@ -280,7 +275,7 @@ class SerializationError extends InfraError {
 function dbErrorToHttpStatus(error) {
   const code = error.code;
   switch (code) {
-    case "NOT_FOUND":
+    case "NotFound":
       return 404;
     case "UNIQUE_VIOLATION":
       return 409;
@@ -331,7 +326,7 @@ function httpToClientError(status, body) {
     case 400:
       if (bodyObj.code === "VALIDATION_FAILED" || bodyObj.issues) {
         const error = {
-          code: "VALIDATION_ERROR",
+          code: "ValidationError",
           message,
           issues: Array.isArray(bodyObj.issues) ? bodyObj.issues : undefined
         };
@@ -340,30 +335,30 @@ function httpToClientError(status, body) {
       return parseUnknownError(status, body);
     case 401:
       return {
-        code: "UNAUTHORIZED",
+        code: "Unauthorized",
         message
       };
     case 403:
       return {
-        code: "FORBIDDEN",
+        code: "Forbidden",
         message
       };
     case 404:
       return {
-        code: "NOT_FOUND",
+        code: "NotFound",
         message,
         resource: typeof bodyObj.resource === "string" ? bodyObj.resource : undefined
       };
     case 409:
       return {
-        code: "CONFLICT",
+        code: "Conflict",
         message,
         field: typeof bodyObj.field === "string" ? bodyObj.field : undefined
       };
     case 422:
       if (bodyObj.code === "VALIDATION_FAILED" || bodyObj.issues) {
         const error = {
-          code: "VALIDATION_ERROR",
+          code: "ValidationError",
           message,
           issues: Array.isArray(bodyObj.issues) ? bodyObj.issues : undefined
         };
@@ -387,6 +382,428 @@ function httpToClientError(status, body) {
 function isUnknownError(error) {
   return error.code === "UNKNOWN";
 }
+// src/result.ts
+var ok = (data) => ({ ok: true, data });
+var err = (error) => ({ ok: false, error });
+function unwrap(result) {
+  if (result.ok) {
+    return result.data;
+  }
+  throw result.error;
+}
+function unwrapOr(result, defaultValue) {
+  if (result.ok) {
+    return result.data;
+  }
+  return defaultValue;
+}
+function map(result, fn) {
+  if (result.ok) {
+    return { ok: true, data: fn(result.data) };
+  }
+  return result;
+}
+function flatMap(result, fn) {
+  if (result.ok) {
+    return fn(result.data);
+  }
+  return result;
+}
+function match(result, handlers) {
+  return result.ok ? handlers.ok(result.data) : handlers.err(result.error);
+}
+function matchErr(result, handlers) {
+  if (result.ok) {
+    return handlers.ok(result.data);
+  }
+  const errorCode = result.error.code;
+  const handlersRecord = handlers;
+  const handler = handlersRecord[errorCode];
+  if (!handler) {
+    throw new Error(`Unhandled error code: ${errorCode}`);
+  }
+  return handler(result.error);
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+// src/fetch.ts
+class FetchError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = this.constructor.name;
+  }
+}
+
+class FetchNetworkError extends FetchError {
+  code = "NetworkError";
+  constructor(message = "Network request failed") {
+    super("NetworkError", message);
+    this.name = "NetworkError";
+  }
+}
+function isFetchNetworkError(error) {
+  return error instanceof FetchNetworkError;
+}
+
+class HttpError extends FetchError {
+  code = "HttpError";
+  status;
+  serverCode;
+  constructor(status, message, serverCode) {
+    super("HttpError", message);
+    this.name = "HttpError";
+    this.status = status;
+    this.serverCode = serverCode;
+  }
+}
+function isHttpError(error) {
+  return error instanceof HttpError;
+}
+
+class FetchBadRequestError extends HttpError {
+  code = "HttpError";
+  constructor(message, serverCode) {
+    super(400, message, serverCode);
+    this.name = "FetchBadRequestError";
+  }
+}
+function isFetchBadRequestError(error) {
+  return error instanceof FetchBadRequestError;
+}
+
+class FetchUnauthorizedError extends HttpError {
+  code = "HttpError";
+  constructor(message, serverCode) {
+    super(401, message, serverCode);
+    this.name = "FetchUnauthorizedError";
+  }
+}
+function isFetchUnauthorizedError(error) {
+  return error instanceof FetchUnauthorizedError;
+}
+
+class FetchForbiddenError extends HttpError {
+  code = "HttpError";
+  constructor(message, serverCode) {
+    super(403, message, serverCode);
+    this.name = "FetchForbiddenError";
+  }
+}
+function isFetchForbiddenError(error) {
+  return error instanceof FetchForbiddenError;
+}
+
+class FetchNotFoundError extends HttpError {
+  code = "HttpError";
+  constructor(message, serverCode) {
+    super(404, message, serverCode);
+    this.name = "FetchNotFoundError";
+  }
+}
+function isFetchNotFoundError(error) {
+  return error instanceof FetchNotFoundError;
+}
+
+class FetchConflictError extends HttpError {
+  code = "HttpError";
+  constructor(message, serverCode) {
+    super(409, message, serverCode);
+    this.name = "FetchConflictError";
+  }
+}
+function isFetchConflictError(error) {
+  return error instanceof FetchConflictError;
+}
+
+class FetchGoneError extends HttpError {
+  code = "HttpError";
+  constructor(message, serverCode) {
+    super(410, message, serverCode);
+    this.name = "FetchGoneError";
+  }
+}
+function isFetchGoneError(error) {
+  return error instanceof FetchGoneError;
+}
+
+class FetchUnprocessableEntityError extends HttpError {
+  code = "HttpError";
+  constructor(message, serverCode) {
+    super(422, message, serverCode);
+    this.name = "FetchUnprocessableEntityError";
+  }
+}
+function isFetchUnprocessableEntityError(error) {
+  return error instanceof FetchUnprocessableEntityError;
+}
+
+class FetchRateLimitError extends HttpError {
+  code = "HttpError";
+  constructor(message, serverCode) {
+    super(429, message, serverCode);
+    this.name = "FetchRateLimitError";
+  }
+}
+function isFetchRateLimitError(error) {
+  return error instanceof FetchRateLimitError;
+}
+
+class FetchInternalServerError extends HttpError {
+  code = "HttpError";
+  constructor(message, serverCode) {
+    super(500, message, serverCode);
+    this.name = "FetchInternalServerError";
+  }
+}
+function isFetchInternalServerError(error) {
+  return error instanceof FetchInternalServerError;
+}
+
+class FetchServiceUnavailableError extends HttpError {
+  code = "HttpError";
+  constructor(message, serverCode) {
+    super(503, message, serverCode);
+    this.name = "FetchServiceUnavailableError";
+  }
+}
+function isFetchServiceUnavailableError(error) {
+  return error instanceof FetchServiceUnavailableError;
+}
+
+class FetchTimeoutError extends FetchError {
+  code = "TimeoutError";
+  constructor(message = "Request timed out") {
+    super("TimeoutError", message);
+    this.name = "TimeoutError";
+  }
+}
+function isFetchTimeoutError(error) {
+  return error instanceof FetchTimeoutError;
+}
+
+class ParseError extends FetchError {
+  code = "ParseError";
+  path;
+  value;
+  constructor(path, message, value) {
+    super("ParseError", message);
+    this.name = "ParseError";
+    this.path = path;
+    this.value = value;
+  }
+}
+function isParseError(error) {
+  return error instanceof ParseError;
+}
+
+class FetchValidationError extends FetchError {
+  code = "ValidationError";
+  errors;
+  constructor(message, errors) {
+    super("ValidationError", message);
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+}
+function isFetchValidationError(error) {
+  return error instanceof FetchValidationError;
+}
+function createHttpError(status, message, serverCode) {
+  switch (status) {
+    case 400:
+      return new FetchBadRequestError(message, serverCode);
+    case 401:
+      return new FetchUnauthorizedError(message, serverCode);
+    case 403:
+      return new FetchForbiddenError(message, serverCode);
+    case 404:
+      return new FetchNotFoundError(message, serverCode);
+    case 409:
+      return new FetchConflictError(message, serverCode);
+    case 410:
+      return new FetchGoneError(message, serverCode);
+    case 422:
+      return new FetchUnprocessableEntityError(message, serverCode);
+    case 429:
+      return new FetchRateLimitError(message, serverCode);
+    case 500:
+      return new FetchInternalServerError(message, serverCode);
+    case 503:
+      return new FetchServiceUnavailableError(message, serverCode);
+    default:
+      return new HttpError(status, message, serverCode);
+  }
+}
+// src/entity.ts
+class EntityError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = this.constructor.name;
+  }
+}
+
+class BadRequestError extends EntityError {
+  code = "BadRequest";
+  constructor(message = "Bad Request") {
+    super("BadRequest", message);
+    this.name = "BadRequestError";
+  }
+}
+function isBadRequestError(error) {
+  return error instanceof BadRequestError;
+}
+
+class EntityUnauthorizedError extends EntityError {
+  code = "Unauthorized";
+  constructor(message = "Unauthorized") {
+    super("Unauthorized", message);
+    this.name = "UnauthorizedError";
+  }
+}
+function isEntityUnauthorizedError(error) {
+  return error instanceof EntityUnauthorizedError;
+}
+
+class EntityForbiddenError extends EntityError {
+  code = "Forbidden";
+  constructor(message = "Forbidden") {
+    super("Forbidden", message);
+    this.name = "ForbiddenError";
+  }
+}
+function isEntityForbiddenError(error) {
+  return error instanceof EntityForbiddenError;
+}
+
+class EntityNotFoundError extends EntityError {
+  code = "NotFound";
+  resource;
+  resourceId;
+  constructor(message = "Not Found", resource, resourceId) {
+    super("NotFound", message);
+    this.name = "NotFoundError";
+    this.resource = resource;
+    this.resourceId = resourceId;
+  }
+}
+function isEntityNotFoundError(error) {
+  return error instanceof EntityNotFoundError;
+}
+
+class MethodNotAllowedError extends EntityError {
+  code = "MethodNotAllowed";
+  allowedMethods;
+  constructor(allowedMethods, message = "Method Not Allowed") {
+    super("MethodNotAllowed", message);
+    this.name = "MethodNotAllowedError";
+    this.allowedMethods = allowedMethods;
+  }
+}
+function isMethodNotAllowedError(error) {
+  return error instanceof MethodNotAllowedError;
+}
+
+class EntityConflictError extends EntityError {
+  code = "Conflict";
+  field;
+  constructor(message = "Conflict", field) {
+    super("Conflict", message);
+    this.name = "ConflictError";
+    this.field = field;
+  }
+}
+function isEntityConflictError(error) {
+  return error instanceof EntityConflictError;
+}
+
+class EntityValidationError extends EntityError {
+  code = "ValidationError";
+  errors;
+  constructor(errors) {
+    super("ValidationError", "Validation failed");
+    this.name = "EntityValidationError";
+    this.errors = errors;
+  }
+}
+function isEntityValidationError(error) {
+  return error instanceof EntityValidationError;
+}
+
+class InternalError extends EntityError {
+  code = "InternalError";
+  constructor(message = "Internal Server Error") {
+    super("InternalError", message);
+    this.name = "InternalError";
+  }
+}
+function isInternalError(error) {
+  return error instanceof InternalError;
+}
+
+class ServiceUnavailableError extends EntityError {
+  code = "ServiceUnavailable";
+  retryAfter;
+  constructor(message = "Service Unavailable", retryAfter) {
+    super("ServiceUnavailable", message);
+    this.name = "ServiceUnavailableError";
+    this.retryAfter = retryAfter;
+  }
+}
+function isServiceUnavailableError(error) {
+  return error instanceof ServiceUnavailableError;
+}
+// src/match-error.ts
+function matchError(error, handlers) {
+  const isFetchError = error.code === "NetworkError" || error.code === "HttpError" || error.code === "TimeoutError" || error.code === "ParseError" || error.code === "ValidationError" && error.name !== "EntityValidationError";
+  if (isFetchError) {
+    const code2 = error.code;
+    switch (code2) {
+      case "NetworkError":
+        return handlers.NetworkError(error);
+      case "HttpError":
+        return handlers.HttpError(error);
+      case "TimeoutError":
+        return handlers.TimeoutError(error);
+      case "ParseError":
+        return handlers.ParseError(error);
+      case "ValidationError":
+        return handlers.ValidationError(error);
+    }
+  }
+  const code = error.code;
+  switch (code) {
+    case "BadRequest":
+      return handlers.BadRequest(error);
+    case "Unauthorized":
+      return handlers.Unauthorized(error);
+    case "Forbidden":
+      return handlers.Forbidden(error);
+    case "NotFound":
+      return handlers.NotFound(error);
+    case "MethodNotAllowed":
+      return handlers.MethodNotAllowed(error);
+    case "Conflict":
+      return handlers.Conflict(error);
+    case "ValidationError":
+      return handlers.ValidationError(error);
+    case "InternalError":
+      return handlers.InternalError(error);
+    case "ServiceUnavailable":
+      return handlers.ServiceUnavailable(error);
+  }
+  const checkExhaustive = (c) => {
+    throw new Error(`Unhandled error code: ${c}`);
+  };
+  return checkExhaustive(code);
+}
 export {
   unwrapOr,
   unwrap,
@@ -394,6 +811,7 @@ export {
   ok,
   notNullViolationToHttpStatus,
   notFoundErrorToHttpStatus,
+  matchError,
   matchErr,
   match,
   map,
@@ -402,20 +820,48 @@ export {
   isUniqueViolation,
   isUnauthorizedError,
   isSessionExpiredError,
-  isValidationError as isSchemaValidationError,
+  isServiceUnavailableError,
+  isValidationError2 as isSchemaValidationError,
   isPermissionDeniedError,
+  isParseError,
   isOk,
   isNotNullViolation,
+  isMigrationQueryError,
+  isMigrationHistoryNotFound,
+  isMigrationChecksumMismatch,
+  isMethodNotAllowedError,
   isInvalidCredentialsError,
+  isInternalError,
+  isHttpError,
   isForbiddenError,
+  isFetchValidationError,
+  isFetchUnprocessableEntityError,
+  isFetchUnauthorizedError,
+  isFetchTimeoutError,
+  isFetchServiceUnavailableError,
+  isFetchRateLimitError,
+  isFetchNotFoundError,
+  isFetchNetworkError,
+  isFetchInternalServerError,
+  isFetchGoneError,
+  isFetchForbiddenError,
+  isFetchConflictError,
+  isFetchBadRequestError,
   isFKViolation,
   isErr,
-  isNotFoundError as isDBNotFoundError,
+  isEntityValidationError,
+  isEntityUnauthorizedError,
+  isEntityNotFoundError,
+  isEntityForbiddenError,
+  isEntityConflictError,
+  isNotFoundError2 as isDBNotFoundError,
   isConflictError,
-  isValidationError2 as isClientValidationError,
+  isValidationError as isClientValidationError,
   isRateLimitedError2 as isClientRateLimitedError,
-  isNotFoundError2 as isClientNotFoundError,
+  isNotFoundError as isClientNotFoundError,
   isCheckViolation,
+  isBadRequestError,
+  isAuthValidationError,
   isRateLimitedError as isAuthRateLimitedError,
   httpToClientError,
   flatMap,
@@ -426,26 +872,57 @@ export {
   createUniqueViolation,
   createUnauthorizedError,
   createSessionExpiredError,
-  createValidationError as createSchemaValidationError,
+  createValidationError2 as createSchemaValidationError,
   createPermissionDeniedError,
   createNotNullViolation,
+  createMigrationQueryError,
+  createMigrationHistoryNotFound,
+  createMigrationChecksumMismatch,
   createInvalidCredentialsError,
+  createHttpError,
   createForbiddenError,
   createFKViolation,
-  createNotFoundError as createDBNotFoundError,
+  createNotFoundError2 as createDBNotFoundError,
   createConflictError,
-  createValidationError2 as createClientValidationError,
+  createValidationError as createClientValidationError,
   createRateLimitedError2 as createClientRateLimitedError,
-  createNotFoundError2 as createClientNotFoundError,
+  createNotFoundError as createClientNotFoundError,
   createCheckViolation,
+  createAuthValidationError,
   createRateLimitedError as createAuthRateLimitedError,
   checkViolationToHttpStatus,
   TimeoutError,
+  ServiceUnavailableError,
   SerializationError,
   QueryError,
   PoolExhaustedError,
+  ParseError,
   NetworkError,
+  MethodNotAllowedError,
+  InternalError,
   InfraError,
+  HttpError,
+  FetchValidationError,
+  FetchUnprocessableEntityError,
+  FetchUnauthorizedError,
+  FetchTimeoutError,
+  FetchServiceUnavailableError,
+  FetchRateLimitError,
+  FetchNotFoundError,
+  FetchNetworkError,
+  FetchInternalServerError,
+  FetchGoneError,
+  FetchForbiddenError,
+  FetchError,
+  FetchConflictError,
+  FetchBadRequestError,
+  EntityValidationError,
+  EntityUnauthorizedError,
+  EntityNotFoundError,
+  EntityForbiddenError,
+  EntityError,
+  EntityConflictError,
   ConnectionError,
+  BadRequestError,
   AppError
 };