@instroc/auth 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,107 @@
+interface AuthUser {
+    id: string;
+    email: string;
+    email_verified: boolean;
+    display_name: string | null;
+    avatar_url: string | null;
+    metadata: Record<string, unknown>;
+    created_at: string;
+}
+interface AuthSession {
+    access_token: string;
+    refresh_token: string;
+    expires_at: string;
+}
+interface AuthState {
+    user: AuthUser | null;
+    session: AuthSession | null;
+    loading: boolean;
+    error: string | null;
+}
+interface LoginCredentials {
+    email: string;
+    password: string;
+}
+interface SignupCredentials {
+    email: string;
+    password: string;
+    displayName?: string;
+    metadata?: Record<string, unknown>;
+}
+type OAuthProvider = "google" | "github" | "microsoft" | "facebook";
+interface AuthConfig {
+    emailAuthEnabled: boolean;
+    googleAuthEnabled: boolean;
+    githubAuthEnabled: boolean;
+    microsoftAuthEnabled: boolean;
+    facebookAuthEnabled: boolean;
+    allowSignup: boolean;
+    requireEmailVerification: boolean;
+}
+interface VisibilityConfig {
+    projectName: string;
+    visibility: "public" | "private";
+    requireLogin: boolean;
+    logoUrl: string | null;
+    welcomeMessage: string | null;
+}
+interface AuthContextValue extends AuthState {
+    login: (credentials: LoginCredentials) => Promise<void>;
+    signup: (credentials: SignupCredentials) => Promise<void>;
+    logout: () => Promise<void>;
+    signInWithOAuth: (provider: OAuthProvider) => void;
+    verifyOTP: (email: string, code: string) => Promise<void>;
+    resendOTP: (email: string) => Promise<void>;
+    updateProfile: (data: UpdateProfileData) => Promise<void>;
+    refreshSession: () => Promise<void>;
+    forgotPassword: (email: string) => Promise<void>;
+    resetPassword: (token: string, newPassword: string) => Promise<void>;
+    setProjectId: (projectId: string) => void;
+    projectId: string | null;
+    authConfig: AuthConfig | null;
+    visibilityConfig: VisibilityConfig | null;
+}
+interface UpdateProfileData {
+    displayName?: string;
+    avatarUrl?: string;
+    metadata?: Record<string, unknown>;
+}
+interface AuthProviderProps {
+    children: React.ReactNode;
+    projectId?: string;
+    baseUrl?: string;
+    persistSession?: boolean;
+    onAuthStateChange?: (user: AuthUser | null) => void;
+}
+interface AuthResponse {
+    user: AuthUser;
+    session: AuthSession;
+}
+interface RefreshResponse {
+    access_token: string;
+    expires_at: string;
+}
+
+declare function AuthProvider({ children, projectId: initialProjectId, baseUrl, persistSession, onAuthStateChange, }: AuthProviderProps): JSX.Element;
+declare function useAuthContext(): AuthContextValue;
+
+declare function useAuth(): AuthContextValue;
+declare function useUser(): {
+    user: AuthUser | null;
+    loading: boolean;
+};
+declare function useSession(): {
+    session: AuthSession | null;
+    loading: boolean;
+};
+declare function useAuthRequired(): {
+    user: null;
+    session: null;
+    loading: boolean;
+} | {
+    user: AuthUser;
+    session: AuthSession | null;
+    loading: boolean;
+};
+
+export { type AuthConfig, type AuthContextValue, AuthProvider, type AuthProviderProps, type AuthResponse, type AuthSession, type AuthState, type AuthUser, type LoginCredentials, type OAuthProvider, type RefreshResponse, type SignupCredentials, type UpdateProfileData, type VisibilityConfig, useAuth, useAuthContext, useAuthRequired, useSession, useUser };

package/dist/index.js

@@ -0,0 +1,536 @@
+// 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 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.error("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 fetch(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 fetch(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 fetch(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 fetch(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 fetch(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.session.access_token) {
+          updateAuthState(authResponse.user, authResponse.session);
+        } else {
+          setUser(authResponse.user);
+        }
+      } 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 fetch(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 fetch(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) {
+      throw new Error("No session to refresh");
+    }
+    const response = await fetch(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 fetch(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 fetch(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 fetch(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 fetch(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 };
+}
+export {
+  AuthProvider,
+  useAuth,
+  useAuthContext,
+  useAuthRequired,
+  useSession,
+  useUser
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@instroc/auth",
+  "version": "1.0.0",
+  "description": "Authentication hooks for Instroc Cloud — useAuth, useUser, AuthProvider",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0"
+  },
+  "devDependencies": {
+    "react": "^18.2.0",
+    "@types/react": "^18.2.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Olaide-EO/robobuild",
+    "directory": "packages/auth"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}