@anythink-cloud/sdk 0.2.1 → 0.3.0

package/dist/index.d.mts

@@ -1,5 +1,7 @@
 import * as zustand_middleware from 'zustand/middleware';
 import * as zustand from 'zustand';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
 import { AxiosInstance, AxiosRequestConfig } from 'axios';
 
 /**
@@ -120,9 +122,11 @@ interface CookieStorageOptions {
 
 interface AuthState {
     session: Session | null;
+    user: User | null;
     isLoading: boolean;
     error: Error | null;
     setSession: (session: Session | null) => void;
+    setUser: (user: User | null) => void;
     signOut: () => void;
     clearError: () => void;
     setLoading: (isLoading: boolean) => void;
@@ -231,12 +235,144 @@ declare class AuthClient {
      * Check if user is authenticated
      */
     isAuthenticated(): boolean;
+    /**
+     * Fetch user information from the API
+     * @returns User object or null if failed
+     */
+    fetchUserInfo(): Promise<{
+        data: {
+            user: User | null;
+        };
+        error: Error | null;
+    }>;
+    /**
+     * Get the current user
+     * @returns User object or null if not available
+     */
+    getUser(): User | null;
     /**
      * Get the Zustand store (for React hooks)
      */
     getStore(): ReturnType<typeof createAuthStore>;
 }
 
+/**
+ * Callback functions for auth events
+ */
+interface AuthCallbacks {
+    /**
+     * Called after successful sign in
+     */
+    onSignIn?: (session: Session) => void | Promise<void>;
+    /**
+     * Called after sign out
+     */
+    onSignOut?: () => void | Promise<void>;
+    /**
+     * Called when token refresh fails and user is signed out
+     */
+    onTokenRefreshFailed?: () => void | Promise<void>;
+}
+/**
+ * Auth context value
+ */
+interface AuthContextValue {
+    /**
+     * Current session
+     */
+    session: Session | null;
+    /**
+     * Current user information
+     */
+    user: User | null;
+    /**
+     * Whether auth operations are in progress
+     */
+    isLoading: boolean;
+    /**
+     * Current error, if any
+     */
+    error: Error | null;
+    /**
+     * Whether user is authenticated
+     */
+    isAuthenticated: boolean;
+    /**
+     * Sign in with email and password
+     */
+    signIn: (email: string, password: string, orgId?: number) => Promise<SignInResponse>;
+    /**
+     * Sign out and clear session
+     */
+    signOut: () => Promise<{
+        error: Error | null;
+    }>;
+    /**
+     * Register a new user
+     */
+    register: (firstName: string, lastName: string, email: string, password: string) => Promise<{
+        error: Error | null;
+    }>;
+    /**
+     * Change password
+     */
+    changePassword: (currentPassword: string, newPassword: string) => Promise<{
+        error: Error | null;
+    }>;
+    /**
+     * Refresh the session token
+     */
+    refreshSession: () => Promise<RefreshResponse>;
+    /**
+     * Get the current access token
+     */
+    getAccessToken: () => string | null;
+    /**
+     * Get the current refresh token
+     */
+    getRefreshToken: () => string | null;
+}
+/**
+ * Props for AuthProvider
+ */
+interface AuthProviderProps {
+    /**
+     * AuthClient instance
+     */
+    authClient: AuthClient;
+    /**
+     * Optional callbacks for auth events
+     */
+    callbacks?: AuthCallbacks;
+    /**
+     * Whether to automatically refresh tokens before they expire
+     * @default true
+     */
+    autoRefresh?: boolean;
+    /**
+     * How many seconds before expiration to refresh the token
+     * @default 60
+     */
+    refreshThreshold?: number;
+    /**
+     * URL to redirect to when user is not authenticated or token refresh fails
+     */
+    loginUrl?: string;
+    /**
+     * Child components
+     */
+    children: ReactNode;
+}
+/**
+ * AuthProvider component that wraps your app and provides auth state
+ */
+declare function AuthProvider({ authClient, callbacks, autoRefresh, refreshThreshold, loginUrl, children, }: AuthProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access auth context
+ * @throws Error if used outside AuthProvider
+ */
+declare function useAuth(): AuthContextValue;
+
 /**
  * Base service class with automatic token injection and refresh handling
  */
@@ -279,4 +415,4 @@ declare class AuthenticatedBaseService {
     getClient(): AxiosInstance;
 }
 
-export { AuthClient, type AuthConfig, AuthenticatedBaseService, type CookieStorageConfig, type RefreshResponse, type Session, type SignInResponse, type TokenPair, type User, createAuthStore };
+export { type AuthCallbacks, AuthClient, type AuthConfig, type AuthContextValue, AuthProvider, type AuthProviderProps, AuthenticatedBaseService, type CookieStorageConfig, type RefreshResponse, type Session, type SignInResponse, type TokenPair, type User, createAuthStore, useAuth };

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 import * as zustand_middleware from 'zustand/middleware';
 import * as zustand from 'zustand';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
 import { AxiosInstance, AxiosRequestConfig } from 'axios';
 
 /**
@@ -120,9 +122,11 @@ interface CookieStorageOptions {
 
 interface AuthState {
     session: Session | null;
+    user: User | null;
     isLoading: boolean;
     error: Error | null;
     setSession: (session: Session | null) => void;
+    setUser: (user: User | null) => void;
     signOut: () => void;
     clearError: () => void;
     setLoading: (isLoading: boolean) => void;
@@ -231,12 +235,144 @@ declare class AuthClient {
      * Check if user is authenticated
      */
     isAuthenticated(): boolean;
+    /**
+     * Fetch user information from the API
+     * @returns User object or null if failed
+     */
+    fetchUserInfo(): Promise<{
+        data: {
+            user: User | null;
+        };
+        error: Error | null;
+    }>;
+    /**
+     * Get the current user
+     * @returns User object or null if not available
+     */
+    getUser(): User | null;
     /**
      * Get the Zustand store (for React hooks)
      */
     getStore(): ReturnType<typeof createAuthStore>;
 }
 
