@doany-ai/sdk 0.1.0

package/dist/modules/functions.d.ts

@@ -0,0 +1,12 @@
+import { AxiosInstance } from "axios";
+import { FunctionsModule, FunctionsModuleConfig } from "./functions.types";
+/**
+ * Creates the functions module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @param config - Optional configuration for fetch functionality
+ * @returns Functions module with methods to invoke custom backend functions
+ * @internal
+ */
+export declare function createFunctionsModule(axios: AxiosInstance, appId: string, config?: FunctionsModuleConfig): FunctionsModule;

package/dist/modules/functions.js

@@ -0,0 +1,79 @@
+/**
+ * Creates the functions module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @param config - Optional configuration for fetch functionality
+ * @returns Functions module with methods to invoke custom backend functions
+ * @internal
+ */
+export function createFunctionsModule(axios, appId, config) {
+    const joinBaseUrl = (base, path) => {
+        if (!base)
+            return path;
+        return `${String(base).replace(/\/$/, "")}${path}`;
+    };
+    const toHeaders = (inputHeaders) => {
+        const headers = new Headers();
+        // Get auth headers from the getter function if provided
+        if (config === null || config === void 0 ? void 0 : config.getAuthHeaders) {
+            const authHeaders = config.getAuthHeaders();
+            Object.entries(authHeaders).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    headers.set(key, String(value));
+                }
+            });
+        }
+        if (inputHeaders) {
+            new Headers(inputHeaders).forEach((value, key) => {
+                headers.set(key, value);
+            });
+        }
+        return headers;
+    };
+    return {
+        // Invoke a custom backend function by name
+        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 } });
+        },
+        // Fetch a backend function endpoint directly.
+        async fetch(path, init = {}) {
+            const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+            const primaryPath = `/functions${normalizedPath}`;
+            const headers = toHeaders(init.headers);
+            const requestInit = {
+                ...init,
+                headers,
+            };
+            const response = await fetch(joinBaseUrl(config === null || config === void 0 ? void 0 : config.baseURL, primaryPath), requestInit);
+            return response;
+        },
+    };
+}

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

