@base44-preview/sdk 0.8.20-pr.143.d04635a → 0.8.21-pr.141.dd114e6

package/dist/client.js

@@ -3,7 +3,7 @@ import { createEntitiesModule } from "./modules/entities.js";
 import { createIntegrationsModule } from "./modules/integrations.js";
 import { createAuthModule } from "./modules/auth.js";
 import { createSsoModule } from "./modules/sso.js";
-import { createConnectorsModule } from "./modules/connectors.js";
+import { createConnectorsModule, createUserConnectorsModule, } from "./modules/connectors.js";
 import { getAccessToken } from "./utils/auth-utils.js";
 import { createFunctionsModule } from "./modules/functions.js";
 import { createAgentsModule } from "./modules/agents.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 : "";
@@ -114,8 +115,20 @@ export function createClient(config) {
             getSocket,
         }),
         integrations: createIntegrationsModule(axiosClient, appId),
+        connectors: createUserConnectorsModule(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 +160,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/client.types.d.ts

@@ -2,7 +2,7 @@ import type { EntitiesModule } from "./modules/entities.types.js";
 import type { IntegrationsModule } from "./modules/integrations.types.js";
 import type { AuthModule } from "./modules/auth.types.js";
 import type { SsoModule } from "./modules/sso.types.js";
-import type { ConnectorsModule } from "./modules/connectors.types.js";
+import type { ConnectorsModule, UserConnectorsModule } from "./modules/connectors.types.js";
 import type { FunctionsModule } from "./modules/functions.types.js";
 import type { AgentsModule } from "./modules/agents.types.js";
 import type { AppLogsModule } from "./modules/app-logs.types.js";
@@ -87,6 +87,8 @@ export interface Base44Client {
     appLogs: AppLogsModule;
     /** {@link AuthModule | Auth module} for user authentication and management. */
     auth: AuthModule;
+    /** {@link UserConnectorsModule | Connectors module} for app-user OAuth flows. */
+    connectors: UserConnectorsModule;
     /** {@link EntitiesModule | Entities module} for CRUD operations on your data models. */
     entities: EntitiesModule;
     /** {@link FunctionsModule | Functions module} for invoking custom backend functions. */

package/dist/index.d.ts

@@ -11,6 +11,6 @@ export type { FunctionsModule, FunctionName, FunctionNameRegistry, } from "./mod
 export type { AgentsModule, AgentName, AgentNameRegistry, AgentConversation, AgentMessage, AgentMessageReasoning, AgentMessageToolCall, AgentMessageUsage, AgentMessageCustomContext, AgentMessageMetadata, CreateConversationParams, } from "./modules/agents.types.js";
 export type { AppLogsModule } from "./modules/app-logs.types.js";
 export type { SsoModule, SsoAccessTokenResponse } from "./modules/sso.types.js";
-export type { ConnectorsModule } from "./modules/connectors.types.js";
+export type { ConnectorsModule, UserConnectorsModule, } from "./modules/connectors.types.js";
 export type { CustomIntegrationsModule, CustomIntegrationCallParams, CustomIntegrationCallResponse, } from "./modules/custom-integrations.types.js";
 export type { GetAccessTokenOptions, SaveAccessTokenOptions, RemoveAccessTokenOptions, GetLoginUrlOptions, } from "./utils/auth-utils.types.js";

package/dist/modules/connectors.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from "axios";
-import { ConnectorsModule } from "./connectors.types.js";
+import { ConnectorsModule, UserConnectorsModule } from "./connectors.types.js";
 /**
  * Creates the Connectors module for the Base44 SDK.
  *
@@ -9,3 +9,12 @@ import { ConnectorsModule } from "./connectors.types.js";
  * @internal
  */
 export declare function createConnectorsModule(axios: AxiosInstance, appId: string): ConnectorsModule;
+/**
+ * Creates the user-scoped Connectors module (app-user OAuth flows).
+ *
+ * @param axios - Axios instance (user-scoped client)
+ * @param appId - Application ID
+ * @returns User connectors module with app-user OAuth methods
+ * @internal
+ */
+export declare function createUserConnectorsModule(axios: AxiosInstance, appId: string): UserConnectorsModule;

package/dist/modules/connectors.js

@@ -35,3 +35,37 @@ export function createConnectorsModule(axios, appId) {
         },
     };
 }
+/**
+ * Creates the user-scoped Connectors module (app-user OAuth flows).
+ *
+ * @param axios - Axios instance (user-scoped client)
+ * @param appId - Application ID
+ * @returns User connectors module with app-user OAuth methods
+ * @internal
+ */
+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");
+            }
+            const response = await axios.post(`/apps/${appId}/app-user-auth/connectors/${connectorId}/initiate`);
+            const data = response;
+            return data.redirect_url;
+        },
+        async disconnectAppUser(connectorId) {
+            if (!connectorId || typeof connectorId !== "string") {
+                throw new Error("Connector ID is required and must be a string");
+            }
+            await axios.delete(`/apps/${appId}/app-user-auth/connectors/${connectorId}`);
+        },
+    };
+}

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

