@vertz/errors 0.2.15 → 0.2.16

package/dist/index.js

@@ -303,207 +303,125 @@ function createValidationError2(message, issues) {
 function isValidationError2(error) {
   return error.code === "VALIDATION_FAILED";
 }
-// src/infra/index.ts
-class InfraError extends Error {
-  constructor(message) {
+// src/entity.ts
+class EntityError extends Error {
+  code;
+  constructor(code, message) {
     super(message);
+    this.code = code;
     this.name = this.constructor.name;
   }
 }
 
-class ConnectionError extends InfraError {
-  constructor(message = "Database connection failed") {
-    super(message);
+class BadRequestError extends EntityError {
+  code = "BadRequest";
+  constructor(message = "Bad Request") {
+    super("BadRequest", message);
+    this.name = "BadRequestError";
   }
 }
-
-class PoolExhaustedError extends InfraError {
-  constructor(message = "Database pool exhausted") {
-    super(message);
-  }
+function isBadRequestError(error) {
+  return error instanceof BadRequestError;
 }
 
-class QueryError extends InfraError {
-  constructor(message = "Query execution failed") {
-    super(message);
+class EntityUnauthorizedError extends EntityError {
+  code = "Unauthorized";
+  constructor(message = "Unauthorized") {
+    super("Unauthorized", message);
+    this.name = "UnauthorizedError";
   }
 }
-
-class TimeoutError extends InfraError {
-  constructor(message = "Operation timed out") {
-    super(message);
-  }
+function isEntityUnauthorizedError(error) {
+  return error instanceof EntityUnauthorizedError;
 }
 
-class NetworkError extends InfraError {
-  constructor(message = "Network request failed") {
-    super(message);
+class EntityForbiddenError extends EntityError {
+  code = "Forbidden";
+  constructor(message = "Forbidden") {
+    super("Forbidden", message);
+    this.name = "ForbiddenError";
   }
 }
-
-class SerializationError extends InfraError {
-  constructor(message = "Failed to decode response") {
-    super(message);
-  }
+function isEntityForbiddenError(error) {
+  return error instanceof EntityForbiddenError;
 }
-// src/mapping/db-to-http.ts
-function dbErrorToHttpStatus(error) {
-  const code = error.code;
-  switch (code) {
-    case "NotFound":
-      return 404;
-    case "UNIQUE_VIOLATION":
-      return 409;
-    case "FK_VIOLATION":
-      return 422;
-    case "NOT_NULL_VIOLATION":
-      return 422;
-    case "CHECK_VIOLATION":
-      return 422;
-    default:
-      return 500;
+
+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 notFoundErrorToHttpStatus(_error) {
-  return 404;
-}
-function uniqueViolationToHttpStatus(_error) {
-  return 409;
-}
-function fkViolationToHttpStatus(_error) {
-  return 422;
-}
-function notNullViolationToHttpStatus(_error) {
-  return 422;
-}
-function checkViolationToHttpStatus(_error) {
-  return 422;
-}
-// src/mapping/http-to-client.ts
-function parseUnknownError(status, body) {
-  const message = typeof body === "object" && body !== null && "message" in body ? String(body.message) : "Request failed";
-  return {
-    code: "UNKNOWN",
-    message,
-    status
-  };
+function isEntityNotFoundError(error) {
+  return error instanceof EntityNotFoundError;
 }
-function httpToClientError(status, body) {
-  if (body === null || body === undefined || body === "") {
-    return parseUnknownError(status, body);
-  }
-  if (typeof body !== "object") {
-    return parseUnknownError(status, body);
-  }
-  const bodyObj = body;
-  const message = typeof bodyObj.message === "string" ? bodyObj.message : "Request failed";
-  switch (status) {
-    case 400:
-      if (bodyObj.code === "VALIDATION_FAILED" || bodyObj.issues) {
-        const error = {
-          code: "ValidationError",
-          message,
-          issues: Array.isArray(bodyObj.issues) ? bodyObj.issues : undefined
-        };
-        return error;
-      }
-      return parseUnknownError(status, body);
-    case 401:
-      return {
-        code: "Unauthorized",
-        message
-      };
-    case 403:
-      return {
-        code: "Forbidden",
-        message
-      };
-    case 404:
-      return {
-        code: "NotFound",
-        message,
-        resource: typeof bodyObj.resource === "string" ? bodyObj.resource : undefined
-      };
-    case 409:
-      return {
-        code: "Conflict",
-        message,
-        field: typeof bodyObj.field === "string" ? bodyObj.field : undefined
-      };
-    case 422:
-      if (bodyObj.code === "VALIDATION_FAILED" || bodyObj.issues) {
-        const error = {
-          code: "ValidationError",
-          message,
-          issues: Array.isArray(bodyObj.issues) ? bodyObj.issues : undefined
-        };
-        return error;
-      }
-    case 429:
-      return {
-        code: "RATE_LIMITED",
-        message,
-        retryAfter: typeof bodyObj.retryAfter === "number" ? bodyObj.retryAfter : undefined
-      };
-    case 500:
-    case 502:
-    case 503:
-    case 504:
-      return parseUnknownError(status, body);
-    default:
-      return parseUnknownError(status, body);
+
+class MethodNotAllowedError extends EntityError {
+  code = "MethodNotAllowed";
+  allowedMethods;
+  constructor(allowedMethods, message = "Method Not Allowed") {
+    super("MethodNotAllowed", message);
+    this.name = "MethodNotAllowedError";
+    this.allowedMethods = allowedMethods;
   }
 }
-function isUnknownError(error) {
-  return error.code === "UNKNOWN";
+function isMethodNotAllowedError(error) {
+  return error instanceof MethodNotAllowedError;
 }
-// src/result.ts
-var ok = (data) => ({ ok: true, data });
-var err = (error) => ({ ok: false, error });
-function unwrap(result) {
-  if (result.ok) {
-    return result.data;
+
+class EntityConflictError extends EntityError {
+  code = "Conflict";
+  field;
+  constructor(message = "Conflict", field) {
+    super("Conflict", message);
+    this.name = "ConflictError";
+    this.field = field;
   }
-  throw result.error;
 }
-function unwrapOr(result, defaultValue) {
-  if (result.ok) {
-    return result.data;
-  }
-  return defaultValue;
+function isEntityConflictError(error) {
+  return error instanceof EntityConflictError;
 }
-function map(result, fn) {
-  if (result.ok) {
-    return { ok: true, data: fn(result.data) };
+
+class EntityValidationError extends EntityError {
+  code = "ValidationError";
+  errors;
+  constructor(errors) {
+    super("ValidationError", "Validation failed");
+    this.name = "EntityValidationError";
+    this.errors = errors;
   }
-  return result;
 }
-function flatMap(result, fn) {
-  if (result.ok) {
-    return fn(result.data);
+function isEntityValidationError(error) {
+  return error instanceof EntityValidationError;
+}
+
+class InternalError extends EntityError {
+  code = "InternalError";
+  constructor(message = "Internal Server Error") {
+    super("InternalError", message);
+    this.name = "InternalError";
   }
-  return result;
 }
-function match(result, handlers) {
-  return result.ok ? handlers.ok(result.data) : handlers.err(result.error);
+function isInternalError(error) {
+  return error instanceof InternalError;
 }
-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}`);
+
+class ServiceUnavailableError extends EntityError {
+  code = "ServiceUnavailable";
+  retryAfter;
+  constructor(message = "Service Unavailable", retryAfter) {
+    super("ServiceUnavailable", message);
+    this.name = "ServiceUnavailableError";
+    this.retryAfter = retryAfter;
   }
-  return handler(result.error);
-}
-function isOk(result) {
-  return result.ok === true;
 }
-function isErr(result) {
-  return result.ok === false;
+function isServiceUnavailableError(error) {
+  return error instanceof ServiceUnavailableError;
 }
 // src/fetch.ts
 class FetchError extends Error {
@@ -715,125 +633,159 @@ function createHttpError(status, message, serverCode) {
       return new HttpError(status, message, serverCode);
   }
 }
-// src/entity.ts
-class EntityError extends Error {
-  code;
-  constructor(code, message) {
+// src/infra/index.ts
+class InfraError extends Error {
+  constructor(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";
+class ConnectionError extends InfraError {
+  constructor(message = "Database connection failed") {
+    super(message);
   }
 }
-function isBadRequestError(error) {
-  return error instanceof BadRequestError;
-}
 
-class EntityUnauthorizedError extends EntityError {
-  code = "Unauthorized";
-  constructor(message = "Unauthorized") {
-    super("Unauthorized", message);
-    this.name = "UnauthorizedError";
+class PoolExhaustedError extends InfraError {
+  constructor(message = "Database pool exhausted") {
+    super(message);
   }
 }
-function isEntityUnauthorizedError(error) {
-  return error instanceof EntityUnauthorizedError;
-}
 
-class EntityForbiddenError extends EntityError {
-  code = "Forbidden";
-  constructor(message = "Forbidden") {
-    super("Forbidden", message);
-    this.name = "ForbiddenError";
+class QueryError extends InfraError {
+  constructor(message = "Query execution failed") {
+    super(message);
   }
 }
-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;
+class TimeoutError extends InfraError {
+  constructor(message = "Operation timed out") {
+    super(message);
   }
 }
-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;
+class NetworkError extends InfraError {
+  constructor(message = "Network request failed") {
+    super(message);
   }
 }
-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;
+class SerializationError extends InfraError {
+  constructor(message = "Failed to decode response") {
+    super(message);
   }
 }
-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;
+// src/mapping/db-to-http.ts
+function dbErrorToHttpStatus(error) {
+  const code = error.code;
+  switch (code) {
+    case "NotFound":
+      return 404;
+    case "UNIQUE_VIOLATION":
+      return 409;
+    case "FK_VIOLATION":
+      return 422;
+    case "NOT_NULL_VIOLATION":
+      return 422;
+    case "CHECK_VIOLATION":
+      return 422;
+    default:
+      return 500;
   }
 }
-function isEntityValidationError(error) {
-  return error instanceof EntityValidationError;
+function notFoundErrorToHttpStatus(_error) {
+  return 404;
 }
-
-class InternalError extends EntityError {
-  code = "InternalError";
-  constructor(message = "Internal Server Error") {
-    super("InternalError", message);
-    this.name = "InternalError";
-  }
+function uniqueViolationToHttpStatus(_error) {
+  return 409;
 }
-function isInternalError(error) {
-  return error instanceof InternalError;
+function fkViolationToHttpStatus(_error) {
+  return 422;
 }
-
-class ServiceUnavailableError extends EntityError {
-  code = "ServiceUnavailable";
-  retryAfter;
-  constructor(message = "Service Unavailable", retryAfter) {
-    super("ServiceUnavailable", message);
-    this.name = "ServiceUnavailableError";
-    this.retryAfter = retryAfter;
+function notNullViolationToHttpStatus(_error) {
+  return 422;
+}
+function checkViolationToHttpStatus(_error) {
+  return 422;
+}
+// src/mapping/http-to-client.ts
+function parseUnknownError(status, body) {
+  const message = typeof body === "object" && body !== null && "message" in body ? String(body.message) : "Request failed";
+  return {
+    code: "UNKNOWN",
+    message,
+    status
+  };
+}
+function httpToClientError(status, body) {
+  if (body === null || body === undefined || body === "") {
+    return parseUnknownError(status, body);
+  }
+  if (typeof body !== "object") {
+    return parseUnknownError(status, body);
+  }
+  const bodyObj = body;
+  const message = typeof bodyObj.message === "string" ? bodyObj.message : "Request failed";
+  switch (status) {
+    case 400:
+      if (bodyObj.code === "VALIDATION_FAILED" || bodyObj.issues) {
+        const error = {
+          code: "ValidationError",
+          message,
+          issues: Array.isArray(bodyObj.issues) ? bodyObj.issues : undefined
+        };
+        return error;
+      }
+      return parseUnknownError(status, body);
+    case 401:
+      return {
+        code: "Unauthorized",
+        message
+      };
+    case 403:
+      return {
+        code: "Forbidden",
+        message
+      };
+    case 404:
+      return {
+        code: "NotFound",
+        message,
+        resource: typeof bodyObj.resource === "string" ? bodyObj.resource : undefined
+      };
+    case 409:
+      return {
+        code: "Conflict",
+        message,
+        field: typeof bodyObj.field === "string" ? bodyObj.field : undefined
+      };
+    case 422:
+      if (bodyObj.code === "VALIDATION_FAILED" || bodyObj.issues) {
+        const error = {
+          code: "ValidationError",
+          message,
+          issues: Array.isArray(bodyObj.issues) ? bodyObj.issues : undefined
+        };
+        return error;
+      }
+    case 429:
+      return {
+        code: "RATE_LIMITED",
+        message,
+        retryAfter: typeof bodyObj.retryAfter === "number" ? bodyObj.retryAfter : undefined
+      };
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return parseUnknownError(status, body);
+    default:
+      return parseUnknownError(status, body);
   }
 }
-function isServiceUnavailableError(error) {
-  return error instanceof ServiceUnavailableError;
+function isUnknownError(error) {
+  return error.code === "UNKNOWN";
 }
 // src/match-error.ts
 function matchError(error, handlers) {
@@ -879,6 +831,54 @@ function matchError(error, handlers) {
   };
   return checkExhaustive(code);
 }
+// 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;
+}
 export {
   unwrapOr,
   unwrap,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertz/errors",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "type": "module",
   "license": "MIT",
   "description": "Unified error taxonomy for Vertz - Result types, domain errors, and mapping utilities",