@githat/nextjs 0.2.1 → 0.3.1

package/dist/index.mjs

@@ -18,15 +18,16 @@ function resolveConfig(config) {
     signInUrl: config.signInUrl || "/sign-in",
     signUpUrl: config.signUpUrl || "/sign-up",
     afterSignInUrl: config.afterSignInUrl || "/dashboard",
-    afterSignOutUrl: config.afterSignOutUrl || "/"
+    afterSignOutUrl: config.afterSignOutUrl || "/",
+    tokenStorage: config.tokenStorage || "localStorage"
   };
 }
 
 // src/client.ts
 var _refreshPromise = null;
-async function refreshTokens(apiUrl, appKey) {
-  const refreshToken = typeof window !== "undefined" ? localStorage.getItem(TOKEN_KEYS.refreshToken) : null;
-  if (!refreshToken) return false;
+async function refreshTokens(apiUrl, appKey, useCookies) {
+  const refreshToken = typeof window !== "undefined" && !useCookies ? localStorage.getItem(TOKEN_KEYS.refreshToken) : null;
+  if (!useCookies && !refreshToken) return false;
   let orgId = null;
   try {
     const orgStr = localStorage.getItem(TOKEN_KEYS.org);
@@ -34,18 +35,22 @@ async function refreshTokens(apiUrl, appKey) {
   } catch {
   }
   try {
-    const res = await fetch(`${apiUrl}/auth/refresh`, {
+    const refreshUrl = useCookies ? `${apiUrl}/auth/refresh?setCookie=true` : `${apiUrl}/auth/refresh`;
+    const res = await fetch(refreshUrl, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         "X-GitHat-App-Key": appKey
       },
-      body: JSON.stringify({ refreshToken, orgId })
+      credentials: useCookies ? "include" : "same-origin",
+      body: JSON.stringify(useCookies ? { orgId } : { refreshToken, orgId })
     });
     if (!res.ok) return false;
     const data = await res.json();
-    if (data.accessToken) localStorage.setItem(TOKEN_KEYS.accessToken, data.accessToken);
-    if (data.refreshToken) localStorage.setItem(TOKEN_KEYS.refreshToken, data.refreshToken);
+    if (!useCookies) {
+      if (data.accessToken) localStorage.setItem(TOKEN_KEYS.accessToken, data.accessToken);
+      if (data.refreshToken) localStorage.setItem(TOKEN_KEYS.refreshToken, data.refreshToken);
+    }
     if (data.org) localStorage.setItem(TOKEN_KEYS.org, JSON.stringify(data.org));
     return true;
   } catch {
@@ -55,23 +60,30 @@ async function refreshTokens(apiUrl, appKey) {
 function clearAuth() {
   if (typeof window === "undefined") return;
   Object.values(TOKEN_KEYS).forEach((key) => localStorage.removeItem(key));
-  window.dispatchEvent(new CustomEvent("githat:auth-changed", {
-    detail: { user: null, org: null, signedIn: false }
-  }));
+  window.dispatchEvent(
+    new CustomEvent("githat:auth-changed", {
+      detail: { user: null, org: null, signedIn: false }
+    })
+  );
 }
-function createClient(apiUrl, appKey) {
-  async function fetchApi(endpoint, options = {}) {
+function createClient(apiUrl, appKey, options = {}) {
+  const { useCookies = false } = options;
+  async function fetchApi(endpoint, fetchOptions = {}) {
     const url = `${apiUrl}${endpoint}`;
-    const token = typeof window !== "undefined" ? localStorage.getItem(TOKEN_KEYS.accessToken) : null;
+    const token = typeof window !== "undefined" && !useCookies ? localStorage.getItem(TOKEN_KEYS.accessToken) : null;
     const headers = {
       "Content-Type": "application/json",
       "X-GitHat-App-Key": appKey,
       ...token && { Authorization: `Bearer ${token}` },
-      ...options.headers
+      ...fetchOptions.headers
     };
     let response;
     try {
-      response = await fetch(url, { ...options, headers });
+      response = await fetch(url, {
+        ...fetchOptions,
+        headers,
+        credentials: useCookies ? "include" : "same-origin"
+      });
     } catch (networkError) {
       if (networkError instanceof TypeError) {
         const isMissingKey = !appKey || !appKey.startsWith("pk_live_");
@@ -81,27 +93,26 @@ function createClient(apiUrl, appKey) {
             "Missing GitHat API key. Add NEXT_PUBLIC_GITHAT_PUBLISHABLE_KEY to .env.local"
           );
         }
-        throw new Error(
-          "Unable to connect to GitHat API. Check your network connection."
-        );
+        throw new Error("Unable to connect to GitHat API. Check your network connection.");
       }
       throw networkError;
     }
     if (response.status === 401) {
       if (!_refreshPromise) {
-        _refreshPromise = refreshTokens(apiUrl, appKey).finally(() => {
+        _refreshPromise = refreshTokens(apiUrl, appKey, useCookies).finally(() => {
           _refreshPromise = null;
         });
       }
       const refreshed = await _refreshPromise;
       if (refreshed) {
-        const newToken = localStorage.getItem(TOKEN_KEYS.accessToken);
+        const newToken = !useCookies && typeof window !== "undefined" ? localStorage.getItem(TOKEN_KEYS.accessToken) : null;
         const retryResponse = await fetch(url, {
-          ...options,
+          ...fetchOptions,
           headers: {
             ...headers,
             ...newToken && { Authorization: `Bearer ${newToken}` }
-          }
+          },
+          credentials: useCookies ? "include" : "same-origin"
         });
         const retryData = await retryResponse.json();
         if (!retryResponse.ok) throw new Error(retryData.error || "Request failed");
@@ -122,38 +133,57 @@ import { jsx } from "react/jsx-runtime";
 var GitHatContext = createContext(null);
 function GitHatProvider({ config: rawConfig, children }) {
   const config = useMemo(() => resolveConfig(rawConfig), [rawConfig]);
-  const clientRef = useRef(createClient(config.apiUrl, config.publishableKey));
+  const useCookies = config.tokenStorage === "cookie";
+  const clientRef = useRef(createClient(config.apiUrl, config.publishableKey, { useCookies }));
   const [user, setUser] = useState(null);
   const [org, setOrg] = useState(null);
   const [isSignedIn, setIsSignedIn] = useState(false);
   const [isLoading, setIsLoading] = useState(true);
   const [authError, setAuthError] = useState(null);
   useEffect(() => {
-    const token = localStorage.getItem(TOKEN_KEYS.accessToken);
-    const storedUser = localStorage.getItem(TOKEN_KEYS.user);
-    if (token && storedUser) {
-      clientRef.current.fetchApi("/auth/me").then((data) => {
-        const u = data.user || JSON.parse(storedUser);
-        setUser(u);
-        const storedOrg = localStorage.getItem(TOKEN_KEYS.org);
-        setOrg(data.currentOrg || (storedOrg ? JSON.parse(storedOrg) : null));
-        setIsSignedIn(true);
-        setAuthError(null);
-      }).catch((err) => {
-        if (err.message === "Session expired") {
+    const validateSession = async () => {
+      try {
+        if (!useCookies) {
+          const token = localStorage.getItem(TOKEN_KEYS.accessToken);
+          const storedUser = localStorage.getItem(TOKEN_KEYS.user);
+          if (!token || !storedUser) {
+            setIsLoading(false);
+            return;
+          }
+        }
+        const data = await clientRef.current.fetchApi("/auth/me");
+        if (data.user) {
+          setUser(data.user);
+          setOrg(data.currentOrg || null);
+          setIsSignedIn(true);
+          setAuthError(null);
+          if (!useCookies) {
+            localStorage.setItem(TOKEN_KEYS.user, JSON.stringify(data.user));
+            if (data.currentOrg) {
+              localStorage.setItem(TOKEN_KEYS.org, JSON.stringify(data.currentOrg));
+            }
+          }
+        }
+      } catch (err) {
+        const error = err;
+        if (error.message === "Session expired") {
           clientRef.current.clearAuth();
-        } else {
-          try {
-            setUser(JSON.parse(storedUser));
-          } catch {
+        } else if (!useCookies) {
+          const storedUser = localStorage.getItem(TOKEN_KEYS.user);
+          if (storedUser) {
+            try {
+              setUser(JSON.parse(storedUser));
+              setIsSignedIn(true);
+            } catch {
+            }
           }
-          setAuthError(err.message || "Failed to verify session");
+          setAuthError(error.message || "Failed to verify session");
         }
-      }).finally(() => setIsLoading(false));
-    } else {
+      }
       setIsLoading(false);
-    }
-  }, []);
+    };
+    validateSession();
+  }, [useCookies]);
   useEffect(() => {
     const handleAuthChanged = (e) => {
       const detail = e.detail;
@@ -171,30 +201,36 @@ function GitHatProvider({ config: rawConfig, children }) {
     return () => window.removeEventListener("githat:auth-changed", handleAuthChanged);
   }, []);
   const signIn = useCallback(async (email, password) => {
-    const data = await clientRef.current.fetchApi("/auth/login", {
+    const loginUrl = useCookies ? "/auth/login?setCookie=true" : "/auth/login";
+    const data = await clientRef.current.fetchApi(loginUrl, {
       method: "POST",
       body: JSON.stringify({ email, password })
     });
-    localStorage.setItem(TOKEN_KEYS.accessToken, data.accessToken);
-    localStorage.setItem(TOKEN_KEYS.refreshToken, data.refreshToken);
-    localStorage.setItem(TOKEN_KEYS.user, JSON.stringify(data.user));
-    if (data.org) localStorage.setItem(TOKEN_KEYS.org, JSON.stringify(data.org));
+    if (!useCookies && data.accessToken && data.refreshToken) {
+      localStorage.setItem(TOKEN_KEYS.accessToken, data.accessToken);
+      localStorage.setItem(TOKEN_KEYS.refreshToken, data.refreshToken);
+      localStorage.setItem(TOKEN_KEYS.user, JSON.stringify(data.user));
+      if (data.org) localStorage.setItem(TOKEN_KEYS.org, JSON.stringify(data.org));
+    }
     setUser(data.user);
     setOrg(data.org || null);
     setIsSignedIn(true);
     window.dispatchEvent(new CustomEvent("githat:auth-changed", {
       detail: { user: data.user, org: data.org, signedIn: true }
     }));
-  }, []);
+  }, [useCookies]);
   const signUp = useCallback(async (signUpData) => {
-    const data = await clientRef.current.fetchApi("/auth/register", {
+    const registerUrl = useCookies ? "/auth/register?setCookie=true" : "/auth/register";
+    const data = await clientRef.current.fetchApi(registerUrl, {
       method: "POST",
       body: JSON.stringify(signUpData)
     });
-    localStorage.setItem(TOKEN_KEYS.accessToken, data.accessToken);
-    localStorage.setItem(TOKEN_KEYS.refreshToken, data.refreshToken);
-    localStorage.setItem(TOKEN_KEYS.user, JSON.stringify(data.user));
-    if (data.org) localStorage.setItem(TOKEN_KEYS.org, JSON.stringify(data.org));
+    if (!useCookies && data.accessToken && data.refreshToken) {
+      localStorage.setItem(TOKEN_KEYS.accessToken, data.accessToken);
+      localStorage.setItem(TOKEN_KEYS.refreshToken, data.refreshToken);
+      localStorage.setItem(TOKEN_KEYS.user, JSON.stringify(data.user));
+      if (data.org) localStorage.setItem(TOKEN_KEYS.org, JSON.stringify(data.org));
+    }
     setUser(data.user);
     setOrg(data.org || null);
     setIsSignedIn(true);
@@ -202,10 +238,11 @@ function GitHatProvider({ config: rawConfig, children }) {
       detail: { user: data.user, org: data.org, signedIn: true }
     }));
     return { requiresVerification: !data.user.emailVerified, email: signUpData.email };
-  }, []);
+  }, [useCookies]);
   const signOut = useCallback(async () => {
     try {
-      await clientRef.current.fetchApi("/auth/logout", { method: "POST" });
+      const logoutUrl = useCookies ? "/auth/logout?setCookie=true" : "/auth/logout";
+      await clientRef.current.fetchApi(logoutUrl, { method: "POST" });
     } catch {
     }
     clientRef.current.clearAuth();
@@ -215,22 +252,24 @@ function GitHatProvider({ config: rawConfig, children }) {
     if (typeof window !== "undefined" && config.afterSignOutUrl) {
       window.location.href = config.afterSignOutUrl;
     }
-  }, [config.afterSignOutUrl]);
+  }, [config.afterSignOutUrl, useCookies]);
   const switchOrg = useCallback(async (orgId) => {
     try {
-      const data = await clientRef.current.fetchApi(`/user/orgs/${orgId}/switch`, { method: "POST" });
-      if (data.accessToken) localStorage.setItem(TOKEN_KEYS.accessToken, data.accessToken);
-      if (data.refreshToken) localStorage.setItem(TOKEN_KEYS.refreshToken, data.refreshToken);
-      const orgData = data.org;
-      localStorage.setItem(TOKEN_KEYS.org, JSON.stringify(orgData));
-      setOrg(orgData);
+      const switchUrl = useCookies ? `/user/orgs/${orgId}/switch?setCookie=true` : `/user/orgs/${orgId}/switch`;
+      const data = await clientRef.current.fetchApi(switchUrl, { method: "POST" });
+      if (!useCookies) {
+        if (data.accessToken) localStorage.setItem(TOKEN_KEYS.accessToken, data.accessToken);
+        if (data.refreshToken) localStorage.setItem(TOKEN_KEYS.refreshToken, data.refreshToken);
+        localStorage.setItem(TOKEN_KEYS.org, JSON.stringify(data.org));
+      }
+      setOrg(data.org);
       window.dispatchEvent(new CustomEvent("githat:auth-changed", {
-        detail: { user, org: orgData, signedIn: true }
+        detail: { user, org: data.org, signedIn: true }
       }));
     } catch (e) {
       console.error("Org switch failed:", e);
     }
-  }, [user]);
+  }, [user, useCookies]);
   const value = useMemo(() => ({
     user,
     org,
@@ -247,7 +286,7 @@ function GitHatProvider({ config: rawConfig, children }) {
 }
 
 // src/hooks.ts
-import { useContext, useMemo as useMemo2 } from "react";
+import { useContext, useMemo as useMemo2, useCallback as useCallback2 } from "react";
 function useAuth() {
   const ctx = useContext(GitHatContext);
   if (!ctx) throw new Error("useAuth must be used within a <GitHatProvider>");
@@ -259,14 +298,119 @@ function useGitHat() {
     () => createClient(ctx.config.apiUrl, ctx.config.publishableKey),
     [ctx.config.apiUrl, ctx.config.publishableKey]
   );
+  const getOrgMetadata = useCallback2(async () => {
+    if (!ctx.org?.id) {
+      throw new Error("No active organization");
+    }
+    const response = await client.fetchApi(
+      `/orgs/${ctx.org.id}/metadata`
+    );
+    return response.metadata || {};
+  }, [client, ctx.org?.id]);
+  const updateOrgMetadata = useCallback2(
+    async (updates) => {
+      if (!ctx.org?.id) {
+        throw new Error("No active organization");
+      }
+      const response = await client.fetchApi(
+        `/orgs/${ctx.org.id}/metadata`,
+        {
+          method: "PATCH",
+          body: JSON.stringify(updates)
+        }
+      );
+      return response.metadata || {};
+    },
+    [client, ctx.org?.id]
+  );
   return {
     fetch: client.fetchApi,
     getUserOrgs: () => client.fetchApi("/user/orgs"),
     verifyMCP: (domain) => client.fetchApi(`/verify/mcp/${domain}`),
-    verifyAgent: (wallet) => client.fetchApi(`/verify/agent/${wallet}`)
+    verifyAgent: (wallet) => client.fetchApi(`/verify/agent/${wallet}`),
+    getOrgMetadata,
+    updateOrgMetadata
   };
 }
 
+// src/data.ts
+import { useMemo as useMemo3 } from "react";
+function useData() {
+  const ctx = useAuth();
+  const client = useMemo3(
+    () => createClient(ctx.config.apiUrl, ctx.config.publishableKey),
+    [ctx.config.apiUrl, ctx.config.publishableKey]
+  );
+  return useMemo3(() => ({
+    /**
+     * Store an item in a collection. If the item exists, it will be updated.
+     * @param collection - Collection name (e.g., 'orders', 'users')
+     * @param data - Data object with required `id` field
+     */
+    put: async (collection, data) => {
+      if (!data.id) {
+        throw new Error('Data must include an "id" field');
+      }
+      return client.fetchApi(`/data/${collection}/${data.id}`, {
+        method: "PUT",
+        body: JSON.stringify(data)
+      });
+    },
+    /**
+     * Get a single item from a collection.
+     * @param collection - Collection name
+     * @param id - Item ID
+     */
+    get: async (collection, id) => {
+      try {
+        const result = await client.fetchApi(`/data/${collection}/${id}`);
+        return result.item;
+      } catch (err) {
+        if (err instanceof Error && err.message === "Item not found") {
+          return null;
+        }
+        throw err;
+      }
+    },
+    /**
+     * Query items from a collection with optional filters and pagination.
+     * @param collection - Collection name
+     * @param options - Query options (limit, cursor, filter)
+     */
+    query: async (collection, options = {}) => {
+      const params = new URLSearchParams();
+      if (options.limit) params.set("limit", options.limit.toString());
+      if (options.cursor) params.set("cursor", options.cursor);
+      if (options.filter) params.set("filter", JSON.stringify(options.filter));
+      const queryString = params.toString();
+      const url = `/data/${collection}${queryString ? `?${queryString}` : ""}`;
+      return client.fetchApi(url);
+    },
+    /**
+     * Delete an item from a collection.
+     * @param collection - Collection name
+     * @param id - Item ID
+     */
+    remove: async (collection, id) => {
+      return client.fetchApi(`/data/${collection}/${id}`, {
+        method: "DELETE"
+      });
+    },
+    /**
+     * Batch operations (put/delete) on a collection.
+     * Maximum 100 operations per request.
+     * @param collection - Collection name
+     * @param operations - Array of operations
+     */
+    batch: async (collection, operations) => {
+      return client.fetchApi(`/data/${collection}/batch`, {
+        method: "POST",
+        body: JSON.stringify({ operations })
+      });
+    }
+  }), [client]);
+}
+
 // src/components/SignInForm.tsx
 import { useState as useState2 } from "react";
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
@@ -639,6 +783,7 @@ export {
   UserButton,
   VerifiedBadge,
   useAuth,
+  useData,
   useGitHat
 };
 //# sourceMappingURL=index.mjs.map