@base44-preview/sdk 0.0.0-preview

package/dist/client.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Create a Base44 client instance
+ * @param {Object} config - Client configuration
+ * @param {string} [config.serverUrl='https://base44.app'] - API server URL
+ * @param {string|number} config.appId - Application ID
+ * @param {string} [config.env='prod'] - Environment ('prod' or 'dev')
+ * @param {string} [config.token] - Authentication token
+ * @param {boolean} [config.requiresAuth=false] - Whether the app requires authentication
+ * @returns {Object} Base44 client instance
+ */
+export declare function createClient(config: {
+    serverUrl?: string;
+    appId: string;
+    env?: string;
+    token?: string;
+    requiresAuth?: boolean;
+}): {
+    entities: {};
+    integrations: {};
+    auth: {
+        me(): Promise<import("axios").AxiosResponse<any, any>>;
+        getSsoAccessToken(): Promise<import("axios").AxiosResponse<any, any>>;
+        updateMe(data: Record<string, any>): Promise<import("axios").AxiosResponse<any, any>>;
+        redirectToLogin(nextUrl: string): void;
+        logout(redirectUrl?: string): void;
+        setToken(token: string, saveToStorage?: boolean): void;
+        loginViaUsernamePassword(email: string, password: string, turnstileToken?: string): Promise<{
+            access_token: string;
+            user: any;
+        }>;
+        isAuthenticated(): Promise<boolean>;
+    };
+    functions: {
+        invoke(functionName: string, data: Record<string, any>): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    /**
+     * Set authentication token for all requests
+     * @param {string} newToken - New auth token
+     */
+    setToken(newToken: string): void;
+    /**
+     * Get current configuration
+     * @returns {Object} Current configuration
+     */
+    getConfig(): {
+        serverUrl: string;
+        appId: string;
+        env: string;
+        requiresAuth: boolean;
+    };
+};

package/dist/client.js

@@ -0,0 +1,98 @@
+import { createAxiosClient } from "./utils/axios-client.js";
+import { createEntitiesModule } from "./modules/entities.js";
+import { createIntegrationsModule } from "./modules/integrations.js";
+import { createAuthModule } from "./modules/auth.js";
+import { getAccessToken } from "./utils/auth-utils.js";
+import { createFunctionsModule } from "./modules/functions.js";
+/**
+ * Create a Base44 client instance
+ * @param {Object} config - Client configuration
+ * @param {string} [config.serverUrl='https://base44.app'] - API server URL
+ * @param {string|number} config.appId - Application ID
+ * @param {string} [config.env='prod'] - Environment ('prod' or 'dev')
+ * @param {string} [config.token] - Authentication token
+ * @param {boolean} [config.requiresAuth=false] - Whether the app requires authentication
+ * @returns {Object} Base44 client instance
+ */
+export function createClient(config) {
+    const { serverUrl = "https://base44.app", appId, env = "prod", token, requiresAuth = false, } = config;
+    // Create the base axios client
+    const axiosClient = createAxiosClient({
+        baseURL: `${serverUrl}/api`,
+        headers: {
+            "X-App-Id": String(appId),
+            "X-Environment": env,
+        },
+        token,
+        requiresAuth, // Pass requiresAuth to axios client
+        appId, // Pass appId for login redirect
+        serverUrl, // Pass serverUrl for login redirect
+    });
+    const functionsAxiosClient = createAxiosClient({
+        baseURL: `${serverUrl}/api`,
+        headers: {
+            "X-App-Id": String(appId),
+            "X-Environment": env,
+        },
+        token,
+        requiresAuth,
+        appId,
+        serverUrl,
+        interceptResponses: false,
+    });
+    // Create modules
+    const entities = createEntitiesModule(axiosClient, appId);
+    const integrations = createIntegrationsModule(axiosClient, appId);
+    const auth = createAuthModule(axiosClient, appId, serverUrl);
+    const functions = createFunctionsModule(functionsAxiosClient, appId);
+    // Always try to get token from localStorage or URL parameters
+    if (typeof window !== "undefined") {
+        // Get token from URL or localStorage
+        const accessToken = token || getAccessToken();
+        if (accessToken) {
+            auth.setToken(accessToken);
+        }
+    }
+    // If authentication is required, verify token and redirect to login if needed
+    if (requiresAuth && typeof window !== "undefined") {
+        // We perform this check asynchronously to not block client creation
+        setTimeout(async () => {
+            try {
+                const isAuthenticated = await auth.isAuthenticated();
+                if (!isAuthenticated) {
+                    auth.redirectToLogin(window.location.href);
+                }
+            }
+            catch (error) {
+                console.error("Authentication check failed:", error);
+                auth.redirectToLogin(window.location.href);
+            }
+        }, 0);
+    }
+    // Assemble and return the client
+    return {
+        entities,
+        integrations,
+        auth,
+        functions,
+        /**
+         * Set authentication token for all requests
+         * @param {string} newToken - New auth token
+         */
+        setToken(newToken) {
+            auth.setToken(newToken);
+        },
+        /**
+         * Get current configuration
+         * @returns {Object} Current configuration
+         */
+        getConfig() {
+            return {
+                serverUrl,
+                appId,
+                env,
+                requiresAuth,
+            };
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { createClient } from "./client.js";
+import { Base44Error } from "./utils/axios-client.js";
+import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl } from "./utils/auth-utils.js";
+export { createClient, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };

package/dist/index.js

@@ -0,0 +1,6 @@
+import { createClient } from "./client.js";
+import { Base44Error } from "./utils/axios-client.js";
+import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, } from "./utils/auth-utils.js";
+export { createClient, Base44Error, 
+// Export auth utilities for easier access
+getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };

package/dist/modules/auth.d.ts

@@ -0,0 +1,61 @@
+import { AxiosInstance } from "axios";
+/**
+ * Creates the auth module for the Base44 SDK
+ * @param {import('axios').AxiosInstance} axios - Axios instance
+ * @param {string|number} appId - Application ID
+ * @param {string} serverUrl - Server URL
+ * @returns {Object} Auth module with authentication methods
+ */
+export declare function createAuthModule(axios: AxiosInstance, appId: string, serverUrl: string): {
+    /**
+     * Get current user information
+     * @returns {Promise<Object>} Current user data
+     */
+    me(): Promise<import("axios").AxiosResponse<any, any>>;
+    /**
+     * Get current user sso access token
+     * @returns {Promise<Object>} Current user sso access_token
+     */
+    getSsoAccessToken(): Promise<import("axios").AxiosResponse<any, any>>;
+    /**
+     * Update current user data
+     * @param {Object} data - Updated user data
+     * @returns {Promise<Object>} Updated user
+     */
+    updateMe(data: Record<string, any>): Promise<import("axios").AxiosResponse<any, any>>;
+    /**
+     * Redirects the user to the app's login page
+     * @param {string} nextUrl - URL to redirect to after successful login
+     * @throws {Error} When not in a browser environment
+     */
+    redirectToLogin(nextUrl: string): void;
+    /**
+     * Logout the current user
+     * Removes the token from localStorage and optionally redirects to a URL or reloads the page
+     * @param redirectUrl - Optional URL to redirect to after logout. Reloads the page if not provided
+     * @returns {Promise<void>}
+     */
+    logout(redirectUrl?: string): void;
+    /**
+     * Set authentication token
+     * @param {string} token - Auth token
+     * @param {boolean} [saveToStorage=true] - Whether to save the token to localStorage
+     */
+    setToken(token: string, saveToStorage?: boolean): void;
+    /**
+     * Login via username and password
+     * @param email - User email
+     * @param password - User password
+     * @param turnstileToken - Optional Turnstile captcha token
+     * @returns Login response with access_token and user
+     */
+    loginViaUsernamePassword(email: string, password: string, turnstileToken?: string): Promise<{
+        access_token: string;
+        user: any;
+    }>;
+    /**
+     * Verify if the current token is valid
+     * @returns {Promise<boolean>} True if token is valid
+     */
+    isAuthenticated(): Promise<boolean>;
+};

package/dist/modules/auth.js

@@ -0,0 +1,144 @@
+/**
+ * Creates the auth module for the Base44 SDK
+ * @param {import('axios').AxiosInstance} axios - Axios instance
+ * @param {string|number} appId - Application ID
+ * @param {string} serverUrl - Server URL
+ * @returns {Object} Auth module with authentication methods
+ */
+export function createAuthModule(axios, appId, serverUrl) {
+    return {
+        /**
+         * Get current user information
+         * @returns {Promise<Object>} Current user data
+         */
+        async me() {
+            return axios.get(`/apps/${appId}/entities/User/me`);
+        },
+        /**
+         * Get current user sso access token
+         * @returns {Promise<Object>} Current user sso access_token
+         */
+        async getSsoAccessToken() {
+            return axios.get(`/apps/${appId}/auth/sso/accesstoken`);
+        },
+        /**
+         * Update current user data
+         * @param {Object} data - Updated user data
+         * @returns {Promise<Object>} Updated user
+         */
+        async updateMe(data) {
+            return axios.put(`/apps/${appId}/entities/User/me`, data);
+        },
+        /**
+         * Redirects the user to the app's login page
+         * @param {string} nextUrl - URL to redirect to after successful login
+         * @throws {Error} When not in a browser environment
+         */
+        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 || window.location.href;
+            // Build the login URL
+            const loginUrl = `/login?from_url=${encodeURIComponent(redirectUrl)}`;
+            // Redirect to the login page
+            window.location.href = loginUrl;
+        },
+        /**
+         * Logout the current user
+         * Removes the token from localStorage and optionally redirects to a URL or reloads the page
+         * @param redirectUrl - Optional URL to redirect to after logout. Reloads the page if not provided
+         * @returns {Promise<void>}
+         */
+        logout(redirectUrl) {
+            // Remove token from axios headers
+            delete axios.defaults.headers.common["Authorization"];
+            // Remove token from localStorage
+            if (typeof window !== "undefined" && window.localStorage) {
+                try {
+                    window.localStorage.removeItem("base44_access_token");
+                }
+                catch (e) {
+                    console.error("Failed to remove token from localStorage:", e);
+                }
+            }
+            // Redirect if a URL is provided
+            if (typeof window !== "undefined") {
+                if (redirectUrl) {
+                    window.location.href = redirectUrl;
+                }
+                else {
+                    window.location.reload();
+                }
+            }
+        },
+        /**
+         * Set authentication token
+         * @param {string} token - Auth token
+         * @param {boolean} [saveToStorage=true] - Whether to save the token to localStorage
+         */
+        setToken(token, saveToStorage = true) {
+            if (!token)
+                return;
+            axios.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);
+                }
+                catch (e) {
+                    console.error("Failed to save token to localStorage:", e);
+                }
+            }
+        },
+        /**
+         * Login via username and password
+         * @param email - User email
+         * @param password - User password
+         * @param turnstileToken - Optional Turnstile captcha token
+         * @returns Login response with access_token and user
+         */
+        async loginViaUsernamePassword(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
+         * @returns {Promise<boolean>} True if token is valid
+         */
+        async isAuthenticated() {
+            try {
+                await this.me();
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        },
+    };
+}

