mtmsdk 0.0.51 → 0.0.53

package/src/supabase/use-sb-query/use-query.ts

@@ -1,340 +0,0 @@
-/**
- * 将 supabase api封装位 react query的 形式.
- * 原官方库: https://github.com/psteinroe/supabase-cache-helpers
- */
-
-import type {
-  AnyPostgrestResponse,
-  BuildNormalizedQueryOps,
-  PostgrestQueryParserOptions,
-} from "@supabase-cache-helpers/postgrest-core";
-import { PostgrestFilter, encodeObject, type DecodedKey } from "@supabase-cache-helpers/postgrest-core";
-import type {
-  PostgrestError,
-  PostgrestMaybeSingleResponse,
-  PostgrestResponse,
-  PostgrestResponseSuccess,
-  PostgrestSingleResponse,
-} from "@supabase/postgrest-js";
-import {
-  useQueryClient,
-  useQuery as useReactQuery,
-  useSuspenseQuery as useReactSuspenseQuery,
-  type UseQueryOptions as UseReactQueryOptions,
-  type UseQueryResult as UseReactQueryResult,
-  type UseSuspenseQueryResult as UseReactSuspenseQueryResult,
-  type UseSuspenseQueryOptions as UserReactSuspenseQueryOptions,
-} from "@tanstack/react-query";
-import { buildQueryOpts, buildSuspenseQueryOpts } from "./build-query-opts";
-import { decode, encode } from "./key";
-
-export const KEY_PREFIX = "postgrest";
-export const INFINITE_KEY_PREFIX = "page";
-
-export type DecodedReactQueryKey = DecodedKey & {
-  isInfinite: boolean;
-  key: string[];
-};
-
-export const POSTGREST_FILTER_KEY_PREFIX = "postgrest-filter";
-
-export const usePostgrestFilterCache = <R extends Record<string, unknown>>() => {
-  const queryClient = useQueryClient();
-
-  return (query: string, opts?: PostgrestQueryParserOptions) => {
-    const key = [POSTGREST_FILTER_KEY_PREFIX, query, opts ? encodeObject(opts) : null];
-    const cacheData = queryClient.getQueryData(key);
-    if (cacheData instanceof PostgrestFilter) {
-      return cacheData;
-    }
-    const filter = PostgrestFilter.fromQuery(query, opts);
-    queryClient.setQueryData(key, filter);
-    return filter as PostgrestFilter<R>;
-  };
-};
-
-export const useQueriesForTableLoader = (table: string) => {
-  const queryClient = useQueryClient();
-  const getPostgrestFilter = usePostgrestFilterCache();
-
-  return () =>
-    queryClient
-      .getQueryCache()
-      .getAll()
-      .map((c) => c.queryKey)
-      .reduce<ReturnType<BuildNormalizedQueryOps["queriesForTable"]>>((prev, curr) => {
-        const decodedKey = decode(curr);
-        if (decodedKey?.table === table) {
-          prev.push(getPostgrestFilter(decodedKey.queryKey).params);
-        }
-        return prev;
-      }, []);
-};
-
-/**
- * Applies Omit over a union, while preserving its union-ness.
- */
-// biome-ignore lint/suspicious/noExplicitAny: keyof any 是 TypeScript 泛型约束的标准用法
-type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
-
-/**
- * Represents the return value of the `useQuery` hook when `query` is expected to return
- * a single row.
- */
-export type UseQuerySingleReturn<Result> = DistributiveOmit<
-  UseReactQueryResult<PostgrestSingleResponse<Result>["data"], PostgrestError>,
-  "refetch"
-> &
-  Pick<UseReactQueryResult<PostgrestSingleResponse<Result>, PostgrestError>, "refetch"> &
-  Pick<PostgrestSingleResponse<Result>, "count">;
-
-/**
- * Represents the return value of the `useQuery` hook when `query` is expected to return
- * either a single row or an empty response.
- */
-export type UseQueryMaybeSingleReturn<Result> = DistributiveOmit<
-  UseReactQueryResult<PostgrestMaybeSingleResponse<Result>["data"], PostgrestError>,
-  "refetch"
-> &
-  Pick<UseReactQueryResult<PostgrestMaybeSingleResponse<Result>, PostgrestError>, "refetch"> &
-  Pick<PostgrestMaybeSingleResponse<Result>, "count">;
-
-/**
- * Represents the return value of the `useQuery` hook when `query` is expected to return
- * one or more rows.
- */
-export type UseQueryReturn<Result> = DistributiveOmit<
-  UseReactQueryResult<PostgrestResponse<Result>["data"], PostgrestError>,
-  "refetch"
-> &
-  Pick<UseReactQueryResult<PostgrestResponse<Result>, PostgrestError>, "refetch"> &
-  Pick<PostgrestResponse<Result>, "count">;
-
-/**
- * Represents the return value of the `useQuery` hook when the type of the query response
- * is not known.
- */
-export type UseQueryAnyReturn<Result> = DistributiveOmit<
-  UseReactQueryResult<AnyPostgrestResponse<Result>["data"], PostgrestError>,
-  "refetch"
-> &
-  Pick<UseReactQueryResult<AnyPostgrestResponse<Result>, PostgrestError>, "refetch"> &
-  Pick<AnyPostgrestResponse<Result>, "count">;
-
-/**
- * React hook to execute a PostgREST query and return a single item response.
- *
- * @param {PromiseLike<PostgrestSingleResponse<Result>>} query A promise that resolves to a PostgREST single item response.
- * @param {Omit<UseReactQueryOptions<PostgrestSingleResponse<Result>, PostgrestError>, 'queryKey' | 'queryFn'>} [config] The React Query options.
- * @returns {UseQuerySingleReturn<Result>} The hook result containing the single item response data.
- */
-function useQuery<Result>(
-  query: PromiseLike<PostgrestSingleResponse<Result>>,
-  config?: Omit<UseReactQueryOptions<PostgrestSingleResponse<Result>, PostgrestError>, "queryKey" | "queryFn">,
-): UseQuerySingleReturn<Result>;
-/**
- * React hook to execute a PostgREST query and return a maybe single item response.
- *
- * @param {PromiseLike<PostgrestMaybeSingleResponse<Result>>} query A promise that resolves to a PostgREST maybe single item response.
- * @param {Omit<UseReactQueryOptions<PostgrestMaybeSingleResponse<Result>, PostgrestError>, 'queryKey' | 'queryFn'>} [config] The React Query options.
- * @returns {UseQueryMaybeSingleReturn<Result>} The hook result containing the maybe single item response data.
- */
-function useQuery<Result>(
-  query: PromiseLike<PostgrestMaybeSingleResponse<Result>>,
-  config?: Omit<UseReactQueryOptions<PostgrestMaybeSingleResponse<Result>, PostgrestError>, "queryKey" | "queryFn">,
-): UseQueryMaybeSingleReturn<Result>;
-/**
- * React hook to execute a PostgREST query.
- *
- * @template Result The expected response data type.
- * @param {PromiseLike<PostgrestResponse<Result>>} query A promise that resolves to a PostgREST response.
- * @param {Omit<UseReactQueryOptions<PostgrestResponse<Result>, PostgrestError>, 'queryKey' | 'queryFn'>} [config] The React Query options.
- * @returns {UseQueryReturn<Result>} The hook result containing the response data.
- */
-function useQuery<Result>(
-  query: PromiseLike<PostgrestResponse<Result>>,
-  config?: Omit<UseReactQueryOptions<PostgrestResponse<Result>, PostgrestError>, "queryKey" | "queryFn">,
-): UseQueryReturn<Result>;
-
-/**
- * React hook to execute a PostgREST query.
- *
- * @template Result The expected response data type.
- * @param {PromiseLike<AnyPostgrestResponse<Result>>} query A promise that resolves to a PostgREST response of any kind.
- * @param {Omit<UseReactQueryOptions<AnyPostgrestResponse<Result>, PostgrestError>, 'queryKey' | 'queryFn'>} [config] The React Query options.
- * @returns {UseQueryAnyReturn<Result>} The hook result containing the response data.
- */
-function useQuery<Result>(
-  query: PromiseLike<AnyPostgrestResponse<Result>>,
-  config?: Omit<UseReactQueryOptions<AnyPostgrestResponse<Result>, PostgrestError>, "queryKey" | "queryFn">,
-): UseQueryAnyReturn<Result> {
-  const result = useReactQuery<AnyPostgrestResponse<Result>, PostgrestError>(buildQueryOpts<Result>(query, config));
-
-  // isPending and isLoadingError are the only cases in which no data is present
-  if (result.isPending || result.isLoadingError) {
-    return {
-      ...result,
-      data: undefined,
-      count: null,
-    } as UseQueryAnyReturn<Result>;
-  }
-
-  return {
-    ...result,
-    data: result.data?.data,
-    count: result.data?.count,
-  } as UseQueryAnyReturn<Result>;
-}
-
-export { useQuery };
-
-// 增加 queryQuery 获取函数
-
-/**
- * 获取 PostgREST 查询的完整 QueryKey
- * @param query Supabase PostgrestBuilder 实例 (例如: sb.from('...').select() 或 sb.rpc(...))
- * @param isInfinite 是否为无限查询 (默认 false)
- */
-export function getSbQueryKey<Result>(query: PromiseLike<AnyPostgrestResponse<Result>>, isInfinite = false): string[] {
-  return encode(query, isInfinite);
-}
-
-/**
- * 获取 PostgREST 查询的 "Base Key" (仅包含前缀、Schema、Table/RPC名称)
- * 用于 invalidateQueries 时模糊匹配整个表或RPC的所有查询，忽略具体的 filter/page 参数。
- *
- * 结构: ['postgrest', 'null'|'page', schema, table|rpc, ...]
- * 返回: 前4个元素
- */
-export function getSbTableKey<Result>(query: PromiseLike<AnyPostgrestResponse<Result>>): string[] {
-  const fullKey = encode(query, false);
-  // 截取前4个元素作为基础Key: [prefix, infinitePrefix, schema, table]
-  // 这样 invalidateQueries(baseKey) 将会匹配该表/RPC下的所有查询变体
-  return fullKey.slice(0, 4);
-}
-
-// 增加 suspense query 的支持 ========================================================================================
-
-/**
- * Represents the return value of the `useSuspenseQuery` hook when `query` is expected to return
- * a single row.
- */
-export type useSuspenseQuerySingleReturn<Result> = DistributiveOmit<
-  UseReactSuspenseQueryResult<PostgrestMaybeSingleResponseV4<Result>["data"], PostgrestError>,
-  "refetch"
-> &
-  Pick<
-    UseReactSuspenseQueryResult<
-      // PostgrestSingleResponse<Result>,
-      Result,
-      PostgrestError
-    >,
-    "refetch"
-  > &
-  Pick<PostgrestSingleResponse<Result>, "count">;
-
-export type PostgrestMaybeSingleResponseV4<T> = PostgrestResponseSuccess<T>;
-
-/**
- * Represents the return value of the `useSuspenseQuery` hook when `query` is expected to return
- * either a single row or an empty response.
- */
-export type useSuspenseQueryMaybeSingleReturn<Result> = DistributiveOmit<
-  UseReactSuspenseQueryResult<PostgrestMaybeSingleResponseV4<NonNullable<Result>>["data"], PostgrestError>,
-  "refetch"
-> &
-  Pick<UseReactSuspenseQueryResult<PostgrestMaybeSingleResponseV4<NonNullable<Result>>, PostgrestError>, "refetch"> &
-  Pick<PostgrestMaybeSingleResponseV4<Result>, "count">;
-
-/**
- * Represents the return value of the `useSuspenseQuery` hook when `query` is expected to return
- * one or more rows.
- */
-export type useSuspenseQueryReturn<Result> = DistributiveOmit<
-  UseReactSuspenseQueryResult<PostgrestResponse<Result>["data"], PostgrestError>,
-  "refetch"
-> &
-  Pick<UseReactSuspenseQueryResult<PostgrestResponse<Result>, PostgrestError>, "refetch"> &
-  Pick<PostgrestResponse<Result>, "count">;
-
-/**
- * Represents the return value of the `useSuspenseQuery` hook when the type of the query response
- * is not known.
- */
-export type useSuspenseQueryAnyReturn<Result> = DistributiveOmit<
-  UseReactSuspenseQueryResult<PostgrestResponse<Result>["data"], PostgrestError>,
-  "refetch"
-> &
-  Pick<UseReactSuspenseQueryResult<PostgrestResponse<Result>, PostgrestError>, "refetch"> &
-  Pick<PostgrestResponse<Result>, "count">;
-
-/**
- * React hook to execute a PostgREST query and return a single item response.
- *
- * @param {PromiseLike<PostgrestSingleResponse<Result>>} query A promise that resolves to a PostgREST single item response.
- * @param {Omit<UseReactQueryOptions<PostgrestSingleResponse<Result>, PostgrestError>, 'queryKey' | 'queryFn'>} [config] The React Query options.
- * @returns {useSuspenseQuerySingleReturn<Result>} The hook result containing the single item response data.
- */
-function useSbSuspenseQuery<Result>(
-  query: PromiseLike<PostgrestSingleResponse<Result>>,
-  config?: Omit<UseReactQueryOptions<PostgrestSingleResponse<Result>, PostgrestError>, "queryKey" | "queryFn">,
-): useSuspenseQuerySingleReturn<NonNullable<Result>>;
-/**
- * React hook to execute a PostgREST query and return a maybe single item response.
- *
- * @param {PromiseLike<PostgrestMaybeSingleResponse<Result>>} query A promise that resolves to a PostgREST maybe single item response.
- * @param {Omit<UseReactQueryOptions<PostgrestMaybeSingleResponse<Result>, PostgrestError>, 'queryKey' | 'queryFn'>} [config] The React Query options.
- * @returns {useSuspenseQueryMaybeSingleReturn<Result>} The hook result containing the maybe single item response data.
- */
-function useSbSuspenseQuery<Result>(
-  query: PromiseLike<PostgrestMaybeSingleResponse<Result>>,
-  config?: Omit<UseReactQueryOptions<PostgrestMaybeSingleResponse<Result>, PostgrestError>, "queryKey" | "queryFn">,
-): useSuspenseQueryMaybeSingleReturn<NonNullable<Result>>;
-/**
- * React hook to execute a PostgREST query.
- *
- * @template Result The expected response data type.
- * @param {PromiseLike<PostgrestResponse<Result>>} query A promise that resolves to a PostgREST response.
- * @param {Omit<UseReactQueryOptions<PostgrestResponse<Result>, PostgrestError>, 'queryKey' | 'queryFn'>} [config] The React Query options.
- * @returns {useSuspenseQueryReturn<Result>} The hook result containing the response data.
- */
-function useSbSuspenseQuery<Result>(
-  query: PromiseLike<PostgrestResponse<Result>>,
-  config?: Omit<UseReactQueryOptions<PostgrestResponse<Result>, PostgrestError>, "queryKey" | "queryFn">,
-): useSuspenseQueryReturn<NonNullable<Result>>;
-
-/**
- * React hook to execute a PostgREST query.
- *
- * @template Result The expected response data type.
- * @param {PromiseLike<AnyPostgrestResponse<Result>>} query A promise that resolves to a PostgREST response of any kind.
- * @param {Omit<UseReactQueryOptions<AnyPostgrestResponse<Result>, PostgrestError>, 'queryKey' | 'queryFn'>} [config] The React Query options.
- * @returns {useSuspenseQueryAnyReturn<Result>} The hook result containing the response data.
- */
-function useSbSuspenseQuery<Result>(
-  query: PromiseLike<PostgrestResponse<Result>>,
-  config?: Omit<UserReactSuspenseQueryOptions<AnyPostgrestResponse<Result>, PostgrestError>, "queryKey" | "queryFn">,
-): useSuspenseQueryReturn<NonNullable<Result>> {
-  const result = useReactSuspenseQuery<AnyPostgrestResponse<Result>, PostgrestError>(
-    buildSuspenseQueryOpts<Result>(query, config),
-  );
-
-  // isPending and isLoadingError are the only cases in which no data is present
-  // if (result.isPending || result.isLoadingError) {
-  // 	return {
-  // 		...result,
-  // 		data: undefined,
-  // 		count: null,
-  // 	} //as useSuspenseQueryAnyReturn<Result>;
-  // }
-
-  return {
-    ...result,
-    data: result.data.data, // NonNullable<Result|Result[]>,
-    count: result.data.count,
-  } as useSuspenseQueryAnyReturn<NonNullable<Result>>;
-}
-
-export const useSbQuery = useQuery;
-
-export { useSbSuspenseQuery };