@@ -33,7 +33,7 @@ export interface ConnectorConnectionResponse {
     connectionConfig: Record<string, string> | null;
 }
 /**
- * Connectors module for managing OAuth tokens for external services.
+ * Connectors module for managing app-scoped OAuth tokens for external services.
  *
  * This module allows you to retrieve OAuth access tokens for external services that the app has connected to. Connectors are app-scoped. When an app builder connects an integration like Google Calendar, Slack, or GitHub, all users of the app share that same connection.
  *
@@ -224,3 +224,73 @@ 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.
+     *
+     * Returns the OAuth token string that belongs to the currently authenticated end user
+     * for the specified connector.
+     *
+     * @param connectorId - The connector ID (OrgConnector database ID).
+     * @returns Promise resolving to the access token string.
+     *
+     * @example
+     * ```typescript
+     * // Get the end user's access token for a connector
+     * const token = await base44.connectors.getCurrentAppUserAccessToken('abc123def');
+     *
+     * const response = await fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events', {
+     *   headers: { 'Authorization': `Bearer ${token}` }
+     * });
+     * ```
+     */
+    getCurrentAppUserAccessToken(connectorId: string): Promise<string>;
+    /**
+     * Initiates the app-user OAuth flow for a specific connector.
+     *
+     * Returns a redirect URL that the end user should be navigated to in order to
+     * authenticate with the external service. The scopes and integration type are
+     * derived from the connector configuration server-side.
+     *
+     * @param connectorId - The connector ID (OrgConnector database ID).
+     * @returns Promise resolving to the redirect URL string.
+     *
+     * @example
+     * ```typescript
+     * // Start OAuth for the end user
+     * const redirectUrl = await base44.connectors.connectAppUser('abc123def');
+     *
+     * // Redirect the user to the OAuth provider
+     * window.location.href = redirectUrl;
+     * ```
+     */
+    connectAppUser(connectorId: string): Promise<string>;
+    /**
+     * Disconnects an end user's OAuth connection for a specific connector.
+     *
+     * Removes the stored OAuth credentials for the currently authenticated end user's
+     * connection to the specified connector.
+     *
+     * @param connectorId - The connector ID (OrgConnector database ID).
+     * @returns Promise resolving when the connection has been removed.
+     *
+     * @example
+     * ```typescript
+     * // Disconnect the end user's connection
+     * await base44.connectors.disconnectAppUser('abc123def');
+     * ```
+     */
+    disconnectAppUser(connectorId: string): Promise<void>;
+}

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

@@ -363,15 +363,18 @@ export interface EntityHandler<T = any> {
      * Updates multiple records matching a query using a MongoDB update operator.
      *
      * Applies the same update operation to all records matching the query.
-     * The `data` parameter must contain exactly one MongoDB update operator
-     * (e.g., `$set`, `$inc`, `$push`).
+     * 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.
      *
-     * Results are batched — when `has_more` is `true` in the response, call
-     * `updateMany` again with the same query to update the next batch.
+     * 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 exactly one MongoDB update operator.
+     * @param data - Update operation object containing one or more MongoDB update operators.
+     * Each field may only appear in one operator per call.
      * Supported operators: `$set`, `$rename`, `$unset`, `$inc`, `$mul`, `$min`, `$max`,
      * `$currentDate`, `$addToSet`, `$push`, `$pull`.
      * @returns Promise resolving to the update result.
@@ -388,10 +391,10 @@ export interface EntityHandler<T = any> {
      *
      * @example
      * ```typescript
-     * // Increment a counter on all matching records
+     * // Combine multiple operators in a single call
      * const result = await base44.entities.MyEntity.updateMany(
      *   { category: 'sales' },
-     *   { $inc: { view_count: 1 } }
+     *   { $set: { status: 'done' }, $inc: { view_count: 1 } }
      * );
      * ```
      *
@@ -418,7 +421,9 @@ export interface EntityHandler<T = any> {
      * `bulkUpdate` allows different updates for each record. Each item in the
      * array must include an `id` field identifying which record to update.
      *
-     * @param data - Array of update objects. Each object must have an `id` field
+     * **Note:** Maximum 500 items 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.
      *

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,20 @@ export interface FunctionNameRegistry {
  * ```
  */
 export type FunctionName = keyof FunctionNameRegistry extends never ? string : keyof FunctionNameRegistry;
+/**
+ * Options for {@linkcode FunctionsModule.fetch}.
+ *
+ * Uses native `fetch` options directly.
+ */
+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.
  *
@@ -68,4 +82,22 @@ 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 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
+     *
+     * Requests are sent to `/api/functions/<path>`.
+     *
+     * @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`
+     */
+    fetch(path: string, init?: FunctionsFetchInit): Promise<Response>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.8.20-pr.143.d04635a",
+  "version": "0.8.21-pr.141.dd114e6",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",