@base44-preview/sdk 0.8.10-pr.58.f752ec2 → 0.8.10-pr.62.2685d84

package/dist/client.js

@@ -104,11 +104,7 @@ export function createClient(config) {
         serverUrl,
     });
     const userModules = {
-        entities: createEntitiesModule({
-            axios: axiosClient,
-            appId,
-            getSocket,
-        }),
+        entities: createEntitiesModule(axiosClient, appId),
         integrations: createIntegrationsModule(axiosClient, appId),
         auth: userAuthModule,
         functions: createFunctionsModule(functionsAxiosClient, appId),
@@ -135,11 +131,7 @@ export function createClient(config) {
         },
     };
     const serviceRoleModules = {
-        entities: createEntitiesModule({
-            axios: serviceRoleAxiosClient,
-            appId,
-            getSocket,
-        }),
+        entities: createEntitiesModule(serviceRoleAxiosClient, appId),
         integrations: createIntegrationsModule(serviceRoleAxiosClient, appId),
         sso: createSsoModule(serviceRoleAxiosClient, appId, token),
         connectors: createConnectorsModule(serviceRoleAxiosClient, appId),

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 { EntitiesModule, EntityHandler, RealtimeEventType, RealtimeEvent, RealtimeCallback, SubscribeOptions, Subscription, } from "./modules/entities.types.js";
+export type { EntitiesModule, EntityHandler, } from "./modules/entities.types.js";
 export type { AuthModule, LoginResponse, RegisterParams, VerifyOtpParams, ChangePasswordParams, ResetPasswordParams, User, } from "./modules/auth.types.js";
 export type { IntegrationsModule, IntegrationPackage, IntegrationEndpointFunction, CoreIntegrations, InvokeLLMParams, GenerateImageParams, GenerateImageResult, UploadFileParams, UploadFileResult, SendEmailParams, SendEmailResult, ExtractDataFromUploadedFileParams, ExtractDataFromUploadedFileResult, UploadPrivateFileParams, UploadPrivateFileResult, CreateFileSignedUrlParams, CreateFileSignedUrlResult, } from "./modules/integrations.types.js";
 export type { FunctionsModule } from "./modules/functions.types.js";
@@ -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/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/entities.d.ts

@@ -1,23 +1,5 @@
 import { AxiosInstance } from "axios";
 import { EntitiesModule } from "./entities.types";
-import { RoomsSocket } from "../utils/socket-utils";
-/**
- * Configuration for the entities module.
- * @internal
- */
-export interface EntitiesModuleConfig {
-    axios: AxiosInstance;
-    appId: string;
-    getSocket: () => ReturnType<typeof RoomsSocket>;
-}
-/**
- * Creates the entities module for the Base44 SDK.
- *
- * @param config - Configuration object containing axios, appId, and getSocket
- * @returns Entities module with dynamic entity access
- * @internal
- */
-export declare function createEntitiesModule(config: EntitiesModuleConfig): EntitiesModule;
 /**
  * Creates the entities module for the Base44 SDK.
  *
@@ -25,6 +7,5 @@ export declare function createEntitiesModule(config: EntitiesModuleConfig): Enti
  * @param appId - Application ID
  * @returns Entities module with dynamic entity access
  * @internal
- * @deprecated Use the config object overload instead
  */
 export declare function createEntitiesModule(axios: AxiosInstance, appId: string): EntitiesModule;

package/dist/modules/entities.js

@@ -1,15 +1,12 @@
-export function createEntitiesModule(configOrAxios, appIdArg) {
-    // Handle both old and new signatures for backwards compatibility
-    const config = "axios" in configOrAxios
-        ? configOrAxios
-        : {
-            axios: configOrAxios,
-            appId: appIdArg,
-            getSocket: () => {
-                throw new Error("Realtime subscriptions are not available. Please update your client configuration.");
-            },
-        };
-    const { axios, appId, getSocket } = config;
+/**
+ * Creates the entities module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @returns Entities module with dynamic entity access
+ * @internal
+ */
+export function createEntitiesModule(axios, appId) {
     // Using Proxy to dynamically handle entity names
     return new Proxy({}, {
         get(target, entityName) {
@@ -20,59 +17,20 @@ export function createEntitiesModule(configOrAxios, appIdArg) {
                 return undefined;
             }
             // Create entity handler
-            return createEntityHandler(axios, appId, entityName, getSocket);
+            return createEntityHandler(axios, appId, entityName);
         },
     });
 }
-/**
- * Creates a stable hash from a query object for room naming.
- * @internal
- */
-function hashQuery(query) {
-    const sortedKeys = Object.keys(query).sort();
-    const normalized = sortedKeys
-        .map((k) => `${k}:${JSON.stringify(query[k])}`)
-        .join("|");
-    // Simple hash function
-    let hash = 0;
-    for (let i = 0; i < normalized.length; i++) {
-        const char = normalized.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash = hash & hash; // Convert to 32bit integer
-    }
-    return Math.abs(hash).toString(36);
-}
-/**
- * Parses the realtime message data and extracts event information.
- * @internal
- */
-function parseRealtimeMessage(dataStr) {
-    var _a;
-    try {
-        const parsed = JSON.parse(dataStr);
-        return {
-            type: parsed.type,
-            data: parsed.data,
-            id: parsed.id || ((_a = parsed.data) === null || _a === void 0 ? void 0 : _a.id),
-            timestamp: parsed.timestamp || new Date().toISOString(),
-            previousData: parsed.previousData,
-        };
-    }
-    catch (_b) {
-        return null;
-    }
-}
 /**
  * Creates a handler for a specific entity.
  *
  * @param axios - Axios instance
  * @param appId - Application ID
  * @param entityName - Entity name
- * @param getSocket - Function to get the socket instance
  * @returns Entity handler with CRUD methods
  * @internal
  */
-function createEntityHandler(axios, appId, entityName, getSocket) {
+function createEntityHandler(axios, appId, entityName) {
     const baseURL = `/apps/${appId}/entities/${entityName}`;
     return {
         // List entities with optional pagination and sorting
@@ -137,52 +95,5 @@ function createEntityHandler(axios, appId, entityName, getSocket) {
                 },
             });
         },
-        // Subscribe to realtime updates
-        subscribe(callbackOrIdOrQuery, callbackOrOptions, optionsArg) {
-            let room;
-            let callback;
-            let options;
-            // Parse overloaded arguments
-            if (typeof callbackOrIdOrQuery === "function") {
-                // subscribe(callback, options?)
-                room = `entities:${appId}:${entityName}`;
-                callback = callbackOrIdOrQuery;
-                options = callbackOrOptions;
-            }
-            else if (typeof callbackOrIdOrQuery === "string") {
-                // subscribe(id, callback, options?)
-                room = `entities:${appId}:${entityName}:${callbackOrIdOrQuery}`;
-                callback = callbackOrOptions;
-                options = optionsArg;
-            }
-            else {
-                // subscribe(query, callback, options?)
-                const queryHash = hashQuery(callbackOrIdOrQuery);
-                room = `entities:${appId}:${entityName}:query:${queryHash}`;
-                callback = callbackOrOptions;
-                options = optionsArg;
-            }
-            const eventFilter = options === null || options === void 0 ? void 0 : options.events;
-            // Get the socket and subscribe to the room
-            const socket = getSocket();
-            const unsubscribe = socket.subscribeToRoom(room, {
-                update_model: (msg) => {
-                    // Only process messages for our room
-                    if (msg.room !== room)
-                        return;
-                    const event = parseRealtimeMessage(msg.data);
-                    if (!event)
-                        return;
-                    // Apply event type filter if specified
-                    if (eventFilter && !eventFilter.includes(event.type)) {
-                        return;
-                    }
-                    callback(event);
-                },
-            });
-            return {
-                unsubscribe,
-            };
-        },
     };
 }

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