@@ -0,0 +1,150 @@
+/**
+ * Registry of function names. The [`types generate`](/developers/references/cli/commands/types-generate) command fills this registry, then [`FunctionName`](#functionname) resolves to a union of the keys.
+ */
+export interface FunctionNameRegistry {
+}
+/**
+ * Union of all function names from the [`FunctionNameRegistry`](#functionnameregistry). Defaults to `string` when no types have been generated.
+ *
+ * @example
+ * ```typescript
+ * // Using generated function name types
+ * // With generated types, you get autocomplete on function names
+ * await base44.functions.invoke('calculateTotal', { items: ['item1', 'item2'] });
+ * ```
+ */
+export type FunctionName = keyof FunctionNameRegistry extends never ? string : keyof FunctionNameRegistry;
+/**
+ * Options for {@linkcode FunctionsModule.fetch}.
+ *
+ * Alias of the native [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit) type.
+ * Any option accepted by the browser `fetch` API is valid (`method`, `headers`, `body`, `signal`, etc.).
+ * Auth headers are merged in automatically; you do not need to set them.
+ */
+export type FunctionsFetchInit = RequestInit;
+/**
+ * Configuration for the functions module.
+ * @internal
+ */
+export interface FunctionsModuleConfig {
+    getAuthHeaders?: () => Record<string, string>;
+    baseURL?: string;
+}
+/**
+ * Functions module for invoking custom backend functions.
+ *
+ * This module allows you to invoke the custom backend functions defined in the app.
+ *
+ * ## Authentication Modes
+ *
+ * This module is available to use with a client in all authentication modes:
+ *
+ * - **Anonymous or User authentication** (`base44.functions`): Functions are invoked with the current user's permissions. Anonymous users invoke functions without authentication, while authenticated users invoke functions with their authentication context.
+ * - **Service role authentication** (`base44.asServiceRole.functions`): Functions are invoked with the service role for backend code that needs elevated permissions.
+ *
+ * ## Generated Types
+ *
+ * If you're working in a TypeScript project, you can generate types from your backend functions to get autocomplete on function names when calling `invoke()`. See the [Dynamic Types](/developers/references/sdk/getting-started/dynamic-types) guide to get started.
+ */
+export interface FunctionsModule {
+    /**
+     * Invokes a custom backend function by name.
+     *
+     * Sends a POST request to a custom backend function deployed to the app.
+     * The function receives the provided data as named parameters and returns
+     * the result. If any parameter is a `File` object, the request will automatically be
+     * sent as `multipart/form-data`. Otherwise, it will be sent as JSON.
+     *
+     * For streaming responses, non-POST methods, or raw response access, use {@linkcode fetch | fetch()} instead.
+     *
+     * @param functionName - The name of the function to invoke.
+     * @param data - An object containing named parameters for the function.
+     * @returns Promise resolving to the function's response. The `data` property contains the data returned by the function, if there is any.
+     *
+     * @example
+     * ```typescript
+     * // Basic function call
+     * const result = await base44.functions.invoke('calculateTotal', {
+     *   items: ['item1', 'item2'],
+     * });
+     * console.log(result.data.total);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Function with file upload in React
+     * const handleFileUpload = async (event: React.ChangeEvent<HTMLInputElement>) => {
+     *   const file = event.target.files?.[0];
+     *   if (file) {
+     *     const processedImage = await base44.functions.invoke('processImage', {
+     *       image: file,
+     *       filter: 'grayscale',
+     *       quality: 80
+     *     });
+     *   }
+     * };
+     * ```
+     */
+    invoke(functionName: FunctionName, data?: Record<string, any>): Promise<any>;
+    /**
+     * Performs a direct HTTP request to a backend function path and returns the native `Response`.
+     *
+     * Use `fetch()` when you need low-level control that {@linkcode invoke | invoke()} doesn't provide, such as:
+     * - Streaming responses, like SSE, chunked text, or NDJSON
+     * - Custom HTTP methods, like PUT, PATCH, or DELETE
+     * - Raw response access, including status codes, headers, and binary bodies
+     *
+     * @param path - Function path. Leading slash is optional, so `/chat` and `chat` are equivalent. For example, `'/streaming_demo'` or `'reports/export'`.
+     * @param init - Optional [`RequestInit`](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit) options such as `method`, `headers`, `body`, and `signal`. Auth headers are added automatically.
+     * @returns Promise resolving to a native [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).
+     *
+     * @example
+     * ```typescript
+     * // Stream an SSE response
+     * const response = await base44.functions.fetch('/chat', {
+     *   method: 'POST',
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: JSON.stringify({ prompt: 'Hello!' }),
+     * });
+     *
+     * const reader = response.body!.getReader();
+     * const decoder = new TextDecoder();
+     *
+     * while (true) {
+     *   const { done, value } = await reader.read();
+     *   if (done) break;
+     *   console.log(decoder.decode(value, { stream: true }));
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // PUT request
+     * const response = await base44.functions.fetch('/users/profile', {
+     *   method: 'PUT',
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: JSON.stringify({ name: 'Jane', role: 'admin' }),
+     * });
+     *
+     * if (!response.ok) {
+     *   throw new Error(`Request failed: ${response.status}`);
+     * }
+     *
+     * const updated = await response.json();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Download a binary file
+     * const response = await base44.functions.fetch('/export/report');
+     * const blob = await response.blob();
+     *
+     * const url = URL.createObjectURL(blob);
+     * const a = document.createElement('a');
+     * a.href = url;
+     * a.download = 'report.pdf';
+     * a.click();
+     * ```
+     */
+    fetch(path: string, init?: FunctionsFetchInit): Promise<Response>;
+}

package/dist/modules/functions.types.js

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

package/dist/modules/integrations.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from "axios";
+import { IntegrationsModule } from "./integrations.types.js";
+/**
+ * Creates the integrations module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @returns Integrations module with dynamic access to integration endpoints
+ * @internal
+ */
+export declare function createIntegrationsModule(axios: AxiosInstance, appId: string): IntegrationsModule;

package/dist/modules/integrations.js

@@ -0,0 +1,77 @@
+import { createCustomIntegrationsModule } from "./custom-integrations.js";
+/**
+ * Creates the integrations module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @returns Integrations module with dynamic access to integration endpoints
+ * @internal
+ */
+export function createIntegrationsModule(axios, appId) {
+    // Create the custom integrations module once
+    const customModule = createCustomIntegrationsModule(axios, appId);
+    return new Proxy({}, {
+        get(target, packageName) {
+            // Skip internal properties
+            if (typeof packageName !== "string" ||
+                packageName === "then" ||
+                packageName.startsWith("_")) {
+                return undefined;
+            }
+            // Handle 'custom' specially - return the custom integrations module
+            if (packageName === "custom") {
+                return customModule;
+            }
+            // 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
+                    // This allows: client.integrations.PackageName.EndpointName(data)
+                    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 } });
+                    };
+                },
+            });
+        },
+    });
+}