@instroc/auth 1.0.1 → 1.1.0

package/dist/index.js

@@ -1,550 +1,28 @@
-// src/provider.tsx
 import {
-  createContext,
-  useContext,
-  useState,
-  useCallback,
-  useEffect,
-  useRef
-} from "react";
-import { jsx } from "react/jsx-runtime";
-var AuthContext = createContext(null);
-var STORAGE_KEY = "instroc_auth_session";
-function AuthProvider({
-  children,
-  projectId: initialProjectId,
-  baseUrl = "/api/baas",
-  persistSession = true,
-  onAuthStateChange
-}) {
-  const [projectId, setProjectId] = useState(
-    initialProjectId || null
-  );
-  const [user, setUser] = useState(null);
-  const [session, setSession] = useState(null);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
-  const [authConfig, setAuthConfig] = useState(null);
-  const [visibilityConfig, setVisibilityConfig] = useState(null);
-  const refreshTimeoutRef = useRef(null);
-  const buildUrl = useCallback(
-    (endpoint) => {
-      if (!projectId) {
-        throw new Error("Project ID is required");
-      }
-      return `${baseUrl}/${projectId}/auth/${endpoint}`;
-    },
-    [projectId, baseUrl]
-  );
-  const authFetch = useCallback(
-    (url, init) => fetch(url, { ...init, credentials: "include" }),
-    []
-  );
-  const saveSession = useCallback(
-    (sessionData) => {
-      if (persistSession && typeof window !== "undefined") {
-        if (sessionData) {
-          localStorage.setItem(STORAGE_KEY, JSON.stringify(sessionData));
-        } else {
-          localStorage.removeItem(STORAGE_KEY);
-        }
-      }
-    },
-    [persistSession]
-  );
-  const loadSession = useCallback(() => {
-    if (persistSession && typeof window !== "undefined") {
-      const stored = localStorage.getItem(STORAGE_KEY);
-      if (stored) {
-        try {
-          return JSON.parse(stored);
-        } catch {
-          localStorage.removeItem(STORAGE_KEY);
-        }
-      }
-    }
-    return null;
-  }, [persistSession]);
-  const scheduleRefresh = useCallback(
-    (expiresAt) => {
-      if (refreshTimeoutRef.current) {
-        clearTimeout(refreshTimeoutRef.current);
-      }
-      const expiresTime = new Date(expiresAt).getTime();
-      const now = Date.now();
-      const refreshIn = expiresTime - now - 5 * 60 * 1e3;
-      if (refreshIn > 0) {
-        refreshTimeoutRef.current = setTimeout(async () => {
-          try {
-            await refreshSession();
-          } catch (err) {
-            console.warn("Token refresh failed:", err);
-            setUser(null);
-            setSession(null);
-            saveSession(null);
-          }
-        }, refreshIn);
-      }
-    },
-    [saveSession]
-  );
-  const updateAuthState = useCallback(
-    (newUser, newSession) => {
-      setUser(newUser);
-      setSession(newSession);
-      saveSession(newSession);
-      if (newSession) {
-        scheduleRefresh(newSession.expires_at);
-      }
-      if (onAuthStateChange) {
-        onAuthStateChange(newUser);
-      }
-    },
-    [saveSession, scheduleRefresh, onAuthStateChange]
-  );
-  const fetchUser = useCallback(async () => {
-    const storedSession = loadSession();
-    if (!storedSession || !projectId) {
-      setLoading(false);
-      return;
-    }
-    try {
-      const response = await authFetch(buildUrl("me"), {
-        headers: {
-          Authorization: `Bearer ${storedSession.access_token}`
-        }
-      });
-      if (response.ok) {
-        const data = await response.json();
-        updateAuthState(data.user, storedSession);
-      } else if (response.status === 401) {
-        try {
-          const refreshResponse = await authFetch(buildUrl("refresh"), {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ refreshToken: storedSession.refresh_token })
-          });
-          if (refreshResponse.ok) {
-            const refreshData = await refreshResponse.json();
-            const newSession = {
-              ...storedSession,
-              access_token: refreshData.access_token,
-              expires_at: refreshData.expires_at
-            };
-            const userResponse = await authFetch(buildUrl("me"), {
-              headers: {
-                Authorization: `Bearer ${newSession.access_token}`
-              }
-            });
-            if (userResponse.ok) {
-              const userData = await userResponse.json();
-              updateAuthState(userData.user, newSession);
-            } else {
-              updateAuthState(null, null);
-            }
-          } else {
-            updateAuthState(null, null);
-          }
-        } catch {
-          updateAuthState(null, null);
-        }
-      } else {
-        updateAuthState(null, null);
-      }
-    } catch (err) {
-      console.error("Failed to fetch user:", err);
-      updateAuthState(null, null);
-    } finally {
-      setLoading(false);
-    }
-  }, [projectId, loadSession, buildUrl, updateAuthState]);
-  useEffect(() => {
-    if (projectId) {
-      fetchUser();
-    } else {
-      setLoading(false);
-    }
-    return () => {
-      if (refreshTimeoutRef.current) {
-        clearTimeout(refreshTimeoutRef.current);
-      }
-    };
-  }, [projectId, fetchUser]);
-  const login = useCallback(
-    async (credentials) => {
-      setError(null);
-      setLoading(true);
-      try {
-        const response = await authFetch(buildUrl("login"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(credentials)
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          throw new Error(data.error || "Login failed");
-        }
-        const authResponse = data;
-        updateAuthState(authResponse.user, authResponse.session);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Login failed";
-        setError(message);
-        throw err;
-      } finally {
-        setLoading(false);
-      }
-    },
-    [buildUrl, updateAuthState]
-  );
-  const signup = useCallback(
-    async (credentials) => {
-      setError(null);
-      setLoading(true);
-      try {
-        const response = await authFetch(buildUrl("signup"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(credentials)
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          throw new Error(data.error || "Signup failed");
-        }
-        const authResponse = data;
-        if (authResponse.needsVerification) {
-          return {
-            status: "needs_verification",
-            email: credentials.email
-          };
-        }
-        if (authResponse.needsApproval) {
-          updateAuthState(authResponse.user, authResponse.session);
-          return { status: "needs_approval", user: authResponse.user };
-        }
-        if (authResponse.session.access_token) {
-          updateAuthState(authResponse.user, authResponse.session);
-          return { status: "authenticated", user: authResponse.user };
-        }
-        return {
-          status: "needs_verification",
-          email: credentials.email
-        };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Signup failed";
-        setError(message);
-        throw err;
-      } finally {
-        setLoading(false);
-      }
-    },
-    [buildUrl, updateAuthState]
-  );
-  const logout = useCallback(async () => {
-    try {
-      if (session) {
-        await authFetch(buildUrl("logout"), {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${session.access_token}`
-          }
-        });
-      }
-    } catch (err) {
-      console.error("Logout error:", err);
-    } finally {
-      updateAuthState(null, null);
-      if (refreshTimeoutRef.current) {
-        clearTimeout(refreshTimeoutRef.current);
-      }
-    }
-  }, [session, buildUrl, updateAuthState]);
-  const updateProfile = useCallback(
-    async (data) => {
-      if (!session) {
-        throw new Error("Not authenticated");
-      }
-      setError(null);
-      try {
-        const response = await authFetch(buildUrl("me"), {
-          method: "PATCH",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${session.access_token}`
-          },
-          body: JSON.stringify(data)
-        });
-        const result = await response.json();
-        if (!response.ok) {
-          throw new Error(result.error || "Update failed");
-        }
-        setUser(result.user);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Update failed";
-        setError(message);
-        throw err;
-      }
-    },
-    [session, buildUrl]
-  );
-  const refreshSession = useCallback(async () => {
-    if (!session)
-      return;
-    const response = await authFetch(buildUrl("refresh"), {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ refreshToken: session.refresh_token })
-    });
-    const data = await response.json();
-    if (!response.ok) {
-      throw new Error(data.error || "Refresh failed");
-    }
-    const refreshData = data;
-    const newSession = {
-      ...session,
-      access_token: refreshData.access_token,
-      expires_at: refreshData.expires_at
-    };
-    updateAuthState(user, newSession);
-  }, [session, user, buildUrl, updateAuthState]);
-  const forgotPassword = useCallback(
-    async (email) => {
-      setError(null);
-      try {
-        const response = await authFetch(buildUrl("forgot-password"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ email })
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          throw new Error(data.error || "Request failed");
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Request failed";
-        setError(message);
-        throw err;
-      }
-    },
-    [buildUrl]
-  );
-  const resetPassword = useCallback(
-    async (token, newPassword) => {
-      setError(null);
-      try {
-        const response = await authFetch(buildUrl("reset-password"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ token, password: newPassword })
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          throw new Error(data.error || "Reset failed");
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Reset failed";
-        setError(message);
-        throw err;
-      }
-    },
-    [buildUrl]
-  );
-  const signInWithOAuth = useCallback(
-    (provider) => {
-      if (!projectId) {
-        setError("Project ID is required");
-        return;
-      }
-      const currentUrl = window.location.origin + window.location.pathname;
-      const oauthUrl = `${baseUrl}/${projectId}/auth/oauth/${provider}?redirect_uri=${encodeURIComponent(currentUrl)}`;
-      window.location.href = oauthUrl;
-    },
-    [projectId, baseUrl]
-  );
-  const verifyOTP = useCallback(
-    async (email, code) => {
-      setError(null);
-      setLoading(true);
-      try {
-        const response = await authFetch(buildUrl("verify-email"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ email, otp: code })
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          throw new Error(data.error || "Verification failed");
-        }
-        if (data.session) {
-          updateAuthState(data.user, data.session);
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Verification failed";
-        setError(message);
-        throw err;
-      } finally {
-        setLoading(false);
-      }
-    },
-    [buildUrl, updateAuthState]
-  );
-  const resendOTP = useCallback(
-    async (email) => {
-      setError(null);
-      try {
-        const response = await authFetch(buildUrl("resend-verification"), {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ email })
-        });
-        const data = await response.json();
-        if (!response.ok) {
-          throw new Error(data.error || "Failed to resend code");
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Failed to resend code";
-        setError(message);
-        throw err;
-      }
-    },
-    [buildUrl]
-  );
-  const fetchAuthConfig = useCallback(async () => {
-    if (!projectId)
-      return;
-    try {
-      const response = await fetch(`${baseUrl}/${projectId}/auth/config`);
-      if (response.ok) {
-        const data = await response.json();
-        setAuthConfig(data.config || null);
-        setVisibilityConfig(
-          data.visibility || {
-            projectName: "App",
-            visibility: "public",
-            requireLogin: false,
-            logoUrl: null,
-            welcomeMessage: null
-          }
-        );
-      }
-    } catch (err) {
-      console.error("Failed to fetch auth config:", err);
-    }
-  }, [projectId, baseUrl]);
-  const parseOAuthCallback = useCallback(() => {
-    if (typeof window === "undefined")
-      return;
-    const hash = window.location.hash;
-    if (hash && hash.startsWith("#auth=")) {
-      try {
-        const authData = decodeURIComponent(hash.substring(6));
-        const tokenData = JSON.parse(authData);
-        if (tokenData.access_token && tokenData.refresh_token) {
-          const newSession = {
-            access_token: tokenData.access_token,
-            refresh_token: tokenData.refresh_token,
-            expires_at: tokenData.expires_at
-          };
-          saveSession(newSession);
-          setSession(newSession);
-          window.history.replaceState({}, "", window.location.pathname);
-          return true;
-        }
-      } catch {
-      }
-    }
-    const params = new URLSearchParams(window.location.search);
-    const verifyEmailToken = params.get("verify_email");
-    if (verifyEmailToken && projectId) {
-      fetch(buildUrl("verify-email"), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ token: verifyEmailToken })
-      }).then((res) => res.json()).then(() => {
-        window.history.replaceState({}, "", window.location.pathname);
-      }).catch(() => {
-        window.history.replaceState({}, "", window.location.pathname);
-      });
-      return true;
-    }
-    const accessToken = params.get("access_token");
-    const refreshToken = params.get("refresh_token");
-    const expiresAt = params.get("expires_at");
-    if (accessToken && refreshToken && expiresAt) {
-      const newSession = {
-        access_token: accessToken,
-        refresh_token: refreshToken,
-        expires_at: expiresAt
-      };
-      saveSession(newSession);
-      setSession(newSession);
-      window.history.replaceState({}, "", window.location.pathname);
-      return true;
-    }
-    return false;
-  }, [projectId, buildUrl, saveSession]);
-  useEffect(() => {
-    fetchAuthConfig();
-  }, [fetchAuthConfig]);
-  useEffect(() => {
-    parseOAuthCallback();
-  }, [parseOAuthCallback]);
-  const value = {
-    user,
-    session,
-    loading,
-    error,
-    login,
-    signup,
-    logout,
-    signInWithOAuth,
-    verifyOTP,
-    resendOTP,
-    updateProfile,
-    refreshSession,
-    forgotPassword,
-    resetPassword,
-    setProjectId,
-    projectId,
-    authConfig,
-    visibilityConfig
-  };
-  return /* @__PURE__ */ jsx(AuthContext.Provider, { value, children });
-}
-function useAuthContext() {
-  const context = useContext(AuthContext);
-  if (!context) {
-    throw new Error("useAuthContext must be used within an AuthProvider");
-  }
-  return context;
-}
-
-// src/use-auth.ts
-function useAuth() {
-  return useAuthContext();
-}
-function useUser() {
-  const { user, loading } = useAuthContext();
-  return { user, loading };
-}
-function useSession() {
-  const { session, loading } = useAuthContext();
-  return { session, loading };
-}
-function useAuthRequired() {
-  const { user, loading, session } = useAuthContext();
-  if (loading) {
-    return { user: null, session: null, loading: true };
-  }
-  if (!user) {
-    throw new Error("Authentication required");
-  }
-  return { user, session, loading: false };
-}
+  AuthError,
+  AuthProvider,
+  useAuth,
+  useAuthContext,
+  useAuthRequired,
+  useForgotPasswordForm,
+  useLoginForm,
+  useOtpForm,
+  useResetPasswordForm,
+  useSession,
+  useSignupForm,
+  useUser
+} from "./chunk-GV63J77S.js";
 export {
+  AuthError,
   AuthProvider,
   useAuth,
   useAuthContext,
   useAuthRequired,
+  useForgotPasswordForm,
+  useLoginForm,
+  useOtpForm,
+  useResetPasswordForm,
   useSession,
+  useSignupForm,
   useUser
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@instroc/auth",
-  "version": "1.0.1",
-  "description": "Authentication hooks for Instroc Cloud — useAuth, useUser, AuthProvider",
+  "version": "1.1.0",
+  "description": "Authentication hooks for Instroc Cloud — useAuth, useUser, AuthProvider, and headless form hooks",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,10 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./forms": {
+      "import": "./dist/forms.js",
+      "types": "./dist/forms.d.ts"
     }
   },
   "files": [