package/dist/modules/entities.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from "axios";
+/**
+ * Creates the entities module for the Base44 SDK
+ * @param {import('axios').AxiosInstance} axios - Axios instance
+ * @param {string|number} appId - Application ID
+ * @returns {Object} Entities module
+ */
+export declare function createEntitiesModule(axios: AxiosInstance, appId: string): {};

package/dist/modules/entities.js

@@ -0,0 +1,139 @@
+/**
+ * Creates the entities module for the Base44 SDK
+ * @param {import('axios').AxiosInstance} axios - Axios instance
+ * @param {string|number} appId - Application ID
+ * @returns {Object} Entities module
+ */
+export function createEntitiesModule(axios, appId) {
+    // Using Proxy to dynamically handle entity names
+    return new Proxy({}, {
+        get(target, entityName) {
+            // Don't create handlers for internal properties
+            if (typeof entityName !== "string" ||
+                entityName === "then" ||
+                entityName.startsWith("_")) {
+                return undefined;
+            }
+            // Create entity handler
+            return createEntityHandler(axios, appId, entityName);
+        },
+    });
+}
+/**
+ * Creates a handler for a specific entity
+ * @param {import('axios').AxiosInstance} axios - Axios instance
+ * @param {string|number} appId - Application ID
+ * @param {string} entityName - Entity name
+ * @returns {Object} Entity handler with CRUD methods
+ */
+function createEntityHandler(axios, appId, entityName) {
+    const baseURL = `/apps/${appId}/entities/${entityName}`;
+    return {
+        /**
+         * List entities with optional pagination and sorting
+         * @param {string} [sort] - Sort parameter
+         * @param {number} [limit] - Limit results
+         * @param {number} [skip] - Skip results (pagination)
+         * @param {string[]} [fields] - Fields to include
+         * @returns {Promise<Array>} List of entities
+         */
+        async list(sort, limit, skip, fields) {
+            const params = {};
+            if (sort)
+                params.sort = sort;
+            if (limit)
+                params.limit = limit;
+            if (skip)
+                params.skip = skip;
+            if (fields)
+                params.fields = Array.isArray(fields) ? fields.join(",") : fields;
+            return axios.get(baseURL, { params });
+        },
+        /**
+         * Filter entities based on query
+         * @param {Object} query - Filter query
+         * @param {string} [sort] - Sort parameter
+         * @param {number} [limit] - Limit results
+         * @param {number} [skip] - Skip results (pagination)
+         * @param {string[]} [fields] - Fields to include
+         * @returns {Promise<Array>} Filtered entities
+         */
+        async filter(query, sort, limit, skip, fields) {
+            const params = {
+                q: JSON.stringify(query),
+            };
+            if (sort)
+                params.sort = sort;
+            if (limit)
+                params.limit = limit;
+            if (skip)
+                params.skip = skip;
+            if (fields)
+                params.fields = Array.isArray(fields) ? fields.join(",") : fields;
+            return axios.get(baseURL, { params });
+        },
+        /**
+         * Get entity by ID
+         * @param {string} id - Entity ID
+         * @returns {Promise<Object>} Entity
+         */
+        async get(id) {
+            return axios.get(`${baseURL}/${id}`);
+        },
+        /**
+         * Create new entity
+         * @param {Object} data - Entity data
+         * @returns {Promise<Object>} Created entity
+         */
+        async create(data) {
+            return axios.post(baseURL, data);
+        },
+        /**
+         * Update entity by ID
+         * @param {string} id - Entity ID
+         * @param {Object} data - Updated entity data
+         * @returns {Promise<Object>} Updated entity
+         */
+        async update(id, data) {
+            return axios.put(`${baseURL}/${id}`, data);
+        },
+        /**
+         * Delete entity by ID
+         * @param {string} id - Entity ID
+         * @returns {Promise<void>}
+         */
+        async delete(id) {
+            return axios.delete(`${baseURL}/${id}`);
+        },
+        /**
+         * Delete multiple entities based on query
+         * @param {Object} query - Delete query
+         * @returns {Promise<void>}
+         */
+        async deleteMany(query) {
+            return axios.delete(baseURL, { data: query });
+        },
+        /**
+         * Create multiple entities in a single request
+         * @param {Array} data - Array of entity data
+         * @returns {Promise<Array>} Created entities
+         */
+        async bulkCreate(data) {
+            return axios.post(`${baseURL}/bulk`, data);
+        },
+        /**
+         * Import entities from a file
+         * @param {File} file - File to import
+         * @returns {Promise<Object>} Import result
+         */
+        async importEntities(file) {
+            const formData = new FormData();
+            formData.append("file", file, file.name);
+            return axios.post(`${baseURL}/import`, formData, {
+                headers: {
+                    "Content-Type": "multipart/form-data",
+                },
+            });
+        },
+    };
+}