package/src/supabase/use-sb-query/use-rpc-mutation.ts

@@ -1,83 +0,0 @@
-/**
- * Supabase RPC Mutation Hook
- * 简化 RPC 写操作（upsert, delete 等）的调用
- *
- * 使用示例:
- * ```tsx
- * const updateProject = useRpcMutation("audit_project_upsert");
- *
- * // 调用
- * await updateProject.mutateAsync({
- *   p_id: projectId,
- *   p_name: "New Name"
- * });
- * ```
- */
-
-import type { PostgrestError } from "@supabase/supabase-js";
-import { useMutation, type UseMutationOptions, type UseMutationResult } from "@tanstack/react-query";
-import { useSupabaseBrowser } from "../context";
-import type { RPCFunctionArgs, RPCFunctionName, RPCFunctionReturns } from "./use-rpc-query";
-
-/**
- * RPC Mutation 的返回类型
- */
-export interface RpcMutationResult<TData> {
-  data: TData | null;
-  error: PostgrestError | null;
-}
-
-/**
- * 基于 RPC 函数名进行 Mutation 操作的 Hook
- *
- * @template TFunc RPC 函数名类型
- * @template TData 返回数据类型
- * @param functionName RPC 函数名
- * @param options React Query Mutation 配置选项
- * @returns Mutation 结果
- *
- * @example
- * ```tsx
- * // 示例1: 基础使用
- * const updateProject = useRpcMutation("audit_project_upsert");
- *
- * // 在表单提交中使用
- * const handleSubmit = async (values) => {
- *   const { data, error } = await updateProject.mutateAsync({
- *     p_id: project.id,
- *     p_name: values.name,
- *     p_target: values.target
- *   });
- *
- *   if (error) {
- *     toast.error(error.message);
- *   } else {
- *     toast.success("Updated successfully");
- *   }
- * };
- *
- * // 示例2: 带类型推断
- * type ProjectResult = { id: string; name: string };
- * const updateProject = useRpcMutation<"audit_project_upsert", ProjectResult>("audit_project_upsert");
- * ```
- */
-export function useRpcMutation<
-  TFunc extends RPCFunctionName,
-  TData = RPCFunctionReturns<TFunc>,
-  TError = PostgrestError,
-  TContext = unknown,
->(
-  functionName: TFunc,
-  options?: Omit<UseMutationOptions<RpcMutationResult<TData>, TError, RPCFunctionArgs<TFunc>, TContext>, "mutationFn">,
-): UseMutationResult<RpcMutationResult<TData>, TError, RPCFunctionArgs<TFunc>, TContext> {
-  const sb = useSupabaseBrowser();
-
-  return useMutation<RpcMutationResult<TData>, TError, RPCFunctionArgs<TFunc>, TContext>({
-    mutationFn: async (args) => {
-      // biome-ignore lint/suspicious/noExplicitAny: 绕过 Supabase 内部类型系统
-      const result = await sb.rpc(functionName, args as any);
-      return result as RpcMutationResult<TData>;
-    },
-    ...options,
-  });
-}

