@base44-preview/sdk 0.8.20-pr.139.6d44627 → 0.8.20-pr.141.01e370e

package/dist/modules/functions.js

@@ -7,6 +7,39 @@
  * @internal
  */
 export function createFunctionsModule(axios, appId) {
+    const joinBaseUrl = (base, path) => {
+        if (!base)
+            return path;
+        return `${String(base).replace(/\/$/, "")}${path}`;
+    };
+    const isBodyInit = (value) => value instanceof FormData ||
+        value instanceof Blob ||
+        value instanceof URLSearchParams ||
+        value instanceof ReadableStream ||
+        value instanceof ArrayBuffer ||
+        ArrayBuffer.isView(value);
+    const toHeaders = (inputHeaders) => {
+        var _a, _b;
+        const headers = new Headers();
+        const appendHeaders = (source) => {
+            if (!source)
+                return;
+            Object.entries(source).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    headers.set(key, String(value));
+                }
+            });
+        };
+        // Axios keeps defaults in method-specific buckets.
+        appendHeaders((_a = axios.defaults.headers) === null || _a === void 0 ? void 0 : _a.common);
+        appendHeaders((_b = axios.defaults.headers) === null || _b === void 0 ? void 0 : _b.post);
+        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 +72,42 @@ export function createFunctionsModule(axios, appId) {
             }
             return axios.post(`/apps/${appId}/functions/${functionName}`, formData || data, { headers: { "Content-Type": contentType } });
         },
+        // Fetch a backend function endpoint directly (supports streaming).
+        async fetch(path, init = {}) {
+            const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+            const primaryPath = `/functions${normalizedPath}`;
+            const fallbackPath = `/apps/${appId}/functions${normalizedPath}`;
+            const { data, ...fetchInit } = init;
+            const headers = toHeaders(fetchInit.headers);
+            if (!headers.has("X-App-Id")) {
+                headers.set("X-App-Id", appId);
+            }
+            let body = fetchInit.body;
+            if (body === undefined && data !== undefined) {
+                if (data === null) {
+                    body = null;
+                }
+                else if (typeof data === "string" ||
+                    isBodyInit(data)) {
+                    body = data;
+                }
+                else {
+                    body = JSON.stringify(data);
+                    if (!headers.has("Content-Type")) {
+                        headers.set("Content-Type", "application/json");
+                    }
+                }
+            }
+            const requestInit = {
+                ...fetchInit,
+                headers,
+                body,
+            };
+            let response = await fetch(joinBaseUrl(axios.defaults.baseURL, primaryPath), requestInit);
+            if (response.status === 404) {
+                response = await fetch(joinBaseUrl(axios.defaults.baseURL, fallbackPath), requestInit);
+            }
+            return response;
+        },
     };
 }

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

@@ -14,6 +14,16 @@ export interface FunctionNameRegistry {
  * ```
  */
 export type FunctionName = keyof FunctionNameRegistry extends never ? string : keyof FunctionNameRegistry;
+/**
+ * Options for {@linkcode FunctionsModule.fetch}.
+ *
+ * Extends native `fetch` options with a `data` convenience property that
+ * is JSON-stringified when `body` is not provided.
+ */
+export type FunctionsFetchInit = RequestInit & {
+    /** Convenience payload for JSON requests when `body` is omitted. */
+    data?: unknown;
+};
 /**
  * Functions module for invoking custom backend functions.
  *
@@ -68,4 +78,18 @@ 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 when you need streaming behavior (SSE, chunked text, NDJSON),
+     * because `invoke()` buffers the full response.
+     *
+     * Requests are sent to `/api/functions/<path>`, with automatic fallback to
+     * `/api/apps/<appId>/functions/<path>` on `404` for compatibility.
+     *
+     * @param path - Function path, e.g. `/streaming_demo` or `/streaming_demo/deep/path`
+     * @param init - Native fetch options, plus optional `data` for JSON payloads.
+     * @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.139.6d44627",
+  "version": "0.8.20-pr.141.01e370e",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",