package/dist/modules/functions.d.ts

@@ -0,0 +1,10 @@
+import { AxiosInstance } from "axios";
+/**
+ * Creates the functions module for the Base44 SDK
+ * @param {import('axios').AxiosInstance} axios - Axios instance
+ * @param {string|number} appId - Application ID
+ * @returns {Object} Functions module
+ */
+export declare function createFunctionsModule(axios: AxiosInstance, appId: string): {
+    invoke(functionName: string, data: Record<string, any>): Promise<import("axios").AxiosResponse<any, any>>;
+};

package/dist/modules/functions.js

@@ -0,0 +1,41 @@
+/**
+ * Creates the functions module for the Base44 SDK
+ * @param {import('axios').AxiosInstance} axios - Axios instance
+ * @param {string|number} appId - Application ID
+ * @returns {Object} Functions module
+ */
+export function createFunctionsModule(axios, appId) {
+    // Using nested Proxy objects to handle dynamic function names
+    return {
+        async invoke(functionName, data) {
+            // Validate input
+            if (typeof data === "string") {
+                throw new Error(`Function ${functionName} must receive an object with named parameters, received: ${data}`);
+            }
+            let formData;
+            let contentType;
+            // Handle file uploads with FormData
+            if (data instanceof FormData ||
+                (data && Object.values(data).some((value) => value instanceof File))) {
+                formData = new FormData();
+                Object.keys(data).forEach((key) => {
+                    if (data[key] instanceof File) {
+                        formData.append(key, data[key], data[key].name);
+                    }
+                    else if (typeof data[key] === "object" && data[key] !== null) {
+                        formData.append(key, JSON.stringify(data[key]));
+                    }
+                    else {
+                        formData.append(key, data[key]);
+                    }
+                });
+                contentType = "multipart/form-data";
+            }
+            else {
+                formData = data;
+                contentType = "application/json";
+            }
+            return axios.post(`/apps/${appId}/functions/${functionName}`, formData || data, { headers: { "Content-Type": contentType } });
+        },
+    };
+}

