@base44-preview/sdk 0.8.20-pr.144.69d591d → 0.8.20-pr.146.0ca6206

package/dist/client.js

@@ -49,6 +49,7 @@ import { createAnalyticsModule } from "./modules/analytics.js";
  * ```
  */
 export function createClient(config) {
+    var _a, _b;
     const { serverUrl = "https://base44.app", appId, token, serviceToken, requiresAuth = false, appBaseUrl, options, functionsVersion, headers: optionalHeaders, } = config;
     // Normalize appBaseUrl to always be a string (empty if not provided or invalid)
     const normalizedAppBaseUrl = typeof appBaseUrl === "string" ? appBaseUrl : "";
@@ -115,7 +116,18 @@ export function createClient(config) {
         }),
         integrations: createIntegrationsModule(axiosClient, appId),
         auth: userAuthModule,
-        functions: createFunctionsModule(functionsAxiosClient, appId),
+        functions: createFunctionsModule(functionsAxiosClient, appId, {
+            getAuthHeaders: () => {
+                const headers = {};
+                // Get current token from storage or initial config
+                const currentToken = token || getAccessToken();
+                if (currentToken) {
+                    headers["Authorization"] = `Bearer ${currentToken}`;
+                }
+                return headers;
+            },
+            baseURL: (_a = functionsAxiosClient.defaults) === null || _a === void 0 ? void 0 : _a.baseURL,
+        }),
         agents: createAgentsModule({
             axios: axiosClient,
             getSocket,
@@ -147,7 +159,17 @@ export function createClient(config) {
         integrations: createIntegrationsModule(serviceRoleAxiosClient, appId),
         sso: createSsoModule(serviceRoleAxiosClient, appId, token),
         connectors: createConnectorsModule(serviceRoleAxiosClient, appId),
-        functions: createFunctionsModule(serviceRoleFunctionsAxiosClient, appId),
+        functions: createFunctionsModule(serviceRoleFunctionsAxiosClient, appId, {
+            getAuthHeaders: () => {
+                const headers = {};
+                // Use service token for authorization
+                if (serviceToken) {
+                    headers["Authorization"] = `Bearer ${serviceToken}`;
+                }
+                return headers;
+            },
+            baseURL: (_b = serviceRoleFunctionsAxiosClient.defaults) === null || _b === void 0 ? void 0 : _b.baseURL,
+        }),
         agents: createAgentsModule({
             axios: serviceRoleAxiosClient,
             getSocket,

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl } from
 export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
 export type { Base44Client, CreateClientConfig, CreateClientOptions, Base44ErrorJSON, };
 export * from "./types.js";
-export type { DeleteManyResult, DeleteResult, EntitiesModule, EntityHandler, EntityRecord, EntityTypeRegistry, ImportResult, RealtimeEventType, RealtimeEvent, RealtimeCallback, SortField, UpdateManyResult, } from "./modules/entities.types.js";
+export type { DeleteManyResult, DeleteResult, EntitiesModule, EntityHandler, EntityRecord, EntityTypeRegistry, ImportResult, RealtimeEventType, RealtimeEvent, RealtimeCallback, SortField, } from "./modules/entities.types.js";
 export type { AuthModule, LoginResponse, RegisterParams, VerifyOtpParams, ChangePasswordParams, ResetPasswordParams, User, } from "./modules/auth.types.js";
 export type { IntegrationsModule, IntegrationEndpointFunction, CoreIntegrations, InvokeLLMParams, GenerateImageParams, GenerateImageResult, UploadFileParams, UploadFileResult, SendEmailParams, SendEmailResult, ExtractDataFromUploadedFileParams, ExtractDataFromUploadedFileResult, UploadPrivateFileParams, UploadPrivateFileResult, CreateFileSignedUrlParams, CreateFileSignedUrlResult, } from "./modules/integrations.types.js";
 export type { FunctionsModule, FunctionName, FunctionNameRegistry, } from "./modules/functions.types.js";

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

@@ -48,42 +48,30 @@ export interface ConnectorConnectionResponse {
  *
  * | Service | Type identifier |
  * |---|---|
- * | Airtable | `airtable` |
  * | Box | `box` |
  * | ClickUp | `clickup` |
  * | Discord | `discord` |
- * | Dropbox | `dropbox` |
  * | GitHub | `github` |
  * | Gmail | `gmail` |
  * | Google Analytics | `google_analytics` |
  * | Google BigQuery | `googlebigquery` |
  * | Google Calendar | `googlecalendar` |
- * | Google Classroom | `google_classroom` |
  * | Google Docs | `googledocs` |
  * | Google Drive | `googledrive` |
- * | Google Search Console | `google_search_console` |
  * | Google Sheets | `googlesheets` |
  * | Google Slides | `googleslides` |
  * | HubSpot | `hubspot` |
- * | Linear | `linear` |
  * | LinkedIn | `linkedin` |
- * | Microsoft Teams | `microsoft_teams` |
- * | Microsoft OneDrive | `one_drive` |
  * | Notion | `notion` |
- * | Outlook | `outlook` |
  * | Salesforce | `salesforce` |
- * | SharePoint | `share_point` |
  * | Slack User | `slack` |
  * | Slack Bot | `slackbot` |
- * | Splitwise | `splitwise` |
  * | TikTok | `tiktok` |
- * | Typeform | `typeform` |
- * | Wix | `wix` |
  * | Wrike | `wrike` |
  *
  * See the integration guides for more details:
  *
- * - **Scopes and permissions**: {@link https://docs.base44.com/Integrations/gmail-connector#gmail-scopes-and-permissions | Gmail}, {@link https://docs.base44.com/Integrations/linkedin-connector#linkedin-scopes-and-permissions | LinkedIn}, {@link https://docs.base44.com/Integrations/slack-connector#slack-scopes-and-permissions | Slack}, {@link https://docs.base44.com/Integrations/github-connector#github-scopes-and-permissions | GitHub}
+ * - **Scopes and permissions**: {@link https://docs.base44.com/Integrations/gmail-connector#gmail-scopes-and-permissions | Gmail}, {@link https://docs.base44.com/Integrations/linkedin-connector#linkedin-scopes-and-permissions | LinkedIn}, {@link https://docs.base44.com/Integrations/slack-connector#slack-scopes-and-permissions | Slack}
  * - **Slack connector types**: {@link https://docs.base44.com/Integrations/slack-connector#about-the-slack-connectors | About the Slack connectors} explains the difference between `slack` and `slackbot`
  *
  * ## Authentication Modes

package/dist/modules/entities.js

@@ -106,14 +106,6 @@ function createEntityHandler(axios, appId, entityName, getSocket) {
         async bulkCreate(data) {
             return axios.post(`${baseURL}/bulk`, data);
         },
-        // Update multiple entities matching a query using a MongoDB update operator
-        async updateMany(query, data) {
-            return axios.patch(`${baseURL}/update-many`, { query, data });
-        },
-        // Update multiple entities by ID, each with its own update data
-        async bulkUpdate(data) {
-            return axios.put(`${baseURL}/bulk`, data);
-        },
         // Import entities from a file
         async importEntities(file) {
             const formData = new FormData();

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

@@ -39,17 +39,6 @@ export interface DeleteManyResult {
     /** Number of entities that were deleted. */
     deleted: number;
 }
-/**
- * Result returned when updating multiple entities using a query.
- */
-export interface UpdateManyResult {
-    /** Whether the operation was successful. */
-    success: boolean;
-    /** Number of entities that were updated. */
-    updated: number;
-    /** Whether there are more entities matching the query that were not updated in this batch. When `true`, call `updateMany` again with the same query to update the next batch. */
-    has_more: boolean;
-}
 /**
  * Result returned when importing entities from a file.
  *
@@ -279,11 +268,6 @@ export interface EntityHandler<T = any> {
      * Updates a record by ID with the provided data. Only the fields
      * included in the data object will be updated.
      *
-     * To update a single record by ID, use this method. To apply the same
-     * update to many records matching a query, use {@linkcode updateMany | updateMany()}.
-     * To update multiple specific records with different data each, use
-     * {@linkcode bulkUpdate | bulkUpdate()}.
-     *
      * @param id - The unique identifier of the record to update.
      * @param data - Object containing the fields to update.
      * @returns Promise resolving to the updated record.
@@ -364,122 +348,6 @@ export interface EntityHandler<T = any> {
      * ```
      */
     bulkCreate(data: Partial<T>[]): Promise<T[]>;
