mtmsdk 0.0.42 → 0.0.44

package/src/supabase/auth-provider.tsx

@@ -0,0 +1,67 @@
+"use client";
+
+import type { Session } from "@supabase/supabase-js";
+import { createContext, useContext, useEffect, useMemo, useState, type PropsWithChildren, type ReactNode } from "react";
+import { useSupabaseBrowser } from "./context";
+
+interface SupabaseAuthContextType {
+  session: Session | null;
+  token: string | undefined;
+  isLoading: boolean;
+}
+
+const SupabaseAuthContext = createContext<SupabaseAuthContextType | undefined>(undefined);
+
+export function useSupabaseAuth() {
+  const context = useContext(SupabaseAuthContext);
+  if (context === undefined) {
+    throw new Error("useSupabaseAuth must be used within a SupabaseAuthProvider");
+  }
+  return context;
+}
+
+export function SupabaseAuthProvider({ children }: PropsWithChildren): ReactNode {
+  const sb = useSupabaseBrowser();
+  const [session, setSession] = useState<Session | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+
+  useEffect(() => {
+    let mounted = true;
+
+    async function loadSession() {
+      const {
+        data: { session },
+      } = await sb.auth.getSession();
+      if (mounted) {
+        setSession(session);
+        setIsLoading(false);
+      }
+    }
+    loadSession();
+
+    const {
+      data: { subscription },
+    } = sb.auth.onAuthStateChange((_event, session) => {
+      if (mounted) {
+        setSession(session);
+        setIsLoading(false);
+      }
+    });
+
+    return () => {
+      mounted = false;
+      subscription.unsubscribe();
+    };
+  }, [sb]);
+
+  const value = useMemo(
+    () => ({
+      session,
+      token: session?.access_token,
+      isLoading,
+    }),
+    [session, isLoading],
+  );
+
+  return <SupabaseAuthContext.Provider value={value}>{children}</SupabaseAuthContext.Provider>;
+}

package/src/supabase/context.tsx

@@ -0,0 +1,51 @@
+"use client";
+
+import { createBrowserClient } from "@supabase/ssr";
+import { createContext, type ReactNode, useContext, useMemo } from "react";
+import type { TypedSupabaseClient } from "../types";
+import type { Database } from "../types/database.types";
+
+let client: TypedSupabaseClient | undefined;
+
+export function getSupabaseBrowserClient(url?: string, key?: string): TypedSupabaseClient {
+  if (url && key) {
+    return createBrowserClient<Database>(url, key);
+  }
+  if (!client) {
+    client = createBrowserClient<Database>(
+      // biome-ignore lint/style/noNonNullAssertion: .
+      process.env.NEXT_PUBLIC_SUPABASE_URL!,
+      // biome-ignore lint/style/noNonNullAssertion: .
+      process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+    );
+  }
+  // biome-ignore lint/style/noNonNullAssertion: 已经确保了初始化
+  return client!;
+}
+
+export const SupabaseContext = createContext<TypedSupabaseClient | undefined>(undefined);
+
+export function useSupabaseContext(): TypedSupabaseClient {
+  const ctx = useContext(SupabaseContext);
+  if (!ctx) {
+    throw new Error("useSupabaseContext must be used within a SupabaseProvider");
+  }
+  return ctx;
+}
+export const useSupabaseBrowser = useSupabaseContext;
+
+interface SupabaseClientProviderProps {
+  children: ReactNode;
+  publicKey?: string;
+  url?: string;
+}
+
+export const SupabaseClientProvider = ({ children, publicKey, url }: SupabaseClientProviderProps): ReactNode => {
+  const client = useMemo(() => getSupabaseBrowserClient(url, publicKey), [url, publicKey]);
+
+  return (
+    <SupabaseContext.Provider value={client}>
+      {children}
+    </SupabaseContext.Provider>
+  );
+};

package/src/supabase/cursor-pagination.ts