package/dist/modules/integrations.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from "axios";
+/**
+ * Creates the integrations module for the Base44 SDK
+ * @param {import('axios').AxiosInstance} axios - Axios instance
+ * @param {string|number} appId - Application ID
+ * @returns {Object} Integrations module
+ */
+export declare function createIntegrationsModule(axios: AxiosInstance, appId: string): {};

package/dist/modules/integrations.js

@@ -0,0 +1,68 @@
+/**
+ * Creates the integrations module for the Base44 SDK
+ * @param {import('axios').AxiosInstance} axios - Axios instance
+ * @param {string|number} appId - Application ID
+ * @returns {Object} Integrations module
+ */
+export function createIntegrationsModule(axios, appId) {
+    // Using nested Proxy objects to handle dynamic package and endpoint names
+    return new Proxy({}, {
+        get(target, packageName) {
+            // Skip internal properties
+            if (typeof packageName !== "string" ||
+                packageName === "then" ||
+                packageName.startsWith("_")) {
+                return undefined;
+            }
+            // Create a proxy for integration endpoints
+            return new Proxy({}, {
+                get(target, endpointName) {
+                    // Skip internal properties
+                    if (typeof endpointName !== "string" ||
+                        endpointName === "then" ||
+                        endpointName.startsWith("_")) {
+                        return undefined;
+                    }
+                    // Return a function that calls the integration endpoint
+                    return async (data) => {
+                        // Validate input
+                        if (typeof data === "string") {
+                            throw new Error(`Integration ${endpointName} must receive an object with named parameters, received: ${data}`);
+                        }
+                        let formData;
+                        let contentType;
+                        // Handle file uploads with FormData
+                        if (data instanceof FormData ||
+                            (data &&
+                                Object.values(data).some((value) => value instanceof File))) {
+                            formData = new FormData();
+                            Object.keys(data).forEach((key) => {
+                                if (data[key] instanceof File) {
+                                    formData.append(key, data[key], data[key].name);
+                                }
+                                else if (typeof data[key] === "object" &&
+                                    data[key] !== null) {
+                                    formData.append(key, JSON.stringify(data[key]));
+                                }
+                                else {
+                                    formData.append(key, data[key]);
+                                }
+                            });
+                            contentType = "multipart/form-data";
+                        }
+                        else {
+                            formData = data;
+                            contentType = "application/json";
+                        }
+                        // For Core package
+                        if (packageName === "Core") {
+                            return axios.post(`/apps/${appId}/integration-endpoints/Core/${endpointName}`, formData || data, { headers: { "Content-Type": contentType } });
+                        }
+                        // For other packages
+                        return axios.post(`/apps/${appId}/integration-endpoints/installable/${packageName}/integration-endpoints/${endpointName}`, formData || data, { headers: { "Content-Type": contentType } });
+                    };
+                },
+            });
+        },
+    });
+}

