@base44-preview/sdk 0.8.9-pr.61.ec411f8 → 0.8.10-pr.62.8f72a2c

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/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,60 @@
+/**
+ * Normalizes parameters to snake_case for the API.
+ *
+ * Supports both camelCase (pathParams) and snake_case (path_params) input,
+ * always outputting snake_case for the backend.
+ */
+function normalizeParams(params) {
+    var _a, _b;
+    if (!params) {
+        return {};
+    }
+    const normalized = {};
+    // Handle payload
+    if (params.payload !== undefined) {
+        normalized.payload = params.payload;
+    }
+    // Handle path_params (support both camelCase and snake_case)
+    const pathParams = (_a = params.pathParams) !== null && _a !== void 0 ? _a : params.path_params;
+    if (pathParams !== undefined) {
+        normalized.path_params = pathParams;
+    }
+    // Handle query_params (support both camelCase and snake_case)
+    const queryParams = (_b = params.queryParams) !== null && _b !== void 0 ? _b : params.query_params;
+    if (queryParams !== undefined) {
+        normalized.query_params = queryParams;
+    }
+    // Handle headers
+    if (params.headers !== undefined) {
+        normalized.headers = params.headers;
+    }
+    return normalized;
+}
+/**
+ * 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) {
+                throw new Error("Integration slug is required");
+            }
+            if (!operationId) {
+                throw new Error("Operation ID is required");
+            }
+            // Normalize parameters to snake_case
+            const normalizedParams = normalizeParams(params);
+            // Make the API call
+            const response = await axios.post(`/apps/${appId}/integrations/custom/${slug}/${operationId}`, normalizedParams);
+            // Return the response data
+            // Note: axios interceptor already extracts data from response
+            return response;
+        },
+    };
+}

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

@@ -0,0 +1,120 @@
+/**
+ * Parameters for calling a custom integration endpoint.
+ *
+ * Supports both camelCase and snake_case parameter names for developer convenience.
+ * The SDK will normalize to snake_case before sending to the API.
+ */
+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" }`).
+     * Can use either `pathParams` (camelCase) or `path_params` (snake_case).
+     */
+    pathParams?: Record<string, string>;
+    /**
+     * Path parameters to substitute in the URL (snake_case variant).
+     * @see {@link pathParams}
+     */
+    path_params?: Record<string, string>;
+    /**
+     * Query string parameters to append to the URL.
+     * Can use either `queryParams` (camelCase) or `query_params` (snake_case).
+     */
+    queryParams?: Record<string, any>;
+    /**
+     * Query string parameters (snake_case variant).
+     * @see {@link queryParams}
+     */
+    query_params?: 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, path params, query params, 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-preview/sdk",
-  "version": "0.8.9-pr.61.ec411f8",
+  "version": "0.8.10-pr.62.8f72a2c",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",