-    /**
-     * Applies the same update to all records that match a query.
-     *
-     * Use this when you need to make the same change across all records that
-     * match specific criteria. For example, you could set every completed order
-     * to "archived", or increment a counter on all active users.
-     *
-     * Results are batched in groups of up to 500. When `has_more` is `true`
-     * in the response, call `updateMany` again with the same query to update
-     * the next batch.
-     *
-     * To update a single record by ID, use {@linkcode update | update()} instead. To update
-     * multiple specific records with different data each, use {@linkcode bulkUpdate | bulkUpdate()}.
-     *
-     * @param query - Query object to filter which records to update. Use field-value
-     * pairs for exact matches, or
-     * [MongoDB query operators](https://www.mongodb.com/docs/manual/reference/operator/query/)
-     * for advanced filtering. Supported query operators include `$eq`, `$ne`, `$gt`,
-     * `$gte`, `$lt`, `$lte`, `$in`, `$nin`, `$and`, `$or`, `$not`, `$nor`,
-     * `$exists`, `$regex`, `$all`, `$elemMatch`, and `$size`.
-     * @param data - Update operation object containing one or more
-     * [MongoDB update operators](https://www.mongodb.com/docs/manual/reference/operator/update/).
-     * Each field may only appear in one operator per call.
-     * Supported update operators include `$set`, `$rename`, `$unset`, `$inc`, `$mul`, `$min`, `$max`,
-     * `$currentDate`, `$addToSet`, `$push`, and `$pull`.
-     * @returns Promise resolving to the update result.
-     *
-     * @example
-     * ```typescript
-     * // Basic usage
-     * // Archive all completed orders
-     * const result = await base44.entities.Order.updateMany(
-     *   { status: 'completed' },
-     *   { $set: { status: 'archived' } }
-     * );
-     * console.log(`Updated ${result.updated} records`);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Multiple query operators
-     * // Flag urgent items that haven't been handled yet
-     * const result = await base44.entities.Task.updateMany(
-     *   { priority: { $in: ['high', 'critical'] }, status: { $ne: 'done' } },
-     *   { $set: { flagged: true } }
-     * );
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Multiple update operators
-     * // Close out sales records and bump the view count
-     * const result = await base44.entities.Deal.updateMany(
-     *   { category: 'sales' },
-     *   { $set: { status: 'done' }, $inc: { view_count: 1 } }
-     * );
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Batched updates
-     * // Process all pending items in batches of 500
-     * let hasMore = true;
-     * let totalUpdated = 0;
-     * while (hasMore) {
-     *   const result = await base44.entities.Job.updateMany(
-     *     { status: 'pending' },
-     *     { $set: { status: 'processed' } }
-     *   );
-     *   totalUpdated += result.updated;
-     *   hasMore = result.has_more;
-     * }
-     * ```
-     */
-    updateMany(query: Partial<T>, data: Record<string, Record<string, any>>): Promise<UpdateManyResult>;
-    /**
-     * Updates the specified records in a single request, each with its own data.
-     *
-     * Use this when you already know which records to update and each one needs
-     * different field values. For example, you could update the status and amount
-     * on three separate invoices in one call.
-     *
-     * You can update up to 500 records per request.
-     *
-     * To apply the same update to all records matching a query, use
-     * {@linkcode updateMany | updateMany()}. To update a single record by ID, use
-     * {@linkcode update | update()}.
-     *
-     * @param data - Array of objects to update. Each object must contain an `id` field identifying which record to update and any fields to change.
-     * @returns Promise resolving to an array of the updated records.
-     *
-     * @example
-     * ```typescript
-     * // Basic usage
-     * // Update three invoices with different statuses and amounts
-     * const updated = await base44.entities.Invoice.bulkUpdate([
-     *   { id: 'inv-1', status: 'paid', amount: 999 },
-     *   { id: 'inv-2', status: 'cancelled' },
-     *   { id: 'inv-3', amount: 450 }
-     * ]);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // More than 500 items
-     * // Reassign each task to a different owner in batches
-     * const allUpdates = reassignments.map(r => ({ id: r.taskId, owner: r.newOwner }));
-     * for (let i = 0; i < allUpdates.length; i += 500) {
-     *   const batch = allUpdates.slice(i, i + 500);
-     *   await base44.entities.Task.bulkUpdate(batch);
-     * }
-     * ```
-     */
-    bulkUpdate(data: (Partial<T> & {
-        id: string;
-    })[]): Promise<T[]>;
     /**
      * Imports records from a file.
      *

package/dist/modules/functions.d.ts

@@ -1,11 +1,12 @@
 import { AxiosInstance } from "axios";
-import { FunctionsModule } from "./functions.types";
+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): FunctionsModule;
+export declare function createFunctionsModule(axios: AxiosInstance, appId: string, config?: FunctionsModuleConfig): FunctionsModule;

package/dist/modules/functions.js

@@ -3,10 +3,34 @@
  *
  * @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) {
+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) {
@@ -39,5 +63,17 @@ export function createFunctionsModule(axios, appId) {
             }
             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

@@ -14,6 +14,22 @@ export interface FunctionNameRegistry {
  * ```
  */
 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.
  *
@@ -34,11 +50,13 @@ export interface FunctionsModule {
     /**
      * Invokes a custom backend function by name.
      *
-     * Calls a custom backend function deployed to the app.
+     * 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.
@@ -68,4 +86,65 @@ export interface FunctionsModule {
      * ```
      */
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.8.20-pr.144.69d591d",
+  "version": "0.8.20-pr.146.0ca6206",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",