package/dist/utils/auth-utils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Utility functions for authentication and token handling
+ */
+/**
+ * Retrieves an access token from either localStorage or URL parameters
+ *
+ * @param {Object} options - Configuration options
+ * @param {string} [options.storageKey='base44_access_token'] - The key to use in localStorage
+ * @param {string} [options.paramName='access_token'] - The URL parameter name
+ * @param {boolean} [options.saveToStorage=true] - Whether to save the token to localStorage if found in URL
+ * @param {boolean} [options.removeFromUrl=true] - Whether to remove the token from URL after retrieval
+ * @returns {string|null} The access token or null if not found
+ */
+export declare function getAccessToken(options?: {
+    storageKey?: string;
+    paramName?: string;
+    saveToStorage?: boolean;
+    removeFromUrl?: boolean;
+}): string | null;
+/**
+ * Saves an access token to localStorage
+ *
+ * @param {string} token - The access token to save
+ * @param {Object} options - Configuration options
+ * @param {string} [options.storageKey='base44_access_token'] - The key to use in localStorage
+ * @returns {boolean} Success status
+ */
+export declare function saveAccessToken(token: string, options: {
+    storageKey?: string;
+}): boolean;
+/**
+ * Removes the access token from localStorage
+ *
+ * @param {Object} options - Configuration options
+ * @param {string} [options.storageKey='base44_access_token'] - The key to use in localStorage
+ * @returns {boolean} Success status
+ */
+export declare function removeAccessToken(options: {
+    storageKey?: string;
+}): boolean;
+/**
+ * Constructs the absolute URL for the login page
+ *
+ * @param {string} nextUrl - URL to redirect back to after login
+ * @param {Object} options - Configuration options
+ * @param {string} options.serverUrl - Server URL (e.g., 'https://base44.app')
+ * @param {string|number} options.appId - Application ID
+ * @param {string} [options.loginPath='/login'] - Path to the login endpoint
+ * @returns {string} The complete login URL
+ */
+export declare function getLoginUrl(nextUrl: string, options: {
+    serverUrl: string;
+    appId: string;
+    loginPath?: string;
+}): string;

