@depup/base44__sdk 0.8.22-depup.0

package/dist/modules/auth.js

@@ -0,0 +1,180 @@
+/**
+ * Creates the auth module for the Base44 SDK.
+ *
+ * @param axios - Axios instance for API requests
+ * @param functionsAxiosClient - Axios instance for functions API requests
+ * @param appId - Application ID
+ * @param options - Configuration options including server URLs
+ * @returns Auth module with authentication and user management methods
+ * @internal
+ */
+export function createAuthModule(axios, functionsAxiosClient, appId, options) {
+    return {
+        // Get current user information
+        async me() {
+            return axios.get(`/apps/${appId}/entities/User/me`);
+        },
+        // Update current user data
+        async updateMe(data) {
+            return axios.put(`/apps/${appId}/entities/User/me`, data);
+        },
+        // Redirects the user to the app's login page
+        redirectToLogin(nextUrl) {
+            // This function only works in a browser environment
+            if (typeof window === "undefined") {
+                throw new Error("Login method can only be used in a browser environment");
+            }
+            // If nextUrl is not provided, use the current URL
+            const redirectUrl = nextUrl
+                ? new URL(nextUrl, window.location.origin).toString()
+                : window.location.href;
+            // Build the login URL
+            const loginUrl = `${options.appBaseUrl}/login?from_url=${encodeURIComponent(redirectUrl)}`;
+            // Redirect to the login page
+            window.location.href = loginUrl;
+        },
+        // Redirects the user to a provider's login page
+        loginWithProvider(provider, fromUrl = "/") {
+            // Build the full redirect URL
+            const redirectUrl = new URL(fromUrl, window.location.origin).toString();
+            const queryParams = `app_id=${appId}&from_url=${encodeURIComponent(redirectUrl)}`;
+            // SSO uses a different URL structure with appId in the path
+            let authPath;
+            if (provider === "sso") {
+                authPath = `/apps/${appId}/auth/sso/login`;
+            }
+            else {
+                // Google is the default provider, so no provider path segment needed
+                const providerPath = provider === "google" ? "" : `/${provider}`;
+                authPath = `/apps/auth${providerPath}/login`;
+            }
+            const loginUrl = `${options.appBaseUrl}/api${authPath}?${queryParams}`;
+            // Redirect to the provider login page
+            window.location.href = loginUrl;
+        },
+        // Logout the current user
+        logout(redirectUrl) {
+            // Remove token from axios headers (always do this)
+            delete axios.defaults.headers.common["Authorization"];
+            // Only do the rest if in a browser environment
+            if (typeof window !== "undefined") {
+                // Remove token from localStorage
+                if (window.localStorage) {
+                    try {
+                        window.localStorage.removeItem("base44_access_token");
+                        // Remove "token" that is set by the built-in SDK of platform version 2
+                        window.localStorage.removeItem("token");
+                    }
+                    catch (e) {
+                        console.error("Failed to remove token from localStorage:", e);
+                    }
+                }
+                // Determine the from_url parameter
+                const fromUrl = redirectUrl || window.location.href;
+                // Redirect to server-side logout endpoint to clear HTTP-only cookies
+                const logoutUrl = `${options.appBaseUrl}/api/apps/auth/logout?from_url=${encodeURIComponent(fromUrl)}`;
+                window.location.href = logoutUrl;
+            }
+        },
+        // Set authentication token
+        setToken(token, saveToStorage = true) {
+            if (!token)
+                return;
+            // handle token change for axios clients
+            axios.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+            functionsAxiosClient.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+            // Save token to localStorage if requested
+            if (saveToStorage &&
+                typeof window !== "undefined" &&
+                window.localStorage) {
+                try {
+                    window.localStorage.setItem("base44_access_token", token);
+                    // Set "token" that is set by the built-in SDK of platform version 2
+                    window.localStorage.setItem("token", token);
+                }
+                catch (e) {
+                    console.error("Failed to save token to localStorage:", e);
+                }
+            }
+        },
+        // Login using username and password
+        async loginViaEmailPassword(email, password, turnstileToken) {
+            var _a;
+            try {
+                const response = await axios.post(`/apps/${appId}/auth/login`, {
+                    email,
+                    password,
+                    ...(turnstileToken && { turnstile_token: turnstileToken }),
+                });
+                const { access_token, user } = response;
+                if (access_token) {
+                    this.setToken(access_token);
+                }
+                return {
+                    access_token,
+                    user,
+                };
+            }
+            catch (error) {
+                // Handle authentication errors and cleanup
+                if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                    await this.logout();
+                }
+                throw error;
+            }
+        },
+        // Verify if the current token is valid
+        async isAuthenticated() {
+            try {
+                await this.me();
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        },
+        // Invite a user to the app
+        inviteUser(userEmail, role) {
+            return axios.post(`/apps/${appId}/users/invite-user`, {
+                user_email: userEmail,
+                role,
+            });
+        },
+        // Register a new user account
+        register(payload) {
+            return axios.post(`/apps/${appId}/auth/register`, payload);
+        },
+        // Verify an OTP (One-time password) code
+        verifyOtp({ email, otpCode }) {
+            return axios.post(`/apps/${appId}/auth/verify-otp`, {
+                email,
+                otp_code: otpCode,
+            });
+        },
+        // Resend an OTP code to the user's email
+        resendOtp(email) {
+            return axios.post(`/apps/${appId}/auth/resend-otp`, { email });
+        },
+        // Request a password reset
+        resetPasswordRequest(email) {
+            return axios.post(`/apps/${appId}/auth/reset-password-request`, {
+                email,
+            });
+        },
+        // Reset password using a reset token
+        resetPassword({ resetToken, newPassword }) {
+            return axios.post(`/apps/${appId}/auth/reset-password`, {
+                reset_token: resetToken,
+                new_password: newPassword,
+            });
+        },
+        // Change the user's password
+        changePassword({ userId, currentPassword, newPassword, }) {
+            return axios.post(`/apps/${appId}/auth/change-password`, {
+                user_id: userId,
+                current_password: currentPassword,
+                new_password: newPassword,
+            });
+        },
+    };
+}