+/**
+ * Callback functions for auth events
+ */
+interface AuthCallbacks {
+    /**
+     * Called after successful sign in
+     */
+    onSignIn?: (session: Session) => void | Promise<void>;
+    /**
+     * Called after sign out
+     */
+    onSignOut?: () => void | Promise<void>;
+    /**
+     * Called when token refresh fails and user is signed out
+     */
+    onTokenRefreshFailed?: () => void | Promise<void>;
+}
+/**
+ * Auth context value
+ */
+interface AuthContextValue {
+    /**
+     * Current session
+     */
+    session: Session | null;
+    /**
+     * Current user information
+     */
+    user: User | null;
+    /**
+     * Whether auth operations are in progress
+     */
+    isLoading: boolean;
+    /**
+     * Current error, if any
+     */
+    error: Error | null;
+    /**
+     * Whether user is authenticated
+     */
+    isAuthenticated: boolean;
+    /**
+     * Sign in with email and password
+     */
+    signIn: (email: string, password: string, orgId?: number) => Promise<SignInResponse>;
+    /**
+     * Sign out and clear session
+     */
+    signOut: () => Promise<{
+        error: Error | null;
+    }>;
+    /**
+     * Register a new user
+     */
+    register: (firstName: string, lastName: string, email: string, password: string) => Promise<{
+        error: Error | null;
+    }>;
+    /**
+     * Change password
+     */
+    changePassword: (currentPassword: string, newPassword: string) => Promise<{
+        error: Error | null;
+    }>;
+    /**
+     * Refresh the session token
+     */
+    refreshSession: () => Promise<RefreshResponse>;
+    /**
+     * Get the current access token
+     */
+    getAccessToken: () => string | null;
+    /**
+     * Get the current refresh token
+     */
+    getRefreshToken: () => string | null;
+}
+/**
+ * Props for AuthProvider
+ */
+interface AuthProviderProps {
+    /**
+     * AuthClient instance
+     */
+    authClient: AuthClient;
+    /**
+     * Optional callbacks for auth events
+     */
+    callbacks?: AuthCallbacks;
+    /**
+     * Whether to automatically refresh tokens before they expire
+     * @default true
+     */
+    autoRefresh?: boolean;
+    /**
+     * How many seconds before expiration to refresh the token
+     * @default 60
+     */
+    refreshThreshold?: number;
+    /**
+     * URL to redirect to when user is not authenticated or token refresh fails
+     */
+    loginUrl?: string;
+    /**
+     * Child components
+     */
+    children: ReactNode;
+}
+/**
+ * AuthProvider component that wraps your app and provides auth state
+ */
+declare function AuthProvider({ authClient, callbacks, autoRefresh, refreshThreshold, loginUrl, children, }: AuthProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access auth context
+ * @throws Error if used outside AuthProvider
+ */
+declare function useAuth(): AuthContextValue;
+
 /**
  * Base service class with automatic token injection and refresh handling
  */
@@ -279,4 +415,4 @@ declare class AuthenticatedBaseService {
     getClient(): AxiosInstance;
 }
 
-export { AuthClient, type AuthConfig, AuthenticatedBaseService, type CookieStorageConfig, type RefreshResponse, type Session, type SignInResponse, type TokenPair, type User, createAuthStore };
+export { type AuthCallbacks, AuthClient, type AuthConfig, type AuthContextValue, AuthProvider, type AuthProviderProps, AuthenticatedBaseService, type CookieStorageConfig, type RefreshResponse, type Session, type SignInResponse, type TokenPair, type User, createAuthStore, useAuth };

package/dist/index.js

@@ -3,6 +3,8 @@
 var axios = require('axios');
 var zustand = require('zustand');
 var middleware = require('zustand/middleware');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -113,13 +115,17 @@ var createAuthStore = (cookieOptions) => {
     middleware.persist(
       (set) => ({
         session: null,
+        user: null,
         isLoading: false,
         error: null,
         setSession: (session) => {
           set({ session, error: null });
         },
+        setUser: (user) => {
+          set({ user });
+        },
         signOut: () => {
-          set({ session: null, error: null });
+          set({ session: null, user: null, error: null });
         },
         clearError: () => {
           set({ error: null });
@@ -143,8 +149,11 @@ var createAuthStore = (cookieOptions) => {
             // User-provided options override defaults
           });
         }),
-        // Only persist the session, not loading/error states
-        partialize: (state) => ({ session: state.session })
+        // Only persist the session and user, not loading/error states
+        partialize: (state) => ({
+          session: state.session,
+          user: state.user
+        })
       }
     )
   );
