@nby.ai/ucm 1.0.1

package/dist/react.js

@@ -0,0 +1,313 @@
+// src/react.tsx
+import { createContext, useContext, useMemo } from "react";
+
+// src/core.ts
+import { createClient } from "@supabase/supabase-js";
+
+// src/types.ts
+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 { 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();
+}
+export {
+  UCMProvider,
+  useUCM,
+  useUCMConfigured,
+  useUCMOptional
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@nby.ai/ucm",
+  "version": "1.0.1",
+  "description": "Universal Content Module - Supabase-based multilingual CMS",
+  "author": "NBY Team",
+  "license": "MIT",
+  "keywords": [
+    "supabase",
+    "cms",
+    "i18n",
+    "content",
+    "react",
+    "typescript"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js",
+      "require": "./dist/react.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/",
+    "prepublishOnly": "pnpm build"
+  },
+  "peerDependencies": {
+    "@supabase/supabase-js": "^2.0.0",
+    "@tanstack/react-query": "^5.0.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "@tanstack/react-query": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@supabase/supabase-js": "^2.95.0",
+    "@tanstack/react-query": "^5.90.0",
+    "@types/react": "^19.0.0",
+    "react": "^19.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.0"
+  }
+}