@insforge/nextjs 0.6.6 → 0.6.8

package/dist/index.mjs

@@ -5,20 +5,6 @@ import { createContext, useContext, useEffect, useState, useCallback, useRef } f
 import { createClient } from "@insforge/sdk";
 import { jsx } from "react/jsx-runtime";
 var InsforgeContext = createContext(void 0);
-async function fetchOAuthProviders(baseUrl) {
-  try {
-    const response = await fetch(`${baseUrl}/api/auth/oauth/configs`);
-    if (!response.ok) return [];
-    const result = await response.json();
-    if (result?.data && Array.isArray(result.data)) {
-      return result.data.map((config) => config.provider);
-    }
-    return [];
-  } catch (error) {
-    console.warn("Failed to fetch OAuth configs:", error);
-    return [];
-  }
-}
 function getTokenFromSDK() {
   console.log("[InsforgeProvider] Getting token from SDK");
   if (typeof window === "undefined") return null;
@@ -62,18 +48,8 @@ function InsforgeProvider({
   const [user, setUser] = useState(null);
   const [session, setSession] = useState(null);
   const [isLoaded, setIsLoaded] = useState(false);
-  const [oauthProviders, setOauthProviders] = useState([]);
-  const [isConfigLoaded, setIsConfigLoaded] = useState(false);
   const refreshIntervalRef = useRef();
   const [insforge] = useState(() => createClient({ baseUrl }));
-  useEffect(() => {
-    async function loadConfig() {
-      const providers = await fetchOAuthProviders(baseUrl);
-      setOauthProviders(providers);
-      setIsConfigLoaded(true);
-    }
-    loadConfig();
-  }, [baseUrl]);
   const loadAuthState = useCallback(async () => {
     try {
       const token = getTokenFromSDK();
@@ -273,59 +249,6 @@ function InsforgeProvider({
     },
     [user, onAuthChange, insforge]
   );
-  const sendVerificationCode = useCallback(
-    async (email, type) => {
-      console.log(`[Verification] Sending ${type} code to ${email}`);
-      console.log("[Verification] Dummy code: 123456");
-      await new Promise((resolve) => setTimeout(resolve, 500));
-    },
-    [insforge]
-  );
-  const verifySignUpCode = useCallback(
-    async (email, password, code) => {
-      if (code !== "123456") {
-        throw new Error("Invalid verification code");
-      }
-      const sdkResult = await insforge.auth.signUp({ email, password });
-      if (sdkResult.data) {
-        const userData = {
-          id: sdkResult.data.user.id,
-          email: sdkResult.data.user.email,
-          name: sdkResult.data.user.name || void 0,
-          createdAt: sdkResult.data.user.createdAt,
-          updatedAt: sdkResult.data.user.updatedAt
-        };
-        const sessionData = {
-          userId: sdkResult.data.user.id,
-          token: sdkResult.data.accessToken,
-          expiresAt: "",
-          createdAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        setUser(userData);
-        setSession(sessionData);
-        if (onAuthChange) {
-          onAuthChange(userData);
-        }
-        try {
-          await syncTokenToCookie(sdkResult.data.accessToken);
-        } catch (error) {
-        }
-      } else {
-        const errorMessage = sdkResult.error?.message || "Sign up failed";
-        throw new Error(errorMessage);
-      }
-    },
-    [insforge, onAuthChange]
-  );
-  const verifySignInCode = useCallback(
-    async (email, code) => {
-      if (code !== "123456") {
-        throw new Error("Invalid verification code");
-      }
-      throw new Error("Passwordless sign in via verification code is not yet implemented in the backend");
-    },
-    [insforge, onAuthChange]
-  );
   return /* @__PURE__ */ jsx(
     InsforgeContext.Provider,
     {
@@ -340,13 +263,10 @@ function InsforgeProvider({
         signUp,
         signOut,
         updateUser,
-        // Verification
-        sendVerificationCode,
-        verifySignUpCode,
-        verifySignInCode,
-        // Config
-        oauthProviders,
-        isConfigLoaded,
+        // Email verification (commented out - verification disabled for now)
+        // sendVerificationCode,
+        // verifySignUpCode,
+        // verifySignInCode,
         // Base
         baseUrl
       },
@@ -381,14 +301,47 @@ function useSession() {
 }
 
 // src/hooks/useOAuthProviders.ts
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { createClient as createClient2 } from "@insforge/sdk";
 function useOAuthProviders() {
-  const { oauthProviders, isConfigLoaded } = useInsforge();
-  return { providers: oauthProviders, isLoaded: isConfigLoaded };
+  const { baseUrl } = useInsforge();
+  const [providers, setProviders] = useState2([]);
+  const [isLoaded, setIsLoaded] = useState2(false);
+  useEffect2(() => {
+    let mounted = true;
+    async function fetchProviders() {
+      try {
+        const insforge = createClient2({ baseUrl });
+        const { data, error } = await insforge.auth.getOAuthProviders();
+        if (!mounted) return;
+        if (error) {
+          console.warn("[useOAuthProviders] Failed to fetch OAuth providers:", error);
+          setProviders([]);
+        } else if (data) {
+          setProviders(data);
+        } else {
+          setProviders([]);
+        }
+        setIsLoaded(true);
+      } catch (error) {
+        console.warn("[useOAuthProviders] Unexpected error:", error);
+        if (mounted) {
+          setProviders([]);
+          setIsLoaded(true);
+        }
+      }
+    }
+    fetchProviders();
+    return () => {
+      mounted = false;
+    };
+  }, [baseUrl]);
+  return { providers, isLoaded };
 }
 
 // src/components/SignIn.tsx
-import { useState as useState3 } from "react";
-import { createClient as createClient2 } from "@insforge/sdk";
+import { useState as useState4 } from "react";
+import { createClient as createClient3 } from "@insforge/sdk";
 
 // src/components/auth/AuthBranding.tsx
 import Link from "next/link";
@@ -500,7 +453,7 @@ function AuthFormField({ label, id, className = "", ...props }) {
 }
 
 // src/components/auth/AuthPasswordField.tsx
-import { useState as useState2 } from "react";
+import { useState as useState3 } from "react";
 import { Eye, EyeOff } from "lucide-react";
 
 // src/components/auth/AuthPasswordStrengthIndicator.tsx
@@ -556,8 +509,8 @@ function AuthPasswordField({
   onFocus,
   ...props
 }) {
-  const [showPassword, setShowPassword] = useState2(false);
-  const [showStrength, setShowStrength] = useState2(false);
+  const [showPassword, setShowPassword] = useState3(false);
+  const [showStrength, setShowStrength] = useState3(false);
   const handleFocus = (e) => {
     if (showStrengthIndicator) {
       setShowStrength(true);
@@ -977,13 +930,14 @@ function SignIn({
   onSuccess,
   onError
 }) {
-  const { signIn, oauthProviders, baseUrl } = useInsforge();
-  const [email, setEmail] = useState3("");
-  const [password, setPassword] = useState3("");
-  const [error, setError] = useState3("");
-  const [loading, setLoading] = useState3(false);
-  const [oauthLoading, setOauthLoading] = useState3(null);
-  const insforge = useState3(() => createClient2({ baseUrl }))[0];
+  const { signIn, baseUrl } = useInsforge();
+  const { providers: oauthProviders } = useOAuthProviders();
+  const [email, setEmail] = useState4("");
+  const [password, setPassword] = useState4("");
+  const [error, setError] = useState4("");
+  const [loading, setLoading] = useState4(false);
+  const [oauthLoading, setOauthLoading] = useState4(null);
+  const insforge = useState4(() => createClient3({ baseUrl }))[0];
   async function handleSubmit(e) {
     e.preventDefault();
     setLoading(true);
@@ -1046,11 +1000,7 @@ function SignIn({
           value: password,
           onChange: (e) => setPassword(e.target.value),
           required: true,
-          autoComplete: "current-password",
-          forgotPasswordLink: {
-            href: "#",
-            text: forgotPasswordText
-          }
+          autoComplete: "current-password"
         }
       ),
       /* @__PURE__ */ jsx16(
@@ -1080,8 +1030,8 @@ function SignIn({
 }
 
 // src/components/SignUp.tsx
-import { useState as useState4 } from "react";
-import { createClient as createClient3 } from "@insforge/sdk";
+import { useState as useState5 } from "react";
+import { createClient as createClient4 } from "@insforge/sdk";
 import { Fragment as Fragment2, jsx as jsx17, jsxs as jsxs14 } from "react/jsx-runtime";
 function SignUp({
   afterSignUpUrl = "/",
@@ -1094,9 +1044,9 @@ function SignUp({
   passwordPlaceholder = "\u2022\u2022\u2022\u2022\u2022\u2022",
   submitButtonText = "Sign Up",
   loadingButtonText = "Creating account...",
-  verifyButtonText = "Continue",
-  loadingVerifyButtonText = "Verifying...",
-  verifiedButtonText = "Verified",
+  // verifyButtonText = "Continue", // Commented out - email verification disabled for now
+  // loadingVerifyButtonText = "Verifying...", // Commented out - email verification disabled for now
+  // verifiedButtonText = "Verified", // Commented out - email verification disabled for now
   signInText = "Already have an account?",
   signInLinkText = "Login Now",
   signInUrl = "/sign-in",
@@ -1104,18 +1054,14 @@ function SignUp({
   onSuccess,
   onError
 }) {
-  const { sendVerificationCode, verifySignUpCode, oauthProviders, baseUrl } = useInsforge();
-  const [email, setEmail] = useState4("");
-  const [password, setPassword] = useState4("");
-  const [verificationCode, setVerificationCode] = useState4("");
-  const [error, setError] = useState4("");
-  const [loading, setLoading] = useState4(false);
-  const [oauthLoading, setOauthLoading] = useState4(null);
-  const [verified, setVerified] = useState4(false);
-  const [step, setStep] = useState4(
-    "credentials"
-  );
-  const insforge = useState4(() => createClient3({ baseUrl }))[0];
+  const { signUp, baseUrl } = useInsforge();
+  const { providers: oauthProviders } = useOAuthProviders();
+  const [email, setEmail] = useState5("");
+  const [password, setPassword] = useState5("");
+  const [error, setError] = useState5("");
+  const [loading, setLoading] = useState5(false);
+  const [oauthLoading, setOauthLoading] = useState5(null);
+  const insforge = useState5(() => createClient4({ baseUrl }))[0];
   async function handleCredentialsSubmit(e) {
     e.preventDefault();
     setLoading(true);
@@ -1126,53 +1072,20 @@ function SignUp({
       return;
     }
     try {
-      await sendVerificationCode(email, "signup");
-      setStep("verification");
-    } catch (err) {
-      const errorMessage = err.message || "Failed to send verification code";
-      setError(errorMessage);
-      if (onError) onError(new Error(errorMessage));
-    } finally {
-      setLoading(false);
-    }
-  }
-  async function handleVerificationSubmit(e) {
-    e.preventDefault();
-    setLoading(true);
-    setError("");
-    if (verificationCode.length !== 6) {
-      setError("Please enter the complete verification code");
-      setLoading(false);
-      return;
-    }
-    try {
-      await verifySignUpCode(email, password, verificationCode);
+      await signUp(email, password);
       if (onSuccess) {
-        setVerified(true);
         const userResult = await insforge.auth.getCurrentUser();
         if (userResult.data) onSuccess(userResult.data);
       }
       window.location.href = afterSignUpUrl;
     } catch (err) {
-      const errorMessage = err.message || "Invalid verification code";
+      const errorMessage = err.message || "Sign up failed";
       setError(errorMessage);
       if (onError) onError(new Error(errorMessage));
     } finally {
       setLoading(false);
     }
   }
-  async function handleResendCode() {
-    setLoading(true);
-    setError("");
-    try {
-      await sendVerificationCode(email, "signup");
-    } catch (err) {
-      const errorMessage = err.message || "Failed to resend code";
-      setError(errorMessage);
-    } finally {
-      setLoading(false);
-    }
-  }
   async function handleOAuth(provider) {
     try {
       setOauthLoading(provider);
@@ -1192,105 +1105,64 @@ function SignUp({
       setOauthLoading(null);
     }
   }
-  if (step === "credentials") {
-    return /* @__PURE__ */ jsxs14(AuthContainer, { style: appearance.container, children: [
-      /* @__PURE__ */ jsx17(AuthHeader, { title, subtitle }),
-      /* @__PURE__ */ jsx17(AuthErrorBanner, { error }),
-      /* @__PURE__ */ jsxs14("form", { onSubmit: handleCredentialsSubmit, className: "insforge-form", children: [
-        /* @__PURE__ */ jsx17(
-          AuthFormField,
-          {
-            id: "email",
-            type: "email",
-            label: emailLabel,
-            placeholder: emailPlaceholder,
-            value: email,
-            onChange: (e) => setEmail(e.target.value),
-            required: true,
-            autoComplete: "email"
-          }
-        ),
-        /* @__PURE__ */ jsx17(
-          AuthPasswordField,
-          {
-            id: "password",
-            label: passwordLabel,
-            placeholder: passwordPlaceholder,
-            value: password,
-            onChange: (e) => setPassword(e.target.value),
-            required: true,
-            minLength: 8,
-            autoComplete: "new-password",
-            showStrengthIndicator: true
-          }
-        ),
-        /* @__PURE__ */ jsx17(
-          AuthSubmitButton,
-          {
-            isLoading: loading,
-            disabled: loading || oauthLoading !== null,
-            style: appearance.button,
-            children: loading ? loadingButtonText : submitButtonText
-          }
-        )
-      ] }),
+  return /* @__PURE__ */ jsxs14(AuthContainer, { style: appearance.container, children: [
+    /* @__PURE__ */ jsx17(AuthHeader, { title, subtitle }),
+    /* @__PURE__ */ jsx17(AuthErrorBanner, { error }),
+    /* @__PURE__ */ jsxs14("form", { onSubmit: handleCredentialsSubmit, className: "insforge-form", children: [
       /* @__PURE__ */ jsx17(
-        AuthLink,
+        AuthFormField,
         {
-          text: signInText,
-          linkText: signInLinkText,
-          href: signInUrl
+          id: "email",
+          type: "email",
+          label: emailLabel,
+          placeholder: emailPlaceholder,
+          value: email,
+          onChange: (e) => setEmail(e.target.value),
+          required: true,
+          autoComplete: "email"
         }
       ),
-      oauthProviders.length > 0 && /* @__PURE__ */ jsxs14(Fragment2, { children: [
-        /* @__PURE__ */ jsx17(AuthDivider, { text: dividerText }),
-        /* @__PURE__ */ jsx17(
-          AuthOAuthProviders,
-          {
-            providers: oauthProviders,
-            onClick: handleOAuth,
-            disabled: loading || oauthLoading !== null,
-            loading: oauthLoading
-          }
-        )
-      ] })
-    ] });
-  }
-  return /* @__PURE__ */ jsxs14(AuthContainer, { style: appearance.container, children: [
-    /* @__PURE__ */ jsx17(AuthHeader, { title, subtitle }),
-    /* @__PURE__ */ jsx17(AuthErrorBanner, { error }),
-    /* @__PURE__ */ jsxs14("form", { onSubmit: handleVerificationSubmit, className: "insforge-form", children: [
       /* @__PURE__ */ jsx17(
-        AuthVerificationCodeInput,
+        AuthPasswordField,
         {
-          email,
-          value: verificationCode,
-          onChange: setVerificationCode,
-          disabled: loading
+          id: "password",
+          label: passwordLabel,
+          placeholder: passwordPlaceholder,
+          value: password,
+          onChange: (e) => setPassword(e.target.value),
+          required: true,
+          minLength: 8,
+          autoComplete: "new-password",
+          showStrengthIndicator: true
         }
       ),
       /* @__PURE__ */ jsx17(
         AuthSubmitButton,
         {
           isLoading: loading,
-          disabled: loading,
+          disabled: loading || oauthLoading !== null,
           style: appearance.button,
-          confirmed: verified,
-          children: verified ? verifiedButtonText : loading ? loadingVerifyButtonText : verifyButtonText
+          children: loading ? loadingButtonText : submitButtonText
         }
       )
     ] }),
-    /* @__PURE__ */ jsxs14("div", { className: "insforge-resend-code", children: [
-      "Did not received the code?",
-      " ",
+    /* @__PURE__ */ jsx17(
+      AuthLink,
+      {
+        text: signInText,
+        linkText: signInLinkText,
+        href: signInUrl
+      }
+    ),
+    oauthProviders.length > 0 && /* @__PURE__ */ jsxs14(Fragment2, { children: [
+      /* @__PURE__ */ jsx17(AuthDivider, { text: dividerText }),
       /* @__PURE__ */ jsx17(
-        "button",
+        AuthOAuthProviders,
         {
-          type: "button",
-          onClick: handleResendCode,
-          disabled: loading,
-          className: "insforge-resend-link",
-          children: "Click to resend"
+          providers: oauthProviders,
+          onClick: handleOAuth,
+          disabled: loading || oauthLoading !== null,
+          loading: oauthLoading
         }
       )
     ] })
@@ -1298,7 +1170,7 @@ function SignUp({
 }
 
 // src/components/UserButton.tsx
-import { useState as useState5, useRef as useRef3, useEffect as useEffect2 } from "react";
+import { useState as useState6, useRef as useRef3, useEffect as useEffect3 } from "react";
 import { LogOut } from "lucide-react";
 import { jsx as jsx18, jsxs as jsxs15 } from "react/jsx-runtime";
 function UserButton({
@@ -1307,9 +1179,9 @@ function UserButton({
   appearance = {}
 }) {
   const { user, signOut } = useInsforge();
-  const [isOpen, setIsOpen] = useState5(false);
+  const [isOpen, setIsOpen] = useState6(false);
   const dropdownRef = useRef3(null);
-  useEffect2(() => {
+  useEffect3(() => {
     function handleClickOutside(event) {
       if (dropdownRef.current && !dropdownRef.current.contains(event.target)) {
         setIsOpen(false);
@@ -1374,7 +1246,7 @@ function SignedOut({ children }) {
 }
 
 // src/components/Protect.tsx
-import { useEffect as useEffect3 } from "react";
+import { useEffect as useEffect4 } from "react";
 import { useRouter } from "next/navigation";
 import { Fragment as Fragment5, jsx as jsx21 } from "react/jsx-runtime";
 function Protect({
@@ -1385,7 +1257,7 @@ function Protect({
 }) {
   const { isSignedIn, isLoaded, user } = useInsforge();
   const router = useRouter();
-  useEffect3(() => {
+  useEffect4(() => {
     if (isLoaded && !isSignedIn) {
       router.push(redirectTo);
     } else if (isLoaded && isSignedIn && condition && user) {