api-core-lib 12.12.111 → 16.2.0

package/dist/client.js

@@ -1,535 +0,0 @@
-"use client";
-import {
-  buildPaginateQuery,
-  callDynamicApi,
-  createApiServices,
-  generateCacheKey,
-  globalStateManager
-} from "./chunk-N7HFSKII.js";
-
-// src/hooks/useApi.ts
-import { useState, useEffect, useCallback, useRef, useMemo } from "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,
-    initialData,
-    initialQuery = {},
-    enabled = true,
-    refetchAfterChange = true,
-    requestConfig,
-    onSuccess,
-    onError
-  } = config;
-  const finalEndpoint = useMemo(
-    () => buildDynamicPath(endpoint, pathParams),
-    [endpoint, pathParams]
-  );
-  const [state, setState] = useState({
-    data: initialData ?? null,
-    rawResponse: null,
-    loading: enabled,
-    error: null,
-    success: false,
-    message: void 0,
-    validationErrors: void 0
-  });
-  const [queryOptions, setQueryOptions] = useState(initialQuery);
-  const apiServices = useMemo(
-    () => createApiServices(axiosInstance, finalEndpoint),
-    [axiosInstance, finalEndpoint]
-  );
-  const savedOnSuccess = useRef(onSuccess);
-  const savedOnError = useRef(onError);
-  useEffect(() => {
-    savedOnSuccess.current = onSuccess;
-    savedOnError.current = onError;
-  }, [onSuccess, onError]);
-  const fetchData = 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]);
-  useEffect(() => {
-    if (enabled) {
-      fetchData();
-    }
-  }, [enabled, fetchData]);
-  const handleActionResult = 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 refetch = useCallback(() => {
-    fetchData();
-  }, [fetchData]);
-  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,
-    refetch,
-    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
-import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2, useRef as useRef2, useMemo as useMemo2 } from "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 = useMemo2(
-    () => buildDynamicPath2(endpoint, pathParams),
-    [endpoint, pathParams]
-  );
-  const initialState = useMemo2(() => ({
-    data: initialData ?? null,
-    rawResponse: null,
-    error: null,
-    loading: enabled && !!recordId,
-    success: false,
-    message: void 0,
-    validationErrors: void 0
-  }), [initialData, enabled, recordId]);
-  const [state, setState] = useState2(initialState);
-  const savedOnSuccess = useRef2(onSuccess);
-  const savedOnError = useRef2(onError);
-  useEffect2(() => {
-    savedOnSuccess.current = onSuccess;
-    savedOnError.current = onError;
-  }, [onSuccess, onError]);
-  const apiServices = useMemo2(
-    () => createApiServices(axiosInstance, finalEndpoint),
-    [axiosInstance, finalEndpoint]
-  );
-  const fetchRecord = useCallback2(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]);
-  useEffect2(() => {
-    if (enabled) {
-      fetchRecord();
-    }
-  }, [enabled, fetchRecord]);
-  const handleActionResult = useCallback2(
-    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
-import { useEffect as useEffect3, useRef as useRef3 } from "react";
-import isEqual from "fast-deep-equal";
-function useDeepCompareEffect(callback, dependencies) {
-  const currentDependenciesRef = useRef3();
-  if (!isEqual(currentDependenciesRef.current, dependencies)) {
-    currentDependenciesRef.current = dependencies;
-  }
-  useEffect3(callback, [currentDependenciesRef.current]);
-}
-
-// src/hooks/useApiModule/useApiModule.ts
-import { createContext, useCallback as useCallback3, useEffect as useEffect4, useMemo as useMemo3, useRef as useRef4, useState as useState3, useSyncExternalStore } from "react";
-var ApiModuleContext = createContext(null);
-var ApiModuleProvider = ApiModuleContext.Provider;
-var createInitialState = () => ({
-  data: null,
-  lastSuccessAt: void 0,
-  meta: [],
-  validationErrors: [],
-  error: null,
-  loading: false,
-  success: false,
-  called: false,
-  isStale: false,
-  rawResponse: null
-});
-function useApiActionState(actionConfig, cacheKey, execute, input, enabled) {
-  const getClientSnapshot = () => globalStateManager.getSnapshot(cacheKey);
-  const getServerSnapshot = () => globalStateManager.getSnapshot(cacheKey);
-  const state = useSyncExternalStore(
-    (callback) => globalStateManager.subscribe(cacheKey, callback),
-    getClientSnapshot,
-    getServerSnapshot
-  );
-  const inputRef = useRef4(input);
-  useEffect4(() => {
-    inputRef.current = input;
-  }, [input]);
-  const refetch = useCallback3(() => {
-    execute(inputRef.current);
-  }, [execute]);
-  const prevCacheKeyRef = useRef4(cacheKey);
-  useEffect4(() => {
-    if (prevCacheKeyRef.current !== cacheKey && enabled && state.called) {
-      refetch();
-    } else if (enabled && actionConfig.autoFetch && !state.called && !state.loading) {
-      refetch();
-    } else if (enabled && state.isStale && !state.loading) {
-      refetch();
-    }
-    prevCacheKeyRef.current = cacheKey;
-  }, [cacheKey, enabled, state.isStale, state.loading, state.called, actionConfig.autoFetch, refetch]);
-  return state;
-}
-function useApiModule(axiosInstance, moduleConfig, options = {}) {
-  const {
-    refetchOnWindowFocus = true,
-    onSuccess,
-    onError,
-    pathParams: modulePathParams,
-    enabled = true,
-    hydratedState,
-    extraContextData
-  } = options;
-  const pathParamsString = useMemo3(() => JSON.stringify(modulePathParams || {}), [modulePathParams]);
-  const [queryOptions, setQueryOptions] = useState3({});
-  const savedCallbacks = useRef4({ onSuccess, onError });
-  useEffect4(() => {
-    savedCallbacks.current = { onSuccess, onError };
-  }, [onSuccess, onError]);
-  useMemo3(() => {
-    if (hydratedState) {
-      globalStateManager.rehydrate(hydratedState);
-    }
-  }, [hydratedState]);
-  const actions = useMemo3(() => {
-    return Object.keys(moduleConfig.actions).reduce((acc, actionName) => {
-      const actionConfig = moduleConfig.actions[actionName];
-      const shouldCache = actionConfig.cacheResponse !== false;
-      const execute = async (input, options2 = {}) => {
-        const finalPathParams = { ...JSON.parse(pathParamsString), ...options2.pathParams };
-        const cacheKey = shouldCache ? generateCacheKey(moduleConfig.baseEndpoint, actionName, input, { pathParams: finalPathParams }) : "";
-        let mutationContext;
-        try {
-          if (options2.onMutate && shouldCache) {
-            mutationContext = await options2.onMutate(input);
-          }
-          if (shouldCache) {
-            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
-          });
-          if (shouldCache) {
-            globalStateManager.setState(cacheKey, (prev) => ({
-              ...prev,
-              loading: false,
-              success: result.success,
-              error: result.success ? null : result.error || prev.error,
-              data: result.data,
-              meta: result.meta,
-              links: result.links,
-              message: result.message,
-              validationErrors: result.validationErrors || [],
-              rawResponse: result.rawResponse
-            }));
-          }
-          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 = error.response?.data || { status: 500, message: error.message };
-          if (shouldCache) {
-            globalStateManager.setState(cacheKey, (prev) => ({ ...prev, error: apiError, loading: false, success: false }));
-          }
-          savedCallbacks.current.onError?.(actionName, apiError.message, apiError);
-          options2.onError?.(apiError, mutationContext);
-          throw error;
-        } finally {
-          if (options2.onSettled) {
-            options2.onSettled();
-          }
-        }
-      };
-      const reset = (input, options2 = {}) => {
-        if (shouldCache) {
-          const finalPathParams = { ...JSON.parse(pathParamsString), ...options2.pathParams };
-          const cacheKey = generateCacheKey(moduleConfig.baseEndpoint, actionName, input, { pathParams: finalPathParams });
-          globalStateManager.setState(cacheKey, () => createInitialState());
-        }
-      };
-      acc[actionName] = { execute, reset };
-      return acc;
-    }, {});
-  }, [axiosInstance, moduleConfig, pathParamsString]);
-  const queries = useMemo3(() => {
-    return Object.keys(moduleConfig.actions).reduce((acc, actionName) => {
-      const actionConfig = moduleConfig.actions[actionName];
-      if (actionConfig?.hasQuery) {
-        const setActionQueryOptions = (updater) => {
-          const key = actionName;
-          setQueryOptions((prev) => ({ ...prev, [key]: typeof updater === "function" ? updater(prev[key] || {}) : updater }));
-        };
-        const specificActionExecute = actions[actionName].execute;
-        const refetch = () => {
-          specificActionExecute(queryOptions[actionName] || {});
-        };
-        acc[actionName] = {
-          options: queryOptions[actionName] || {},
-          refetch,
-          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 acc;
-    }, {});
-  }, [actions, queryOptions, moduleConfig.actions]);
-  const states = {};
-  function isActionWithQuery(key, actions2) {
-    return actions2[key]?.hasQuery === true;
-  }
-  for (const actionName in moduleConfig.actions) {
-    if (Object.prototype.hasOwnProperty.call(moduleConfig.actions, actionName)) {
-      const actionConfig = moduleConfig.actions[actionName];
-      if (actionConfig.cacheResponse !== false) {
-        let currentQueryOptions;
-        if (isActionWithQuery(actionName, moduleConfig.actions)) {
-          currentQueryOptions = queries[actionName]?.options;
-        }
-        const input = currentQueryOptions;
-        const pathParams = JSON.parse(pathParamsString);
-        const cacheKey = generateCacheKey(
-          moduleConfig.baseEndpoint,
-          actionName,
-          input,
-          { pathParams }
-        );
-        states[actionName] = useApiActionState(
-          actionConfig,
-          cacheKey,
-          actions[actionName].execute,
-          input,
-          enabled
-        );
-      } else {
-        states[actionName] = createInitialState();
-      }
-    }
-  }
-  const lastBlurTimestamp = useRef4(Date.now());
-  useEffect4(() => {
-    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 = useMemo3(() => {
-    return () => globalStateManager.dehydrate();
-  }, []);
-  const baseApiReturn = { actions, states, queries, dehydrate };
-  const finalApiReturn = useMemo3(() => ({
-    ...baseApiReturn,
-    ...extraContextData || {}
-  }), [baseApiReturn, extraContextData]);
-  return finalApiReturn;
-}
-
-// src/hooks/useApiModule/apiModuleContext.ts
-import { createContext as createContext2, useContext as useContext2, createElement } from "react";
-function createApiModuleContext() {
-  const Context = createContext2(null);
-  Context.displayName = "ApiModuleContext";
-  const Provider = ({ value, children }) => {
-    return createElement(Context.Provider, { value }, children);
-  };
-  const useConsumer = () => {
-    const context = useContext2(Context);
-    if (!context) {
-      throw new Error("This component must be used within its corresponding ApiModuleProvider.");
-    }
-    return context;
-  };
-  return {
-    Context,
-    Provider,
-    useContext: useConsumer
-  };
-}
-export {
-  ApiModuleProvider,
-  createApiModuleContext,
-  useApi,
-  useApiModule,
-  useApiRecord,
-  useDeepCompareEffect
-};