@base44/sdk 0.8.22 → 0.8.23

package/dist/client.js

@@ -92,9 +92,13 @@ export function createClient(config) {
         interceptResponses: false,
         onError: options === null || options === void 0 ? void 0 : options.onError,
     });
+    const serviceRoleHeaders = {
+        ...headers,
+        ...(token ? { "on-behalf-of": `Bearer ${token}` } : {}),
+    };
     const serviceRoleAxiosClient = createAxiosClient({
         baseURL: `${serverUrl}/api`,
-        headers,
+        headers: serviceRoleHeaders,
         token: serviceToken,
         onError: options === null || options === void 0 ? void 0 : options.onError,
     });
@@ -158,7 +162,7 @@ export function createClient(config) {
             getSocket,
         }),
         integrations: createIntegrationsModule(serviceRoleAxiosClient, appId),
-        sso: createSsoModule(serviceRoleAxiosClient, appId, token),
+        sso: createSsoModule(serviceRoleAxiosClient, appId),
         connectors: createConnectorsModule(serviceRoleAxiosClient, appId),
         functions: createFunctionsModule(serviceRoleFunctionsAxiosClient, appId, {
             getAuthHeaders: () => {

package/dist/modules/connectors.js

@@ -33,6 +33,14 @@ export function createConnectorsModule(axios, appId) {
                 connectionConfig: (_a = data.connection_config) !== null && _a !== void 0 ? _a : null,
             };
         },
+        async getCurrentAppUserAccessToken(connectorId) {
+            if (!connectorId || typeof connectorId !== "string") {
+                throw new Error("Connector ID is required and must be a string");
+            }
+            const response = await axios.get(`/apps/${appId}/app-user-auth/connectors/${connectorId}/token`);
+            const data = response;
+            return data.access_token;
+        },
     };
 }
 /**
@@ -45,14 +53,6 @@ export function createConnectorsModule(axios, appId) {
  */
 export function createUserConnectorsModule(axios, appId) {
     return {
-        async getCurrentAppUserAccessToken(connectorId) {
-            if (!connectorId || typeof connectorId !== "string") {
-                throw new Error("Connector ID is required and must be a string");
-            }
-            const response = await axios.get(`/apps/${appId}/app-user-auth/connectors/${connectorId}/token`);
-            const data = response;
-            return data.access_token;
-        },
         async connectAppUser(connectorId) {
             if (!connectorId || typeof connectorId !== "string") {
                 throw new Error("Connector ID is required and must be a string");

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

@@ -223,20 +223,6 @@ export interface ConnectorsModule {
      * ```
      */
     getConnection(integrationType: ConnectorIntegrationType): Promise<ConnectorConnectionResponse>;
-}
-/**
- * User-scoped connectors module for managing app-user OAuth connections.
- *
- * This module provides methods for app-user OAuth flows: initiating an OAuth connection,
- * retrieving the end user's access token, and disconnecting the end user's connection.
- *
- * Unlike {@link ConnectorsModule | ConnectorsModule} which manages app-scoped tokens,
- * this module manages tokens scoped to individual end users. Methods are keyed on
- * the connector ID (the OrgConnector's database ID) rather than the integration type.
- *
- * Available via `base44.connectors`.
- */
-export interface UserConnectorsModule {
     /**
      * Retrieves an OAuth access token for an end user's connection to a specific connector.
      *
@@ -249,7 +235,7 @@ export interface UserConnectorsModule {
      * @example
      * ```typescript
      * // Get the end user's access token for a connector
-     * const token = await base44.connectors.getCurrentAppUserAccessToken('abc123def');
+     * const token = await base44.asServiceRole.connectors.getCurrentAppUserAccessToken('abc123def');
      *
      * const response = await fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events', {
      *   headers: { 'Authorization': `Bearer ${token}` }
@@ -257,6 +243,20 @@ export interface UserConnectorsModule {
      * ```
      */
     getCurrentAppUserAccessToken(connectorId: string): Promise<string>;
+}
+/**
+ * User-scoped connectors module for managing app-user OAuth connections.
+ *
+ * This module provides methods for app-user OAuth flows: initiating an OAuth connection,
+ * retrieving the end user's access token, and disconnecting the end user's connection.
+ *
+ * Unlike {@link ConnectorsModule | ConnectorsModule} which manages app-scoped tokens,
+ * this module manages tokens scoped to individual end users. Methods are keyed on
+ * the connector ID (the OrgConnector's database ID) rather than the integration type.
+ *
+ * Available via `base44.connectors`.
+ */
+export interface UserConnectorsModule {
     /**
      * Initiates the app-user OAuth flow for a specific connector.
      *

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

@@ -40,7 +40,7 @@ export interface DeleteManyResult {
     deleted: number;
 }
 /**
- * Result returned when updating multiple entities via a query.
+ * Result returned when updating multiple entities using a query.
  */
 export interface UpdateManyResult {
     /** Whether the operation was successful. */
@@ -279,6 +279,11 @@ 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.
@@ -360,29 +365,39 @@ export interface EntityHandler<T = any> {
      */
     bulkCreate(data: Partial<T>[]): Promise<T[]>;
     /**
-     * Updates multiple records matching a query using a MongoDB update operator.
+     * Applies the same update to all records that match a query.
      *
-     * Applies the same update operation to all records matching the query.
-     * The `data` parameter must contain one or more MongoDB update operators
-     * (e.g., `$set`, `$inc`, `$push`). Multiple operators can be combined in a
-     * single call, but each field may only appear in one operator.
+     * 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`
+     * 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.
-     *
-     * @param query - Query object to filter which records to update. Records matching all
-     * specified criteria will be updated.
-     * @param data - Update operation object containing one or more MongoDB update operators.
+     * the next batch. Make sure the query excludes already-updated records
+     * so you don't re-process the same entities on each iteration. For
+     * example, filter by `status: 'pending'` when setting status to `'processed'`.
+     *
+     * 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 operators: `$set`, `$rename`, `$unset`, `$inc`, `$mul`, `$min`, `$max`,
-     * `$currentDate`, `$addToSet`, `$push`, `$pull`.
+     * 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
-     * // Set status to 'archived' for all completed records
-     * const result = await base44.entities.MyEntity.updateMany(
+     * // Basic usage
+     * // Archive all completed orders
+     * const result = await base44.entities.Order.updateMany(
      *   { status: 'completed' },
      *   { $set: { status: 'archived' } }
      * );
@@ -391,8 +406,19 @@ export interface EntityHandler<T = any> {
      *
      * @example
      * ```typescript
-     * // Combine multiple operators in a single call
-     * const result = await base44.entities.MyEntity.updateMany(
+     * // 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 } }
      * );
@@ -400,11 +426,14 @@ export interface EntityHandler<T = any> {
      *
      * @example
      * ```typescript
-     * // Handle batched updates for large datasets
+     * // Batched updates
+     * // Process all pending items in batches of 500.
+     * // The query filters by 'pending', so updated records (now 'processed')
+     * // are automatically excluded from the next batch.
      * let hasMore = true;
      * let totalUpdated = 0;
      * while (hasMore) {
-     *   const result = await base44.entities.MyEntity.updateMany(
+     *   const result = await base44.entities.Job.updateMany(
      *     { status: 'pending' },
      *     { $set: { status: 'processed' } }
      *   );
@@ -415,27 +444,42 @@ export interface EntityHandler<T = any> {
      */
     updateMany(query: Partial<T>, data: Record<string, Record<string, any>>): Promise<UpdateManyResult>;
     /**
-     * Updates multiple records in a single request, each with its own update data.
+     * Updates the specified records in a single request, each with its own data.
      *
-     * Unlike `updateMany` which applies the same update to all matching records,
-     * `bulkUpdate` allows different updates for each record. Each item in the
-     * array must include an `id` field identifying which record to update.
+     * 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.
      *
-     * **Note:** Maximum 500 items per request.
+     * You can update up to 500 records per request.
      *
-     * @param data - Array of update objects (max 500). Each object must have an `id` field
-     * and any number of fields to update.
-     * @returns Promise resolving to an array of updated records.
+     * 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
-     * // Update multiple records with different data
-     * const updated = await base44.entities.MyEntity.bulkUpdate([
-     *   { id: 'entity-1', status: 'paid', amount: 999 },
-     *   { id: 'entity-2', status: 'cancelled' },
-     *   { id: 'entity-3', name: 'Renamed Item' }
+     * // 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;

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

@@ -17,7 +17,9 @@ export type FunctionName = keyof FunctionNameRegistry extends never ? string : k
 /**
  * Options for {@linkcode FunctionsModule.fetch}.
  *
- * Uses native `fetch` options directly.
+ * 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;
 /**
@@ -48,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.
@@ -85,19 +89,62 @@ export interface FunctionsModule {
     /**
      * Performs a direct HTTP request to a backend function path and returns the native `Response`.
      *
-     * Use this method when you need low-level control over the request/response that the higher-level
-     * `invoke()` abstraction doesn't provide, such as:
-     * - Streaming responses (SSE, chunked text, NDJSON)
-     * - Custom HTTP methods (PUT, PATCH, DELETE, etc.)
-     * - Custom headers or request configuration
-     * - Access to raw response metadata (status, headers)
-     * - Direct control over request/response bodies
+     * 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();
      *
-     * Requests are sent to `/api/functions/<path>`.
+     * while (true) {
+     *   const { done, value } = await reader.read();
+     *   if (done) break;
+     *   console.log(decoder.decode(value, { stream: true }));
+     * }
+     * ```
      *
-     * @param path - Function path, e.g. `/streaming_demo` or `/streaming_demo/deep/path`
-     * @param init - Native fetch options.
-     * @returns Promise resolving to a native fetch `Response`
+     * @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/sso.d.ts

@@ -9,4 +9,4 @@ import { SsoModule } from "./sso.types";
  * @returns SSO module with authentication methods
  * @internal
  */
-export declare function createSsoModule(axios: AxiosInstance, appId: string, userToken?: string): SsoModule;
+export declare function createSsoModule(axios: AxiosInstance, appId: string): SsoModule;

package/dist/modules/sso.js

@@ -7,17 +7,12 @@
  * @returns SSO module with authentication methods
  * @internal
  */
-export function createSsoModule(axios, appId, userToken) {
+export function createSsoModule(axios, appId) {
     return {
         // Get SSO access token for a specific user
         async getAccessToken(userid) {
             const url = `/apps/${appId}/auth/sso/accesstoken/${userid}`;
-            // Prepare headers with both tokens if available
-            const headers = {};
-            if (userToken) {
-                headers["on-behalf-of"] = `Bearer ${userToken}`;
-            }
-            return axios.get(url, { headers });
+            return axios.get(url);
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44/sdk",
-  "version": "0.8.22",
+  "version": "0.8.23",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",