api-core-lib 12.0.4 → 12.0.6

package/dist/index.cjs

@@ -0,0 +1,1151 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiModuleProvider: () => ApiModuleProvider,
+  buildPaginateQuery: () => buildPaginateQuery,
+  cacheManager: () => cacheManager,
+  callDynamicApi: () => callDynamicApi,
+  createApiActions: () => createApiActions,
+  createApiClient: () => createApiClient,
+  createApiServices: () => createApiServices,
+  globalStateManager: () => globalStateManager,
+  processResponse: () => processResponse,
+  useApi: () => useApi,
+  useApiModule: () => useApiModule,
+  useApiRecord: () => useApiRecord,
+  useDeepCompareEffect: () => useDeepCompareEffect,
+  useModuleContext: () => useModuleContext
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/client.ts
+var import_axios = __toESM(require("axios"), 1);
+var import_uuid = require("uuid");
+async function runMiddleware(context, middlewares = []) {
+  const run = async (index) => {
+    if (index >= middlewares.length) return;
+    const middleware = middlewares[index];
+    await middleware(context, () => run(index + 1));
+  };
+  await run(0);
+}
+async function refreshToken(config, tokenManager) {
+  const { refreshTokenConfig } = config;
+  if (!refreshTokenConfig) {
+    console.warn("Token refresh is disabled: `refreshTokenConfig` is not provided.");
+    await tokenManager.clearTokens();
+    return null;
+  }
+  try {
+    const currentTokens = await tokenManager.getTokens();
+    if (!currentTokens.refreshToken) {
+      throw new Error("No refresh token available to perform refresh.");
+    }
+    const { path, buildRequestBody, buildRequestHeaders, extractTokens } = refreshTokenConfig;
+    const requestBody = buildRequestBody ? buildRequestBody(currentTokens.refreshToken) : { refresh_token: currentTokens.refreshToken };
+    const requestHeaders = buildRequestHeaders ? buildRequestHeaders(currentTokens) : {};
+    const response = await import_axios.default.post(
+      `${config.baseURL}${path}`,
+      requestBody,
+      { headers: requestHeaders, withCredentials: config.withCredentials }
+    );
+    const extracted = extractTokens(response.data);
+    if (!extracted || !extracted.accessToken || typeof extracted.expiresIn !== "number") {
+      throw new Error("extractTokens function failed to return a valid token structure.");
+    }
+    const newTokens = {
+      accessToken: extracted.accessToken,
+      refreshToken: extracted.refreshToken || currentTokens.refreshToken,
+      expiresAt: Date.now() + extracted.expiresIn * 1e3,
+      tokenType: extracted.tokenType || "Bearer"
+    };
+    await tokenManager.setTokens(newTokens);
+    console.info("Tokens refreshed successfully.");
+    return newTokens;
+  } catch (err) {
+    console.error("Failed to refresh token.", err.response?.data || err.message);
+    if (config.onRefreshError) {
+      config.onRefreshError(err);
+    }
+    await tokenManager.clearTokens();
+    return null;
+  }
+}
+function createApiClient(config) {
+  const {
+    baseURL,
+    tokenManager,
+    timeout = 15e3,
+    headers = {},
+    withCredentials = false,
+    middleware = [],
+    defaultIsPublic = false,
+    maxTokenRefreshRetries = 2,
+    maxQueueSize = 50,
+    onRefreshError
+  } = config;
+  const axiosInstance = import_axios.default.create({
+    baseURL,
+    timeout,
+    headers: { "Content-Type": "application/json", ...headers },
+    withCredentials
+  });
+  let isRefreshing = false;
+  let refreshAttempts = 0;
+  let failedQueue = [];
+  const processQueue = (error, token = null) => {
+    failedQueue.forEach((prom) => error ? prom.reject(error) : prom.resolve(token));
+    failedQueue = [];
+  };
+  const safeRunMiddleware = async (context, middlewareList) => {
+    try {
+      await runMiddleware(context, middlewareList);
+    } catch (err) {
+      console.error("Middleware Error", err);
+    }
+  };
+  axiosInstance.interceptors.request.use(async (req) => {
+    req.headers["X-Request-ID"] = (0, import_uuid.v4)();
+    try {
+      const fullUrl = import_axios.default.getUri({ ...req, baseURL: req.baseURL ?? baseURL });
+      console.log(`Request Sent > ${req.method?.toUpperCase()} ${fullUrl}`, `(ID: ${req.headers["X-Request-ID"]})`);
+    } catch {
+      console.warn("Failed to build full request URL for logging.");
+    }
+    await safeRunMiddleware({ req, custom: {} }, middleware);
+    if (req.isPublic ?? defaultIsPublic) {
+      return req;
+    }
+    if (tokenManager.isHttpOnly()) return req;
+    let tokens = await tokenManager.getTokens();
+    const now = Date.now();
+    const tokenBuffer = 60 * 1e3;
+    if (tokens.accessToken && tokens.expiresAt && tokens.expiresAt - now < tokenBuffer && !isRefreshing) {
+      if (config.refreshTokenConfig) {
+        console.info("Proactive token refresh initiated.");
+        isRefreshing = true;
+        try {
+          const newTokens = await refreshToken(config, tokenManager);
+          if (newTokens) tokens = newTokens;
+        } catch (err) {
+          console.error("Proactive refresh failed", err);
+        } finally {
+          isRefreshing = false;
+        }
+      }
+    }
+    if (tokens.accessToken) {
+      req.headers.Authorization = `${tokens.tokenType || "Bearer"} ${tokens.accessToken}`;
+    }
+    return req;
+  });
+  axiosInstance.interceptors.response.use(
+    async (res) => {
+      try {
+        const fullUrl = import_axios.default.getUri(res.config);
+        console.log(`Response Received < ${res.config.method?.toUpperCase()} ${fullUrl}`, `(ID: ${res.config.headers["X-Request-ID"]}, Status: ${res.status})`);
+      } catch {
+        console.warn("Failed to build full response URL for logging.");
+      }
+      await safeRunMiddleware({ req: res.config, res, custom: {} }, middleware);
+      return res;
+    },
+    async (error) => {
+      const originalRequest = error.config;
+      try {
+        const fullUrl = import_axios.default.getUri(originalRequest);
+        const method = originalRequest.method?.toUpperCase();
+        const status = error.response?.status;
+        const responseData = error.response?.data;
+        const summary = `Response Error < ${method} ${fullUrl} | Status: ${status || "N/A"}`;
+        const apiMessage = responseData?.message || error.message;
+        console.error(summary);
+        console.error(`> Message: ${apiMessage}`);
+        if (error.response) {
+          console.groupCollapsed("Full Error Response Details");
+          console.dir(error.response.data);
+          console.groupEnd();
+        }
+      } catch {
+        console.error("Response Error: Failed to build full URL for logging.", error.message);
+      }
+      await safeRunMiddleware({ req: originalRequest, error, custom: {} }, middleware);
+      const isHttpOnlyMode = tokenManager.isHttpOnly();
+      const canAttemptRefresh = error.response?.status === 401 && !originalRequest._retry && config.refreshTokenConfig;
+      if (isHttpOnlyMode && canAttemptRefresh) {
+        console.error("401 in httpOnly mode. Token refresh must be handled by the server.");
+        return Promise.reject(error);
+      }
+      if (!isHttpOnlyMode && canAttemptRefresh) {
+        if (isRefreshing) {
+          if (failedQueue.length >= maxQueueSize) {
+            console.warn("Failed request queue overflow, rejecting request.");
+            return Promise.reject(error);
+          }
+          return new Promise((resolve, reject) => failedQueue.push({ resolve, reject })).then((token) => {
+            originalRequest.headers["Authorization"] = `Bearer ${token}`;
+            return axiosInstance(originalRequest);
+          });
+        }
+        if (refreshAttempts >= maxTokenRefreshRetries) {
+          console.error("Max token refresh attempts reached.");
+          return Promise.reject(error);
+        }
+        refreshAttempts++;
+        originalRequest._retry = true;
+        isRefreshing = true;
+        try {
+          const newTokens = await refreshToken(config, tokenManager);
+          if (!newTokens?.accessToken) {
+            throw new Error("Token refresh failed to produce a new access token.");
+          }
+          processQueue(null, newTokens.accessToken);
+          originalRequest.headers["Authorization"] = `${newTokens.tokenType || "Bearer"} ${newTokens.accessToken}`;
+          return axiosInstance(originalRequest);
+        } catch (refreshError) {
+          processQueue(refreshError, null);
+          return Promise.reject(refreshError);
+        } finally {
+          isRefreshing = false;
+        }
+      }
+      return Promise.reject(error);
+    }
+  );
+  return axiosInstance;
+}
+
+// src/core/processor.ts
+var import_axios3 = __toESM(require("axios"), 1);
+
+// src/core/utils.ts
+var import_axios2 = __toESM(require("axios"), 1);
+function isAxiosResponse(obj) {
+  return obj && obj.data !== void 0 && obj.status !== void 0 && obj.config !== void 0;
+}
+function buildPaginateQuery(options) {
+  const params = new URLSearchParams();
+  for (const key in options) {
+    const value = options[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (key === "filter" && typeof value === "object" && !Array.isArray(value)) {
+      for (const filterKey in value) {
+        const filterValue = value[filterKey];
+        if (filterValue !== null && filterValue !== void 0) {
+          params.append(`filter[${filterKey}]`, String(filterValue));
+        }
+      }
+    } else if (key === "sortBy" && Array.isArray(value)) {
+      value.forEach((sortItem) => {
+        if (sortItem && sortItem.key && sortItem.direction) {
+          params.append("sortBy[]", `${sortItem.key}:${sortItem.direction}`);
+        }
+      });
+    } else {
+      params.append(key, String(value));
+    }
+  }
+  return params.toString();
+}
+function isServerError(error) {
+  return import_axios2.default.isAxiosError(error) && error.response !== void 0;
+}
+function isNetworkError(error) {
+  return import_axios2.default.isAxiosError(error) && error.response === void 0 && error.request !== void 0;
+}
+
+// src/core/processor.ts
+var processResponse = (responseOrError) => {
+  if (isAxiosResponse(responseOrError)) {
+    const response = responseOrError;
+    const rawData = response.data;
+    const isStandardApiResponse = rawData && typeof rawData.success === "boolean" && rawData.data !== void 0;
+    return {
+      data: isStandardApiResponse ? rawData.data : rawData,
+      links: isStandardApiResponse ? rawData.links : void 0,
+      meta: isStandardApiResponse ? rawData.meta : void 0,
+      rawResponse: rawData,
+      loading: false,
+      success: true,
+      error: null,
+      message: isStandardApiResponse ? rawData.message : "Request successful.",
+      validationErrors: []
+    };
+  }
+  if (isServerError(responseOrError)) {
+    const error = responseOrError;
+    const responseData = error.response.data;
+    const status = error.response.status;
+    let defaultMessage = "An unexpected server error occurred.";
+    switch (status) {
+      case 400:
+        defaultMessage = "Bad Request";
+        break;
+      case 401:
+        defaultMessage = "Unauthorized";
+        break;
+      case 403:
+        defaultMessage = "Forbidden";
+        break;
+      case 404:
+        defaultMessage = "Not Found";
+        break;
+      case 422:
+        defaultMessage = "Validation Failed";
+        break;
+      case 500:
+        defaultMessage = "Internal Server Error";
+        break;
+      case 503:
+        defaultMessage = "Service Unavailable";
+        break;
+      default:
+        defaultMessage = `Server Error (${status})`;
+    }
+    const finalApiError = {
+      message: responseData?.message || defaultMessage,
+      status,
+      code: responseData?.code || error.code,
+      errors: responseData?.errors || []
+    };
+    return {
+      data: null,
+      rawResponse: responseData,
+      error: finalApiError,
+      validationErrors: finalApiError.errors,
+      success: false,
+      loading: false,
+      message: finalApiError.message
+    };
+  }
+  if (isNetworkError(responseOrError)) {
+    const error = responseOrError;
+    return {
+      data: null,
+      rawResponse: error.request,
+      error: { message: "Network Error: Unable to connect.", status: 0, code: error.code },
+      success: false,
+      loading: false,
+      message: "Network Error."
+    };
+  }
+  if (import_axios3.default.isCancel(responseOrError)) {
+    return {
+      data: null,
+      rawResponse: null,
+      error: { message: "Request Canceled.", status: 499 },
+      success: false,
+      loading: false,
+      message: "Request Canceled."
+    };
+  }
+  return {
+    data: null,
+    rawResponse: responseOrError,
+    error: { message: "An unknown error occurred.", status: -1 },
+    success: false,
+    loading: false,
+    message: "An unknown error occurred."
+  };
+};
+
+// src/core/buildDynamicUrl.ts
+function buildDynamicUrl(template, params) {
+  if (!params) {
+    return template;
+  }
+  return template.replace(/\{(\w+)\}/g, (placeholder, key) => {
+    return params.hasOwnProperty(key) ? String(params[key]) : placeholder;
+  });
+}
+
+// src/services/crud.ts
+function createApiServices(axiosInstance, baseEndpoint) {
+  const resolveUrl = (config = {}, id) => {
+    const endpointTemplate = config.endpoint || (id != null ? `${baseEndpoint}/{id}` : baseEndpoint);
+    const params = id != null ? { id, tenant: id, tenantId: id, recordId: id } : {};
+    return buildDynamicUrl(endpointTemplate, params);
+  };
+  const get = async (id, config) => {
+    const url = resolveUrl(config, id);
+    try {
+      const response = await axiosInstance.get(url, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const getWithQuery = async (query, config) => {
+    const url = `${baseEndpoint}?${query}`;
+    try {
+      const response = await axiosInstance.get(url, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const post = async (data, config) => {
+    const url = resolveUrl(config);
+    try {
+      const response = await axiosInstance.post(url, data, config);
+      console.log("[lib] response POST: ", response);
+      console.log("[lib] response processResponse POST: ", processResponse(response));
+      return processResponse(response);
+    } catch (error) {
+      console.log("[lib] response error POST: ", processResponse(error));
+      return processResponse(error);
+    }
+  };
+  const put = async (id, data, config) => {
+    const url = resolveUrl(config, id);
+    try {
+      const response = await axiosInstance.put(url, data, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const patch = async (id, data, config) => {
+    const url = resolveUrl(config, id);
+    try {
+      const response = await axiosInstance.patch(url, data, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const remove = async (id, config) => {
+    const url = resolveUrl(config, id);
+    try {
+      const response = await axiosInstance.delete(url, config);
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const bulkDelete = async (ids, config) => {
+    const url = resolveUrl(config);
+    try {
+      const response = await axiosInstance.delete(url, { data: { ids }, ...config });
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  const upload = async (file, additionalData, config) => {
+    const url = resolveUrl(config);
+    const formData = new FormData();
+    formData.append("file", file);
+    if (additionalData) {
+      Object.keys(additionalData).forEach((key) => formData.append(key, String(additionalData[key])));
+    }
+    try {
+      const response = await axiosInstance.post(url, formData, {
+        ...config,
+        headers: { ...config?.headers, "Content-Type": "multipart/form-data" }
+      });
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+  return { get, getWithQuery, post, put, patch, remove, bulkDelete, upload };
+}
+async function callDynamicApi(axiosInstance, baseEndpoint, actionConfig, params) {
+  const { pathParams, body, config } = params;
+  const urlTemplate = `${baseEndpoint}${actionConfig.path}`;
+  const finalUrl = buildDynamicUrl(urlTemplate, pathParams || {});
+  try {
+    const { method } = actionConfig;
+    let response;
+    if (method === "POST" || method === "PUT" || method === "PATCH") {
+      response = await axiosInstance[method.toLowerCase()](finalUrl, body, config);
+    } else if (method === "DELETE") {
+      response = await axiosInstance.delete(finalUrl, { data: body, ...config });
+    } else {
+      response = await axiosInstance.get(finalUrl, { params: body, ...config });
+    }
+    return processResponse(response);
+  } catch (error) {
+    return processResponse(error);
+  }
+}
+
+// src/services/actions.ts
+function createAction(axiosInstance, method, endpoint) {
+  return async (payload, config) => {
+    try {
+      const response = await axiosInstance.request({
+        url: endpoint,
+        method,
+        ...method.toUpperCase() === "GET" ? { params: payload } : { data: payload },
+        ...config
+      });
+      return processResponse(response);
+    } catch (error) {
+      return processResponse(error);
+    }
+  };
+}
+function createApiActions(axiosInstance, actionsConfig) {
+  const actions = {};
+  for (const actionName in actionsConfig) {
+    if (Object.prototype.hasOwnProperty.call(actionsConfig, actionName)) {
+      const { method, endpoint, log } = actionsConfig[actionName];
+      actions[actionName] = createAction(axiosInstance, method, endpoint);
+    }
+  }
+  return actions;
+}
+
+// src/core/globalStateManager.ts
+var createInitialState = () => ({
+  data: null,
+  links: void 0,
+  meta: void 0,
+  error: null,
+  loading: false,
+  success: false,
+  called: false,
+  isStale: false,
+  message: void 0,
+  validationErrors: [],
+  rawResponse: null
+});
+var GlobalStateManager = class {
+  store = /* @__PURE__ */ new Map();
+  /**
+   * يحصل على لقطة (snapshot) للحالة الحالية لمفتاح معين.
+   */
+  getSnapshot(key) {
+    return this.store.get(key)?.state ?? createInitialState();
+  }
+  /**
+   * يسجل دالة callback للاستماع إلى التغييرات على مفتاح معين.
+   * @returns دالة لإلغاء الاشتراك.
+   */
+  subscribe(key, callback) {
+    if (!this.store.has(key)) {
+      this.store.set(key, { state: createInitialState(), listeners: /* @__PURE__ */ new Set() });
+    }
+    const item = this.store.get(key);
+    item.listeners.add(callback);
+    return () => {
+      item.listeners.delete(callback);
+    };
+  }
+  /**
+   * يحدّث الحالة لمفتاح معين ويقوم بإعلام جميع المشتركين.
+   */
+  setState(key, updater) {
+    const currentState = this.getSnapshot(key);
+    const newState = updater(currentState);
+    if (!this.store.has(key)) {
+      this.store.set(key, { state: newState, listeners: /* @__PURE__ */ new Set() });
+    } else {
+      this.store.get(key).state = newState;
+    }
+    this.store.get(key).listeners.forEach((listener) => listener());
+  }
+  /**
+   * يجعل البيانات المرتبطة بمفتاح معين "قديمة" (stale).
+   */
+  invalidate(key) {
+    const state = this.getSnapshot(key);
+    if (state.called) {
+      this.setState(key, (prev) => ({ ...prev, isStale: true }));
+    }
+  }
+  /**
+  * [نسخة محدثة وأكثر قوة]
+  * يجعل كل البيانات التي تبدأ بمفتاح معين "قديمة" (stale).
+  * @example invalidateByPrefix('myModule/list::') سيبطل كل صفحات القائمة.
+  */
+  invalidateByPrefix(prefix) {
+    this.store.forEach((value, key) => {
+      if (key.startsWith(prefix)) {
+        const state = this.getSnapshot(key);
+        if (state.called) {
+          this.setState(key, (prev) => ({ ...prev, isStale: true }));
+        }
+      }
+    });
+  }
+  /**
+  * Serializes the current state of the query store into a JSON string.
+  * This is used on the server to pass the initial state to the client.
+  * @returns A JSON string representing the dehydrated state.
+  */
+  dehydrate() {
+    const stateToPersist = {};
+    this.store.forEach((value, key) => {
+      if (value.state.called) {
+        stateToPersist[key] = value.state;
+      }
+    });
+    return JSON.stringify(stateToPersist);
+  }
+  /**
+   * Merges a dehydrated state object into the current store.
+   * This is used on the client to hydrate the state received from the server.
+   * @param hydratedState - A JSON string from the `dehydrate` method.
+   */
+  rehydrate(hydratedState) {
+    try {
+      const parsedState = JSON.parse(hydratedState);
+      for (const key in parsedState) {
+        this.setState(key, () => parsedState[key]);
+      }
+    } catch (e) {
+      console.error("[api-core-lib] Failed to rehydrate state:", e);
+    }
+  }
+};
+var globalStateManager = new GlobalStateManager();
+
+// src/core/cache.ts
+var CacheManager = class {
+  cache = /* @__PURE__ */ new Map();
+  defaultDuration = 15 * 60 * 1e3;
+  // 15 minutes
+  set(key, data, duration) {
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now(),
+      duration: duration || this.defaultDuration
+    });
+  }
+  get(key) {
+    const item = this.cache.get(key);
+    if (!item) return null;
+    const isExpired = Date.now() - item.timestamp > item.duration;
+    if (isExpired) {
+      this.cache.delete(key);
+      return null;
+    }
+    return item.data;
+  }
+  /**
+   * [FIX] تم تحويلها إلى دالة عامة (generic) لتعيد النوع الصحيح.
+   * الآن بدلًا من إرجاع CacheItem<unknown>، ستُرجع CacheItem<T>.
+   */
+  getWithMeta(key) {
+    const item = this.cache.get(key);
+    if (!item) return null;
+    const isExpired = Date.now() - item.timestamp > item.duration;
+    if (isExpired) {
+      this.cache.delete(key);
+      return null;
+    }
+    return item;
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  invalidateByPrefix(prefix) {
+    const keysToDelete = [];
+    for (const key of this.cache.keys()) {
+      if (key.startsWith(prefix)) {
+        keysToDelete.push(key);
+      }
+    }
+    keysToDelete.forEach((key) => this.cache.delete(key));
+    console.log(`Invalidated ${keysToDelete.length} cache entries with prefix: ${prefix}`);
+  }
+};
+var cacheManager = new CacheManager();
+
+// src/hooks/useApi.ts
+var import_react = require("react");
+function buildDynamicPath(template, params) {
+  if (!params) return template;
+  let path = template;
+  for (const key in params) {
+    path = path.replace(new RegExp(`{${key}}`, "g"), String(params[key]));
+  }
+  return path;
+}
+function useApi(axiosInstance, config) {
+  const {
+    endpoint,
+    pathParams,
+    // [REMOVE] لم نعد بحاجة لهذا الخيار
+    // encodeQuery = true, 
+    initialData,
+    initialQuery = {},
+    enabled = true,
+    refetchAfterChange = true,
+    requestConfig,
+    onSuccess,
+    onError
+  } = config;
+  const finalEndpoint = (0, import_react.useMemo)(
+    () => buildDynamicPath(endpoint, pathParams),
+    [endpoint, pathParams]
+  );
+  const [state, setState] = (0, import_react.useState)({
+    data: initialData ?? null,
+    rawResponse: null,
+    loading: enabled,
+    error: null,
+    success: false,
+    message: void 0,
+    validationErrors: void 0
+  });
+  const [queryOptions, setQueryOptions] = (0, import_react.useState)(initialQuery);
+  const apiServices = (0, import_react.useMemo)(
+    () => createApiServices(axiosInstance, finalEndpoint),
+    [axiosInstance, finalEndpoint]
+  );
+  const savedOnSuccess = (0, import_react.useRef)(onSuccess);
+  const savedOnError = (0, import_react.useRef)(onError);
+  (0, import_react.useEffect)(() => {
+    savedOnSuccess.current = onSuccess;
+    savedOnError.current = onError;
+  }, [onSuccess, onError]);
+  const fetchData = (0, import_react.useCallback)(async (currentQueryOptions) => {
+    setState((prev) => ({ ...prev, loading: true, error: null }));
+    try {
+      const finalQuery = currentQueryOptions || queryOptions;
+      const hasQueryParams = Object.keys(finalQuery).length > 0;
+      const queryString = buildPaginateQuery(finalQuery);
+      const result = hasQueryParams ? await apiServices.getWithQuery(queryString, requestConfig) : await apiServices.get(void 0, requestConfig);
+      setState(result);
+      if (result.success && savedOnSuccess.current) {
+        savedOnSuccess.current(result.message || "Fetch successful!", result.data ?? void 0);
+      } else if (!result.success && savedOnError.current) {
+        savedOnError.current(result.message || "Fetch failed", result.error ?? void 0);
+      }
+    } catch (e) {
+      const apiError = { status: 500, message: e.message || "An unexpected client-side error occurred." };
+      setState((prev) => ({ ...prev, loading: false, error: apiError, success: false }));
+      if (savedOnError.current) {
+        savedOnError.current(apiError.message, apiError);
+      }
+    }
+  }, [apiServices, queryOptions, requestConfig]);
+  (0, import_react.useEffect)(() => {
+    if (enabled) {
+      fetchData();
+    }
+  }, [enabled, fetchData]);
+  const handleActionResult = (0, import_react.useCallback)(async (actionPromise) => {
+    setState((prev) => ({ ...prev, loading: true }));
+    try {
+      const result = await actionPromise;
+      if (result.success) {
+        if (savedOnSuccess.current) {
+          savedOnSuccess.current(result.message || "Action successful!", result.data ?? void 0);
+        }
+        if (refetchAfterChange) {
+          await fetchData(queryOptions);
+        } else {
+          setState((prev) => ({ ...prev, ...result, loading: false }));
+        }
+      } else {
+        if (savedOnError.current) {
+          savedOnError.current(result.message || "Action failed", result.error ?? void 0);
+        }
+        setState((prev) => ({ ...prev, loading: false, error: result.error, success: false }));
+      }
+      return result;
+    } catch (e) {
+      const apiError = { status: 500, message: e.message || "An unexpected error occurred during action." };
+      setState((prev) => ({ ...prev, loading: false, error: apiError, success: false }));
+      if (savedOnError.current) {
+        savedOnError.current(apiError.message, apiError);
+      }
+      return { data: null, error: apiError, loading: false, success: false, rawResponse: e };
+    }
+  }, [refetchAfterChange, fetchData, queryOptions]);
+  const actions = {
+    fetch: fetchData,
+    create: (newItem, options) => handleActionResult(apiServices.post(newItem, options)),
+    put: (id, item, options) => handleActionResult(apiServices.put(id, item, options)),
+    update: (id, updatedItem, options) => handleActionResult(apiServices.patch(id, updatedItem, options)),
+    remove: (id, options) => handleActionResult(apiServices.remove(id, options)),
+    bulkRemove: (ids, options) => handleActionResult(apiServices.bulkDelete(ids, options))
+  };
+  const query = {
+    options: queryOptions,
+    setOptions: setQueryOptions,
+    setPage: (page) => setQueryOptions((prev) => ({ ...prev, page })),
+    setLimit: (limit) => setQueryOptions((prev) => ({ ...prev, page: 1, limit })),
+    setSearchTerm: (search) => setQueryOptions((prev) => ({ ...prev, page: 1, search })),
+    setSorting: (sortBy) => setQueryOptions((prev) => ({ ...prev, sortBy })),
+    setFilters: (filter) => setQueryOptions((prev) => ({ ...prev, page: 1, filter })),
+    setQueryParam: (key, value) => setQueryOptions((prev) => ({ ...prev, [key]: value, page: key !== "page" ? 1 : value })),
+    reset: () => setQueryOptions(initialQuery)
+  };
+  return { state, setState, actions, query };
+}
+
+// src/hooks/useApiRecord/index.ts
+var import_react2 = require("react");
+function buildDynamicPath2(template, params) {
+  if (!params) return template;
+  let path = template;
+  for (const key in params) {
+    path = path.replace(new RegExp(`{${key}}`, "g"), String(params[key]));
+  }
+  return path;
+}
+function useApiRecord(axiosInstance, config) {
+  const {
+    endpoint,
+    pathParams,
+    recordId,
+    initialData,
+    enabled = true,
+    refetchAfterChange = true,
+    requestConfig,
+    onSuccess,
+    onError
+  } = config;
+  const finalEndpoint = (0, import_react2.useMemo)(
+    () => buildDynamicPath2(endpoint, pathParams),
+    [endpoint, pathParams]
+  );
+  const initialState = (0, import_react2.useMemo)(() => ({
+    data: initialData ?? null,
+    rawResponse: null,
+    error: null,
+    loading: enabled && !!recordId,
+    success: false,
+    message: void 0,
+    validationErrors: void 0
+  }), [initialData, enabled, recordId]);
+  const [state, setState] = (0, import_react2.useState)(initialState);
+  const savedOnSuccess = (0, import_react2.useRef)(onSuccess);
+  const savedOnError = (0, import_react2.useRef)(onError);
+  (0, import_react2.useEffect)(() => {
+    savedOnSuccess.current = onSuccess;
+    savedOnError.current = onError;
+  }, [onSuccess, onError]);
+  const apiServices = (0, import_react2.useMemo)(
+    () => createApiServices(axiosInstance, finalEndpoint),
+    [axiosInstance, finalEndpoint]
+  );
+  const fetchRecord = (0, import_react2.useCallback)(async () => {
+    if (!recordId) {
+      setState(initialState);
+      return;
+    }
+    setState((prev) => ({ ...prev, loading: true, error: null, success: false }));
+    try {
+      const result = await apiServices.get(recordId, requestConfig);
+      setState(result);
+      if (result.success && savedOnSuccess.current) {
+        savedOnSuccess.current(result.message || "Record fetched successfully!", result.data ?? void 0);
+      } else if (!result.success && savedOnError.current) {
+        savedOnError.current(result.message || "Fetch failed", result.error ?? void 0);
+      }
+    } catch (e) {
+      console.error("[useApiRecord Fetch Error]", e);
+      const apiError = {
+        status: e.response?.status || 500,
+        message: e.message || "An unexpected client-side error occurred.",
+        code: e.code
+      };
+      setState((prev) => ({ ...prev, loading: false, success: false, error: apiError }));
+      if (savedOnError.current) {
+        savedOnError.current(apiError.message, apiError);
+      }
+    }
+  }, [apiServices, recordId, requestConfig, initialState]);
+  (0, import_react2.useEffect)(() => {
+    if (enabled) {
+      fetchRecord();
+    }
+  }, [enabled, fetchRecord]);
+  const handleActionResult = (0, import_react2.useCallback)(
+    async (actionPromise, options) => {
+      setState((prev) => ({ ...prev, loading: true }));
+      try {
+        const result = await actionPromise;
+        if (result.success) {
+          if (savedOnSuccess.current) {
+            savedOnSuccess.current(result.message || "Action successful!", result.data);
+          }
+          const shouldRefetch = options?.refetch ?? refetchAfterChange;
+          if (shouldRefetch) {
+            await fetchRecord();
+          } else {
+            setState({ ...result, loading: false, data: result.data });
+          }
+        } else {
+          if (savedOnError.current) {
+            savedOnError.current(result.message || "Action failed", result.error ?? void 0);
+          }
+          setState((prev) => ({ ...prev, ...result, loading: false }));
+        }
+        return result;
+      } catch (e) {
+        console.error("[useApiRecord Action Error]", e);
+        const apiError = {
+          status: e.response?.status || 500,
+          message: e.message || "An unexpected error occurred during the action.",
+          code: e.code
+        };
+        const errorResponse = { ...initialState, loading: false, success: false, error: apiError, rawResponse: e, data: null };
+        setState(errorResponse);
+        if (savedOnError.current) {
+          savedOnError.current(apiError.message, apiError);
+        }
+        return errorResponse;
+      }
+    },
+    [refetchAfterChange, fetchRecord, initialState]
+  );
+  const actions = {
+    fetch: fetchRecord,
+    update: (updatedItem, options) => handleActionResult(apiServices.patch(recordId, updatedItem, { ...requestConfig, ...options }), options),
+    put: (item, options) => handleActionResult(apiServices.put(recordId, item, { ...requestConfig, ...options }), options),
+    remove: (options) => handleActionResult(apiServices.remove(recordId, { ...requestConfig, ...options }), options),
+    resetState: () => setState(initialState)
+  };
+  return { state, setState, actions };
+}
+
+// src/hooks/useDeepCompareEffect/index.ts
+var import_react3 = require("react");
+var import_fast_deep_equal = __toESM(require("fast-deep-equal"), 1);
+function useDeepCompareEffect(callback, dependencies) {
+  const currentDependenciesRef = (0, import_react3.useRef)();
+  if (!(0, import_fast_deep_equal.default)(currentDependenciesRef.current, dependencies)) {
+    currentDependenciesRef.current = dependencies;
+  }
+  (0, import_react3.useEffect)(callback, [currentDependenciesRef.current]);
+}
+
+// src/hooks/useApiModule/useApiModule.ts
+var import_react4 = require("react");
+var ApiModuleContext = (0, import_react4.createContext)(null);
+var ApiModuleProvider = ApiModuleContext.Provider;
+function useModuleContext() {
+  const context = (0, import_react4.useContext)(ApiModuleContext);
+  if (!context) {
+    throw new Error("useModuleContext must be used within an ApiModuleProvider");
+  }
+  return context;
+}
+var generateCacheKey = (moduleName, actionName, input, callOptions = {}) => {
+  const params = { path: callOptions.pathParams, body: input };
+  try {
+    return `${moduleName}/${actionName}::${JSON.stringify(params)}`;
+  } catch (error) {
+    return `${moduleName}/${actionName}::${Date.now()}`;
+  }
+};
+function useApiModule(axiosInstance, moduleConfig, options = {}) {
+  const { refetchOnWindowFocus = true, onSuccess, onError, pathParams: modulePathParams, enabled = true, hydratedState } = options;
+  const pathParamsString = (0, import_react4.useMemo)(() => JSON.stringify(modulePathParams || {}), [modulePathParams]);
+  const [queryOptions, setQueryOptions] = (0, import_react4.useState)({});
+  const savedCallbacks = (0, import_react4.useRef)({ onSuccess, onError });
+  (0, import_react4.useEffect)(() => {
+    savedCallbacks.current = { onSuccess, onError };
+  }, [onSuccess, onError]);
+  (0, import_react4.useMemo)(() => {
+    if (hydratedState) {
+      globalStateManager.rehydrate(hydratedState);
+    }
+  }, [hydratedState]);
+  const actions = (0, import_react4.useMemo)(() => {
+    return Object.keys(moduleConfig.actions).reduce((acc, actionName) => {
+      const actionConfig = moduleConfig.actions[actionName];
+      const execute = async (input, options2 = {}) => {
+        const finalPathParams = { ...JSON.parse(pathParamsString), ...options2.pathParams };
+        const cacheKey = generateCacheKey(moduleConfig.baseEndpoint, actionName, input, { pathParams: finalPathParams });
+        let mutationContext;
+        try {
+          if (options2.onMutate) {
+            mutationContext = await options2.onMutate(input);
+          }
+          globalStateManager.setState(cacheKey, (prev) => ({ ...prev, loading: true, called: true, error: null, isStale: false }));
+          const result = await callDynamicApi(axiosInstance, moduleConfig.baseEndpoint, actionConfig, {
+            pathParams: finalPathParams,
+            body: input,
+            config: options2.config
+          });
+          globalStateManager.setState(cacheKey, (prev) => ({ ...prev, ...result, loading: false }));
+          if (result.success) {
+            savedCallbacks.current.onSuccess?.(actionName, result.message || "Action successful", result.data);
+            options2.onSuccess?.(result.data, mutationContext);
+            actionConfig.invalidates?.forEach((keyToInvalidate) => {
+              const prefix = `${moduleConfig.baseEndpoint}/${keyToInvalidate}::`;
+              globalStateManager.invalidateByPrefix(prefix);
+            });
+          } else {
+            savedCallbacks.current.onError?.(actionName, result.message || "Action failed", result.error ?? void 0);
+            options2.onError?.(result.error, mutationContext);
+          }
+          return result;
+        } catch (error) {
+          const apiError = { status: 500, message: error.message };
+          const errorResult = { data: null, error: apiError, loading: false, success: false, rawResponse: error };
+          globalStateManager.setState(cacheKey, (prev) => ({ ...prev, ...errorResult, loading: false }));
+          savedCallbacks.current.onError?.(actionName, apiError.message, apiError);
+          options2.onError?.(apiError, mutationContext);
+          return errorResult;
+        }
+      };
+      const reset = (input, options2 = {}) => {
+        const finalPathParams = { ...JSON.parse(pathParamsString), ...options2.pathParams };
+        const cacheKey = generateCacheKey(moduleConfig.baseEndpoint, actionName, input, { pathParams: finalPathParams });
+        globalStateManager.setState(cacheKey, () => ({
+          data: null,
+          error: null,
+          loading: false,
+          success: false,
+          called: false,
+          isStale: false,
+          rawResponse: null
+        }));
+      };
+      acc[actionName] = { execute, reset };
+      return acc;
+    }, {});
+  }, [axiosInstance, moduleConfig, pathParamsString]);
+  const queries = (0, import_react4.useMemo)(() => {
+    const builtQueries = {};
+    for (const actionName in moduleConfig.actions) {
+      if (moduleConfig.actions[actionName]?.hasQuery) {
+        const setActionQueryOptions = (updater) => {
+          setQueryOptions((prev) => ({ ...prev, [actionName]: typeof updater === "function" ? updater(prev[actionName] || {}) : updater }));
+        };
+        builtQueries[actionName] = {
+          options: queryOptions[actionName] || {},
+          setOptions: setActionQueryOptions,
+          setPage: (page) => setActionQueryOptions((p) => ({ ...p, page })),
+          setLimit: (limit) => setActionQueryOptions((p) => ({ ...p, limit, page: 1 })),
+          setSearchTerm: (search) => setActionQueryOptions((p) => ({ ...p, search, page: 1 })),
+          setFilters: (filter) => setActionQueryOptions((p) => ({ ...p, filter, page: 1 })),
+          setSorting: (sortBy) => setActionQueryOptions((p) => ({ ...p, sortBy })),
+          setQueryParam: (key, value) => setActionQueryOptions((p) => ({ ...p, [key]: value, page: key !== "page" ? value : p.page })),
+          reset: () => setActionQueryOptions({})
+        };
+      }
+    }
+    return builtQueries;
+  }, [queryOptions, moduleConfig.actions]);
+  const states = (0, import_react4.useMemo)(() => {
+    const finalStates = {};
+    for (const actionName of Object.keys(moduleConfig.actions)) {
+      Object.defineProperty(finalStates, actionName, {
+        get: () => {
+          const actionConfig = moduleConfig.actions[actionName];
+          const query = queries[actionName]?.options;
+          const input = actionConfig.hasQuery ? query : void 0;
+          const pathParams = JSON.parse(pathParamsString);
+          const cacheKey = generateCacheKey(moduleConfig.baseEndpoint, actionName, input, { pathParams });
+          const state = (0, import_react4.useSyncExternalStore)(
+            (callback) => globalStateManager.subscribe(cacheKey, callback),
+            () => globalStateManager.getSnapshot(cacheKey)
+          );
+          (0, import_react4.useEffect)(() => {
+            if (enabled && state.isStale && !state.loading) {
+              actions[actionName].execute(input);
+            }
+          }, [enabled, state.isStale, state.loading, input, actions, actionName]);
+          return state;
+        },
+        enumerable: true
+      });
+    }
+    return finalStates;
+  }, [moduleConfig, pathParamsString, queries, enabled, actions]);
+  (0, import_react4.useEffect)(() => {
+    if (!enabled) return;
+    const actionKeys = Object.keys(moduleConfig.actions);
+    for (const actionName of actionKeys) {
+      const state = states[actionName];
+      const actionConfig = moduleConfig.actions[actionName];
+      if (actionConfig.autoFetch && state && !state.called && !state.loading) {
+        const query = queries[actionName]?.options;
+        const input = actionConfig.hasQuery ? query : void 0;
+        actions[actionName].execute(input);
+      }
+    }
+  }, [enabled, moduleConfig, actions, states, queries]);
+  const lastBlurTimestamp = (0, import_react4.useRef)(Date.now());
+  (0, import_react4.useEffect)(() => {
+    if (!enabled || !refetchOnWindowFocus) return;
+    const onFocus = () => {
+      if (Date.now() - lastBlurTimestamp.current > 1e4) {
+        const actionKeys = Object.keys(moduleConfig.actions);
+        for (const actionName of actionKeys) {
+          const state = states[actionName];
+          if (state && state.called && !state.loading) {
+            const prefix = `${moduleConfig.baseEndpoint}/${actionName}::`;
+            globalStateManager.invalidateByPrefix(prefix);
+          }
+        }
+      }
+    };
+    const onBlur = () => {
+      lastBlurTimestamp.current = Date.now();
+    };
+    window.addEventListener("focus", onFocus);
+    window.addEventListener("blur", onBlur);
+    return () => {
+      window.removeEventListener("focus", onFocus);
+      window.removeEventListener("blur", onBlur);
+    };
+  }, [enabled, refetchOnWindowFocus, moduleConfig, states]);
+  const dehydrate = (0, import_react4.useMemo)(() => {
+    return () => globalStateManager.dehydrate();
+  }, []);
+  return { actions, states, queries, dehydrate };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiModuleProvider,
+  buildPaginateQuery,
+  cacheManager,
+  callDynamicApi,
+  createApiActions,
+  createApiClient,
+  createApiServices,
+  globalStateManager,
+  processResponse,
+  useApi,
+  useApiModule,
+  useApiRecord,
+  useDeepCompareEffect,
+  useModuleContext
+});
+//# sourceMappingURL=index.cjs.map