package/dist/utils/auth-utils.js

@@ -0,0 +1,113 @@
+/**
+ * Utility functions for authentication and token handling
+ */
+/**
+ * Retrieves an access token from either localStorage or URL parameters
+ *
+ * @param {Object} options - Configuration options
+ * @param {string} [options.storageKey='base44_access_token'] - The key to use in localStorage
+ * @param {string} [options.paramName='access_token'] - The URL parameter name
+ * @param {boolean} [options.saveToStorage=true] - Whether to save the token to localStorage if found in URL
+ * @param {boolean} [options.removeFromUrl=true] - Whether to remove the token from URL after retrieval
+ * @returns {string|null} The access token or null if not found
+ */
+export function getAccessToken(options = {}) {
+    const { storageKey = "base44_access_token", paramName = "access_token", saveToStorage = true, removeFromUrl = true, } = options;
+    let token = null;
+    // Try to get token from URL parameters
+    if (typeof window !== "undefined" && window.location) {
+        try {
+            const urlParams = new URLSearchParams(window.location.search);
+            token = urlParams.get(paramName);
+            // If token found in URL
+            if (token) {
+                // Save token to localStorage if requested
+                if (saveToStorage) {
+                    saveAccessToken(token, { storageKey });
+                }
+                // Remove token from URL for security if requested
+                if (removeFromUrl) {
+                    urlParams.delete(paramName);
+                    const newUrl = `${window.location.pathname}${urlParams.toString() ? `?${urlParams.toString()}` : ""}${window.location.hash}`;
+                    window.history.replaceState({}, document.title, newUrl);
+                }
+                return token;
+            }
+        }
+        catch (e) {
+            console.error("Error retrieving token from URL:", e);
+        }
+    }
+    // If no token in URL, try localStorage
+    if (typeof window !== "undefined" && window.localStorage) {
+        try {
+            token = window.localStorage.getItem(storageKey);
+            return token;
+        }
+        catch (e) {
+            console.error("Error retrieving token from localStorage:", e);
+        }
+    }
+    return null;
+}
+/**
+ * Saves an access token to localStorage
+ *
+ * @param {string} token - The access token to save
+ * @param {Object} options - Configuration options
+ * @param {string} [options.storageKey='base44_access_token'] - The key to use in localStorage
+ * @returns {boolean} Success status
+ */
+export function saveAccessToken(token, options) {
+    const { storageKey = "base44_access_token" } = options;
+    if (typeof window === "undefined" || !window.localStorage || !token) {
+        return false;
+    }
+    try {
+        window.localStorage.setItem(storageKey, token);
+        return true;
+    }
+    catch (e) {
+        console.error("Error saving token to localStorage:", e);
+        return false;
+    }
+}
+/**
+ * Removes the access token from localStorage
+ *
+ * @param {Object} options - Configuration options
+ * @param {string} [options.storageKey='base44_access_token'] - The key to use in localStorage
+ * @returns {boolean} Success status
+ */
+export function removeAccessToken(options) {
+    const { storageKey = "base44_access_token" } = options;
+    if (typeof window === "undefined" || !window.localStorage) {
+        return false;
+    }
+    try {
+        window.localStorage.removeItem(storageKey);
+        return true;
+    }
+    catch (e) {
+        console.error("Error removing token from localStorage:", e);
+        return false;
+    }
+}
+/**
+ * Constructs the absolute URL for the login page
+ *
+ * @param {string} nextUrl - URL to redirect back to after login
+ * @param {Object} options - Configuration options
+ * @param {string} options.serverUrl - Server URL (e.g., 'https://base44.app')
+ * @param {string|number} options.appId - Application ID
+ * @param {string} [options.loginPath='/login'] - Path to the login endpoint
+ * @returns {string} The complete login URL
+ */
+export function getLoginUrl(nextUrl, options) {
+    const { serverUrl, appId, loginPath = "/login" } = options;
+    if (!serverUrl || !appId) {
+        throw new Error("serverUrl and appId are required to construct login URL");
+    }
+    const encodedRedirectUrl = encodeURIComponent(nextUrl || (typeof window !== "undefined" ? window.location.href : ""));
+    return `${serverUrl}${loginPath}?from_url=${encodedRedirectUrl}&app_id=${appId}`;
+}