package/src/supabase/use-sb-query/use-rpc-query.ts

@@ -1,231 +0,0 @@
-/**
- * 简化版的 Supabase RPC 查询 Hook
- * 自动处理 Supabase Client 的获取，无需手动调用 useSupabaseBrowser()
- *
- * 使用示例:
- * ```tsx
- * // 方式1: 自动推断类型
- * const query1 = useRpcQuery("dash_navitems_list", { p_location: "sidebar_admin" });
- *
- * // 方式2: 使用 Zod Schema 进行类型验证和推断 (推荐)
- * const navItemSchema = z.object({ label: z.string(), url: z.string().optional() });
- * const query2 = useRpcQuery("dash_navitems_list", { p_location: "sidebar_admin" }, {
- *   schema: z.object({ rows: z.array(navItemSchema) })
- * });
- * // data 的类型为 { rows: { label: string; url?: string }[] } | undefined
- *
- * // 方式3: 显式泛型指定返回类型
- * type NavItem = { label: string; url?: string };
- * const query3 = useRpcQuery<NavItem[]>("dash_navitems_list", { p_location: "sidebar_admin" });
- * ```
- */
-
-import { useMemo } from "react";
-import type { z } from "zod";
-import type { SBFunctions } from "../../types";
-import { useSupabaseBrowser } from "../context";
-import {
-    KEY_PREFIX,
-    type UseQueryAnyReturn,
-    type UseQuerySingleReturn,
-    useSbQuery,
-    useSbSuspenseQuery,
-} from "./use-query";
-
-/** 从 SBFunctions 中提取 RPC 函数名的类型 */
-export type RPCFunctionName = keyof SBFunctions;
-
-/**
- * 获取 RPC 查询的通用 Query Key 前缀 (用于 invalidation)
- * 对应 supabase-cache-helpers 生成的 key 结构: ['postgrest', 'null'|'page', schema, table|rpc, ...]
- *
- * @param functionName RPC 函数名
- * @returns Standard Query Key Prefix e.g. ["postgrest", "null", "public", "function_name"]
- */
-export function getRpcQueryKey(functionName: string): string[] {
-  // 默认 schema 为 public, infinite prefix 默认为 "null" (即使是 infinite query, invalidate prefix 通常也能匹配?)
-  // 注意: explicit invalidation 最好匹配 prefix.
-  // supabase-cache-helpers 的 getSbTableKey 返回的是 4 个元素
-  // 注: 对于 RPC，表名解析为 rpc/名称
-  return [KEY_PREFIX, "null", "public", `rpc/${functionName}`];
-}
-
-/** 提取指定 RPC 函数的参数类型 */
-export type RPCFunctionArgs<T extends RPCFunctionName> = SBFunctions[T]["Args"] extends never
-  ? Record<string, never>
-  : SBFunctions[T]["Args"];
-
-/** 提取指定 RPC 函数的返回类型 */
-export type RPCFunctionReturns<T extends RPCFunctionName> = SBFunctions[T]["Returns"];
-
-/**
- * RPC 查询的额外选项
- */
-export interface RpcQueryOptions {
-  /**
-   * 可选的 Zod Schema 用于验证和推断返回类型
-   * 当传入时，将自动验证数据并从 schema 推断类型
-   *
-   * @example
-   * ```tsx
-   * const navItemSchema = z.object({ label: z.string(), url: z.string().optional() });
-   * const resultSchema = z.object({ rows: z.array(navItemSchema), meta: z.any() });
-   *
-   * const { data } = useRpcQuery("dash_navitems_list", { p_location: "sidebar_admin" }, {
-   *   schema: resultSchema
-   * });
-   * // data 类型自动推断为 { rows: { label: string; url?: string }[]; meta: any } | undefined
-   * ```
-   */
-  schema?: z.ZodType;
-}
-
-/**
- * 基于 RPC 函数名和参数进行查询的 Hook (普通模式)
- *
- * @template TData 返回数据类型（显式指定或从数据库函数推断）
- * @param functionName RPC 函数名
- * @param args RPC 函数参数
- * @param options 配置选项，包含 React Query 配置和可选的 schema
- * @returns 查询结果
- *
- * @example
- * ```tsx
- * // 示例1: 基础使用（自动推断）
- * const { data } = useRpcQuery("sys_config_get", { p_key: "github_app" });
- *
- * // 示例2: 使用 Zod Schema（推荐）
- * const navItemSchema = z.object({ label: z.string(), url: z.string().optional() });
- * const { data } = useRpcQuery("dash_navitems_list", { p_location: "sidebar_admin" }, {
- *   schema: z.object({ rows: z.array(navItemSchema), meta: z.any() })
- * });
- *
- * // 示例3: 显式泛型
- * type NavItem = { label: string; url?: string };
- * const { data } = useRpcQuery<NavItem[]>("dash_navitems_list", { p_location: "sidebar_admin" });
- * ```
- */
-// Overload 1: Schema provided -> Infer TData from Schema
-export function useRpcQuery<TFunc extends RPCFunctionName, TSchema extends z.ZodType>(
-  functionName: TFunc,
-  args: RPCFunctionArgs<TFunc> | undefined,
-  options: { schema: TSchema } & Record<string, any>,
-): UseQuerySingleReturn<z.infer<TSchema>>;
-
-// Overload 2: No schema provided -> Infer TData from Generic (defaulting to RPC return)
-export function useRpcQuery<TFunc extends RPCFunctionName, TData = RPCFunctionReturns<TFunc>>(
-  functionName: TFunc,
-  args?: RPCFunctionArgs<TFunc>,
-  options?: { schema?: undefined } & Record<string, any>,
-): UseQueryAnyReturn<TData>;
-
-// Overload 3: Legacy/Fallback
-export function useRpcQuery<TData = any>(
-  functionName: string,
-  args?: any,
-  options?: { schema?: z.ZodType } & Record<string, any>,
-): UseQueryAnyReturn<TData>;
-
-export function useRpcQuery<TFunc extends RPCFunctionName, TData = RPCFunctionReturns<TFunc>>(
-  functionName: TFunc,
-  args?: RPCFunctionArgs<TFunc>,
-  options?: RpcQueryOptions & Record<string, any>,
-): UseQueryAnyReturn<TData> {
-  const sb = useSupabaseBrowser();
-  const query = sb.rpc(functionName, args as never);
-
-  const { schema, ...reactQueryConfig } = options || {};
-
-  // biome-ignore lint/suspicious/noExplicitAny: 绕过 Supabase 内部类型系统
-  const baseResult = useSbQuery(query as any, reactQueryConfig);
-
-  // 如果提供了 schema，对数据进行验证和转换
-  const transformedResult = useMemo(() => {
-    if (!schema || !baseResult.data) {
-      return baseResult;
-    }
-
-    try {
-      const validatedData = schema.parse(baseResult.data);
-      return {
-        ...baseResult,
-        data: validatedData as TData,
-      };
-    } catch (error) {
-      console.error(`[useRpcQuery] Schema validation failed for ${String(functionName)}:`, error);
-      // 验证失败时返回原始数据，避免阻断用户流程
-      return baseResult;
-    }
-  }, [schema, baseResult, functionName]);
-
-  return transformedResult as UseQueryAnyReturn<TData>;
-}
-
-/**
- * 基于 RPC 函数名和参数进行查询的 Hook (Suspense 模式)
- *
- * @template TData 返回数据类型（通过 schema 或泛型指定）
- * @param functionName RPC 函数名
- * @param args RPC 函数参数
- * @param options 配置选项
- * @returns Suspense 查询结果
- *
- * @example
- * ```tsx
- * const navItemSchema = z.object({ label: z.string(), url: z.string().optional() });
- * const { data } = useRpcSuspenseQuery("dash_navitems_list", { p_location: "sidebar_admin" }, {
- *   schema: z.object({ rows: z.array(navItemSchema) })
- * });
- * // data 类型: { rows: { label: string; url?: string }[] }
- * ```
- */
-// Overload 1: Schema provided
-export function useRpcSuspenseQuery<TFunc extends RPCFunctionName, TSchema extends z.ZodType>(
-  functionName: TFunc,
-  args: RPCFunctionArgs<TFunc> | undefined,
-  // biome-ignore lint/suspicious/noExplicitAny: 允许传入 schema
-  options: { schema: TSchema } & Omit<any, "queryKey" | "queryFn">,
-): { data: z.infer<TSchema>; [key: string]: unknown };
-
-// Overload 2: No schema
-export function useRpcSuspenseQuery<TFunc extends RPCFunctionName, TData = RPCFunctionReturns<TFunc>>(
-  functionName: TFunc,
-  args?: RPCFunctionArgs<TFunc>,
-  // biome-ignore lint/suspicious/noExplicitAny: 普通模式
-  options?: { schema?: undefined } & Omit<any, "queryKey" | "queryFn">,
-): { data: TData; [key: string]: unknown };
-
-export function useRpcSuspenseQuery<TFunc extends RPCFunctionName, TData = RPCFunctionReturns<TFunc>>(
-  functionName: TFunc,
-  args?: RPCFunctionArgs<TFunc>,
-  // biome-ignore lint/suspicious/noExplicitAny: 绕过 Supabase 和 ReactQuery 过于复杂的类型推断系统，保持对外类型安全
-  options?: RpcQueryOptions & Omit<any, "queryKey" | "queryFn">,
-): { data: TData; [key: string]: unknown } {
-  const sb = useSupabaseBrowser();
-  const query = sb.rpc(functionName, args as never);
-
-  const { schema, ...reactQueryConfig } = options || {};
-
-  // biome-ignore lint/suspicious/noExplicitAny: 绕过 Supabase 内部类型系统
-  const baseResult = useSbSuspenseQuery(query as any, reactQueryConfig);
-
-  // 如果提供了 schema，对数据进行验证和转换
-  const transformedResult = useMemo(() => {
-    if (!schema) {
-      return baseResult;
-    }
-
-    try {
-      const validatedData = schema.parse(baseResult.data);
-      return {
-        ...baseResult,
-        data: validatedData as TData,
-      };
-    } catch (error) {
-      console.error(`[useRpcSuspenseQuery] Schema validation failed for ${String(functionName)}:`, error);
-      return baseResult;
-    }
-  }, [schema, baseResult, functionName]);
-
-  return transformedResult as { data: TData; [key: string]: unknown };
-}