package/dist/modules/auth.types.d.ts

@@ -0,0 +1,481 @@
+/**
+ * An authenticated user.
+ */
+export interface User {
+    /** Unique user identifier. */
+    id: string;
+    /** When the user was created. */
+    created_date: string;
+    /** When the user was last updated. */
+    updated_date: string;
+    /** User's email address. */
+    email: string;
+    /** User's full name. */
+    full_name: string | null;
+    /** Whether the user is disabled. */
+    disabled: boolean | null;
+    /** Whether the user's email has been verified. */
+    is_verified: boolean;
+    /** The app ID this user belongs to. */
+    app_id: string;
+    /** Whether this is a service account. */
+    is_service: boolean;
+    /** Internal app role.
+     * @internal
+     */
+    _app_role: string;
+    /**
+     * User's role in the app. Roles are configured in the app settings and determine the user's permissions and access levels.
+     */
+    role: string;
+    /**
+     * Additional custom fields defined in the user schema. Any custom properties added to the user schema in the app will be available here with their configured types and values.
+     */
+    [key: string]: any;
+}
+/**
+ * Response from login endpoints containing user information and access token.
+ */
+export interface LoginResponse {
+    /** JWT access token for authentication. */
+    access_token: string;
+    /** User information. */
+    user: User;
+}
+/**
+ * Payload for user registration.
+ */
+export interface RegisterParams {
+    /** User's email address. */
+    email: string;
+    /** User's password. */
+    password: string;
+    /** Optional {@link https://developers.cloudflare.com/turnstile/ | Cloudflare Turnstile CAPTCHA token} for bot protection. */
+    turnstile_token?: string | null;
+    /** Optional {@link https://docs.base44.com/Getting-Started/Referral-program | referral code} from an existing user. */
+    referral_code?: string | null;
+}
+/**
+ * Parameters for OTP verification.
+ */
+export interface VerifyOtpParams {
+    /** User's email address. */
+    email: string;
+    /** One-time password code received by email. */
+    otpCode: string;
+}
+/**
+ * Parameters for changing a user's password.
+ */
+export interface ChangePasswordParams {
+    /** User ID. */
+    userId: string;
+    /** Current password for verification. */
+    currentPassword: string;
+    /** New password to set. */
+    newPassword: string;
+}
+/**
+ * Parameters for resetting a password with a token.
+ */
+export interface ResetPasswordParams {
+    /** Reset token received by email. */
+    resetToken: string;
+    /** New password to set. */
+    newPassword: string;
+}
+/**
+ * Configuration options for the auth module.
+ */
+export interface AuthModuleOptions {
+    /** Server URL for API requests. */
+    serverUrl: string;
+    /** Base URL for the app (used for login redirects). */
+    appBaseUrl: string;
+}
+/**
+ * Authentication module for managing user authentication and authorization. The module automatically stores tokens in local storage when available and manages authorization headers for API requests.
+ *
+ * ## Features
+ *
+ * This module provides comprehensive authentication functionality including:
+ * - Email/password login and registration
+ * - Token management
+ * - User profile access and updates
+ * - Password reset flows
+ * - OTP verification
+ * - User invitations
+ *
+ * ## Authentication Modes
+ *
+ * The auth module is only available in user authentication mode (`base44.auth`).
+ */
+export interface AuthModule {
+    /**
+     * Gets the current authenticated user's information.
+     *
+     * @returns Promise resolving to the user's profile data.
+     *
+     * @example
+     * ```typescript
+     * // Get current user information
+     * const user = await base44.auth.me();
+     * console.log(`Logged in as: ${user.email}`);
+     * console.log(`User ID: ${user.id}`);
+     * ```
+     */
+    me(): Promise<User>;
+    /**
+     * Updates the current authenticated user's information.
+     *
+     * Only the fields included in the data object will be updated.
+     * Commonly updated fields include `full_name` and custom profile fields.
+     *
+     * @param data - Object containing the fields to update.
+     * @returns Promise resolving to the updated user data.
+     *
+     * @example
+     * ```typescript
+     * // Update specific fields
+     * const updatedUser = await base44.auth.updateMe({
+     *   full_name: 'John Doe'
+     * });
+     * console.log(`Updated user: ${updatedUser.full_name}`);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Update custom fields defined in your User entity
+     * await base44.auth.updateMe({
+     *   bio: 'Software developer',
+     *   phone: '+1234567890',
+     *   preferences: { theme: 'dark' }
+     * });
+     * ```
+     */
+    updateMe(data: Partial<Omit<User, "id" | "created_date" | "updated_date">>): Promise<User>;
+    /**
+     * Redirects the user to the app's login page.
+     *
+     * Redirects with a callback URL to return to after successful authentication. Requires a browser environment and can't be used in the backend.
+     *
+     * @param nextUrl - URL to redirect to after successful login.
+     * @throws {Error} When not in a browser environment.
+     *
+     * @example
+     * ```typescript
+     * // Redirect to login and come back to current page
+     * base44.auth.redirectToLogin(window.location.href);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Redirect to login and then go to the dashboard page
+     * base44.auth.redirectToLogin('/dashboard');
+     * ```
+     */
+    redirectToLogin(nextUrl: string): void;
+    /**
+     * Redirects the user to a third-party authentication provider's login page.
+     *
+     * Initiates an OAuth login flow with one of the built-in providers. Requires a browser environment and can't be used in the backend.
+     *
+     * Supported providers:
+     * - `'google'`: {@link https://developers.google.com/identity/protocols/oauth2 | Google OAuth}. Enabled by default.
+     * - `'microsoft'`: {@link https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-auth-code-flow | Microsoft OAuth}. Enable Microsoft in your app's authentication settings before specifying this provider.
+     * - `'facebook'`: {@link https://developers.facebook.com/docs/facebook-login | Facebook Login}. Enable Facebook in your app's authentication settings before using.
+     * - `'apple'`: {@link https://developer.apple.com/sign-in-with-apple/ | Sign in with Apple}. Enable Apple in your app's authentication settings before using this provider.
+     * - `'sso'`: Enterprise SSO. {@link https://docs.base44.com/Setting-up-your-app/Setting-up-SSO | Set up an SSO provider} in your app's authentication settings before using this provider.
+     *
+     * @param provider - The authentication provider to use: `'google'`, `'microsoft'`, `'facebook'`, `'apple'`, or `'sso'`.
+     * @param fromUrl - URL to redirect to after successful authentication. Defaults to `'/'`.
+     *
+     * @example
+     * ```typescript
+     * // Google
+     * base44.auth.loginWithProvider('google', window.location.pathname);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Microsoft
+     * base44.auth.loginWithProvider('microsoft', '/dashboard');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Apple
+     * base44.auth.loginWithProvider('apple', '/dashboard');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // SSO
+     * base44.auth.loginWithProvider('sso', '/dashboard');
+     * ```
+     *
+     */
+    loginWithProvider(provider: string, fromUrl?: string): void;
+    /**
+     * Logs out the current user.
+     *
+     * Removes the authentication token from local storage and Axios headers, then optionally redirects to a URL or reloads the page. Requires a browser environment and can't be used in the backend.
+     *
+     * @param redirectUrl - Optional URL to redirect to after logout. Reloads the page if not provided.
+     *
+     * @example
+     * ```typescript
+     * // Logout and reload page
+     * base44.auth.logout();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Logout and redirect to login page
+     * base44.auth.logout('/login');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Logout and redirect to home
+     * base44.auth.logout('/');
+     * ```
+     */
+    logout(redirectUrl?: string): void;
+    /**
+     * Sets the authentication token.
+     *
+     * Updates the authorization header for API requests and optionally saves the token to local storage for persistence. Saving to local storage requires a browser environment and is automatically skipped in backend environments.
+     *
+     * @param token - JWT authentication token.
+     * @param saveToStorage - Whether to save the token to local storage. Defaults to true.
+     *
+     * @example
+     * ```typescript
+     * // Set token and save to local storage
+     * base44.auth.setToken('eyJhbGciOiJIUzI1NiIs...');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Set token without saving to local storage
+     * base44.auth.setToken('eyJhbGciOiJIUzI1NiIs...', false);
+     * ```
+     */
+    setToken(token: string, saveToStorage?: boolean): void;
+    /**
+     * Logs in a registered user using email and password.
+     *
+     * Authenticates a user with email and password credentials. The user must already have a registered account. For new users, use {@linkcode register | register()} first to create an account. On successful login, automatically sets the token for subsequent requests.
+     *
+     * @param email - User's email address.
+     * @param password - User's password.
+     * @param turnstileToken - Optional {@link https://developers.cloudflare.com/turnstile/ | Cloudflare Turnstile CAPTCHA token} for bot protection.
+     * @returns Promise resolving to login response with access token and user data.
+     * @throws Error if the email and password combination is invalid or the user is not registered.
+     *
+     * @example
+     * ```typescript
+     * // Login with email and password
+     * try {
+     *   const { access_token, user } = await base44.auth.loginViaEmailPassword(
+     *     'user@example.com',
+     *     'securePassword123'
+     *   );
+     *   console.log('Login successful!', user);
+     * } catch (error) {
+     *   console.error('Login failed:', error);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // With captcha token
+     * const response = await base44.auth.loginViaEmailPassword(
+     *   'user@example.com',
+     *   'securePassword123',
+     *   'captcha-token-here'
+     * );
+     * ```
+     */
+    loginViaEmailPassword(email: string, password: string, turnstileToken?: string): Promise<LoginResponse>;
+    /**
+     * Checks if the current user is authenticated.
+     *
+     * @returns Promise resolving to true if authenticated, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * // Check authentication status
+     * const isAuthenticated = await base44.auth.isAuthenticated();
+     * if (isAuthenticated) {
+     *   console.log('User is logged in');
+     * } else {
+     *   // Redirect to login page
+     *   base44.auth.redirectToLogin(window.location.href);
+     * }
+     * ```
+     */
+    isAuthenticated(): Promise<boolean>;
+    /**
+     * Invites a user to the app.
+     *
+     * Sends an invitation email to a potential user with a specific role.
+     * Roles are configured in the app settings and determine
+     * the user's permissions and access levels.
+     *
+     * @param userEmail - Email address of the user to invite.
+     * @param role - Role to assign to the invited user. Must match a role defined in the app. For example, `'admin'` or `'user'`.
+     * @returns Promise that resolves when the invitation is sent successfully. Throws an error if the invitation fails.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await base44.auth.inviteUser('newuser@example.com', 'user');
+     *   console.log('Invitation sent successfully!');
+     * } catch (error) {
+     *   console.error('Failed to send invitation:', error);
+     * }
+     * ```
+     */
+    inviteUser(userEmail: string, role: string): Promise<any>;
+    /**
+     * Registers a new user account.
+     *
+     * Creates a new user account with email and password. After successful registration,
+     * use {@linkcode loginViaEmailPassword | loginViaEmailPassword()} to log in the user.
+     *
+     * @param params - Registration details including email, password, and optional fields.
+     * @returns Promise resolving to the registration response.
+     *
+     * @example
+     * ```typescript
+     * // Register a new user
+     * await base44.auth.register({
+     *   email: 'newuser@example.com',
+     *   password: 'securePassword123',
+     *   referral_code: 'FRIEND2024'
+     * });
+     *
+     * // Login after registration
+     * const { access_token, user } = await base44.auth.loginViaEmailPassword(
+     *   'newuser@example.com',
+     *   'securePassword123'
+     * );
+     * ```
+     */
+    register(params: RegisterParams): Promise<any>;
+    /**
+     * Verifies an OTP (One-time password) code.
+     *
+     * Validates an OTP code sent to the user's email during registration
+     * or authentication.
+     *
+     * @param params - Object containing email and OTP code.
+     * @returns Promise resolving to the verification response if valid.
+     * @throws Error if the OTP code is invalid, expired, or verification fails.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await base44.auth.verifyOtp({
+     *     email: 'user@example.com',
+     *     otpCode: '123456'
+     *   });
+     *   console.log('Email verified successfully!');
+     * } catch (error) {
+     *   console.error('Invalid or expired OTP code');
+     * }
+     * ```
+     */
+    verifyOtp(params: VerifyOtpParams): Promise<any>;
+    /**
+     * Resends an OTP code to the user's email address.
+     *
+     * Requests a new OTP code to be sent to the specified email address.
+     *
+     * @param email - Email address to send the OTP to.
+     * @returns Promise resolving when the OTP is sent successfully.
+     * @throws Error if the email is invalid or the request fails.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await base44.auth.resendOtp('user@example.com');
+     *   console.log('OTP resent! Please check your email.');
+     * } catch (error) {
+     *   console.error('Failed to resend OTP:', error);
+     * }
+     * ```
+     */
+    resendOtp(email: string): Promise<any>;
+    /**
+     * Requests a password reset.
+     *
+     * Sends a password reset email to the specified email address.
+     *
+     * @param email - Email address for the account to reset.
+     * @returns Promise resolving when the password reset email is sent successfully.
+     * @throws Error if the email is invalid or the request fails.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await base44.auth.resetPasswordRequest('user@example.com');
+     *   console.log('Password reset email sent!');
+     * } catch (error) {
+     *   console.error('Failed to send password reset email:', error);
+     * }
+     * ```
+     */
+    resetPasswordRequest(email: string): Promise<any>;
+    /**
+     * Resets password using a reset token.
+     *
+     * Completes the password reset flow by setting a new password
+     * using the token received by email.
+     *
+     * @param params - Object containing the reset token and new password.
+     * @returns Promise resolving when the password is reset successfully.
+     * @throws Error if the reset token is invalid, expired, or the request fails.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await base44.auth.resetPassword({
+     *     resetToken: 'token-from-email',
+     *     newPassword: 'newSecurePassword456'
+     *   });
+     *   console.log('Password reset successful!');
+     * } catch (error) {
+     *   console.error('Failed to reset password:', error);
+     * }
+     * ```
+     */
+    resetPassword(params: ResetPasswordParams): Promise<any>;
+    /**
+     * Changes the user's password.
+     *
+     * Updates the password for an authenticated user by verifying
+     * the current password and setting a new one.
+     *
+     * @param params - Object containing user ID, current password, and new password.
+     * @returns Promise resolving when the password is changed successfully.
+     * @throws Error if the current password is incorrect or the request fails.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await base44.auth.changePassword({
+     *     userId: 'user-123',
+     *     currentPassword: 'oldPassword123',
+     *     newPassword: 'newSecurePassword456'
+     *   });
+     *   console.log('Password changed successfully!');
+     * } catch (error) {
+     *   console.error('Failed to change password:', error);
+     * }
+     * ```
+     */
+    changePassword(params: ChangePasswordParams): Promise<any>;
+}

package/dist/modules/auth.types.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/connectors.d.ts

@@ -0,0 +1,20 @@
+import { AxiosInstance } from "axios";
+import { ConnectorsModule, UserConnectorsModule } from "./connectors.types.js";
+/**
+ * Creates the Connectors module for the Base44 SDK.
+ *
+ * @param axios - Axios instance (should be service role client)
+ * @param appId - Application ID
+ * @returns Connectors module with methods to retrieve OAuth tokens
+ * @internal
+ */
+export declare function createConnectorsModule(axios: AxiosInstance, appId: string): ConnectorsModule;
+/**
+ * Creates the user-scoped Connectors module (app-user OAuth flows).
+ *
+ * @param axios - Axios instance (user-scoped client)
+ * @param appId - Application ID
+ * @returns User connectors module with app-user OAuth methods
+ * @internal
+ */
+export declare function createUserConnectorsModule(axios: AxiosInstance, appId: string): UserConnectorsModule;