api-core-lib 12.11.4 → 12.12.100

package/dist/client.js

@@ -0,0 +1,547 @@
+"use client";
+import {
+  buildPaginateQuery,
+  callDynamicApi,
+  createApiServices,
+  generateCacheKey,
+  globalStateManager
+} from "./chunk-KPZ7BF52.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,
+    // [REMOVE] لم نعد بحاجة لهذا الخيار
+    // encodeQuery = true, 
+    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 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
+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) {
+      console.log(`[Cache Key Changed] from ${prevCacheKeyRef.current} to ${cacheKey}. Refetching...`);
+      refetch();
+    } else if (enabled && actionConfig.autoFetch && !state.called && !state.loading) {
+      console.log(`[Auto Fetch] for ${cacheKey}. Fetching...`);
+      refetch();
+    } else if (enabled && state.isStale && !state.loading) {
+      console.log(`[Stale State] for ${cacheKey}. Refetching...`);
+      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]);
+  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
+          });
+          console.log("[API Result execute]", result);
+          if (shouldCache) {
+            globalStateManager.setState(cacheKey, (prev) => ({
+              ...prev,
+              // احتفظ بالخصائص القديمة مثل 'called'
+              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
+              // isStale تم تعيينه إلى false في بداية execute، وسيظل كذلك
+            }));
+          }
+          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}::`;
+              console.log(`[Invalidating] by prefix: ${prefix}`);
+              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(() => {
+    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 = {};
+  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 queryOptions2;
+        if (isActionWithQuery(actionName, moduleConfig.actions)) {
+          queryOptions2 = queries[actionName]?.options;
+        }
+        const input = queryOptions2;
+        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
+};