@base44/sdk 0.8.9 → 0.8.11

package/dist/index.d.ts

@@ -12,4 +12,5 @@ export type { AgentsModule, AgentConversation, AgentMessage, AgentMessageReasoni
 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 { CustomIntegrationsModule, CustomIntegrationCallParams, CustomIntegrationCallResponse, } from "./modules/custom-integrations.types.js";
 export type { GetAccessTokenOptions, SaveAccessTokenOptions, RemoveAccessTokenOptions, GetLoginUrlOptions, } from "./utils/auth-utils.types.js";

package/dist/modules/analytics.js

@@ -46,9 +46,9 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
         });
     };
     // currently disabled, until fully tested  //
-    const beaconRequest = async (events) => {
-        const beaconPayload = JSON.stringify({ events });
+    const beaconRequest = (events) => {
         try {
+            const beaconPayload = JSON.stringify({ events });
             const blob = new Blob([beaconPayload], { type: "application/json" });
             return (typeof navigator === "undefined" ||
                 beaconPayload.length > 60000 ||
@@ -58,11 +58,15 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
             return false;
         }
     };
-    const flush = async (eventsData) => {
+    const flush = async (eventsData, options = {}) => {
+        if (eventsData.length === 0)
+            return;
         const sessionContext_ = await getSessionContext(userAuthModule);
         const events = eventsData.map(transformEventDataToApiRequestData(sessionContext_));
         try {
-            return batchRequestFallback(events);
+            if (!options.isBeacon || !beaconRequest(events)) {
+                await batchRequestFallback(events);
+            }
         }
         catch (_a) {
             // do nothing
@@ -94,10 +98,10 @@ export const createAnalyticsModule = ({ axiosClient, serverUrl, appId, userAuthM
     };
     const onDocHidden = () => {
         stopAnalyticsProcessor();
+        clearHeartBeatProcessor === null || clearHeartBeatProcessor === void 0 ? void 0 : clearHeartBeatProcessor();
         //  flush entire queue on visibility change and hope for the best //
         const eventsData = analyticsSharedState.requestsQueue.splice(0);
-        flush(eventsData);
-        clearHeartBeatProcessor === null || clearHeartBeatProcessor === void 0 ? void 0 : clearHeartBeatProcessor();
+        flush(eventsData, { isBeacon: true });
     };
     const onVisibilityChange = () => {
         if (typeof window === "undefined")

package/dist/modules/custom-integrations.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from "axios";
+import { CustomIntegrationsModule } from "./custom-integrations.types.js";
+/**
+ * Creates the custom integrations module for the Base44 SDK.
+ *
+ * @param axios - Axios instance for making HTTP requests
+ * @param appId - Application ID
+ * @returns Custom integrations module with `call()` method
+ * @internal
+ */
+export declare function createCustomIntegrationsModule(axios: AxiosInstance, appId: string): CustomIntegrationsModule;

package/dist/modules/custom-integrations.js

@@ -0,0 +1,32 @@
+/**
+ * Creates the custom integrations module for the Base44 SDK.
+ *
+ * @param axios - Axios instance for making HTTP requests
+ * @param appId - Application ID
+ * @returns Custom integrations module with `call()` method
+ * @internal
+ */
+export function createCustomIntegrationsModule(axios, appId) {
+    return {
+        async call(slug, operationId, params) {
+            // Validate required parameters
+            if (!(slug === null || slug === void 0 ? void 0 : slug.trim())) {
+                throw new Error("Integration slug is required and cannot be empty");
+            }
+            if (!(operationId === null || operationId === void 0 ? void 0 : operationId.trim())) {
+                throw new Error("Operation ID is required and cannot be empty");
+            }
+            // Convert camelCase to snake_case for Python backend
+            const { pathParams, queryParams, ...rest } = params !== null && params !== void 0 ? params : {};
+            const body = {
+                ...rest,
+                ...(pathParams && { path_params: pathParams }),
+                ...(queryParams && { query_params: queryParams }),
+            };
+            // Make the API call
+            const response = await axios.post(`/apps/${appId}/integrations/custom/${slug}/${operationId}`, body);
+            // The axios interceptor extracts response.data, so we get the payload directly
+            return response;
+        },
+    };
+}

package/dist/modules/custom-integrations.types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Parameters for calling a custom integration endpoint.
+ */
+export interface CustomIntegrationCallParams {
+    /**
+     * Request body payload to send to the external API.
+     */
+    payload?: Record<string, any>;
+    /**
+     * Path parameters to substitute in the URL (e.g., `{ owner: "user", repo: "repo" }`).
+     */
+    pathParams?: Record<string, string>;
+    /**
+     * Query string parameters to append to the URL.
+     */
+    queryParams?: Record<string, any>;
+    /**
+     * Additional headers to send with this specific request.
+     * These are merged with the integration's configured headers.
+     */
+    headers?: Record<string, string>;
+}
+/**
+ * Response from a custom integration call.
+ */
+export interface CustomIntegrationCallResponse {
+    /**
+     * Whether the external API returned a 2xx status code.
+     */
+    success: boolean;
+    /**
+     * The HTTP status code returned by the external API.
+     */
+    status_code: number;
+    /**
+     * The response data from the external API.
+     * Can be any JSON-serializable value depending on the external API's response.
+     */
+    data: any;
+}
+/**
+ * Module for calling custom workspace-level API integrations.
+ *
+ * Custom integrations allow workspace administrators to connect any external API
+ * by importing an OpenAPI specification. Apps in the workspace can then call
+ * these integrations using this module.
+ *
+ * Unlike the built-in integrations (like `Core`), custom integrations:
+ * - Are defined per-workspace by importing OpenAPI specs
+ * - Use a slug-based identifier instead of package names
+ * - Proxy requests through Base44's backend (credentials never exposed to frontend)
+ *
+ * @example
+ * ```typescript
+ * // Call a custom GitHub integration
+ * const response = await base44.integrations.custom.call(
+ *   "github",        // integration slug (defined by workspace admin)
+ *   "listIssues",    // operation ID from the OpenAPI spec
+ *   {
+ *     pathParams: { owner: "myorg", repo: "myrepo" },
+ *     queryParams: { state: "open", per_page: 100 }
+ *   }
+ * );
+ *
+ * if (response.success) {
+ *   console.log("Issues:", response.data);
+ * } else {
+ *   console.error("API returned error:", response.status_code);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Call with request body payload
+ * const response = await base44.integrations.custom.call(
+ *   "github",
+ *   "createIssue",
+ *   {
+ *     pathParams: { owner: "myorg", repo: "myrepo" },
+ *     payload: {
+ *       title: "Bug report",
+ *       body: "Something is broken",
+ *       labels: ["bug"]
+ *     }
+ *   }
+ * );
+ * ```
+ */
+export interface CustomIntegrationsModule {
+    /**
+     * Call a custom integration endpoint.
+     *
+     * @param slug - The integration's unique identifier (slug), as defined by the workspace admin.
+     * @param operationId - The operation ID from the OpenAPI spec (e.g., "listIssues", "getUser").
+     * @param params - Optional parameters including payload, pathParams, queryParams, and headers.
+     * @returns Promise resolving to the integration call response.
+     *
+     * @throws {Error} If slug is not provided.
+     * @throws {Error} If operationId is not provided.
+     * @throws {Base44Error} If the integration or operation is not found (404).
+     * @throws {Base44Error} If the external API call fails (502).
+     * @throws {Base44Error} If the request times out (504).
+     */
+    call(slug: string, operationId: string, params?: CustomIntegrationCallParams): Promise<CustomIntegrationCallResponse>;
+}

package/dist/modules/custom-integrations.types.js

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

package/dist/modules/integrations.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from "axios";
-import { IntegrationsModule } from "./integrations.types";
+import { IntegrationsModule } from "./integrations.types.js";
 /**
  * Creates the integrations module for the Base44 SDK.
  *

package/dist/modules/integrations.js

@@ -1,3 +1,4 @@
+import { createCustomIntegrationsModule } from "./custom-integrations.js";
 /**
  * Creates the integrations module for the Base44 SDK.
  *
@@ -7,6 +8,8 @@
  * @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
@@ -15,6 +18,10 @@ export function createIntegrationsModule(axios, appId) {
                 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) {

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

@@ -1,3 +1,4 @@
+import { CustomIntegrationsModule } from "./custom-integrations.types.js";
 /**
  * Function signature for calling an integration endpoint.
  *
@@ -341,6 +342,25 @@ export type IntegrationsModule = {
      * Core package containing built-in Base44 integration functions.
      */
     Core: CoreIntegrations;
+    /**
+     * Custom integrations module for calling workspace-level API integrations.
+     *
+     * Allows calling external APIs that workspace admins have configured
+     * by importing OpenAPI specifications.
+     *
+     * @example
+     * ```typescript
+     * const response = await base44.integrations.custom.call(
+     *   "github",        // integration slug
+     *   "listIssues",    // operation ID
+     *   {
+     *     pathParams: { owner: "myorg", repo: "myrepo" },
+     *     queryParams: { state: "open" }
+     *   }
+     * );
+     * ```
+     */
+    custom: CustomIntegrationsModule;
 } & {
     /**
      * Access to additional integration packages.

package/package.json

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