package/dist/utils/axios-client.d.ts

@@ -0,0 +1,34 @@
+export declare class Base44Error extends Error {
+    status: number;
+    code: string;
+    data: any;
+    originalError: unknown;
+    constructor(message: string, status: number, code: string, data: any, originalError: unknown);
+    toJSON(): {
+        name: string;
+        message: string;
+        status: number;
+        code: string;
+        data: any;
+    };
+}
+/**
+ * Creates an axios client with default configuration and interceptors
+ * @param {Object} options - Client configuration options
+ * @param {string} options.baseURL - Base URL for all requests
+ * @param {Object} options.headers - Additional headers
+ * @param {string} options.token - Auth token
+ * @param {boolean} options.requiresAuth - Whether the application requires authentication
+ * @param {string|number} options.appId - Application ID (needed for login redirect)
+ * @param {string} options.serverUrl - Server URL (needed for login redirect)
+ * @returns {import('axios').AxiosInstance} Configured axios instance
+ */
+export declare function createAxiosClient({ baseURL, headers, token, requiresAuth, appId, serverUrl, interceptResponses, }: {
+    baseURL: string;
+    headers?: Record<string, string>;
+    token?: string;
+    requiresAuth?: boolean;
+    appId: string;
+    serverUrl: string;
+    interceptResponses?: boolean;
+}): import("axios").AxiosInstance;

package/dist/utils/axios-client.js