@@ -0,0 +1,155 @@
+/**
+ * 游标分页工具函数
+ *
+ * 提供类型安全的游标分页支持，配合 react-query 的 useInfiniteQuery 使用。
+ *
+ * @module mtmsdk/supabase/cursor-pagination
+ */
+
+/**
+ * 游标类型定义
+ *
+ * 使用复合游标 (updated_at + id) 确保分页的唯一性和稳定性
+ */
+export interface CursorPagination {
+  cursor: string | null; // ISO 时间戳字符串, 如 "2026-01-20T08:00:00Z"
+  cursorId: string | null; // UUID 字符串
+}
+
+/**
+ * 从数据列表中提取下一页游标
+ *
+ * @param items - 当前页的数据列表
+ * @param limit - 每页数量
+ * @param cursorField - 游标字段名 (默认 "updated_at")
+ * @param idField - ID 字段名 (默认 "id")
+ * @returns 下一页游标, 如果没有更多数据则返回 undefined
+ *
+ * @example
+ * ```tsx
+ * const { data, fetchNextPage, hasNextPage } = useInfiniteQuery({
+ *   queryKey: ['projects', kw],
+ *   queryFn: async ({ pageParam }) => {
+ *     const { data } = await sb.rpc('audit_project_list_cursor', {
+ *       p_cursor: pageParam?.cursor ?? null,
+ *       p_cursor_id: pageParam?.cursorId ?? null,
+ *       p_limit: 20,
+ *       p_kw: kw
+ *     });
+ *     return data ?? [];
+ *   },
+ *   getNextPageParam: (lastPage) => getNextCursor(lastPage, 20),
+ *   initialPageParam: null as CursorPagination | null
+ * });
+ * ```
+ */
+export function getNextCursor<
+  T extends Record<string, unknown>,
+>(
+  items: T[] | null | undefined,
+  limit: number,
+  cursorField: keyof T = "updated_at" as keyof T,
+  idField: keyof T = "id" as keyof T,
+): CursorPagination | undefined {
+  // 如果数据为空或数量小于 limit，说明已到达最后一页
+  if (!items || items.length < limit) {
+    return undefined;
+  }
+
+  // 获取最后一条记录
+  const lastItem = items[items.length - 1];
+  if (!lastItem) {
+    return undefined;
+  }
+
+  const cursorValue = lastItem[cursorField];
+  const idValue = lastItem[idField];
+
+  // 验证游标值有效性
+  if (cursorValue === undefined || cursorValue === null) {
+    return undefined;
+  }
+
+  return {
+    cursor: String(cursorValue),
+    cursorId: idValue != null ? String(idValue) : null,
+  };
+}
+
+/**
+ * 将所有分页数据合并为单一列表
+ *
+ * @param pages - useInfiniteQuery 返回的 pages 数组
+ * @returns 合并后的扁平数据列表
+ *
+ * @example
+ * ```tsx
+ * const { data } = useInfiniteQuery({ ... });
+ * const allProjects = flattenPages(data?.pages);
+ * ```
+ */
+export function flattenPages<T>(
+  pages: T[][] | undefined,
+): T[] {
+  if (!pages) return [];
+  return pages.flat();
+}
+
+/**
+ * 无限滚动分页状态
+ */
+export interface InfiniteScrollState {
+  isLoading: boolean;
+  isFetchingNextPage: boolean;
+  hasNextPage: boolean;
+  error: Error | null;
+}
+
+/**
+ * 创建 IntersectionObserver 用于无限滚动
+ *
+ * @param onIntersect - 当元素进入视口时的回调
+ * @param options - IntersectionObserver 配置选项
+ * @returns cleanup 函数
+ *
+ * @example
+ * ```tsx
+ * const loadMoreRef = useRef<HTMLDivElement>(null);
+ *
+ * useEffect(() => {
+ *   if (!loadMoreRef.current) return;
+ *   return createInfiniteScrollObserver(
+ *     () => {
+ *       if (hasNextPage && !isFetchingNextPage) {
+ *         fetchNextPage();
+ *       }
+ *     },
+ *     { root: scrollContainerRef.current }
+ *   )(loadMoreRef.current);
+ * }, [hasNextPage, isFetchingNextPage, fetchNextPage]);
+ * ```
+ */
+export function createInfiniteScrollObserver(
+  onIntersect: () => void,
+  options?: IntersectionObserverInit,
+): (element: Element) => () => void {
+  return (element: Element) => {
+    const observer = new IntersectionObserver((entries) => {
+      const [entry] = entries;
+      if (entry?.isIntersecting) {
+        onIntersect();
+      }
+    }, {
+      root: null,
+      rootMargin: "100px",
+      threshold: 0.1,
+      ...options,
+    });
+
+    observer.observe(element);
+
+    return () => {
+      observer.disconnect();
+    };
+  };
+}

package/src/supabase/schema/browser.ts

