@relia-fe/core 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -1,3 +1,679 @@
+// src/api/base/request.ts
+import axios, {
+  AxiosHeaders
+} from "axios";
+var isBrowser = typeof window !== "undefined";
+var shouldRemoveBaseURL = (url) => {
+  if (!url) return false;
+  return url.startsWith("http") || url.startsWith("/api/");
+};
+var setAuthorizationHeader = (headers, token) => {
+  if (headers instanceof AxiosHeaders) {
+    const newHeaders = new AxiosHeaders(headers);
+    newHeaders.set("Authorization", `TOKEN ${token}`);
+    return newHeaders;
+  } else {
+    return {
+      ...headers,
+      Authorization: `TOKEN ${token}`
+    };
+  }
+};
+var applyAuthorizationToConfig = (requestConfig, token) => {
+  return {
+    ...requestConfig,
+    headers: setAuthorizationHeader(
+      requestConfig.headers ?? {},
+      token
+    )
+  };
+};
+var is401Error = (error) => {
+  return !!error && typeof error === "object" && "response" in error && error.response?.status === 401;
+};
+var createBaseRequest = (config) => {
+  return axios.create({
+    baseURL: config.baseURL,
+    headers: {
+      "Content-Type": "application/json",
+      ...config.headers
+    }
+  });
+};
+var _baseRequest = null;
+var getBaseRequest = () => {
+  if (!_baseRequest) {
+    _baseRequest = createBaseRequest({ baseURL: "" });
+  }
+  return _baseRequest;
+};
+var configureBaseRequest = (config) => {
+  _baseRequest = createBaseRequest(config);
+};
+var createAuthRequest = (config) => {
+  const { authService, axiosConfig } = config;
+  const requestInterceptor = async (reqConfig) => {
+    let token = authService.getToken();
+    if (!token && isBrowser) {
+      const result = await authService.authenticate("request-init");
+      if (result.success && result.token) {
+        token = result.token;
+      } else {
+        throw new Error("Authentication required");
+      }
+    }
+    if (!token) {
+      throw new Error("Authentication required");
+    }
+    let newConfig = applyAuthorizationToConfig(reqConfig, token);
+    if (shouldRemoveBaseURL(newConfig.url)) {
+      newConfig = { ...newConfig, baseURL: void 0 };
+    }
+    return newConfig;
+  };
+  const clearAuthAndRedirect = () => {
+    authService.logout();
+    if (isBrowser) {
+      window.location.replace("/");
+    }
+  };
+  const handle401Retry = async (error, retryFn) => {
+    const originalConfig = error.config;
+    if (originalConfig._retry) {
+      console.warn("[Fetcher] Re-authentication retry failed");
+      clearAuthAndRedirect();
+      return Promise.reject(error);
+    }
+    originalConfig._retry = true;
+    const authResult = await authService.authenticate("token-refresh");
+    if (authResult.success && authResult.token) {
+      const newConfig = applyAuthorizationToConfig(
+        originalConfig,
+        authResult.token
+      );
+      console.log("[Fetcher] Re-authentication successful, retrying request");
+      return retryFn(newConfig);
+    }
+    console.warn("[Fetcher] Re-authentication failed, redirecting to home");
+    clearAuthAndRedirect();
+    return Promise.reject(error);
+  };
+  const responseErrorHandler = async (error, retryFn) => {
+    console.error(error);
+    if (!isBrowser) {
+      return Promise.reject(error);
+    }
+    if (is401Error(error)) {
+      return handle401Retry(error, retryFn);
+    }
+    return Promise.reject(error);
+  };
+  const baseReq = getBaseRequest();
+  const instance = axiosConfig ? baseReq.create(axiosConfig) : baseReq.create();
+  instance.interceptors.request.use(
+    requestInterceptor,
+    (error) => Promise.reject(error)
+  );
+  instance.interceptors.response.use(
+    (response) => response,
+    (error) => responseErrorHandler(error, (cfg) => instance.request(cfg))
+  );
+  return instance;
+};
+
+// src/api/base/definition.ts
+function defineFetch(uri, method, option) {
+  return {
+    uri,
+    method,
+    host: option?.host,
+    // absoluteUri: `${option?.host ?? HOST_PREFIX}${uri}`,
+    noAuth: option?.noAuth
+  };
+}
+function defineResource(uri, option) {
+  return {
+    uri,
+    method: "get",
+    host: option?.host,
+    // absoluteUri: `${option?.host ?? HOST_PREFIX}${uri}`,
+    noAuth: option?.noAuth
+  };
+}
+function defineResourceList(uri, option) {
+  return {
+    uri,
+    method: "get",
+    host: option?.host,
+    // absoluteUri: `${option?.host ?? HOST_PREFIX}${uri}`,
+    noAuth: option?.noAuth
+  };
+}
+function defineMutation(uri, option) {
+  return {
+    uri,
+    method: option?.method ?? "post",
+    host: option?.host,
+    // absoluteUri: `${option?.host ?? HOST_PREFIX}${uri}`,
+    noAuth: option?.noAuth
+  };
+}
+
+// src/api/base/TokenStorageService.ts
+var isBrowser2 = typeof window !== "undefined";
+var STORAGE_KEY = "auth_tokens";
+var TokenStorageService = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.boundHandleStorage = null;
+  }
+  setToken(token, address) {
+    if (!isBrowser2) return;
+    const key = address?.toLowerCase() ?? "_default";
+    const map = this.getMap();
+    if (token === void 0) {
+      delete map[key];
+    } else {
+      map[key] = token;
+    }
+    this.saveMap(map);
+  }
+  getToken(address) {
+    const key = address?.toLowerCase() ?? "_default";
+    return this.getMap()[key] ?? null;
+  }
+  getMap() {
+    if (!isBrowser2) return {};
+    try {
+      const data = localStorage.getItem(STORAGE_KEY);
+      return data ? JSON.parse(data) : {};
+    } catch {
+      return {};
+    }
+  }
+  saveMap(map) {
+    if (!isBrowser2) return;
+    try {
+      if (Object.keys(map).length === 0) {
+        localStorage.removeItem(STORAGE_KEY);
+      } else {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify(map));
+      }
+    } catch (e) {
+      console.error("Failed to persist auth tokens", e);
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    if (isBrowser2 && this.listeners.size === 1) {
+      this.boundHandleStorage = (e) => {
+        if (e.key === STORAGE_KEY) {
+          this.listeners.forEach((l) => l());
+        }
+      };
+      window.addEventListener("storage", this.boundHandleStorage);
+    }
+    return () => {
+      this.listeners.delete(listener);
+      if (isBrowser2 && this.listeners.size === 0 && this.boundHandleStorage) {
+        window.removeEventListener("storage", this.boundHandleStorage);
+        this.boundHandleStorage = null;
+      }
+    };
+  }
+};
+var defaultTokenStorageService = new TokenStorageService();
+
+// src/api/base/AuthError.ts
+var AuthError = class _AuthError extends Error {
+  constructor(message, errorType) {
+    super(message);
+    this.name = "AuthError";
+    this.errorType = errorType;
+    Object.setPrototypeOf(this, _AuthError.prototype);
+  }
+};
+
+// src/api/base/AuthService.ts
+var AuthService = class {
+  constructor(config) {
+    this.authPromise = null;
+    // 用于并发控制
+    // 状态管理
+    this.state = { status: "idle" };
+    this.listeners = /* @__PURE__ */ new Set();
+    this.refreshToken = config.refreshToken;
+    this.tokenStorageService = config.tokenStorageService ?? defaultTokenStorageService;
+    this.tokenStorageService.subscribe(() => this.handleStorageChange());
+  }
+  /**
+   * Authenticate with concurrency control
+   * Multiple concurrent calls will share the same Promise
+   * Stores token on success
+   */
+  async authenticate(context) {
+    if (this.state.status === "authenticating" && this.authPromise) {
+      console.log(
+        `[AuthService] Authentication already in progress, reusing Promise`
+      );
+      return this.authPromise;
+    }
+    const startAddress = this.state.address;
+    this.setState({
+      status: "authenticating",
+      address: startAddress
+    });
+    this.authPromise = this.refreshToken(context);
+    try {
+      const result = await this.authPromise;
+      const currentAddress = this.state.address;
+      if (this.state.status !== "authenticating") {
+        console.log(
+          `[AuthService] Authentication was cancelled, ignoring result`
+        );
+        throw new AuthError("Authentication was cancelled", "cancelled" /* CANCELLED */);
+      }
+      if (currentAddress !== startAddress) {
+        console.log(
+          `[AuthService] Address changed during auth, ignoring result`
+        );
+        throw new AuthError(
+          "Address changed during authentication",
+          "address_changed" /* ADDRESS_CHANGED */
+        );
+      }
+      this.tokenStorageService.setToken(
+        result.token,
+        currentAddress ?? void 0
+      );
+      this.setState({
+        status: "authenticated",
+        address: currentAddress
+      });
+      console.log(`[AuthService] Token stored successfully`);
+      return result;
+    } catch (error) {
+      const currentAddress = this.state.address;
+      if (error instanceof AuthError) {
+        this.setState({
+          status: "unauthenticated",
+          address: currentAddress,
+          error
+        });
+        throw error;
+      }
+      const authError = new AuthError(
+        error instanceof Error ? error.message : "Unknown error",
+        "unknown" /* UNKNOWN */
+      );
+      this.setState({
+        status: "unauthenticated",
+        address: currentAddress,
+        error: authError
+      });
+      throw authError;
+    } finally {
+      this.authPromise = null;
+    }
+  }
+  /**
+   * 重置内部认证状态（私有方法）
+   */
+  reset() {
+    this.authPromise = null;
+  }
+  /**
+   * Get current token for the current wallet address
+   */
+  getToken() {
+    return this.tokenStorageService.getToken(this.state.address ?? void 0);
+  }
+  /**
+   * 检查地址是否有有效 token（私有方法）
+   */
+  isAddressAuthenticated(address) {
+    if (!address) return false;
+    return this.tokenStorageService.getToken(address) !== null;
+  }
+  /**
+   * Logout: clear token for current address and update state
+   */
+  logout() {
+    const address = this.state.address;
+    this.tokenStorageService.setToken(void 0, address ?? void 0);
+    this.reset();
+    this.setState({ status: "unauthenticated", address });
+  }
+  /**
+   * Get current authentication state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Subscribe to state changes
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /**
+   * Handle wallet address changes
+   * Note: Wallet disconnection should be handled externally by calling logout()
+   */
+  handleWalletChange(address) {
+    const isAuthenticating = this.state.status === "authenticating";
+    if (isAuthenticating && this.state.address !== address) {
+      this.reset();
+      this.setState({ status: "idle", address });
+    }
+    if (this.isAddressAuthenticated(address)) {
+      if (this.state.status !== "authenticated" || this.state.address !== address) {
+        this.setState({ status: "authenticated", address });
+      }
+      return;
+    }
+    const isAlreadyAuthForThisAddress = this.state.status === "authenticated" && this.state.address === address;
+    if (!isAuthenticating && !isAlreadyAuthForThisAddress) {
+      this.setState({ status: "idle", address });
+      this.authenticate("wallet-connect").catch(() => {
+      });
+    }
+  }
+  /**
+   * 处理 StorageChange 事件（用于多选项卡同步）
+   * 当 localStorage 在另一个选项卡中发生更改时调用
+   */
+  handleStorageChange() {
+    const address = this.state.address;
+    if (!address) return;
+    const hasToken = this.isAddressAuthenticated(address);
+    const currentStatus = this.state.status;
+    if (!hasToken && currentStatus === "authenticated") {
+      this.setState({ status: "unauthenticated", address });
+    } else if (hasToken && currentStatus !== "authenticated") {
+      this.setState({ status: "authenticated", address });
+    }
+  }
+  /**
+   * 更新状态并通知监听者
+   */
+  setState(newState) {
+    this.state = newState;
+    this.listeners.forEach((listener) => listener(newState));
+  }
+};
+
+// src/api/provider/AuthProvider.tsx
+import {
+  createContext,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { SWRConfig, useSWRConfig } from "swr";
+import { jsx } from "react/jsx-runtime";
+function isInstanceConfig(config) {
+  return "authService" in config && "authRequest" in config;
+}
+var AuthContext = createContext(null);
+var AuthRequestContext = createContext(null);
+var useAuthInternal = ({
+  authService,
+  address
+}) => {
+  const { mutate: globalMutate } = useSWRConfig();
+  const [authState, setAuthState] = useState(() => authService.getState());
+  useEffect(() => {
+    return authService.subscribe(setAuthState);
+  }, [authService]);
+  useEffect(() => {
+    authService.handleWalletChange(address);
+  }, [address, authService]);
+  const prevStatusRef = useRef(void 0);
+  const prevAddressRef = useRef(void 0);
+  useEffect(() => {
+    const prevStatus = prevStatusRef.current;
+    const prevAddress = prevAddressRef.current;
+    const currentStatus = authState.status;
+    const currentAddress = authState.address;
+    prevStatusRef.current = currentStatus;
+    prevAddressRef.current = currentAddress;
+    if (currentStatus === "authenticated" && prevStatus !== "authenticated" || currentStatus === "authenticated" && currentAddress !== prevAddress) {
+      globalMutate(() => true, void 0, { revalidate: true });
+    }
+  }, [authState.status, authState.address, globalMutate]);
+  const authenticate = useCallback(async () => {
+    if (!address) {
+      console.warn("[Auth] Cannot authenticate without address");
+      return;
+    }
+    if (authState.status === "authenticating") {
+      console.log("[Auth] Authentication already in progress");
+      return;
+    }
+    try {
+      await authService.authenticate("wallet-connect");
+    } catch (error) {
+      console.error("[Auth] Authentication failed:", error);
+    }
+  }, [authService, address, authState.status]);
+  const logout = useCallback(() => {
+    authService.logout();
+  }, [authService]);
+  return {
+    status: authState.status,
+    error: authState.error,
+    address: authState.address,
+    isAuthenticated: authState.status === "authenticated",
+    isAuthenticating: authState.status === "authenticating",
+    authenticate,
+    logout
+  };
+};
+var AuthProvider = ({
+  children,
+  ...config
+}) => {
+  const { authService, authRequest, address } = useMemo(() => {
+    if (isInstanceConfig(config)) {
+      return {
+        authService: config.authService,
+        authRequest: config.authRequest,
+        address: config.address
+      };
+    }
+    const { refreshTokenFn, axiosConfig, tokenStorageService, address: address2 } = config;
+    const service = new AuthService({
+      refreshToken: refreshTokenFn,
+      tokenStorageService
+    });
+    const request = createAuthRequest({
+      authService: service,
+      axiosConfig
+    });
+    return { authService: service, authRequest: request, address: address2 };
+  }, [config]);
+  const auth = useAuthInternal({ authService, address });
+  return /* @__PURE__ */ jsx(AuthContext.Provider, { value: auth, children: /* @__PURE__ */ jsx(AuthRequestContext.Provider, { value: authRequest, children: /* @__PURE__ */ jsx(
+    SWRConfig,
+    {
+      value: {
+        revalidateOnFocus: false,
+        shouldRetryOnError: false,
+        dedupingInterval: 2e3,
+        revalidateOnReconnect: false
+      },
+      children
+    }
+  ) }) });
+};
+
+// src/api/hooks/useAuth.ts
+import { useContext } from "react";
+var useAuth = () => {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error("useAuth must be used within AuthProvider");
+  }
+  return context;
+};
+
+// src/api/hooks/useAuthChange.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+function useAuthChange(onChange) {
+  const { status, error, address } = useAuth();
+  const prevStatusRef = useRef2(void 0);
+  const prevAddressRef = useRef2(void 0);
+  useEffect2(() => {
+    const prevStatus = prevStatusRef.current;
+    const prevAddress = prevAddressRef.current;
+    prevStatusRef.current = status;
+    prevAddressRef.current = address;
+    if (status === "authenticated" && prevStatus !== "authenticated" || status === "authenticated" && address !== prevAddress) {
+      onChange({ type: "authenticated" });
+    } else if (error && status !== prevStatus) {
+      onChange({ type: "error", error });
+    } else if (status === "unauthenticated" && prevStatus && prevStatus !== "idle") {
+      onChange({ type: "unauthenticated", error });
+    }
+  }, [status, error, address, onChange]);
+}
+
+// src/api/hooks/useAuthRequest.ts
+import { useContext as useContext2 } from "react";
+var useAuthRequest = () => {
+  const context = useContext2(AuthRequestContext);
+  if (!context) {
+    throw new Error("useAuthRequest must be used within AuthProvider");
+  }
+  return context;
+};
+
+// src/api/hooks/useResource.ts
+import useSWR from "swr";
+import { useMemo as useMemo2 } from "react";
+
+// src/api/hooks/fetcherFactory.ts
+var createFetchFn = (authRequest) => {
+  return async (requestIdentity, payload) => {
+    const { method, uri, noAuth } = requestIdentity;
+    const instance = noAuth ? getBaseRequest() : authRequest;
+    if (!method || method === "get") {
+      const { data: data2 } = await instance.get(uri, {
+        params: payload
+      });
+      return data2;
+    }
+    if (method === "delete") {
+      const { data: data2 } = await instance.delete(uri, {
+        data: payload
+      });
+      return data2;
+    }
+    const { data } = await instance.post(uri, payload);
+    return data;
+  };
+};
+var createFetcherInterceptor = (authRequest) => {
+  const fetchFn = createFetchFn(authRequest);
+  async function fetcherInterceptor(params) {
+    if (Array.isArray(params[0])) {
+      const multiParams = params;
+      return await Promise.all(
+        multiParams.map(([identity2, payload2]) => fetchFn(identity2, payload2))
+      );
+    }
+    const [identity, payload] = params;
+    return await fetchFn(identity, payload);
+  }
+  return fetcherInterceptor;
+};
+var createFetcherMutation = (authRequest) => {
+  const fetchFn = createFetchFn(authRequest);
+  return async (requestIdentity, { arg }) => {
+    const res = await fetchFn(requestIdentity, arg);
+    if (!res.success || res.code !== 0 && res.code !== 10001) {
+      throw Error(res.message);
+    }
+    return res;
+  };
+};
+
+// src/api/hooks/useResource.ts
+var useResource = (requestIdentity, params, option) => {
+  const authRequest = useAuthRequest();
+  const fetcher = useMemo2(
+    () => createFetcherInterceptor(authRequest),
+    [authRequest]
+  );
+  const { data, ...query } = useSWR(
+    requestIdentity && [requestIdentity, params],
+    fetcher,
+    option
+  );
+  return {
+    ...query,
+    response: data,
+    data: data?.data
+  };
+};
+
+// src/api/hooks/useResourceList.ts
+import useSWR2 from "swr";
+import { useMemo as useMemo3, useState as useState2 } from "react";
+var useResourceList = (requestIdentity, params, option) => {
+  const authRequest = useAuthRequest();
+  const fetcher = useMemo3(
+    () => createFetcherInterceptor(authRequest),
+    [authRequest]
+  );
+  const [page, setPage] = useState2(option?.page ?? 1);
+  const [size, setSize] = useState2(option?.size ?? 10);
+  const pageMapping = option?.pageMapping || ((pageInfo) => pageInfo);
+  const keyWithPage = requestIdentity && [
+    requestIdentity,
+    { ...pageMapping({ page, size }), ...params }
+  ];
+  const { data, ...query } = useSWR2(
+    keyWithPage,
+    fetcher,
+    option
+  );
+  return {
+    ...query,
+    response: data,
+    list: data?.data?.items,
+    pagination: {
+      count: (data?.data?.total ?? 0) / size,
+      page,
+      size,
+      setPage,
+      setSize
+    }
+  };
+};
+
+// src/api/hooks/useMutation.ts
+import useSWRMutation from "swr/mutation";
+import { useMemo as useMemo4 } from "react";
+var useMutation = (key, option) => {
+  const authRequest = useAuthRequest();
+  const fetcher = useMemo4(
+    () => createFetcherMutation(authRequest),
+    [authRequest]
+  );
+  const { data, error, ...query } = useSWRMutation(key, fetcher, option);
+  return {
+    ...query,
+    error,
+    response: data,
+    data: data?.data
+  };
+};
+
 // src/utils/index.ts
 import { omit, pick, debounce, throttle } from "radash";
 import {
@@ -36,14 +712,30 @@ var copyToClipboard = async (text) => {
   }
 };
 export {
+  AuthError,
+  AuthProvider,
+  AuthService,
+  TokenStorageService,
   cloneDeep,
+  configureBaseRequest,
   copyToClipboard,
+  createAuthRequest,
+  createBaseRequest,
+  createFetcherInterceptor,
+  createFetcherMutation,
   debounce,
+  defaultTokenStorageService,
+  defineFetch,
+  defineMutation,
+  defineResource,
+  defineResourceList,
   formatCurrency,
   formatDate,
   generateId,
   get,
+  getBaseRequest,
   groupBy,
+  isBrowser,
   isEmpty,
   isEqual,
   merge,
@@ -55,6 +747,12 @@ export {
   sortBy,
   throttle,
   uniq,
-  uniqBy
+  uniqBy,
+  useAuth,
+  useAuthChange,
+  useAuthRequest,
+  useMutation,
+  useResource,
+  useResourceList
 };
 //# sourceMappingURL=index.mjs.map