@igniter-js/caller 0.1.4 → 0.1.51

package/dist/client/index.js

@@ -0,0 +1,688 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/client/builders/provider.builder.tsx
+
+// src/client/utils/cache.ts
+var _IgniterCallerClientCache = class _IgniterCallerClientCache {
+  static get(key, staleTime) {
+    const entry = _IgniterCallerClientCache.cache.get(key);
+    if (!entry) return void 0;
+    if (staleTime && Date.now() - entry.timestamp > staleTime) {
+      _IgniterCallerClientCache.cache.delete(key);
+      return void 0;
+    }
+    return entry.data;
+  }
+  static set(key, data) {
+    _IgniterCallerClientCache.cache.set(key, {
+      data,
+      timestamp: Date.now()
+    });
+  }
+  static replacePrefix(prefix, data) {
+    for (const [key, entry] of _IgniterCallerClientCache.cache.entries()) {
+      if (key.startsWith(prefix)) {
+        _IgniterCallerClientCache.cache.set(key, {
+          data,
+          timestamp: entry.timestamp
+        });
+      }
+    }
+  }
+  static clearPrefix(prefix) {
+    for (const key of _IgniterCallerClientCache.cache.keys()) {
+      if (key.startsWith(prefix)) {
+        _IgniterCallerClientCache.cache.delete(key);
+      }
+    }
+  }
+};
+_IgniterCallerClientCache.cache = /* @__PURE__ */ new Map();
+var IgniterCallerClientCache = _IgniterCallerClientCache;
+
+// src/client/utils/query-key.ts
+var EMPTY_KEY = "{}";
+function stableStringify(value) {
+  if (value === null || value === void 0) return EMPTY_KEY;
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  return `{${entries.map(([key, val]) => `${JSON.stringify(key)}:${stableStringify(val)}`).join(",")}}`;
+}
+function buildQueryKey(params) {
+  const { callerKey, method, path, query, params: pathParams } = params;
+  const payload = {
+    params: pathParams || {},
+    query: query || {}
+  };
+  return `${callerKey}::${method.toUpperCase()}::${path}::${stableStringify(payload)}`;
+}
+function buildQueryPrefix(params) {
+  const { callerKey, method, path } = params;
+  return `${callerKey}::${method.toUpperCase()}::${path}`;
+}
+
+// src/client/utils/cookies.ts
+function buildCookieHeader(cookies) {
+  if (!cookies || Object.keys(cookies).length === 0) return void 0;
+  return Object.entries(cookies).map(([key, value]) => `${key}=${value}`).join("; ");
+}
+
+// src/client/builders/hooks.builder.tsx
+function mergeQueryInput(config, options, variables) {
+  const headers = {
+    ...config.headers || {},
+    ...options?.headers || {},
+    ...variables?.headers || {}
+  };
+  const cookies = {
+    ...config.cookies || {},
+    ...options?.cookies || {},
+    ...variables?.cookies || {}
+  };
+  const query = {
+    ...config.query || {},
+    ...options?.query || {},
+    ...variables?.query || {},
+    ...options?.params || {},
+    ...variables?.params || {}
+  };
+  const cookieHeader = buildCookieHeader(cookies);
+  if (cookieHeader && !headers.Cookie) {
+    headers.Cookie = cookieHeader;
+  }
+  return {
+    headers,
+    cookies,
+    query,
+    params: variables?.params || options?.params
+  };
+}
+function mergeMutateInput(config, options, variables) {
+  const merged = mergeQueryInput(config, options, variables);
+  return {
+    ...merged,
+    body: variables?.body ?? options?.body
+  };
+}
+function createUseQuery(params) {
+  const {
+    callerKey,
+    method,
+    path,
+    buildRequest,
+    register,
+    unregister,
+    invalidate,
+    getMergedConfig,
+    onError
+  } = params;
+  return (options) => {
+    const [status, setStatus] = react.useState(
+      options?.initialData ? "success" : "loading"
+    );
+    const [isFetching, setIsFetching] = react.useState(false);
+    const [response, setResponse] = react.useState({
+      data: options?.initialData ?? null,
+      error: null
+    });
+    const [variables, setVariables] = react.useState(
+      void 0
+    );
+    const optionsRef = react.useRef(options);
+    optionsRef.current = options;
+    const lastVariablesRef = react.useRef(void 0);
+    const stableKey = react.useMemo(() => {
+      const mergedConfig = getMergedConfig();
+      const mergedInput = mergeQueryInput(
+        mergedConfig,
+        options,
+        lastVariablesRef.current
+      );
+      return buildQueryKey({
+        callerKey,
+        method,
+        path,
+        query: mergedInput.query,
+        params: mergedInput.params
+      });
+    }, [
+      callerKey,
+      method,
+      path,
+      getMergedConfig,
+      JSON.stringify(options?.params || {}),
+      JSON.stringify(options?.query || {})
+    ]);
+    const execute = react.useCallback(
+      async (nextVariables) => {
+        if (optionsRef.current?.enabled === false) return;
+        const mergedConfig = getMergedConfig();
+        const mergedInput = mergeQueryInput(
+          mergedConfig,
+          optionsRef.current,
+          nextVariables
+        );
+        const queryKey = buildQueryKey({
+          callerKey,
+          method,
+          path,
+          query: mergedInput.query,
+          params: mergedInput.params
+        });
+        lastVariablesRef.current = nextVariables;
+        setVariables(nextVariables);
+        setIsFetching(true);
+        setStatus("loading");
+        optionsRef.current?.onLoading?.(true);
+        mergedConfig.onQueryLoading?.(true);
+        if (optionsRef.current?.staleTime) {
+          const cached = IgniterCallerClientCache.get(
+            queryKey,
+            optionsRef.current.staleTime
+          );
+          if (cached !== void 0) {
+            setResponse({ data: cached, error: null });
+            setStatus("success");
+            optionsRef.current?.onSuccess?.(cached);
+            mergedConfig.onQuerySuccess?.(cached);
+            optionsRef.current?.onLoading?.(false);
+            mergedConfig.onQueryLoading?.(false);
+            setIsFetching(false);
+            return {
+              data: cached,
+              error: void 0
+            };
+          }
+        }
+        try {
+          const result = await buildRequest(method, path, mergedInput).execute();
+          optionsRef.current?.onRequest?.(result);
+          if (result.error) {
+            setResponse({ data: null, error: result.error });
+            setStatus("error");
+            optionsRef.current?.onError?.(result.error);
+            mergedConfig.onQueryError?.(result.error);
+            onError?.(result.error);
+          } else {
+            const data = result.data ?? null;
+            setResponse({ data, error: null });
+            setStatus("success");
+            optionsRef.current?.onSuccess?.(data);
+            mergedConfig.onQuerySuccess?.(data);
+            if (optionsRef.current?.staleTime && data !== null) {
+              IgniterCallerClientCache.set(queryKey, data);
+            }
+          }
+          optionsRef.current?.onSettled?.(
+            result.data ?? null,
+            result.error ?? null
+          );
+          mergedConfig.onQuerySettled?.(
+            result.data ?? null,
+            result.error ?? null
+          );
+          return result;
+        } catch (error) {
+          const typedError = error;
+          setResponse({ data: null, error: typedError });
+          setStatus("error");
+          optionsRef.current?.onError?.(typedError);
+          mergedConfig.onQueryError?.(typedError);
+          onError?.(typedError);
+          optionsRef.current?.onSettled?.(null, typedError);
+          mergedConfig.onQuerySettled?.(null, typedError);
+        } finally {
+          setIsFetching(false);
+          optionsRef.current?.onLoading?.(false);
+          mergedConfig.onQueryLoading?.(false);
+        }
+      },
+      [callerKey, method, path, buildRequest, getMergedConfig, onError]
+    );
+    const refetch = react.useCallback(() => {
+      void execute(lastVariablesRef.current);
+    }, [execute]);
+    const invalidateQuery = react.useCallback(
+      (data) => {
+        const prefix = buildQueryPrefix({ callerKey, method, path });
+        invalidate(prefix, data);
+      },
+      [callerKey, method, path, invalidate]
+    );
+    react.useEffect(() => {
+      register(stableKey, refetch);
+      return () => unregister(stableKey, refetch);
+    }, [register, unregister, refetch, stableKey]);
+    react.useEffect(() => {
+      if (optionsRef.current?.enabled === false) return;
+      if (optionsRef.current?.refetchOnMount === false) return;
+      void execute(lastVariablesRef.current);
+    }, [stableKey, execute]);
+    react.useEffect(() => {
+      const interval = optionsRef.current?.refetchInterval;
+      if (!interval) return;
+      const handler = setInterval(() => {
+        if (optionsRef.current?.refetchIntervalInBackground === false && typeof document !== "undefined" && document.hidden) {
+          return;
+        }
+        void execute(lastVariablesRef.current);
+      }, interval);
+      return () => clearInterval(handler);
+    }, [execute]);
+    react.useEffect(() => {
+      if (optionsRef.current?.refetchOnWindowFocus === false) return;
+      if (typeof window === "undefined") return;
+      const handler = () => {
+        void execute(lastVariablesRef.current);
+      };
+      window.addEventListener("focus", handler);
+      return () => window.removeEventListener("focus", handler);
+    }, [execute]);
+    return {
+      data: response.data,
+      error: response.error,
+      variables,
+      isLoading: status === "loading",
+      isFetching,
+      isSuccess: status === "success",
+      isError: status === "error",
+      status,
+      refetch,
+      invalidate: invalidateQuery,
+      execute
+    };
+  };
+}
+function createUseMutate(params) {
+  const {
+    callerKey,
+    method,
+    path,
+    buildRequest,
+    getMergedConfig,
+    onError
+  } = params;
+  return (options) => {
+    const [status, setStatus] = react.useState(
+      "success"
+    );
+    const [response, setResponse] = react.useState({ data: null, error: null });
+    const [variables, setVariables] = react.useState(
+      void 0
+    );
+    const optionsRef = react.useRef(options);
+    optionsRef.current = options;
+    const lastVariablesRef = react.useRef(void 0);
+    const mutate = react.useCallback(
+      async (nextVariables) => {
+        const mergedConfig = getMergedConfig();
+        const mergedInput = mergeMutateInput(
+          mergedConfig,
+          optionsRef.current,
+          nextVariables
+        );
+        lastVariablesRef.current = nextVariables;
+        setVariables(nextVariables);
+        setStatus("loading");
+        optionsRef.current?.onLoading?.(true);
+        mergedConfig.onMutationLoading?.(true);
+        try {
+          const result = await buildRequest(method, path, mergedInput).execute();
+          optionsRef.current?.onRequest?.(result);
+          if (result.error) {
+            setResponse({ data: null, error: result.error });
+            setStatus("error");
+            optionsRef.current?.onError?.(result.error);
+            mergedConfig.onMutationError?.(result.error);
+            onError?.(result.error);
+          } else {
+            const data = result.data ?? null;
+            setResponse({ data, error: null });
+            setStatus("success");
+            optionsRef.current?.onSuccess?.(data);
+            mergedConfig.onMutationSuccess?.(data);
+          }
+          optionsRef.current?.onSettled?.(
+            result.data ?? null,
+            result.error ?? null
+          );
+          mergedConfig.onMutationSettled?.(
+            result.data ?? null,
+            result.error ?? null
+          );
+          return result;
+        } catch (error) {
+          const typedError = error;
+          setResponse({ data: null, error: typedError });
+          setStatus("error");
+          optionsRef.current?.onError?.(typedError);
+          mergedConfig.onMutationError?.(typedError);
+          onError?.(typedError);
+          optionsRef.current?.onSettled?.(null, typedError);
+          mergedConfig.onMutationSettled?.(null, typedError);
+        } finally {
+          optionsRef.current?.onLoading?.(false);
+          mergedConfig.onMutationLoading?.(false);
+        }
+      },
+      [method, path, buildRequest, getMergedConfig, onError]
+    );
+    const retry = react.useCallback(() => {
+      void mutate(lastVariablesRef.current);
+    }, [mutate]);
+    return {
+      data: response.data,
+      error: response.error,
+      variables,
+      isLoading: status === "loading",
+      isSuccess: status === "success",
+      isError: status === "error",
+      status,
+      mutate,
+      retry
+    };
+  };
+}
+
+// src/client/builders/client.builder.ts
+function applyRequestInput(builder, input) {
+  if (input.query && Object.keys(input.query).length > 0) {
+    builder.params(input.query);
+  }
+  if (input.headers && Object.keys(input.headers).length > 0) {
+    builder.headers(input.headers);
+  }
+  if (input.body !== void 0) {
+    builder.body(input.body);
+  }
+}
+function createIgniterCallerClient(context, callerKey) {
+  const caller = context.callers[callerKey];
+  const getMergedConfig = () => context.getMergedConfig(callerKey);
+  const buildRequest = (method, path, input) => {
+    if (!path) {
+      throw new Error(
+        "IgniterCallerClient: path is required when using hooks with Caller client."
+      );
+    }
+    const methodKey = method.toLowerCase();
+    const builder = caller[methodKey](path);
+    applyRequestInput(builder, input);
+    return builder;
+  };
+  const invalidate = (pathOrPaths, data) => {
+    const paths = Array.isArray(pathOrPaths) ? pathOrPaths : [pathOrPaths];
+    const prefixes = paths.map(
+      (path) => buildQueryPrefix({
+        callerKey: String(callerKey),
+        method: "GET",
+        path
+      })
+    );
+    context.invalidate(prefixes, data);
+  };
+  const config = {
+    set: (key, value) => context.setConfig(callerKey, key, value),
+    get: (key) => context.getConfig(callerKey, key),
+    reset: () => context.setConfigBatch(callerKey, {})
+  };
+  const get = (path) => {
+    const builder = caller.get(path);
+    const useQuery = createUseQuery({
+      callerKey: String(callerKey),
+      method: "GET",
+      path: path || "",
+      buildRequest,
+      register: context.register,
+      unregister: context.unregister,
+      invalidate: context.invalidate,
+      getMergedConfig,
+      onError: context.onError
+    });
+    builder.useQuery = useQuery;
+    return builder;
+  };
+  const head = (path) => {
+    const builder = caller.head(path);
+    const useQuery = createUseQuery({
+      callerKey: String(callerKey),
+      method: "HEAD",
+      path: path || "",
+      buildRequest,
+      register: context.register,
+      unregister: context.unregister,
+      invalidate: context.invalidate,
+      getMergedConfig,
+      onError: context.onError
+    });
+    builder.useQuery = useQuery;
+    return builder;
+  };
+  const post = (path) => {
+    const builder = caller.post(path);
+    const useMutate = createUseMutate({
+      callerKey: String(callerKey),
+      method: "POST",
+      path: path || "",
+      buildRequest,
+      getMergedConfig,
+      onError: context.onError
+    });
+    builder.useMutate = useMutate;
+    return builder;
+  };
+  const put = (path) => {
+    const builder = caller.put(path);
+    const useMutate = createUseMutate({
+      callerKey: String(callerKey),
+      method: "PUT",
+      path: path || "",
+      buildRequest,
+      getMergedConfig,
+      onError: context.onError
+    });
+    builder.useMutate = useMutate;
+    return builder;
+  };
+  const patch = (path) => {
+    const builder = caller.patch(path);
+    const useMutate = createUseMutate({
+      callerKey: String(callerKey),
+      method: "PATCH",
+      path: path || "",
+      buildRequest,
+      getMergedConfig,
+      onError: context.onError
+    });
+    builder.useMutate = useMutate;
+    return builder;
+  };
+  const del = (path) => {
+    const builder = caller.delete(path);
+    const useMutate = createUseMutate({
+      callerKey: String(callerKey),
+      method: "DELETE",
+      path: path || "",
+      buildRequest,
+      getMergedConfig,
+      onError: context.onError
+    });
+    builder.useMutate = useMutate;
+    return builder;
+  };
+  return {
+    raw: caller,
+    config,
+    invalidate,
+    get,
+    post,
+    put,
+    patch,
+    delete: del,
+    head
+  };
+}
+var IgniterCallerClientContext = react.createContext(void 0);
+function mergeConfig(globalConfig, localConfig) {
+  return {
+    ...globalConfig,
+    ...localConfig,
+    headers: {
+      ...globalConfig.headers || {},
+      ...localConfig?.headers || {}
+    },
+    cookies: {
+      ...globalConfig.cookies || {},
+      ...localConfig?.cookies || {}
+    },
+    query: {
+      ...globalConfig.query || {},
+      ...localConfig?.query || {}
+    }
+  };
+}
+function IgniterCallerProvider(props) {
+  const { callers, configs, hooks, onError, children } = props;
+  const [configState, setConfigState] = react.useState(configs || {});
+  const [listeners] = react.useState(
+    () => /* @__PURE__ */ new Map()
+  );
+  const globalConfig = react.useMemo(
+    () => hooks || {},
+    [hooks]
+  );
+  const register = react.useCallback(
+    (key, refetch) => {
+      const current = listeners.get(key) || /* @__PURE__ */ new Set();
+      current.add(refetch);
+      listeners.set(key, current);
+    },
+    [listeners]
+  );
+  const unregister = react.useCallback(
+    (key, refetch) => {
+      const current = listeners.get(key);
+      if (!current) return;
+      current.delete(refetch);
+      if (current.size === 0) {
+        listeners.delete(key);
+      }
+    },
+    [listeners]
+  );
+  const invalidate = react.useCallback(
+    (keys, data) => {
+      const keysArray = Array.isArray(keys) ? keys : [keys];
+      keysArray.forEach((prefix) => {
+        if (data !== void 0) {
+          IgniterCallerClientCache.replacePrefix(prefix, data);
+        } else {
+          IgniterCallerClientCache.clearPrefix(prefix);
+        }
+        listeners.forEach((refetchFns, registeredKey) => {
+          if (registeredKey.startsWith(prefix)) {
+            refetchFns.forEach((refetch) => refetch(true));
+          }
+        });
+      });
+    },
+    [listeners]
+  );
+  const setConfig = react.useCallback(
+    (callerKey, key, value2) => {
+      setConfigState((prev) => ({
+        ...prev,
+        [callerKey]: {
+          ...prev[callerKey] || {},
+          [key]: value2
+        }
+      }));
+    },
+    []
+  );
+  const setConfigBatch = react.useCallback(
+    (callerKey, config) => {
+      setConfigState((prev) => ({
+        ...prev,
+        [callerKey]: {
+          ...prev[callerKey] || {},
+          ...config
+        }
+      }));
+    },
+    []
+  );
+  const getMergedConfig = react.useCallback(
+    (callerKey) => mergeConfig(globalConfig, configState[callerKey]),
+    [globalConfig, configState]
+  );
+  const getConfig = react.useCallback(
+    (callerKey, key) => getMergedConfig(callerKey)[key],
+    [getMergedConfig]
+  );
+  const value = react.useMemo(
+    () => ({
+      callers,
+      configs: configState,
+      globalConfig,
+      setConfig,
+      setConfigBatch,
+      getConfig,
+      getMergedConfig,
+      register,
+      unregister,
+      invalidate,
+      listeners,
+      onError
+    }),
+    [
+      callers,
+      configState,
+      globalConfig,
+      getConfig,
+      getMergedConfig,
+      invalidate,
+      listeners,
+      onError,
+      register,
+      setConfig,
+      setConfigBatch,
+      unregister
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(IgniterCallerClientContext.Provider, { value, children });
+}
+function useIgniterCallerContext() {
+  const context = react.useContext(
+    IgniterCallerClientContext
+  );
+  if (!context) {
+    throw new Error(
+      "IgniterCallerProvider is missing. Wrap your app with <IgniterCallerProvider>."
+    );
+  }
+  return context;
+}
+function useIgniterCaller() {
+  const context = useIgniterCallerContext();
+  return (callerKey) => createIgniterCallerClient(context, callerKey);
+}
+
+exports.IgniterCallerClientCache = IgniterCallerClientCache;
+exports.IgniterCallerProvider = IgniterCallerProvider;
+exports.buildCookieHeader = buildCookieHeader;
+exports.buildQueryKey = buildQueryKey;
+exports.buildQueryPrefix = buildQueryPrefix;
+exports.createIgniterCallerClient = createIgniterCallerClient;
+exports.useIgniterCaller = useIgniterCaller;
+exports.useIgniterCallerContext = useIgniterCallerContext;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map