@softimist/api 1.0.0

package/dist/index.cjs

@@ -0,0 +1,665 @@
+"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, {
+  BaseApiClient: () => BaseApiClient,
+  QueryProvider: () => QueryProvider,
+  getErrorMessage: () => getErrorMessage,
+  getQueryClient: () => getQueryClient,
+  getSuccessMessage: () => getSuccessMessage,
+  makeQueryClient: () => makeQueryClient,
+  useApi: () => useApi,
+  useApiAction: () => useApiAction,
+  useInfiniteQuery: () => import_react_query3.useInfiniteQuery,
+  useMockPaginatedApi: () => useMockPaginatedApi,
+  usePaginatedApi: () => usePaginatedApi,
+  useQuery: () => import_react_query3.useQuery
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_axios = __toESM(require("axios"), 1);
+var BaseApiClient = class {
+  axiosInstance;
+  getAuthToken;
+  getRefreshToken;
+  setAuthToken;
+  setRefreshToken;
+  clearAuthTokens;
+  refreshTokenUrl;
+  isRefreshing = false;
+  failedQueue = [];
+  constructor(config = {}) {
+    const defaultHeaders = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...config.headers
+    };
+    this.axiosInstance = import_axios.default.create({
+      baseURL: config.baseURL || "",
+      timeout: config.timeout || 3e4,
+      headers: defaultHeaders
+    });
+    this.getAuthToken = config.getAuthToken;
+    this.getRefreshToken = config.getRefreshToken;
+    this.setAuthToken = config.setAuthToken;
+    this.setRefreshToken = config.setRefreshToken;
+    this.clearAuthTokens = config.clearAuthTokens;
+    this.refreshTokenUrl = config.refreshTokenUrl || `${config.baseURL || ""}/v1/auth/refresh`;
+    this.axiosInstance.interceptors.request.use(
+      (requestConfig) => {
+        if (this.getAuthToken) {
+          const token = this.getAuthToken();
+          if (token) {
+            requestConfig.headers.Authorization = `Bearer ${token}`;
+          }
+        }
+        return requestConfig;
+      },
+      (error) => {
+        return Promise.reject(error);
+      }
+    );
+    this.axiosInstance.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        const originalRequest = error.config;
+        if (error.response?.status === 401 && !originalRequest._retry && this.getRefreshToken) {
+          if (this.isRefreshing) {
+            return new Promise((resolve, reject) => {
+              this.failedQueue.push({ resolve, reject });
+            }).then((token) => {
+              originalRequest.headers.Authorization = `Bearer ${token}`;
+              return this.axiosInstance(originalRequest);
+            }).catch((err) => {
+              return Promise.reject(err);
+            });
+          }
+          originalRequest._retry = true;
+          this.isRefreshing = true;
+          try {
+            const accessToken = await this.refreshAuthToken();
+            originalRequest.headers.Authorization = `Bearer ${accessToken}`;
+            this.processQueue(null, accessToken);
+            this.isRefreshing = false;
+            return this.axiosInstance(originalRequest);
+          } catch (refreshError) {
+            this.processQueue(refreshError, null);
+            this.isRefreshing = false;
+            return Promise.reject(this.handleError(refreshError));
+          }
+        }
+        return Promise.reject(this.handleError(error));
+      }
+    );
+  }
+  /**
+   * Process queued requests after token refresh
+   */
+  processQueue(error, token = null) {
+    this.failedQueue.forEach(({ resolve, reject }) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(token);
+      }
+    });
+    this.failedQueue = [];
+  }
+  /**
+   * Refresh authentication token
+   */
+  async refreshAuthToken() {
+    if (!this.getRefreshToken) {
+      throw new Error("No refresh token function provided");
+    }
+    const refreshToken = this.getRefreshToken();
+    if (!refreshToken) {
+      if (this.clearAuthTokens) {
+        this.clearAuthTokens();
+      }
+      throw new Error("No refresh token available");
+    }
+    try {
+      const response = await import_axios.default.post(this.refreshTokenUrl, {
+        refresh_token: refreshToken
+      }, {
+        baseURL: ""
+        // Use absolute URL or empty to avoid baseURL duplication
+      });
+      const { access_token, refresh_token } = response.data;
+      if (this.setAuthToken) {
+        this.setAuthToken(access_token);
+      }
+      if (refresh_token && this.setRefreshToken) {
+        this.setRefreshToken(refresh_token);
+      }
+      return access_token;
+    } catch (error) {
+      if (this.clearAuthTokens) {
+        this.clearAuthTokens();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Handle request errors
+   */
+  handleError(error) {
+    if (error.response) {
+      const message = error.response.data?.message || error.response.data?.error || error.message || "An unknown error occurred";
+      return new Error(message);
+    } else if (error.request) {
+      return new Error("Network error: No response from server");
+    } else {
+      return error instanceof Error ? error : new Error(String(error));
+    }
+  }
+  /**
+   * Make HTTP GET request
+   * Returns unwrapped server response data
+   */
+  async get(url, config) {
+    const axiosConfig = {
+      params: config?.params,
+      headers: config?.headers,
+      ...config
+    };
+    delete axiosConfig.params;
+    delete axiosConfig.headers;
+    const response = await this.axiosInstance.get(url, {
+      ...axiosConfig,
+      params: config?.params,
+      headers: config?.headers
+    });
+    return response.data;
+  }
+  /**
+   * Make HTTP POST request
+   * Returns unwrapped server response data
+   */
+  async post(url, data, config) {
+    const axiosConfig = {
+      headers: config?.headers,
+      ...config
+    };
+    delete axiosConfig.headers;
+    const response = await this.axiosInstance.post(url, data, {
+      ...axiosConfig,
+      headers: config?.headers
+    });
+    return response.data;
+  }
+  /**
+   * Make HTTP PATCH request
+   * Returns unwrapped server response data
+   */
+  async patch(url, data, config) {
+    const axiosConfig = {
+      headers: config?.headers,
+      ...config
+    };
+    delete axiosConfig.headers;
+    const response = await this.axiosInstance.patch(url, data, {
+      ...axiosConfig,
+      headers: config?.headers
+    });
+    return response.data;
+  }
+  /**
+   * Make HTTP PUT request
+   * Returns unwrapped server response data
+   */
+  async put(url, data, config) {
+    const axiosConfig = {
+      headers: config?.headers,
+      ...config
+    };
+    delete axiosConfig.headers;
+    const response = await this.axiosInstance.put(url, data, {
+      ...axiosConfig,
+      headers: config?.headers
+    });
+    return response.data;
+  }
+  /**
+   * Make HTTP DELETE request
+   * Returns unwrapped server response data
+   */
+  async delete(url, config) {
+    const axiosConfig = {
+      headers: config?.headers,
+      ...config
+    };
+    delete axiosConfig.headers;
+    const response = await this.axiosInstance.delete(url, {
+      ...axiosConfig,
+      headers: config?.headers
+    });
+    return response.data;
+  }
+  /**
+   * Get the underlying axios instance for advanced usage
+   */
+  get axios() {
+    return this.axiosInstance;
+  }
+  /**
+   * Create a new client instance with a different baseURL
+   * Useful for server-side requests or different API endpoints
+   */
+  withBaseURL(baseURL) {
+    const ConfigClass = this.constructor;
+    const headers = { ...this.axiosInstance.defaults.headers };
+    return new ConfigClass({
+      baseURL,
+      getAuthToken: this.getAuthToken,
+      getRefreshToken: this.getRefreshToken,
+      setAuthToken: this.setAuthToken,
+      setRefreshToken: this.setRefreshToken,
+      clearAuthTokens: this.clearAuthTokens,
+      refreshTokenUrl: this.refreshTokenUrl,
+      timeout: this.axiosInstance.defaults.timeout,
+      headers
+    });
+  }
+};
+
+// src/hooks.ts
+var import_react_query2 = require("@tanstack/react-query");
+var import_nuqs = require("nuqs");
+var import_react = require("react");
+var import_sonner = require("sonner");
+
+// src/tanstack-query.tsx
+var import_react_query = require("@tanstack/react-query");
+var import_jsx_runtime = require("react/jsx-runtime");
+function makeQueryClient() {
+  return new import_react_query.QueryClient({
+    defaultOptions: {
+      queries: {
+        refetchOnWindowFocus: false,
+        refetchOnReconnect: false
+      }
+    }
+  });
+}
+var browserQueryClient = void 0;
+function getQueryClient() {
+  if (typeof window === "undefined") {
+    return makeQueryClient();
+  } else {
+    if (!browserQueryClient) browserQueryClient = makeQueryClient();
+    return browserQueryClient;
+  }
+}
+function QueryProvider({ children }) {
+  const queryClient = getQueryClient();
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_query.QueryClientProvider, { client: queryClient, children });
+}
+
+// src/hooks.ts
+function useApi(httpClient, url, options = {}) {
+  const { queryKey, enabled = true, ...restOptions } = options;
+  return (0, import_react_query2.useQuery)({
+    queryKey: queryKey || [url],
+    queryFn: async () => {
+      if (!url) throw new Error("URL is required");
+      return httpClient.get(url);
+    },
+    enabled: url !== null && enabled,
+    ...restOptions
+  });
+}
+function useApiAction(httpClient, options) {
+  const { action, showToast = true, invalidateQueries, onSuccess, onError } = options;
+  const [isExecuted, setIsExecuted] = (0, import_react.useState)(false);
+  const mutation = (0, import_react_query2.useMutation)({
+    mutationFn: action,
+    onSuccess: (res) => {
+      onSuccess?.(res.data);
+      setIsExecuted(true);
+      if (showToast) {
+        import_sonner.toast.success(res.message || "Success");
+      }
+      if (invalidateQueries && invalidateQueries.length > 0) {
+        const queryClient = getQueryClient();
+        invalidateQueries.forEach((queryKey) => {
+          queryClient.invalidateQueries({ queryKey });
+        });
+      }
+    },
+    onError: (err) => {
+      onError?.(err);
+      if (showToast) {
+        import_sonner.toast.error(err.message || "An error occurred");
+      }
+    }
+  });
+  const execute = () => {
+    mutation.mutate();
+  };
+  return {
+    isLoading: mutation.isPending,
+    error: mutation.error ?? void 0,
+    data: mutation.data?.data,
+    execute,
+    isExecuted
+  };
+}
+var parseAsFilterArray = (0, import_nuqs.createParser)({
+  parse: (value) => {
+    return JSON.parse(value);
+  },
+  serialize: (value) => {
+    return JSON.stringify(value);
+  }
+});
+function usePaginationState(options) {
+  const { persist = true, params: defaultParams } = options;
+  const defaultPerPage = defaultParams?.per_page || 20;
+  const defaultPage = defaultParams?.page || 1;
+  const [perPageQuery, setPerPageQuery] = (0, import_nuqs.useQueryState)(
+    "per_page",
+    import_nuqs.parseAsInteger.withDefault(defaultPerPage)
+  );
+  const [pageQuery, setPageQuery] = (0, import_nuqs.useQueryState)("page", import_nuqs.parseAsInteger.withDefault(defaultPage));
+  const [searchQuery, setSearchQuery] = (0, import_nuqs.useQueryState)("search", import_nuqs.parseAsString.withDefault(""));
+  const [filtersQuery, setFiltersQuery] = (0, import_nuqs.useQueryState)(
+    "filters",
+    parseAsFilterArray.withDefault([])
+  );
+  const [sortQuery, setSortQuery] = (0, import_nuqs.useQueryState)("sort", import_nuqs.parseAsString.withDefault(""));
+  const [perPageState, setPerPageState] = (0, import_react.useState)(defaultPerPage);
+  const [pageState, setPageState] = (0, import_react.useState)(defaultPage);
+  const [searchState, setSearchState] = (0, import_react.useState)("");
+  const [filtersState, setFiltersState] = (0, import_react.useState)([]);
+  const [sortState, setSortState] = (0, import_react.useState)();
+  const perPage = persist ? perPageQuery : perPageState;
+  const page = persist ? pageQuery : pageState;
+  const search = persist ? searchQuery : searchState;
+  const filters = persist ? filtersQuery : filtersState;
+  const sort = persist ? sortQuery : sortState;
+  const setPerPage = (value) => {
+    if (persist) {
+      setPerPageQuery(value);
+    } else {
+      setPerPageState(value);
+    }
+  };
+  const setPage = (value) => {
+    if (persist) {
+      setPageQuery(value);
+    } else {
+      setPageState(value);
+    }
+  };
+  const setSearch = (value) => {
+    if (persist) {
+      setSearchQuery(value);
+    } else {
+      setSearchState(value);
+    }
+  };
+  const setFilters = (value) => {
+    if (persist) {
+      setFiltersQuery(value);
+    } else {
+      setFiltersState(value);
+    }
+  };
+  const setSort = (value) => {
+    if (persist) {
+      setSortQuery(value);
+    } else {
+      setSortState(typeof value === "function" ? value(sortState || "") : value);
+    }
+  };
+  const getParams = () => {
+    const params = new URLSearchParams();
+    if (defaultParams) {
+      Object.entries(defaultParams).forEach(([key, value]) => {
+        if (value !== void 0) {
+          params.set(key, value.toString());
+        }
+      });
+    }
+    if (perPage) params.set("per_page", perPage.toString());
+    if (page) params.set("page", page.toString());
+    if (search) params.set("search", search);
+    if (sort) {
+      const [sortBy, sortDirection] = sort.split(":");
+      if (sortBy) params.set("sort_by", sortBy);
+      if (sortDirection) params.set("sort_dir", sortDirection);
+    }
+    filters?.forEach((filter) => {
+      if (Array.isArray(filter.value)) {
+        filter.value.forEach((v) => {
+          params.append(filter.key, v.toString());
+        });
+      } else {
+        params.set(filter.key, filter.value.toString());
+      }
+    });
+    return params;
+  };
+  return {
+    perPage,
+    page,
+    search,
+    filters,
+    sort,
+    setPerPage,
+    setPage,
+    setSearch,
+    setFilters,
+    setSort,
+    getParams
+  };
+}
+function usePaginatedApi(httpClient, path, options = {}) {
+  const {
+    perPage,
+    page,
+    search,
+    filters,
+    sort,
+    setPerPage,
+    setPage,
+    setSearch,
+    setFilters,
+    setSort,
+    getParams
+  } = usePaginationState(options);
+  const getUrl = () => {
+    if (!path) return null;
+    const params = getParams();
+    return params.size === 0 ? path : `${path}?${params.toString()}`;
+  };
+  const url = getUrl();
+  const { data, isLoading, error, refetch, isSuccess, isFetching } = (0, import_react_query2.useQuery)({
+    queryKey: [path, options, page, perPage, search, filters, sort],
+    queryFn: async () => {
+      if (!url) throw new Error("URL is required");
+      return httpClient.get(url);
+    },
+    enabled: !!url
+  });
+  function getBulkActionUrl(action, additionalFilters) {
+    const params = getParams();
+    params.delete("page");
+    params.delete("per_page");
+    Object.entries(additionalFilters || {}).forEach(([key, value]) => {
+      if (value === void 0) {
+        params.delete(key);
+      } else if (Array.isArray(value)) {
+        value.forEach((v) => {
+          params.append(key, v);
+        });
+      } else {
+        params.set(key, value);
+      }
+    });
+    if (params.size === 0) return `${path}/${action}`;
+    return `${path}/${action}?${params.toString()}`;
+  }
+  function setFilter(key, value) {
+    if (value === void 0) {
+      removeFilter(key);
+      return;
+    }
+    const index = filters.findIndex((filter) => filter.key === key);
+    if (index === -1) {
+      setFilters([...filters, { key, value }]);
+    } else {
+      setFilters([...filters.slice(0, index), { key, value }, ...filters.slice(index + 1)]);
+    }
+  }
+  function removeFilter(key) {
+    setFilters(filters.filter((filter) => filter.key !== key));
+  }
+  function getFilterValue(key) {
+    return filters.find((filter) => filter.key === key)?.value;
+  }
+  function resetFilters() {
+    setFilters([]);
+  }
+  return {
+    message: data?.message || "",
+    data: data?.data || [],
+    pagination: data?.pagination,
+    isLoading,
+    isSuccess,
+    isFetching,
+    error,
+    mutate: refetch,
+    page,
+    setPage,
+    perPage,
+    setPerPage,
+    search,
+    setSearch,
+    filters,
+    setFilters,
+    setFilter,
+    removeFilter,
+    getFilterValue,
+    resetFilters,
+    getBulkActionUrl,
+    sort,
+    setSort
+  };
+}
+function useMockPaginatedApi(data) {
+  return {
+    data,
+    pagination: {
+      total: data.length,
+      per_page: 10,
+      current_page: 1,
+      total_pages: Math.ceil(data.length / 10),
+      from: 1,
+      to: data.length
+    },
+    message: "Data fetched successfully",
+    isLoading: false,
+    isSuccess: true,
+    isFetching: false,
+    mutate: () => {
+    },
+    page: 1,
+    setPage: () => {
+    },
+    perPage: 10,
+    setPerPage: () => {
+    },
+    search: "",
+    setSearch: () => {
+    },
+    filters: [],
+    setFilters: () => {
+    },
+    getFilterValue: () => void 0,
+    resetFilters: () => {
+    },
+    setFilter: () => {
+    },
+    removeFilter: () => {
+    },
+    sort: "",
+    setSort: () => {
+    },
+    getBulkActionUrl: () => ""
+  };
+}
+
+// src/utils.ts
+function getErrorMessage(error) {
+  const err = error;
+  const apiMessage = err?.response?.data?.message;
+  if (typeof apiMessage === "string" && apiMessage.trim() !== "") {
+    return apiMessage;
+  }
+  const apiError = err?.response?.data?.error;
+  if (typeof apiError === "string" && apiError.trim() !== "") {
+    return apiError;
+  }
+  const message = err?.message;
+  if (typeof message === "string" && message.trim() !== "") {
+    return message;
+  }
+  if (error instanceof Error && error.message.trim() !== "") {
+    return error.message;
+  }
+  return "Something went wrong";
+}
+function getSuccessMessage(response, defaultMessage) {
+  return response?.data?.message || defaultMessage || "Success";
+}
+
+// src/index.ts
+var import_react_query3 = require("@tanstack/react-query");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseApiClient,
+  QueryProvider,
+  getErrorMessage,
+  getQueryClient,
+  getSuccessMessage,
+  makeQueryClient,
+  useApi,
+  useApiAction,
+  useInfiniteQuery,
+  useMockPaginatedApi,
+  usePaginatedApi,
+  useQuery
+});
+//# sourceMappingURL=index.cjs.map