@exyconn/common 2.3.2 → 2.3.3

package/dist/client/http/index.mjs

@@ -1,109 +1,466 @@
 import axios from 'axios';
 
-// src/client/http/axios-instance.ts
-var createHttpClient = (options) => {
-  const {
-    baseURL,
-    timeout = 3e4,
-    withCredentials = true,
-    getAuthToken,
-    onUnauthorized,
-    onServerError
-  } = options;
-  const instance = axios.create({
-    baseURL,
-    timeout,
-    withCredentials,
-    headers: {
-      "Content-Type": "application/json"
-    }
-  });
-  instance.interceptors.request.use(
-    (config) => {
-      if (getAuthToken) {
-        const token = getAuthToken();
-        if (token && config.headers) {
-          config.headers.Authorization = `Bearer ${token}`;
-        }
+// src/client/http/http.ts
+
+// src/client/http/logger.ts
+var Logger = class {
+  constructor() {
+    this.isDevelopment = typeof window !== "undefined" && window.location.hostname === "localhost";
+  }
+  /**
+   * Log informational messages
+   */
+  info(message, data, options) {
+    if (this.isDevelopment) {
+      const prefix = options?.context ? `[${options.context}]` : "";
+      console.log(`${prefix} ${message}`, data ?? "");
+    }
+  }
+  /**
+   * Log warning messages
+   */
+  warn(message, data, options) {
+    if (this.isDevelopment) {
+      const prefix = options?.context ? `[${options.context}]` : "";
+      console.warn(`${prefix} ${message}`, data ?? "");
+    }
+  }
+  /**
+   * Log error messages
+   */
+  error(message, error, options) {
+    const prefix = options?.context ? `[${options.context}]` : "";
+    if (this.isDevelopment) {
+      console.error(`${prefix} ${message}`, error, options?.metadata || "");
+    }
+  }
+  /**
+   * Log debug messages (only in development)
+   */
+  debug(message, data, options) {
+    if (this.isDevelopment) {
+      const prefix = options?.context ? `[${options.context}]` : "";
+      console.debug(`${prefix} ${message}`, data || "");
+    }
+  }
+  /**
+   * Log API errors with structured information
+   */
+  apiError(endpoint, error, metadata) {
+    this.error(`API Error: ${endpoint}`, error, {
+      context: "API",
+      metadata: {
+        endpoint,
+        ...metadata
       }
-      return config;
-    },
-    (error) => Promise.reject(error)
-  );
-  instance.interceptors.response.use(
-    (response) => response,
-    (error) => {
-      if (error.response) {
-        const status = error.response.status;
-        if (status === 401 && onUnauthorized) {
-          onUnauthorized();
-        }
-        if (status >= 500 && onServerError) {
-          onServerError(error);
-        }
+    });
+  }
+};
+var logger = new Logger();
+
+// src/client/http/response-parser.ts
+var STATUS_CODES = {
+  SUCCESS: 200,
+  CREATED: 201,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  ERROR: 500
+};
+var STATUS_MESSAGES = {
+  SUCCESS: "success",
+  CREATED: "created",
+  NO_CONTENT: "no_content",
+  BAD_REQUEST: "bad_request",
+  UNAUTHORIZED: "unauthorized",
+  FORBIDDEN: "forbidden",
+  NOT_FOUND: "not_found",
+  CONFLICT: "conflict",
+  ERROR: "error"
+};
+var SUCCESS_CODES = [200, 201, 204];
+var ERROR_CODES = [400, 401, 403, 404, 409, 500];
+var parseResponseData = (response, fallback = null) => {
+  try {
+    if (!response || typeof response !== "object") {
+      return fallback;
+    }
+    const resp = response;
+    if ("data" in resp) {
+      return resp["data"] ?? fallback;
+    }
+    return response;
+  } catch (error) {
+    logger.error("Error parsing response data", error);
+    return fallback;
+  }
+};
+var parseResponseMessage = (response, fallback = "") => {
+  try {
+    if (!response || typeof response !== "object") {
+      return fallback;
+    }
+    const resp = response;
+    if ("message" in resp && typeof resp["message"] === "string") {
+      return resp["message"];
+    }
+    return fallback;
+  } catch (error) {
+    logger.error("Error parsing response message", error);
+    return fallback;
+  }
+};
+var parseResponseStatus = (response) => {
+  try {
+    if (!response || typeof response !== "object") {
+      return null;
+    }
+    const resp = response;
+    if ("statusCode" in resp && typeof resp["statusCode"] === "number") {
+      return resp["statusCode"];
+    }
+    if ("status" in resp && typeof resp["status"] === "number") {
+      return resp["status"];
+    }
+    return null;
+  } catch (error) {
+    logger.error("Error parsing response status", error);
+    return null;
+  }
+};
+var parseResponseStatusMessage = (response, fallback = "") => {
+  try {
+    if (!response || typeof response !== "object") {
+      return fallback;
+    }
+    const resp = response;
+    if ("status" in resp && typeof resp["status"] === "string") {
+      return resp["status"];
+    }
+    return fallback;
+  } catch (error) {
+    logger.error("Error parsing response status message", error);
+    return fallback;
+  }
+};
+var isSuccessResponse = (response) => {
+  try {
+    const statusCode = parseResponseStatus(response);
+    if (statusCode !== null) {
+      return SUCCESS_CODES.includes(statusCode);
+    }
+    const status = parseResponseStatusMessage(response);
+    return [STATUS_MESSAGES.SUCCESS, STATUS_MESSAGES.CREATED, STATUS_MESSAGES.NO_CONTENT].includes(
+      status
+    );
+  } catch (error) {
+    logger.error("Error checking response success", error);
+    return false;
+  }
+};
+var isErrorResponse = (response) => {
+  try {
+    const statusCode = parseResponseStatus(response);
+    if (statusCode !== null) {
+      return ERROR_CODES.includes(statusCode);
+    }
+    return false;
+  } catch (error) {
+    logger.error("Error checking response error", error);
+    return false;
+  }
+};
+var parsePaginatedResponse = (response) => {
+  try {
+    if (!response || typeof response !== "object") {
+      return { items: [], total: 0, page: 1, limit: 10 };
+    }
+    const resp = response;
+    let items = [];
+    if ("data" in resp && Array.isArray(resp["data"])) {
+      items = resp["data"];
+    }
+    let total = items.length;
+    let page = 1;
+    let limit = 10;
+    let totalPages;
+    if ("paginationData" in resp && resp["paginationData"] && typeof resp["paginationData"] === "object") {
+      const paginationData = resp["paginationData"];
+      if ("total" in paginationData && typeof paginationData["total"] === "number") {
+        total = paginationData["total"];
+      }
+      if ("page" in paginationData && typeof paginationData["page"] === "number") {
+        page = paginationData["page"];
+      }
+      if ("limit" in paginationData && typeof paginationData["limit"] === "number") {
+        limit = paginationData["limit"];
+      }
+      if ("totalPages" in paginationData && typeof paginationData["totalPages"] === "number") {
+        totalPages = paginationData["totalPages"];
       }
-      return Promise.reject(error);
     }
-  );
-  return instance;
+    let columns;
+    if ("columns" in resp && Array.isArray(resp["columns"])) {
+      columns = resp["columns"];
+    }
+    return {
+      items,
+      total,
+      page,
+      limit,
+      ...totalPages !== void 0 && { totalPages },
+      ...columns !== void 0 && { columns }
+    };
+  } catch (error) {
+    logger.error("Error parsing paginated response", error);
+    return { items: [], total: 0, page: 1, limit: 10 };
+  }
 };
-var withFormData = () => ({
-  headers: {
-    "Content-Type": "multipart/form-data"
+var extractNestedData = (response, path, fallback = null) => {
+  try {
+    const keys = path.split(".");
+    let current = response;
+    for (const key of keys) {
+      if (current && typeof current === "object" && key in current) {
+        current = current[key];
+      } else {
+        return fallback;
+      }
+    }
+    return current;
+  } catch (error) {
+    logger.error("Error extracting nested data", error);
+    return fallback;
   }
-});
-var withTimeout = (ms) => ({
-  timeout: ms
-});
-var withAbortSignal = (signal) => ({
-  signal
-});
-
-// src/client/http/response-parser.ts
-var parseResponse = (response) => {
-  if (response.data?.success && response.data?.data !== void 0) {
-    return response.data.data;
+};
+var safeJsonParse = (json, fallback = null) => {
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    logger.error("Error parsing JSON", error);
+    return fallback;
   }
-  return null;
 };
-var parseFullResponse = (response) => {
-  return response.data;
+var parseAxiosErrorMessage = (error) => {
+  try {
+    if (!error || typeof error !== "object") {
+      return "An unexpected error occurred";
+    }
+    const err = error;
+    if ("response" in err && err["response"] && typeof err["response"] === "object") {
+      const response = err["response"];
+      if ("data" in response && response["data"] && typeof response["data"] === "object") {
+        const data = response["data"];
+        if ("data" in data && data["data"] && typeof data["data"] === "object") {
+          const nestedData = data["data"];
+          if ("message" in nestedData && typeof nestedData["message"] === "string") {
+            return nestedData["message"];
+          }
+        }
+        if ("message" in data && typeof data["message"] === "string") {
+          return data["message"];
+        }
+        if ("error" in data && typeof data["error"] === "string") {
+          return data["error"];
+        }
+      }
+    }
+    if ("message" in err && typeof err["message"] === "string") {
+      return err["message"];
+    }
+    if (typeof error === "string") {
+      return error;
+    }
+    return "An unexpected error occurred";
+  } catch (parseError2) {
+    logger.error("Error parsing axios error message", parseError2);
+    return "An unexpected error occurred";
+  }
 };
 var parseError = (error) => {
-  if (error.response?.data?.message) {
-    return error.response.data.message;
+  try {
+    if (!error || typeof error !== "object") {
+      return {
+        message: "An unexpected error occurred",
+        statusCode: null,
+        data: null
+      };
+    }
+    const err = error;
+    let statusCode = null;
+    let data = null;
+    let status;
+    if ("response" in err && err["response"] && typeof err["response"] === "object") {
+      const response = err["response"];
+      if ("status" in response && typeof response["status"] === "number") {
+        statusCode = response["status"];
+      }
+      if ("data" in response && response["data"] !== void 0) {
+        data = response["data"];
+        if (data && typeof data === "object" && "status" in data) {
+          const dataObj = data;
+          if (typeof dataObj["status"] === "string") {
+            status = dataObj["status"];
+          }
+        }
+      }
+    }
+    if (statusCode === null && "statusCode" in err && typeof err["statusCode"] === "number") {
+      statusCode = err["statusCode"];
+    }
+    if (data === null && "data" in err && err["data"] !== void 0) {
+      data = err["data"];
+    }
+    if (!status && "status" in err && typeof err["status"] === "string") {
+      status = err["status"];
+    }
+    return {
+      message: parseAxiosErrorMessage(error),
+      statusCode,
+      data,
+      ...status !== void 0 && { status }
+    };
+  } catch (err) {
+    logger.error("Error parsing error object", err);
+    return {
+      message: "An unexpected error occurred",
+      statusCode: null,
+      data: null
+    };
   }
-  if (error.response?.data?.error) {
-    return error.response.data.error;
+};
+var simpleParseResponse = (response) => {
+  return response?.data?.data?.data;
+};
+var simpleMetaParseResponse = (response) => {
+  return response?.data?.data?.meta;
+};
+var simpleParseDualDataResponse = (response) => {
+  return response?.data?.data;
+};
+
+// src/client/http/http.ts
+var isDevelopment = typeof window !== "undefined" && window.location.hostname === "localhost";
+var API_BASE_URL = isDevelopment ? "http://localhost:4002" : "https://service-api.exyconn.com";
+var API_PREFIX = "/v1/api";
+var axiosInstance = axios.create({
+  baseURL: API_BASE_URL,
+  timeout: 3e4,
+  // 30 seconds
+  headers: {
+    "Content-Type": "application/json"
   }
-  if (error.code === "ERR_NETWORK") {
-    return "Network error. Please check your connection.";
+});
+axiosInstance.interceptors.request.use(
+  (config) => {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        const selectedOrg = localStorage.getItem("selectedOrganization");
+        if (selectedOrg) {
+          const org = JSON.parse(selectedOrg);
+          if (org && org._id) {
+            config.headers["x-organization-id"] = org._id;
+          }
+        }
+      }
+    } catch (error) {
+      logger.warn("Failed to read organization from localStorage", error);
+    }
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
   }
-  if (error.code === "ECONNABORTED") {
-    return "Request timed out. Please try again.";
+);
+axiosInstance.interceptors.response.use(
+  (response) => response,
+  (error) => {
+    const parsedError = parseError(error);
+    logger.error("API Error", parsedError);
+    return Promise.reject(parsedError);
   }
-  return error.message || "An unexpected error occurred.";
+);
+var buildHeaders = (customHeaders) => {
+  const headers = {
+    "Content-Type": "application/json",
+    ...customHeaders
+  };
+  return headers;
 };
-var isSuccess = (response) => {
-  return response.data?.success === true;
+var buildConfig = (params, customHeaders) => {
+  const config = {
+    headers: buildHeaders(customHeaders)
+  };
+  if (params) {
+    config.params = params;
+  }
+  return config;
+};
+var getRequest = async (url, params, customHeaders) => {
+  const config = buildConfig(params, customHeaders);
+  return axiosInstance.get(url, config);
 };
-var isStatusError = (error, statusCode) => {
-  return error.response?.status === statusCode;
+var postRequest = async (url, data, customHeaders) => {
+  const config = buildConfig(void 0, customHeaders);
+  return axiosInstance.post(url, data, config);
 };
-var isUnauthorized = (error) => {
-  return isStatusError(error, 401);
+var putRequest = async (url, data, customHeaders) => {
+  const config = buildConfig(void 0, customHeaders);
+  return axiosInstance.put(url, data, config);
 };
-var isForbidden = (error) => {
-  return isStatusError(error, 403);
+var patchRequest = async (url, data, customHeaders) => {
+  const config = buildConfig(void 0, customHeaders);
+  return axiosInstance.patch(url, data, config);
+};
+var deleteRequest = async (url, params, customHeaders) => {
+  const config = buildConfig(params, customHeaders);
+  return axiosInstance.delete(url, config);
+};
+var uploadFile = async (url, file, additionalData) => {
+  const formData = new FormData();
+  formData.append("file", file);
+  if (additionalData) {
+    Object.entries(additionalData).forEach(([key, value]) => {
+      formData.append(key, String(value));
+    });
+  }
+  const config = {
+    headers: {
+      "Content-Type": "multipart/form-data"
+    }
+  };
+  return axiosInstance.post(url, formData, config);
+};
+var extractData = (response) => {
+  return parseResponseData(response.data);
+};
+var extractMessage = (response) => {
+  return parseResponseMessage(response, "");
+};
+var isSuccess = (response) => {
+  return response.status >= 200 && response.status < 300;
+};
+var extractPaginatedData = (response) => {
+  return parsePaginatedResponse(response.data);
+};
+
+// src/client/http/slug.ts
+var generateSlug = (text) => {
+  if (!text) return "";
+  return text.trim().replace(/[^\w\s]/g, "").replace(/\s+(.)/g, (_, char) => char.toUpperCase()).replace(/\s+/g, "").replace(/^(.)/, (_, char) => char.toLowerCase());
 };
-var isNotFound = (error) => {
-  return isStatusError(error, 404);
+var generateUrlSlug = (text) => {
+  if (!text) return "";
+  return text.trim().toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 };
-var isServerError = (error) => {
-  const status = error.response?.status;
-  return status !== void 0 && status >= 500;
+var generateSnakeSlug = (text) => {
+  if (!text) return "";
+  return text.trim().toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
 };
 
-export { createHttpClient, isForbidden, isNotFound, isServerError, isStatusError, isSuccess, isUnauthorized, parseError, parseFullResponse, parseResponse, withAbortSignal, withFormData, withTimeout };
+export { API_BASE_URL, API_PREFIX, ERROR_CODES, STATUS_CODES, STATUS_MESSAGES, SUCCESS_CODES, axiosInstance as axios, deleteRequest, extractData, extractMessage, extractNestedData, extractPaginatedData, generateSlug, generateSnakeSlug, generateUrlSlug, getRequest, isErrorResponse, isSuccess, isSuccessResponse, logger, parseAxiosErrorMessage, parseError, parsePaginatedResponse, parseResponseData, parseResponseMessage, parseResponseStatus, parseResponseStatusMessage, patchRequest, postRequest, putRequest, safeJsonParse, simpleMetaParseResponse, simpleParseDualDataResponse, simpleParseResponse, uploadFile };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map