@@ -0,0 +1,45 @@
+import z from "zod";
+
+export const zRpcBaseResponse = z.object({
+  error: z.object({
+    message: z.string(),
+  }),
+});
+export const zBrowserUpsertArgs = z
+  .object({
+    id: z.string().nullish(),//.transform( x => x ?? undefined ),
+    title: z.string(),
+    profile_id: z.string().nullish(),//.transform( x => x ?? undefined ),
+    description: z.string().nullish()//.transform( x => x ?? undefined ),
+  })
+  .meta({ ref: "BrowserUpsertArgs" });
+
+export const zBrowserListReq = z
+  .object({
+    kw: z.string().optional(),
+  })
+  .describe("BrowserListReq")
+  .meta({ ref: "BrowserListReq" });
+
+const zBrowserItem = z
+  .object({
+    id: z.string(),
+    title: z.string(),
+  })
+  .describe("BrowserItem")
+  .meta({ ref: "BrowserItem" });
+
+export const zBrowserData = z
+  .object({
+    id: z.string(),
+    title: z.string(),
+  })
+  .describe("BrowserData")
+  .meta({ ref: "BrowserData" });
+
+export const zBrowserListResponse = zRpcBaseResponse
+  .extend({
+    data: z.array(zBrowserItem),
+  })
+  // .describe("BrowserProfileResponse")
+  .meta({ ref: "BrowserList" });

package/src/supabase/schema/index.ts

@@ -0,0 +1,50 @@
+import z from "zod";
+
+const singleRowPreprocessor = (val: unknown) => {
+  if (Array.isArray(val)) {
+    if (val.length === 0) return null;
+    if (val.length === 1) return val[0];
+  }
+  return val;
+};
+
+export const gatewayUrlConfigSchema = z.preprocess(
+  singleRowPreprocessor,
+  z
+    .object({
+      mtgate_url: z.string().url({ message: "必须是有效的 URL" }).optional().or(z.literal("")),
+    })
+    .nullable(),
+);
+
+export const domainConfigSchema = z.preprocess(
+  singleRowPreprocessor,
+  z
+    .object({
+      primary_domain: z.string().min(1, "主域名不能为空"),
+      worker_subdomain_prefix: z.string().optional().default(""),
+    })
+    .nullable(),
+);
+
+export const sharedServerGetSchema = z.preprocess(
+  singleRowPreprocessor,
+  z
+    .object({
+      id: z.string(),
+      name: z.string(),
+      url: z.string().nullable().optional(),
+      is_shared: z.boolean(),
+    })
+    .nullable(),
+);
+
+export const smsProviderConfigSchema = z.object({
+  default_provider: z.enum(["manual", "demo"]).optional().default("manual"),
+});
+
+export const geminiProxyConfigSchema = z.object({
+  default_model: z.string().optional().default("gemini-1.5-pro"),
+  model_mapping: z.record(z.string(), z.string()).optional().default({}),
+  api_version: z.enum(["v1", "v1beta"]).optional().default("v1"),
+});

package/src/supabase/supabase-client.ts

@@ -0,0 +1,30 @@
+import { createServerClient } from "@supabase/ssr";
+import type { cookies } from "next/headers";
+import type { Database } from "../types/database.types";
+
+export function useSupabaseServer(
+	cookieStore: Awaited<ReturnType<typeof cookies>>,
+) {
+	return createServerClient<Database>(
+		process.env.NEXT_PUBLIC_SUPABASE_URL!,
+		process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+		{
+			cookies: {
+				getAll() {
+					return cookieStore.getAll();
+				},
+				setAll(cookiesToSet) {
+					try {
+						for (const co of cookiesToSet) {
+							cookieStore.set(co.name, co.value, co.options);
+						}
+					} catch (e) {
+						//!!! 提示,对于nextjs + honoapi 后端方式使用,可能出现以下错误:
+						// Cookies can only be modified in a Server Action or Route Handler. Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options
+						//可以直接忽略.
+					}
+				},
+			},
+		},
+	);
+}

package/src/supabase/supabase.ts