@@ -0,0 +1,114 @@
+import axios from "axios";
+export class Base44Error extends Error {
+    constructor(message, status, code, data, originalError) {
+        super(message);
+        this.name = "Base44Error";
+        this.status = status;
+        this.code = code;
+        this.data = data;
+        this.originalError = originalError;
+    }
+    // Add a method to safely serialize this error without circular references
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            status: this.status,
+            code: this.code,
+            data: this.data,
+        };
+    }
+}
+/**
+ * Safely logs error information without circular references
+ * @param {string} prefix - Prefix for the log message
+ * @param {Error} error - The error to log
+ */
+function safeErrorLog(prefix, error) {
+    if (error instanceof Base44Error) {
+        console.error(`${prefix} ${error.status}: ${error.message}`);
+        if (error.data) {
+            try {
+                console.error("Error data:", JSON.stringify(error.data, null, 2));
+            }
+            catch (e) {
+                console.error("Error data: [Cannot stringify error data]");
+            }
+        }
+    }
+    else {
+        console.error(`${prefix} ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Redirects to the login page with the current URL as return destination
+ * @param {string} serverUrl - Base server URL
+ * @param {string|number} appId - Application ID
+ */
+function redirectToLogin(serverUrl, appId) {
+    if (typeof window === "undefined") {
+        return; // Can't redirect in non-browser environment
+    }
+    const currentUrl = encodeURIComponent(window.location.href);
+    const loginUrl = `${serverUrl}/login?from_url=${currentUrl}&app_id=${appId}`;
+    window.location.href = loginUrl;
+}
+/**
+ * Creates an axios client with default configuration and interceptors
+ * @param {Object} options - Client configuration options
+ * @param {string} options.baseURL - Base URL for all requests
+ * @param {Object} options.headers - Additional headers
+ * @param {string} options.token - Auth token
+ * @param {boolean} options.requiresAuth - Whether the application requires authentication
+ * @param {string|number} options.appId - Application ID (needed for login redirect)
+ * @param {string} options.serverUrl - Server URL (needed for login redirect)
+ * @returns {import('axios').AxiosInstance} Configured axios instance
+ */
+export function createAxiosClient({ baseURL, headers = {}, token, requiresAuth = false, appId, serverUrl, interceptResponses = true, }) {
+    const client = axios.create({
+        baseURL,
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...headers,
+        },
+    });
+    // Add token to requests if available
+    if (token) {
+        client.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+    }
+    // Add origin URL in browser environment
+    client.interceptors.request.use((config) => {
+        if (typeof window !== "undefined") {
+            config.headers.set("X-Origin-URL", window.location.href);
+        }
+        return config;
+    });
+    // Handle responses
+    if (interceptResponses) {
+        client.interceptors.response.use((response) => response.data, (error) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            const message = ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) ||
+                ((_d = (_c = error.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.detail) ||
+                error.message;
+            const base44Error = new Base44Error(message, (_e = error.response) === null || _e === void 0 ? void 0 : _e.status, (_g = (_f = error.response) === null || _f === void 0 ? void 0 : _f.data) === null || _g === void 0 ? void 0 : _g.code, (_h = error.response) === null || _h === void 0 ? void 0 : _h.data, error);
+            // Log errors in development
+            if (process.env.NODE_ENV !== "production") {
+                safeErrorLog("[Base44 SDK Error]", base44Error);
+            }
+            // Check for 403 Forbidden (authentication required) and redirect to login if requiresAuth is true
+            console.log(requiresAuth, (_j = error.response) === null || _j === void 0 ? void 0 : _j.status, typeof window !== "undefined");
+            if (requiresAuth &&
+                ((_k = error.response) === null || _k === void 0 ? void 0 : _k.status) === 403 &&
+                typeof window !== "undefined") {
+                console.log("Authentication required. Redirecting to login...");
+                // Use a slight delay to allow the error to propagate first
+                setTimeout(() => {
+                    redirectToLogin(serverUrl, appId);
+                }, 100);
+            }
+            return Promise.reject(base44Error);
+        });
+    }
+    return client;
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@base44-preview/sdk",
+  "version": "0.0.0-preview",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist",
+    "!README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint src",
+    "test": "vitest run",
+    "test:unit": "vitest run tests/unit",
+    "test:e2e": "vitest run tests/e2e",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "axios": "^1.6.2"
+  },
+  "devDependencies": {
+    "vitest": "^1.0.0",
+    "@vitest/ui": "^1.0.0",
+    "@vitest/coverage-istanbul": "^1.0.0",
+    "@vitest/coverage-v8": "^1.0.0",
+    "dotenv": "^16.3.1",
+    "eslint": "^8.54.0",
+    "nock": "^13.4.0",
+    "typescript": "^5.3.2"
+  },
+  "keywords": [
+    "api",
+    "sdk"
+  ],
+  "license": "MIT"
+}