@doany-ai/sdk 0.1.0

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

@@ -0,0 +1,142 @@
+/**
+ * @internal
+ */
+export interface AppMessageContent {
+    content?: string;
+    file_urls?: string[];
+    custom_context?: unknown;
+    additional_message_params?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * @internal
+ */
+export interface AppConversationMessage extends AppMessageContent {
+    id?: string | null;
+    role?: "user" | "assistant" | string;
+}
+/**
+ * @internal
+ */
+export interface AppConversationLike {
+    id?: string | null;
+    messages?: AppMessageContent[] | null;
+    model?: string;
+    functions_fail_silently?: boolean;
+}
+/**
+ * @internal
+ */
+export interface DenoProjectLike {
+    project_id: string;
+    project_name: string;
+    app_id: string;
+    deployment_name_to_info: Record<string, {
+        id: string;
+        code: string;
+    }>;
+}
+/**
+ * @internal
+ */
+export interface AppLike {
+    id?: string;
+    conversation?: AppConversationLike | null;
+    app_stage?: "pending" | "product_flows" | "ready" | string;
+    created_date?: string;
+    updated_date?: string;
+    created_by?: string;
+    organization_id?: string;
+    name?: string;
+    user_description?: string;
+    entities?: Record<string, any>;
+    additional_user_data_schema?: any;
+    pages?: {
+        [key: string]: string;
+    };
+    components: {
+        [key: string]: any;
+    };
+    layout?: string;
+    globals_css?: string;
+    agents?: Record<string, any>;
+    logo_url?: string;
+    slug?: string;
+    public_settings?: "private_with_login" | "public_with_login" | "public_without_login" | "workspace_with_login" | string;
+    is_blocked?: boolean;
+    github_repo_url?: string;
+    main_page?: string;
+    installable_integrations?: any;
+    backend_project?: DenoProjectLike;
+    last_deployed_at?: string;
+    is_remixable?: boolean;
+    remixed_from_app_id?: string;
+    hide_entity_created_by?: boolean;
+    platform_version?: number;
+    enable_username_password?: boolean;
+    auth_config?: AuthConfigLike;
+    status?: {
+        state?: string;
+        details?: any;
+        last_updated_date?: string;
+    };
+    custom_instructions?: any;
+    frozen_files?: string[];
+    deep_coding_mode?: boolean;
+    needs_to_add_diff?: boolean;
+    installed_integration_context_items?: any[];
+    model?: string;
+    is_starred?: boolean;
+    agents_enabled?: boolean;
+    categories?: string[];
+    functions?: any;
+    function_names?: string[];
+    user_entity?: UserEntityLike;
+    app_code_hash?: string;
+    has_backend_functions_enabled?: boolean;
+}
+/**
+ * @internal
+ */
+export interface UserLike {
+    id?: string | null;
+}
+/**
+ * @internal
+ */
+export interface UserEntityLike {
+    type: string;
+    name: string;
+    title?: string;
+    properties?: {
+        role?: {
+            type?: string;
+            description?: string;
+            enum?: ("admin" | "user" | string)[];
+        };
+        email?: {
+            type?: string;
+            description?: string;
+        };
+        full_name?: {
+            type?: string;
+            description?: string;
+        };
+    };
+    required: string[];
+}
+/**
+ * @internal
+ */
+export interface AuthConfigLike {
+    enable_username_password?: boolean;
+    enable_google_login?: boolean;
+    enable_microsoft_login?: boolean;
+    enable_facebook_login?: boolean;
+    sso_provider_name?: string;
+    enable_sso_login?: boolean;
+}
+/**
+ * @internal
+ */
+export type LoginInfoResponse = Pick<AppLike, "id" | "name" | "slug" | "logo_url" | "user_description" | "updated_date" | "created_date" | "auth_config" | "platform_version">;

package/dist/modules/app.types.js

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

package/dist/modules/auth.d.ts

@@ -0,0 +1,13 @@
+import { AxiosInstance } from "axios";
+import { AuthModule, AuthModuleOptions } from "./auth.types";
+/**
+ * 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 declare function createAuthModule(axios: AxiosInstance, functionsAxiosClient: AxiosInstance, appId: string, options: AuthModuleOptions): AuthModule;

package/dist/modules/auth.js

@@ -0,0 +1,240 @@
+function isInsideIframe() {
+    if (typeof window === "undefined")
+        return false;
+    return window !== window.parent;
+}
+/**
+ * Opens a URL in a centered popup and waits for the backend to postMessage
+ * the auth result back. On success, redirects the current window to
+ * redirectUrl with the token params appended, preserving the same behaviour
+ * as a normal full-page redirect flow.
+ *
+ * @param url - The login URL to open in the popup (should include popup_origin).
+ * @param redirectUrl - Where to redirect after auth (the original fromUrl).
+ * @param expectedOrigin - The origin we expect the postMessage to come from.
+ */
+function loginViaPopup(url, redirectUrl, expectedOrigin) {
+    const width = 500;
+    const height = 600;
+    const left = Math.round(window.screenX + (window.outerWidth - width) / 2);
+    const top = Math.round(window.screenY + (window.outerHeight - height) / 2);
+    const popup = window.open(url, "base44_auth", `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes`);
+    if (!popup) {
+        return;
+    }
+    const cleanup = () => {
+        window.removeEventListener("message", onMessage);
+        clearInterval(pollTimer);
+        if (!popup.closed)
+            popup.close();
+    };
+    const onMessage = (event) => {
+        var _a;
+        if (event.origin !== expectedOrigin)
+            return;
+        if (event.source !== popup)
+            return;
+        if (!((_a = event.data) === null || _a === void 0 ? void 0 : _a.access_token))
+            return;
+        cleanup();
+        const callbackUrl = new URL(redirectUrl);
+        const { access_token, is_new_user } = event.data;
+        callbackUrl.searchParams.set("access_token", access_token);
+        if (is_new_user != null) {
+            callbackUrl.searchParams.set("is_new_user", String(is_new_user));
+        }
+        window.location.href = callbackUrl.toString();
+    };
+    // Only used to detect the user closing the popup before auth completes
+    const pollTimer = setInterval(() => {
+        if (popup.closed)
+            cleanup();
+    }, 500);
+    window.addEventListener("message", onMessage);
+}
+/**
+ * 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}`;
+            // When running inside an iframe, use a popup to avoid OAuth providers
+            // blocking iframe navigation.
+            if (isInsideIframe()) {
+                const popupLoginUrl = `${loginUrl}&popup_origin=${encodeURIComponent(window.location.origin)}`;
+                return loginViaPopup(popupLoginUrl, redirectUrl, window.location.origin);
+            }
+            // Default: full-page redirect
+            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,
+            });
+        },
+    };
+}