@@ -1,40 +1,3 @@
-/**
- * Event types for realtime entity updates.
- */
-export type RealtimeEventType = "create" | "update" | "delete";
-/**
- * Payload received when a realtime event occurs.
- */
-export interface RealtimeEvent<T = Record<string, any>> {
-    /** The type of change that occurred */
-    type: RealtimeEventType;
-    /** The entity data (new/updated for create/update, previous for delete) */
-    data: T;
-    /** The unique identifier of the affected entity */
-    id: string;
-    /** ISO 8601 timestamp of when the event occurred */
-    timestamp: string;
-    /** For update events, contains the previous data before the change */
-    previousData?: T;
-}
-/**
- * Callback function invoked when a realtime event occurs.
- */
-export type RealtimeCallback<T = Record<string, any>> = (event: RealtimeEvent<T>) => void;
-/**
- * Options for subscribing to realtime updates.
- */
-export interface SubscribeOptions {
-    /** Filter events by type. Defaults to all types. */
-    events?: RealtimeEventType[];
-}
-/**
- * Handle returned from subscribe, used to unsubscribe.
- */
-export interface Subscription {
-    /** Stops listening to updates and cleans up the subscription. */
-    unsubscribe: () => void;
-}
 /**
  * Entity handler providing CRUD operations for a specific entity type.
  *
@@ -279,93 +242,6 @@ export interface EntityHandler {
      * ```
      */
     importEntities(file: File): Promise<any>;
