@nby.ai/ucm 1.0.1

package/dist/index.js

@@ -0,0 +1,759 @@
+// src/core.ts
+import { createClient } from "@supabase/supabase-js";
+
+// src/types.ts
+function getLocalizedText(text, locale, fallback = "en") {
+  if (!text) return "";
+  return text[locale] || text[fallback] || Object.values(text)[0] || "";
+}
+function buildCategoryTree(categories) {
+  const map = /* @__PURE__ */ new Map();
+  const roots = [];
+  categories.forEach((cat) => {
+    map.set(cat.id, { ...cat, children: [] });
+  });
+  categories.forEach((cat) => {
+    const node = map.get(cat.id);
+    if (cat.parent_id && map.has(cat.parent_id)) {
+      map.get(cat.parent_id).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  });
+  const sortByOrder = (a, b) => a.sort_order - b.sort_order;
+  roots.sort(sortByOrder);
+  roots.forEach((root) => root.children?.sort(sortByOrder));
+  return roots;
+}
+
+// src/core.ts
+function createUCMClient(config) {
+  const { url, anonKey, options = {} } = config;
+  if (!url || !anonKey) {
+    throw new Error("UCM: url and anonKey are required");
+  }
+  const supabase = createClient(url, anonKey, {
+    auth: {
+      persistSession: options.persistSession ?? false,
+      autoRefreshToken: options.autoRefreshToken ?? false
+    }
+  });
+  const contents = {
+    async list(params = {}) {
+      const {
+        type,
+        category_id,
+        tags,
+        featured,
+        visibility,
+        // v2.0: 可见性筛选
+        limit = 20,
+        offset = 0,
+        orderBy = "published_at",
+        orderDirection = "desc"
+      } = params;
+      let query = supabase.from("contents").select("*").order("pinned", { ascending: false }).order(orderBy, { ascending: orderDirection === "asc", nullsFirst: false }).range(offset, offset + limit - 1);
+      if (type) query = query.eq("type", type);
+      if (category_id) query = query.eq("category_id", category_id);
+      if (tags && tags.length > 0) query = query.overlaps("tags", tags);
+      if (featured !== void 0) query = query.eq("featured", featured);
+      if (visibility) query = query.eq("visibility", visibility);
+      const { data, error } = await query;
+      if (error) {
+        throw new Error(`UCM: Failed to fetch contents: ${error.message}`);
+      }
+      return data || [];
+    },
+    async getBySlug(slug) {
+      const { data, error } = await supabase.from("contents").select("*").eq("slug", slug).single();
+      if (error) {
+        if (error.code === "PGRST116") return null;
+        throw new Error(`UCM: Failed to fetch content: ${error.message}`);
+      }
+      return data;
+    },
+    async getById(id) {
+      const { data, error } = await supabase.from("contents").select("*").eq("id", id).single();
+      if (error) {
+        if (error.code === "PGRST116") return null;
+        throw new Error(`UCM: Failed to fetch content: ${error.message}`);
+      }
+      return data;
+    },
+    async count(params = {}) {
+      const { type, category_id, tags, featured, visibility } = params;
+      let query = supabase.from("contents").select("*", { count: "exact", head: true });
+      if (type) query = query.eq("type", type);
+      if (category_id) query = query.eq("category_id", category_id);
+      if (tags && tags.length > 0) query = query.overlaps("tags", tags);
+      if (featured !== void 0) query = query.eq("featured", featured);
+      if (visibility) query = query.eq("visibility", visibility);
+      const { count, error } = await query;
+      if (error) {
+        console.error("UCM: Failed to get count:", error);
+        return 0;
+      }
+      return count || 0;
+    },
+    async create(input) {
+      const { data, error } = await supabase.from("contents").insert(input).select().single();
+      if (error) {
+        throw new Error(`UCM: Failed to create content: ${error.message}`);
+      }
+      return data;
+    },
+    async update(id, input) {
+      const { data, error } = await supabase.from("contents").update(input).eq("id", id).select().single();
+      if (error) {
+        throw new Error(`UCM: Failed to update content: ${error.message}`);
+      }
+      return data;
+    },
+    async delete(id) {
+      const { error } = await supabase.from("contents").delete().eq("id", id);
+      if (error) {
+        throw new Error(`UCM: Failed to delete content: ${error.message}`);
+      }
+    },
+    async incrementView(id) {
+      try {
+        await supabase.rpc("increment_view_count", { content_id: id });
+      } catch {
+      }
+    },
+    async search(query, type, visibility = "public") {
+      if (!query || query.trim().length === 0) {
+        return [];
+      }
+      const { data, error } = await supabase.rpc("search_contents", {
+        search_query: query.trim(),
+        content_type: type || null,
+        content_visibility: visibility
+      });
+      if (error) {
+        throw new Error(`UCM: Failed to search contents: ${error.message}`);
+      }
+      return data || [];
+    },
+    async getTags(type) {
+      let query = supabase.from("contents").select("tags");
+      if (type) {
+        query = query.eq("type", type);
+      }
+      const { data, error } = await query;
+      if (error) {
+        console.error("UCM: Failed to fetch tags:", error);
+        return [];
+      }
+      const allTags = /* @__PURE__ */ new Set();
+      data?.forEach((item) => {
+        if (item.tags && Array.isArray(item.tags)) {
+          item.tags.forEach((tag) => allTags.add(tag));
+        }
+      });
+      return Array.from(allTags).sort((a, b) => a.localeCompare(b));
+    }
+  };
+  const categories = {
+    async list(params = {}) {
+      const { parent_id } = params;
+      let query = supabase.from("categories").select("*").order("sort_order");
+      if (parent_id !== void 0) {
+        if (parent_id === null) {
+          query = query.is("parent_id", null);
+        } else {
+          query = query.eq("parent_id", parent_id);
+        }
+      }
+      const { data, error } = await query;
+      if (error) {
+        throw new Error(`UCM: Failed to fetch categories: ${error.message}`);
+      }
+      return data || [];
+    },
+    async getTree() {
+      const allCategories = await this.list();
+      return buildCategoryTree(allCategories);
+    },
+    async getBySlug(slug) {
+      const { data, error } = await supabase.from("categories").select("*").eq("slug", slug).single();
+      if (error) {
+        if (error.code === "PGRST116") return null;
+        throw new Error(`UCM: Failed to fetch category: ${error.message}`);
+      }
+      return data;
+    },
+    async getById(id) {
+      const { data, error } = await supabase.from("categories").select("*").eq("id", id).single();
+      if (error) {
+        if (error.code === "PGRST116") return null;
+        throw new Error(`UCM: Failed to fetch category: ${error.message}`);
+      }
+      return data;
+    },
+    async getChildren(parentId) {
+      return this.list({ parent_id: parentId });
+    },
+    async getRoots() {
+      return this.list({ parent_id: null });
+    },
+    async getBreadcrumb(categoryId) {
+      const breadcrumb = [];
+      let currentId = categoryId;
+      while (currentId) {
+        const category = await this.getById(currentId);
+        if (!category) break;
+        breadcrumb.unshift(category);
+        currentId = category.parent_id;
+      }
+      return breadcrumb;
+    }
+  };
+  const storage = {
+    getUrl(path, bucket = "content-images") {
+      if (!path) return "";
+      if (path.startsWith("http")) return path;
+      return `${url}/storage/v1/object/public/${bucket}/${path}`;
+    },
+    getImageUrl(path, options2) {
+      const baseUrl = this.getUrl(path);
+      if (!baseUrl || !options2) return baseUrl;
+      const params = new URLSearchParams();
+      if (options2.width) params.set("width", options2.width.toString());
+      if (options2.height) params.set("height", options2.height.toString());
+      if (options2.quality) params.set("quality", options2.quality.toString());
+      if (options2.format) params.set("format", options2.format);
+      const queryString = params.toString();
+      return queryString ? `${baseUrl}?${queryString}` : baseUrl;
+    }
+  };
+  return {
+    supabase,
+    contents,
+    categories,
+    storage,
+    isConfigured: () => true
+  };
+}
+function createNullClient() {
+  const nullSupabase = null;
+  return {
+    supabase: nullSupabase,
+    contents: {
+      list: async () => [],
+      getBySlug: async () => null,
+      getById: async () => null,
+      count: async () => 0,
+      search: async () => [],
+      getTags: async () => [],
+      create: async () => {
+        throw new Error("UCM: Client not configured");
+      },
+      update: async () => {
+        throw new Error("UCM: Client not configured");
+      },
+      delete: async () => {
+        throw new Error("UCM: Client not configured");
+      },
+      incrementView: async () => {
+      }
+    },
+    categories: {
+      list: async () => [],
+      getTree: async () => [],
+      getBySlug: async () => null,
+      getById: async () => null,
+      getChildren: async () => [],
+      getRoots: async () => [],
+      getBreadcrumb: async () => []
+    },
+    storage: {
+      getUrl: () => "",
+      getImageUrl: () => ""
+    },
+    isConfigured: () => false
+  };
+}
+
+// src/react.tsx
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var UCMContext = createContext(null);
+function UCMProvider({ config, client, children }) {
+  const ucmClient = useMemo(() => {
+    if (client) {
+      return client;
+    }
+    if (config?.url && config?.anonKey) {
+      return createUCMClient(config);
+    }
+    console.warn("UCM: No config provided, using null client");
+    return createNullClient();
+  }, [config?.url, config?.anonKey, client]);
+  return /* @__PURE__ */ jsx(UCMContext.Provider, { value: ucmClient, children });
+}
+function useUCM() {
+  const context = useContext(UCMContext);
+  if (!context) {
+    throw new Error("useUCM must be used within a UCMProvider");
+  }
+  return context;
+}
+function useUCMOptional() {
+  const context = useContext(UCMContext);
+  return context || createNullClient();
+}
+function useUCMConfigured() {
+  const ucm = useUCMOptional();
+  return ucm.isConfigured();
+}
+
+// src/hooks.ts
+import { useCallback, useEffect, useMemo as useMemo2, useRef, useState } from "react";
+import {
+  useQuery,
+  useInfiniteQuery,
+  useMutation,
+  useQueryClient
+} from "@tanstack/react-query";
+var ucmKeys = {
+  all: ["ucm"],
+  contents: () => [...ucmKeys.all, "contents"],
+  contentsList: (params) => [...ucmKeys.contents(), "list", params],
+  contentsInfinite: (params) => [...ucmKeys.contents(), "infinite", params],
+  content: (identifier) => [...ucmKeys.contents(), "detail", identifier],
+  contentsCount: (params) => [...ucmKeys.contents(), "count", params],
+  contentsTags: (type) => [...ucmKeys.contents(), "tags", type],
+  contentsSearch: (query, type) => [...ucmKeys.contents(), "search", query, type],
+  contentsAdjacent: (slug, type) => [...ucmKeys.contents(), "adjacent", slug, type],
+  categories: () => [...ucmKeys.all, "categories"],
+  categoriesList: (params) => [...ucmKeys.categories(), "list", params],
+  categoriesTree: () => [...ucmKeys.categories(), "tree"],
+  category: (identifier) => [...ucmKeys.categories(), "detail", identifier],
+  categoryBreadcrumb: (id) => [...ucmKeys.categories(), "breadcrumb", id]
+};
+function useContents(options = {}) {
+  const ucm = useUCMOptional();
+  const queryClient = useQueryClient();
+  const {
+    type,
+    category_id,
+    tags,
+    featured,
+    visibility,
+    limit = 20,
+    orderBy = "published_at",
+    orderDirection = "desc",
+    autoLoad = true,
+    paginated = true
+  } = options;
+  const queryParams = useMemo2(
+    () => ({
+      type,
+      category_id,
+      tags,
+      featured,
+      visibility,
+      limit,
+      orderBy,
+      orderDirection
+    }),
+    [
+      type,
+      category_id,
+      tags,
+      featured,
+      visibility,
+      limit,
+      orderBy,
+      orderDirection
+    ]
+  );
+  const { data: total = 0 } = useQuery({
+    queryKey: ucmKeys.contentsCount({
+      type,
+      category_id,
+      tags,
+      featured,
+      visibility
+    }),
+    queryFn: () => ucm.contents.count({ type, category_id, tags, featured, visibility }),
+    enabled: ucm.isConfigured() && autoLoad
+  });
+  const {
+    data,
+    isLoading,
+    isFetchingNextPage,
+    error,
+    hasNextPage,
+    fetchNextPage,
+    refetch
+  } = useInfiniteQuery({
+    queryKey: ucmKeys.contentsInfinite(queryParams),
+    queryFn: async ({ pageParam = 0 }) => {
+      return ucm.contents.list({
+        ...queryParams,
+        offset: pageParam * limit
+      });
+    },
+    getNextPageParam: (lastPage, allPages) => {
+      if (lastPage.length < limit) {
+        return void 0;
+      }
+      return allPages.length;
+    },
+    initialPageParam: 0,
+    enabled: ucm.isConfigured() && autoLoad
+  });
+  const contents = data?.pages.flat() ?? [];
+  const page = data?.pages.length ?? 0;
+  const load = useCallback(async () => {
+    await refetch();
+  }, [refetch]);
+  const loadMore = useCallback(async () => {
+    if (hasNextPage) {
+      await fetchNextPage();
+    }
+  }, [fetchNextPage, hasNextPage]);
+  const refresh = useCallback(async () => {
+    await refetch();
+  }, [refetch]);
+  const reset = useCallback(() => {
+    queryClient.removeQueries({
+      queryKey: ucmKeys.contentsInfinite(queryParams)
+    });
+  }, [queryClient, queryParams]);
+  return {
+    contents,
+    isLoading,
+    isLoadingMore: isFetchingNextPage,
+    error,
+    total,
+    hasMore: paginated ? hasNextPage ?? false : false,
+    page,
+    load,
+    loadMore,
+    refresh,
+    reset
+  };
+}
+function useContent(options = {}) {
+  const ucm = useUCMOptional();
+  const { slug, id, autoLoad = true, trackView = true } = options;
+  const viewTrackedRef = useRef(false);
+  const identifier = useMemo2(() => ({ slug, id }), [slug, id]);
+  const incrementViewMutation = useMutation({
+    mutationFn: (contentId) => ucm.contents.incrementView(contentId)
+  });
+  const {
+    data: content,
+    isLoading,
+    error,
+    refetch
+  } = useQuery({
+    queryKey: ucmKeys.content(identifier),
+    queryFn: async () => {
+      if (slug) {
+        return ucm.contents.getBySlug(slug);
+      }
+      if (id) {
+        return ucm.contents.getById(id);
+      }
+      return null;
+    },
+    enabled: ucm.isConfigured() && autoLoad && !!(slug || id)
+  });
+  useEffect(() => {
+    if (content && trackView && !viewTrackedRef.current) {
+      viewTrackedRef.current = true;
+      incrementViewMutation.mutate(content.id);
+    }
+  }, [content, trackView]);
+  useEffect(() => {
+    viewTrackedRef.current = false;
+  }, [slug, id]);
+  const load = useCallback(async () => {
+    await refetch();
+  }, [refetch]);
+  const refresh = useCallback(async () => {
+    viewTrackedRef.current = true;
+    await refetch();
+  }, [refetch]);
+  return {
+    content: content ?? null,
+    isLoading,
+    error,
+    notFound: !isLoading && !error && !content && !!(slug || id),
+    load,
+    refresh
+  };
+}
+function useCategories(options = {}) {
+  const ucm = useUCMOptional();
+  const { parentId, asTree = false, autoLoad = true } = options;
+  const listQuery = useQuery({
+    queryKey: ucmKeys.categoriesList({ parentId }),
+    queryFn: async () => {
+      if (parentId === null) {
+        return ucm.categories.getRoots();
+      }
+      if (parentId) {
+        return ucm.categories.getChildren(parentId);
+      }
+      return ucm.categories.list();
+    },
+    enabled: ucm.isConfigured() && autoLoad
+  });
+  const treeQuery = useQuery({
+    queryKey: ucmKeys.categoriesTree(),
+    queryFn: () => ucm.categories.getTree(),
+    enabled: ucm.isConfigured() && autoLoad && asTree
+  });
+  const load = useCallback(async () => {
+    await Promise.all([
+      listQuery.refetch(),
+      asTree ? treeQuery.refetch() : Promise.resolve()
+    ]);
+  }, [listQuery, treeQuery, asTree]);
+  const refresh = useCallback(async () => {
+    await load();
+  }, [load]);
+  return {
+    categories: listQuery.data ?? [],
+    tree: treeQuery.data ?? [],
+    isLoading: listQuery.isLoading || asTree && treeQuery.isLoading,
+    error: listQuery.error || treeQuery.error,
+    load,
+    refresh
+  };
+}
+function useCategory(options = {}) {
+  const ucm = useUCMOptional();
+  const { slug, id, autoLoad = true } = options;
+  const identifier = useMemo2(() => ({ slug, id }), [slug, id]);
+  const {
+    data: category,
+    isLoading,
+    error,
+    refetch
+  } = useQuery({
+    queryKey: ucmKeys.category(identifier),
+    queryFn: async () => {
+      if (slug) {
+        return ucm.categories.getBySlug(slug);
+      }
+      if (id) {
+        return ucm.categories.getById(id);
+      }
+      return null;
+    },
+    enabled: ucm.isConfigured() && autoLoad && !!(slug || id)
+  });
+  const load = useCallback(async () => {
+    await refetch();
+  }, [refetch]);
+  return {
+    category: category ?? null,
+    isLoading,
+    error,
+    notFound: !isLoading && !error && !category && !!(slug || id),
+    load
+  };
+}
+function useCategoryBreadcrumb(categoryId) {
+  const ucm = useUCMOptional();
+  const {
+    data: breadcrumb,
+    isLoading,
+    error,
+    refetch
+  } = useQuery({
+    queryKey: ucmKeys.categoryBreadcrumb(categoryId ?? ""),
+    queryFn: () => ucm.categories.getBreadcrumb(categoryId),
+    enabled: ucm.isConfigured() && !!categoryId
+  });
+  const load = useCallback(async () => {
+    await refetch();
+  }, [refetch]);
+  return {
+    breadcrumb: breadcrumb ?? [],
+    isLoading,
+    error,
+    load
+  };
+}
+function useAdjacentContents(options) {
+  const ucm = useUCMOptional();
+  const { slug, type = "blog", autoLoad = true } = options;
+  const {
+    data: adjacent,
+    isLoading,
+    error,
+    refetch
+  } = useQuery({
+    queryKey: ucmKeys.contentsAdjacent(slug, type),
+    queryFn: async () => {
+      const current = await ucm.contents.getBySlug(slug);
+      if (!current || !current.published_at) {
+        return { prev: null, next: null };
+      }
+      const allContents = await ucm.contents.list({
+        type,
+        limit: 100,
+        orderBy: "published_at",
+        orderDirection: "desc"
+      });
+      const currentIndex = allContents.findIndex((c) => c.slug === slug);
+      let prev = null;
+      let next = null;
+      if (currentIndex !== -1) {
+        if (currentIndex > 0) {
+          next = allContents[currentIndex - 1];
+        }
+        if (currentIndex < allContents.length - 1) {
+          prev = allContents[currentIndex + 1];
+        }
+      }
+      return { prev, next };
+    },
+    enabled: ucm.isConfigured() && autoLoad && !!slug
+  });
+  const load = useCallback(async () => {
+    await refetch();
+  }, [refetch]);
+  return {
+    adjacent: adjacent ?? { prev: null, next: null },
+    isLoading,
+    error,
+    load
+  };
+}
+function useSearchContents(options = {}) {
+  const ucm = useUCMOptional();
+  const { type, debounceMs = 300 } = options;
+  const [query, setQuery] = useState("");
+  const [debouncedQuery, setDebouncedQuery] = useState("");
+  const debounceTimerRef = useRef(null);
+  useEffect(() => {
+    if (debounceTimerRef.current) {
+      clearTimeout(debounceTimerRef.current);
+    }
+    debounceTimerRef.current = setTimeout(() => {
+      setDebouncedQuery(query);
+    }, debounceMs);
+    return () => {
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
+      }
+    };
+  }, [query, debounceMs]);
+  const {
+    data: results,
+    isLoading: isSearching,
+    error
+  } = useQuery({
+    queryKey: ucmKeys.contentsSearch(debouncedQuery, type),
+    queryFn: () => ucm.contents.search(debouncedQuery.trim(), type),
+    enabled: ucm.isConfigured() && debouncedQuery.trim().length > 0
+  });
+  const search = useCallback((searchQuery) => {
+    setQuery(searchQuery);
+  }, []);
+  const clear = useCallback(() => {
+    setQuery("");
+    setDebouncedQuery("");
+  }, []);
+  return {
+    results: results ?? [],
+    isSearching: isSearching || query !== debouncedQuery,
+    error,
+    query,
+    search,
+    clear
+  };
+}
+function useTags(options = {}) {
+  const ucm = useUCMOptional();
+  const { type, autoLoad = true } = options;
+  const {
+    data: tags,
+    isLoading,
+    error,
+    refetch
+  } = useQuery({
+    queryKey: ucmKeys.contentsTags(type),
+    queryFn: () => ucm.contents.getTags(type),
+    enabled: ucm.isConfigured() && autoLoad
+  });
+  const load = useCallback(async () => {
+    await refetch();
+  }, [refetch]);
+  const refresh = useCallback(async () => {
+    await refetch();
+  }, [refetch]);
+  return {
+    tags: tags ?? [],
+    isLoading,
+    error,
+    load,
+    refresh
+  };
+}
+function useThoughts(options = {}) {
+  const { agentId, thoughtType, limit = 10, autoLoad = true } = options;
+  const {
+    contents,
+    isLoading,
+    isLoadingMore,
+    error,
+    hasMore,
+    total,
+    load,
+    loadMore,
+    refresh
+  } = useContents({
+    type: "thought",
+    limit,
+    autoLoad,
+    orderBy: "created_at",
+    orderDirection: "desc",
+    paginated: true
+  });
+  const thoughts = contents.filter((c) => {
+    const metadata = c.metadata;
+    if (agentId && metadata?.agent_id !== agentId) return false;
+    if (thoughtType && metadata?.thought_type !== thoughtType) return false;
+    return true;
+  });
+  return {
+    thoughts,
+    isLoading,
+    isLoadingMore,
+    error,
+    hasMore,
+    total,
+    load,
+    loadMore,
+    refresh
+  };
+}
+export {
+  UCMProvider,
+  buildCategoryTree,
+  createNullClient,
+  createUCMClient,
+  getLocalizedText,
+  useAdjacentContents,
+  useCategories,
+  useCategory,
+  useCategoryBreadcrumb,
+  useContent,
+  useContents,
+  useSearchContents,
+  useTags,
+  useThoughts,
+  useUCM,
+  useUCMConfigured,
+  useUCMOptional
+};
+//# sourceMappingURL=index.js.map