@@ -181,7 +190,7 @@ var AuthClient = class {
       this.store.getState().clearError();
       const params = orgId ? { org_id: orgId.toString() } : void 0;
       const response = await this.axiosClient.post(
-        this.config.tokenEndpoint ?? "/auth/v1/token",
+        this.config.tokenEndpoint ?? `/org/${this.config.orgId}/auth/v1/token`,
         { email, password },
         { params }
       );
@@ -194,6 +203,7 @@ var AuthClient = class {
       };
       this.store.getState().setSession(session);
       this.store.getState().setLoading(false);
+      await this.fetchUserInfo();
       return { data: { session }, error: null };
     } catch (error) {
       let authError;
@@ -223,7 +233,7 @@ var AuthClient = class {
   async register(firstName, lastName, email, password) {
     try {
       await this.axiosClient.post(
-        this.config.registerEndpoint ?? "/auth/v1/register",
+        this.config.registerEndpoint ?? `/org/${this.config.orgId}/auth/v1/register`,
         {
           first_name: firstName,
           last_name: lastName,
@@ -264,7 +274,7 @@ var AuthClient = class {
       this.store.getState().setLoading(true);
       this.store.getState().clearError();
       const response = await this.axiosClient.post(
-        this.config.refreshEndpoint ?? "/auth/v1/refresh",
+        this.config.refreshEndpoint ?? `/org/${this.config.orgId}/auth/v1/refresh`,
         { token: session.refresh_token }
       );
       const tokenPair = response.data;
@@ -276,6 +286,7 @@ var AuthClient = class {
       };
       this.store.getState().setSession(newSession);
       this.store.getState().setLoading(false);
+      await this.fetchUserInfo();
       return { data: { session: newSession }, error: null };
     } catch (error) {
       this.store.getState().setSession(null);
@@ -324,6 +335,7 @@ var AuthClient = class {
         expires_at: Math.floor(Date.now() / 1e3) + expires_in
       };
       this.store.getState().setSession(session);
+      await this.fetchUserInfo();
       return { error: null };
     } catch (error) {
       return {
@@ -344,7 +356,7 @@ var AuthClient = class {
         throw new Error("No access token found");
       }
       await this.axiosClient.post(
-        this.config.changePasswordEndpoint ?? "/users/me/password",
+        this.config.changePasswordEndpoint ?? `/org/${this.config.orgId}/users/me/password`,
         {
           current_password: currentPassword,
           new_password: newPassword
@@ -380,7 +392,7 @@ var AuthClient = class {
     if (refreshToken) {
       try {
         await this.axiosClient.post(
-          this.config.logoutEndpoint ?? "/auth/v1/logout",
+          this.config.logoutEndpoint ?? `/org/${this.config.orgId}/auth/v1/logout`,
           {
             token: refreshToken
           }
@@ -427,6 +439,51 @@ var AuthClient = class {
     }
     return true;
   }
+  /**
+   * Fetch user information from the API
+   * @returns User object or null if failed
+   */
+  async fetchUserInfo() {
+    const token = this.getAccessToken();
+    if (!token) {
+      return {
+        data: { user: null },
+        error: new Error("No access token found")
+      };
+    }
+    try {
+      const response = await this.axiosClient.get(
+        `/org/${this.config.orgId}/users/me`,
+        {
+          headers: {
+            Authorization: `Bearer ${token}`
+          }
+        }
+      );
+      const user = response.data;
+      this.store.getState().setUser(user);
+      return { data: { user }, error: null };
+    } catch (error) {
+      let authError;
+      if (error instanceof axios.AxiosError) {
+        const errorMessage = typeof error.response?.data === "string" ? error.response.data : error.response?.data?.message || error.message || "Failed to fetch user information";
+        authError = new Error(errorMessage);
+      } else {
+        authError = error instanceof Error ? error : new Error("Failed to fetch user information");
+      }
+      return {
+        data: { user: null },
+        error: authError
+      };
+    }
+  }
+  /**
+   * Get the current user
+   * @returns User object or null if not available
+   */
+  getUser() {
+    return this.store.getState().user;
+  }
   /**
    * Get the Zustand store (for React hooks)
    */
@@ -434,6 +491,190 @@ var AuthClient = class {
     return this.store;
   }
 };
+var AuthContext = react.createContext(null);
+function AuthProvider({
+  authClient,
+  callbacks,
+  autoRefresh = true,
+  refreshThreshold = 60,
+  loginUrl,
+  children
+}) {
+  const store = authClient.getStore();
+  const session = store((state) => state.session);
+  const user = store((state) => state.user);
+  const isLoading = store((state) => state.isLoading);
+  const error = store((state) => state.error);
+  const refreshTimerRef = react.useRef(null);
+  const isRefreshingRef = react.useRef(false);
+  const hasInitializedRef = react.useRef(false);
+  const isAuthenticated = react.useMemo(() => {
+    if (!session) return false;
+    if (session.expires_at && Date.now() >= session.expires_at * 1e3) {
+      return false;
+    }
+    return true;
+  }, [session]);
+  const redirectToLogin = react.useCallback(() => {
+    if (loginUrl && typeof window !== "undefined") {
+      window.location.href = loginUrl;
+    }
+  }, [loginUrl]);
+  const refreshTokenIfNeeded = react.useCallback(async () => {
+    if (isRefreshingRef.current) {
+      return;
+    }
+    const currentSession = authClient.getSession().data.session;
+    if (!currentSession || !currentSession.expires_at) {
+      return;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const timeUntilExpiry = currentSession.expires_at - now;
+    if (timeUntilExpiry <= refreshThreshold) {
+      isRefreshingRef.current = true;
+      try {
+        const { data, error: refreshError } = await authClient.refreshSession();
+        if (refreshError || !data.session) {
+          if (callbacks?.onTokenRefreshFailed) {
+            await callbacks.onTokenRefreshFailed();
+          }
+          redirectToLogin();
+        }
+      } catch (err) {
+        if (callbacks?.onTokenRefreshFailed) {
+          await callbacks.onTokenRefreshFailed();
+        }
+        redirectToLogin();
+      } finally {
+        isRefreshingRef.current = false;
+      }
+    }
+  }, [authClient, refreshThreshold, callbacks, redirectToLogin]);
+  react.useEffect(() => {
+    if (hasInitializedRef.current) {
+      return;
+    }
+    hasInitializedRef.current = true;
+    let isMounted = true;
+    const initializeAuth = async () => {
+      try {
+        const currentSession = authClient.getSession().data.session;
+        if (!currentSession || !currentSession.expires_at) {
+          if (loginUrl && isMounted) {
+            redirectToLogin();
+          }
+          return;
+        }
+        const now = Math.floor(Date.now() / 1e3);
+        if (currentSession.expires_at <= now) {
+          const { data, error: refreshError } = await authClient.refreshSession();
+          if (!isMounted) {
+            return;
+          }
+          if (refreshError || !data.session) {
+            if (loginUrl) {
+              redirectToLogin();
+            }
+            return;
+          }
+        }
+        const { error: userError } = await authClient.fetchUserInfo();
+        if (!isMounted) {
+          return;
+        }
+        if (userError) {
+          const { data, error: refreshError } = await authClient.refreshSession();
+          if (!isMounted) {
+            return;
+          }
+          if (refreshError || !data.session) {
+            if (loginUrl) {
+              redirectToLogin();
+            }
+            return;
+          }
+          const { error: retryError } = await authClient.fetchUserInfo();
+          if (!isMounted) {
+            return;
+          }
+          if (retryError && loginUrl) {
+            redirectToLogin();
+          }
+        }
+      } catch (error2) {
+        if (isMounted && loginUrl) {
+          redirectToLogin();
+        }
+      }
+    };
+    initializeAuth();
+    return () => {
+      isMounted = false;
+    };
+  }, [authClient, loginUrl, redirectToLogin]);
+  react.useEffect(() => {
+    if (!autoRefresh || !session || !session.expires_at) {
+      if (refreshTimerRef.current) {
+        clearInterval(refreshTimerRef.current);
+        refreshTimerRef.current = null;
+      }
+      return;
+    }
+    if (refreshTimerRef.current) {
+      clearInterval(refreshTimerRef.current);
+    }
+    const checkAndRefresh = () => {
+      refreshTokenIfNeeded();
+    };
+    checkAndRefresh();
+    refreshTimerRef.current = setInterval(checkAndRefresh, 3e4);
+    return () => {
+      if (refreshTimerRef.current) {
+        clearInterval(refreshTimerRef.current);
+        refreshTimerRef.current = null;
+      }
+    };
+  }, [session, autoRefresh, refreshThreshold, refreshTokenIfNeeded]);
+  const signIn = react.useCallback(
+    async (email, password, orgId) => {
+      const result = await authClient.signIn(email, password, orgId);
+      if (result.data.session && !result.error && callbacks?.onSignIn) {
+        await callbacks.onSignIn(result.data.session);
+      }
+      return result;
+    },
+    [authClient, callbacks]
+  );
+  const signOut = react.useCallback(async () => {
+    const result = await authClient.signOut();
+    if (!result.error && callbacks?.onSignOut) {
+      await callbacks.onSignOut();
+    }
+    return result;
+  }, [authClient, callbacks]);
+  const contextValue = {
+    session,
+    user,
+    isLoading,
+    error,
+    isAuthenticated,
+    signIn,
+    signOut,
+    register: authClient.register.bind(authClient),
+    changePassword: authClient.changePassword.bind(authClient),
+    refreshSession: authClient.refreshSession.bind(authClient),
+    getAccessToken: authClient.getAccessToken.bind(authClient),
+    getRefreshToken: authClient.getRefreshToken.bind(authClient)
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(AuthContext.Provider, { value: contextValue, children });
+}
+function useAuth() {
+  const context = react.useContext(AuthContext);
+  if (!context) {
+    throw new Error("useAuth must be used within an AuthProvider");
+  }
+  return context;
+}
 var AuthenticatedBaseService = class {
   constructor(authClient, instanceUrl) {
     this.authClient = authClient;
@@ -559,7 +800,9 @@ var AuthenticatedBaseService = class {
 };
 
 exports.AuthClient = AuthClient;
+exports.AuthProvider = AuthProvider;
 exports.AuthenticatedBaseService = AuthenticatedBaseService;
 exports.createAuthStore = createAuthStore;
+exports.useAuth = useAuth;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map