-    /**
-     * Subscribes to realtime updates for all records of this entity type.
-     *
-     * Receives notifications whenever any record is created, updated, or deleted.
-     *
-     * @param callback - Function called when an entity changes.
-     * @param options - Optional configuration for filtering events.
-     * @returns Subscription handle with an unsubscribe method.
-     *
-     * @example
-     * ```typescript
-     * // Subscribe to all Task changes
-     * const subscription = base44.entities.Task.subscribe((event) => {
-     *   console.log(`Task ${event.id} was ${event.type}d:`, event.data);
-     * });
-     *
-     * // Later, unsubscribe
-     * subscription.unsubscribe();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Subscribe only to create events
-     * const subscription = base44.entities.Task.subscribe(
-     *   (event) => console.log("New task:", event.data),
-     *   { events: ["create"] }
-     * );
-     * ```
-     */
-    subscribe(callback: RealtimeCallback, options?: SubscribeOptions): Subscription;
-    /**
-     * Subscribes to realtime updates for a specific entity record.
-     *
-     * Receives notifications when the specified record is updated or deleted.
-     *
-     * @param id - The unique identifier of the record to watch.
-     * @param callback - Function called when the entity changes.
-     * @param options - Optional configuration for filtering events.
-     * @returns Subscription handle with an unsubscribe method.
-     *
-     * @example
-     * ```typescript
-     * // Subscribe to a specific task
-     * const subscription = base44.entities.Task.subscribe("task-123", (event) => {
-     *   if (event.type === "update") {
-     *     console.log("Task updated:", event.data);
-     *   } else if (event.type === "delete") {
-     *     console.log("Task was deleted");
-     *   }
-     * });
-     * ```
-     */
-    subscribe(id: string, callback: RealtimeCallback, options?: SubscribeOptions): Subscription;
-    /**
-     * Subscribes to realtime updates for records matching a query.
-     *
-     * Receives notifications for records that match the specified criteria.
-     * Includes create events when new records match the query, update events
-     * when matching records change, and delete events when matching records
-     * are removed.
-     *
-     * @param query - Query object with field-value pairs to filter records.
-     * @param callback - Function called when a matching entity changes.
-     * @param options - Optional configuration for filtering events.
-     * @returns Subscription handle with an unsubscribe method.
-     *
-     * @example
-     * ```typescript
-     * // Subscribe to all completed tasks
-     * const subscription = base44.entities.Task.subscribe(
-     *   { isCompleted: true },
-     *   (event) => {
-     *     console.log(`Completed task ${event.type}:`, event.data);
-     *   }
-     * );
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Subscribe to high-priority active tasks
-     * const subscription = base44.entities.Task.subscribe(
-     *   { priority: "high", status: "active" },
-     *   (event) => console.log("High priority task changed:", event.data)
-     * );
-     * ```
-     */
-    subscribe(query: Record<string, any>, callback: RealtimeCallback, options?: SubscribeOptions): Subscription;
 }
 /**
  * Entities module for managing app data.

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-preview/sdk",
-  "version": "0.8.10-pr.58.f752ec2",
+  "version": "0.8.10-pr.62.2685d84",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",