@@ -0,0 +1,65 @@
+import { createServerClient, parseCookieHeader } from "@supabase/ssr";
+import { createClient } from "@supabase/supabase-js";
+import type { Context } from "hono";
+import { setCookie } from "hono/cookie";
+import type { TypedSupabaseClient } from "../types";
+
+export const getSupabaseUrl = () => {
+  if (!process.env.NEXT_PUBLIC_SUPABASE_URL) {
+    throw new Error("NEXT_PUBLIC_SUPABASE_URL missing!");
+  }
+  return process.env.NEXT_PUBLIC_SUPABASE_URL;
+};
+export const getSupabasePublicKey = () => {
+  if (!process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY) {
+    throw new Error("NEXT_PUBLIC_SUPABASE_ANON_KEY missing!");
+  }
+  return process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+};
+
+export const getSupabaseProjectRef = () => {
+  const uri = new URL(getSupabaseUrl());
+  const supabasePrject = uri.hostname.split(".")[0];
+  return supabasePrject;
+};
+
+export const getSupabase = (c: Context) => {
+  const client: TypedSupabaseClient = createServerClient(getSupabaseUrl(), getSupabasePublicKey(), {
+    cookies: {
+      //@ts-expect-error
+      getAll() {
+        return parseCookieHeader(c.req.header("Cookie") ?? "");
+      },
+      setAll(cookiesToSet) {
+        for (const co of cookiesToSet) {
+          //@ts-expect-error
+          setCookie(c, co.name, co.value, co.options);
+        }
+      },
+    },
+    global: {
+      // 由于gomtm supabase 客户端已经登录.所以这里直接传递 Authorization 头,即可.
+      headers: {
+        ...(c.req.header("Authorization") && {
+          Authorization: c.req.header("Authorization"),
+        }),
+      },
+    },
+  });
+  return client;
+};
+
+export const getSupabaseAdmin = () => {
+  const serviceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+  if (!serviceRoleKey) {
+    throw new Error("require SUPABASE_SERVICE_ROLE_KEY");
+  }
+  const client: TypedSupabaseClient = createClient(getSupabaseUrl(), serviceRoleKey, {
+    auth: {
+      autoRefreshToken: false,
+      persistSession: false,
+    },
+  });
+
+  return client;
+};

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

@@ -0,0 +1,56 @@
+import {
+  type AnyPostgrestResponse,
+  isPostgrestBuilder,
+  isPostgrestTransformBuilder,
+} from "@supabase-cache-helpers/postgrest-core";
+import type { PostgrestError } from "@supabase/postgrest-js";
+import type {
+  UseQueryOptions as UseReactQueryOptions,
+  UseSuspenseQueryOptions,
+} from "@tanstack/react-query";
+
+import { encode } from "./key";
+
+export function buildQueryOpts<Result>(
+	query: PromiseLike<AnyPostgrestResponse<Result>>,
+	config?: Omit<
+		UseReactQueryOptions<AnyPostgrestResponse<Result>, PostgrestError>,
+		"queryKey" | "queryFn"
+	>,
+): UseReactQueryOptions<AnyPostgrestResponse<Result>, PostgrestError> {
+	return {
+		queryKey: encode<Result>(query, false),
+		queryFn: async ({ signal }) => {
+			if (isPostgrestTransformBuilder(query)) {
+				query = query.abortSignal(signal);
+			}
+			if (isPostgrestBuilder(query)) {
+				query = query.throwOnError();
+			}
+			return await query;
+		},
+		...config,
+	};
+}
+
+export function buildSuspenseQueryOpts<Result>(
+	query: PromiseLike<AnyPostgrestResponse<Result>>,
+	config?: Omit<
+		UseSuspenseQueryOptions<AnyPostgrestResponse<Result>, PostgrestError>,
+		"queryKey" | "queryFn"
+	>,
+): UseSuspenseQueryOptions<AnyPostgrestResponse<Result>, PostgrestError> {
+	return {
+		queryKey: encode<Result>(query, false),
+		queryFn: async ({ signal }) => {
+			if (isPostgrestTransformBuilder(query)) {
+				query = query.abortSignal(signal);
+			}
+			if (isPostgrestBuilder(query)) {
+				query = query.throwOnError();
+			}
+			return await query;
+		},
+		...config,
+	};
+}

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

