@ram_28/kf-ai-sdk 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ram_28/kf-ai-sdk",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Type-safe, AI-driven SDK for building modern web applications with role-based access control",
   "author": "Ramprasad",
   "license": "MIT",

package/sdk/auth/AuthProvider.tsx

@@ -89,7 +89,8 @@ export function AuthProvider({
     retryDelay: authConfig.retry.delay,
     staleTime: authConfig.staleTime,
     gcTime: authConfig.staleTime * 2,
-    refetchOnWindowFocus: true,
+    refetchOnWindowFocus: authConfig.refetchOnWindowFocus ?? true,
+    refetchOnReconnect: authConfig.refetchOnReconnect ?? true,
     refetchInterval: authConfig.sessionCheckInterval || false,
   });
 
@@ -167,6 +168,11 @@ export function AuthProvider({
   );
 
   const refreshSession = useCallback(async (): Promise<SessionResponse | null> => {
+    // Prevent concurrent refreshes - return existing data if already fetching
+    if (isFetching) {
+      return sessionData || null;
+    }
+
     try {
       const result = await refetch();
       return result.data || null;
@@ -174,7 +180,7 @@ export function AuthProvider({
       setError(err as Error);
       return null;
     }
-  }, [refetch]);
+  }, [refetch, isFetching, sessionData]);
 
   const hasRole = useCallback(
     (role: string): boolean => {

package/sdk/auth/authClient.ts

@@ -61,38 +61,86 @@ export async function fetchSession(): Promise<SessionResponse> {
 }
 
 /**
- * Initiate login flow by redirecting to the auth provider
- * The server handles the OAuth flow and sets cookies
+ * Initiates OAuth login flow by redirecting to the auth provider.
+ *
+ * @remarks
+ * This function redirects the browser and never resolves.
+ * Any code after calling this function will not execute.
+ *
+ * @param provider - OAuth provider to use (defaults to config.defaultProvider)
+ * @param options - Login options including callback URL and custom params
+ * @returns Promise that never resolves (browser redirects away)
+ *
+ * @example
+ * ```typescript
+ * // Correct usage - no code after login()
+ * function handleLoginClick() {
+ *   login('google');
+ *   // Don't put code here - it won't run
+ * }
+ * ```
  */
 export function initiateLogin(
   provider?: AuthProviderName,
   options?: LoginOptions
-): void {
-  const config = getAuthConfig();
-  const baseUrl = getAuthBaseUrl();
-  const selectedProvider = provider || config.defaultProvider;
+): Promise<never> {
+  return new Promise(() => {
+    const config = getAuthConfig();
+    const baseUrl = getAuthBaseUrl();
+
+    // Validate base URL
+    if (!baseUrl) {
+      throw new Error(
+        'Auth base URL is not configured. Call setApiBaseUrl("https://...") or configureAuth({ baseUrl: "https://..." }) first.'
+      );
+    }
 
-  const providerConfig = getProviderConfig(selectedProvider);
-  if (!providerConfig) {
-    throw new Error(`Auth provider "${selectedProvider}" is not configured`);
-  }
+    const selectedProvider = provider || config.defaultProvider;
+    const providerConfig = getProviderConfig(selectedProvider);
 
-  const loginUrl = new URL(`${baseUrl}${providerConfig.loginPath}`);
+    // Validate provider config
+    if (!providerConfig) {
+      const availableProviders = Object.keys(config.providers || {}).join(", ") || "none";
+      throw new Error(
+        `Auth provider "${selectedProvider}" is not configured. Available providers: ${availableProviders}`
+      );
+    }
 
-  if (options?.callbackUrl || config.callbackUrl) {
-    loginUrl.searchParams.set(
-      "callbackUrl",
-      options?.callbackUrl || config.callbackUrl || window.location.href
-    );
-  }
+    // Validate login path
+    if (!providerConfig.loginPath) {
+      throw new Error(
+        `Login path not configured for provider "${selectedProvider}". ` +
+        `Configure it with: configureAuth({ providers: { ${selectedProvider}: { loginPath: '/api/auth/...' } } })`
+      );
+    }
 
-  if (options?.params) {
-    Object.entries(options.params).forEach(([key, value]) => {
-      loginUrl.searchParams.set(key, value);
-    });
-  }
+    // Validate URL construction
+    let loginUrl: URL;
+    try {
+      loginUrl = new URL(`${baseUrl}${providerConfig.loginPath}`);
+    } catch {
+      throw new Error(
+        `Failed to construct login URL. Base URL: "${baseUrl}", Login path: "${providerConfig.loginPath}". ` +
+        `Ensure baseUrl is a valid URL (e.g., "https://example.com").`
+      );
+    }
+
+    if (options?.callbackUrl || config.callbackUrl) {
+      loginUrl.searchParams.set(
+        "callbackUrl",
+        options?.callbackUrl || config.callbackUrl || window.location.href
+      );
+    }
 
-  window.location.href = loginUrl.toString();
+    if (options?.params) {
+      Object.entries(options.params).forEach(([key, value]) => {
+        loginUrl.searchParams.set(key, value);
+      });
+    }
+
+    window.location.href = loginUrl.toString();
+    // Promise never resolves - browser navigates away
+  });
 }
 
 /**

package/sdk/auth/authConfig.ts

@@ -18,13 +18,15 @@ const defaultAuthConfig: AuthConfig = {
     },
   },
   defaultProvider: "google",
-  autoRedirect: true,
+  autoRedirect: false,
   sessionCheckInterval: 0,
   retry: {
     count: 3,
     delay: 1000,
   },
   staleTime: 5 * 60 * 1000,
+  refetchOnWindowFocus: false,
+  refetchOnReconnect: true,
 };
 
 /**
@@ -80,10 +82,10 @@ export function getAuthConfig(): Readonly<AuthConfig> {
 
 /**
  * Get the base URL for auth endpoints
- * Falls back to API base URL if not explicitly set
+ * Falls back to API base URL, then window.location.origin
  */
 export function getAuthBaseUrl(): string {
-  return authConfig.baseUrl || getApiBaseUrl();
+  return authConfig.baseUrl || getApiBaseUrl() || (typeof window !== 'undefined' ? window.location.origin : '');
 }
 
 /**

package/sdk/auth/index.ts

@@ -8,33 +8,14 @@ export { AuthProvider } from "./AuthProvider";
 // Main hook
 export { useAuth } from "./useAuth";
 
-// Configuration functions
-export {
-  configureAuth,
-  setAuthProvider,
-  getAuthConfig,
-  getAuthBaseUrl,
-  resetAuthConfig,
-} from "./authConfig";
-
-// API client functions (for advanced use cases)
-export {
-  fetchSession,
-  initiateLogin,
-  performLogout,
-  AuthenticationError,
-} from "./authClient";
+// Error class (for error handling)
+export { AuthenticationError } from "./authClient";
 
 // Type exports
 export type {
   UserDetails,
   SessionResponse,
   AuthStatus,
-  AuthConfig,
-  AuthProviderName,
-  AuthEndpointConfig,
   AuthProviderProps,
   UseAuthReturn,
-  LoginOptions,
-  LogoutOptions,
 } from "./types";

package/sdk/auth/types.ts

@@ -79,6 +79,12 @@ export interface AuthConfig {
 
   /** React Query stale time for session data */
   staleTime: number;
+
+  /** Refetch session when window regains focus (default: true) */
+  refetchOnWindowFocus?: boolean;
+
+  /** Refetch session when network reconnects (default: true) */
+  refetchOnReconnect?: boolean;
 }
 
 /**

package/sdk/auth/useAuth.ts

@@ -3,6 +3,7 @@
 // ============================================================
 // Main hook for consuming authentication state
 
+import { useMemo } from "react";
 import type { UseAuthReturn } from "./types";
 import { useAuthContext } from "./AuthProvider";
 
@@ -33,35 +34,36 @@ import { useAuthContext } from "./AuthProvider";
 export function useAuth(): UseAuthReturn {
   const context = useAuthContext();
 
-  const {
-    user,
-    staticBaseUrl,
-    buildId,
-    status,
-    isAuthenticated,
-    isLoading,
-    login,
-    logout,
-    refreshSession,
-    hasRole,
-    hasAnyRole,
-    error,
-    clearError,
-  } = context;
-
-  return {
-    user,
-    staticBaseUrl,
-    buildId,
-    status,
-    isAuthenticated,
-    isLoading,
-    login,
-    logout,
-    refreshSession,
-    hasRole,
-    hasAnyRole,
-    error,
-    clearError,
-  };
+  return useMemo(
+    () => ({
+      user: context.user,
+      staticBaseUrl: context.staticBaseUrl,
+      buildId: context.buildId,
+      status: context.status,
+      isAuthenticated: context.isAuthenticated,
+      isLoading: context.isLoading,
+      login: context.login,
+      logout: context.logout,
+      refreshSession: context.refreshSession,
+      hasRole: context.hasRole,
+      hasAnyRole: context.hasAnyRole,
+      error: context.error,
+      clearError: context.clearError,
+    }),
+    [
+      context.user,
+      context.staticBaseUrl,
+      context.buildId,
+      context.status,
+      context.isAuthenticated,
+      context.isLoading,
+      context.login,
+      context.logout,
+      context.refreshSession,
+      context.hasRole,
+      context.hasAnyRole,
+      context.error,
+      context.clearError,
+    ]
+  );
 }