@@ -0,0 +1,57 @@
+import { type DecodedKey, isPostgrestBuilder, PostgrestParser } from "@supabase-cache-helpers/postgrest-core";
+
+export const KEY_PREFIX = "postgrest";
+export const INFINITE_KEY_PREFIX = "page";
+
+export type DecodedReactQueryKey = DecodedKey & {
+  isInfinite: boolean;
+  key: string[];
+};
+
+export const encode = <Result>(key: unknown, isInfinite: boolean): string[] => {
+  if (!isPostgrestBuilder<Result>(key)) {
+    throw new Error("Key is not a PostgrestBuilder");
+  }
+
+  const parser = new PostgrestParser<Result>(key);
+  return [
+    KEY_PREFIX,
+    isInfinite ? INFINITE_KEY_PREFIX : "null",
+    parser.schema,
+    parser.table,
+    parser.queryKey,
+    parser.bodyKey ?? "null",
+    `count=${parser.count}`,
+    `head=${parser.isHead}`,
+    parser.orderByKey,
+  ];
+};
+
+export const decode = (key: unknown): DecodedReactQueryKey | null => {
+  if (!Array.isArray(key)) return null;
+
+  const [prefix, infinitePrefix, schema, table, queryKey, bodyKey, count, head, orderByKey] = key;
+
+  // Exit early if not a postgrest key
+  if (prefix !== KEY_PREFIX) return null;
+
+  const params = new URLSearchParams(queryKey);
+  const limit = params.get("limit");
+  const offset = params.get("offset");
+
+  const countValue = count.replace("count=", "");
+
+  return {
+    limit: limit ? Number(limit) : undefined,
+    offset: offset ? Number(offset) : undefined,
+    bodyKey,
+    count: countValue === "null" ? null : countValue,
+    isHead: head === "head=true",
+    isInfinite: infinitePrefix === INFINITE_KEY_PREFIX,
+    key,
+    queryKey,
+    schema,
+    table,
+    orderByKey,
+  };
+};

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

@@ -0,0 +1,59 @@
+import { type AnyPostgrestResponse, isPostgrestBuilder } from "@supabase-cache-helpers/postgrest-core";
+import type {
+  PostgrestError,
+  PostgrestMaybeSingleResponse,
+  PostgrestResponse,
+  PostgrestSingleResponse,
+} from "@supabase/postgrest-js";
+import type { FetchQueryOptions, QueryClient } from "@tanstack/react-query";
+import { buildQueryOpts } from "./build-query-opts";
+import { encode } from "./key";
+
+function prefetchQuery<Result>(
+  queryClient: QueryClient,
+  query: PromiseLike<PostgrestSingleResponse<Result>>,
+  config?: Omit<FetchQueryOptions<PostgrestSingleResponse<Result>, PostgrestError>, "queryKey" | "queryFn">,
+): Promise<void>;
+function prefetchQuery<Result>(
+  queryClient: QueryClient,
+  query: PromiseLike<PostgrestMaybeSingleResponse<Result>>,
+  config?: Omit<FetchQueryOptions<PostgrestMaybeSingleResponse<Result>, PostgrestError>, "queryKey" | "queryFn">,
+): Promise<void>;
+function prefetchQuery<Result>(
+  queryClient: QueryClient,
+  query: PromiseLike<PostgrestResponse<Result>>,
+  config?: Omit<FetchQueryOptions<PostgrestResponse<Result>, PostgrestError>, "queryKey" | "queryFn">,
+): Promise<void>;
+
+async function prefetchQuery<Result>(
+  queryClient: QueryClient,
+  query: PromiseLike<AnyPostgrestResponse<Result>>,
+  config?: Omit<FetchQueryOptions<AnyPostgrestResponse<Result>, PostgrestError>, "queryKey" | "queryFn">,
+) {
+  await queryClient.prefetchQuery<AnyPostgrestResponse<Result>, PostgrestError>(buildQueryOpts(query, config));
+}
+
+function fetchQueryInitialData<Result>(
+  query: PromiseLike<PostgrestSingleResponse<Result>>,
+): Promise<[string[], PostgrestSingleResponse<Result>]>;
+
+function fetchQueryInitialData<Result>(
+  query: PromiseLike<PostgrestMaybeSingleResponse<Result>>,
+): Promise<[string[], PostgrestMaybeSingleResponse<Result>]>;
+
+function fetchQueryInitialData<Result>(
+  query: PromiseLike<PostgrestResponse<Result>>,
+): Promise<[string[], PostgrestResponse<Result>]>;
+
+async function fetchQueryInitialData<Result>(
+  query: PromiseLike<AnyPostgrestResponse<Result>>,
+): Promise<[string[], AnyPostgrestResponse<Result>]> {
+  if (!isPostgrestBuilder<Result>(query)) {
+    throw new Error("Query is not a PostgrestBuilder");
+  }
+
+  return [encode(query, false), await query.throwOnError()];
+}
+
+export { fetchQueryInitialData, prefetchQuery };
+