@inflector/aura 0.2.9 → 0.2.11

package/dist/bin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AA+KA,wBAAgB,KAAK,CAAC,MAAM,UAAQ,QA2CnC;AA0aD,wBAAsB,GAAG,kBAsExB"}
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AAmLA,wBAAgB,KAAK,CAAC,MAAM,UAAQ,QAgDnC;AAwaD,wBAAsB,GAAG,kBAsExB"}

package/dist/bin.js

@@ -125,7 +125,12 @@ function scanFolderWithTypes(folder) {
 function objectToTypeWithReturn(name, obj, auraType = "AuraFunctionHandler") {
     const lines = [];
     function toFnType(returnType) {
-        return `(...args: any[]) => Promise<${returnType}>`;
+        if (returnType === "SSEHandler") {
+            return `(...args: any[]) => Promise<SSEEvent>`;
+        }
+        else {
+            return `(...args: any[]) => Promise<${returnType}>`;
+        }
     }
     function recurse(o, indent = "  ") {
         const inner = [];
@@ -163,6 +168,11 @@ export function build(silent = false) {
         // - SSEHandler is NOT generic
         // - Client exposes parsed data, not raw SSE events
         const header = `
+export type SSEEvent = {
+  event: string;
+  data: any;
+};
+
 export type SSEStream<T> = {
   onMessage(cb: (data: T) => void): Promise<void>;
   abort(): void;

package/dist/function.d.ts

@@ -1,12 +1,2 @@
-export type SSEEvent<T = unknown> = {
-    event: string;
-    data: T;
-    raw: string;
-};
-export type SSEHandler<T> = (evt: SSEEvent<T>) => void;
-export type FunctionResult<TJson, TSse> = Promise<TJson> | {
-    onMessage(cb: SSEHandler<TSse>): Promise<void>;
-    abort(): void;
-};
-export declare function createFunctionHandler<TFunctions extends Record<string, any>>(workspace: string): TFunctions;
+export declare function createFunctionHandler(workspace: string, functionsFolder?: string): any;
 //# sourceMappingURL=function.d.ts.map

package/dist/function.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../src/function.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,CAAC,CAAC,GAAG,OAAO,IAAI;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,CAAC,CAAC;IACR,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAEvD,MAAM,MAAM,cAAc,CAAC,KAAK,EAAE,IAAI,IAClC,OAAO,CAAC,KAAK,CAAC,GACd;IACE,SAAS,CAAC,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAqDN,wBAAgB,qBAAqB,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1E,SAAS,EAAE,MAAM,cAyDlB"}
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../src/function.ts"],"names":[],"mappings":"AAAA,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,eAAe,CAAC,EAAE,MAAM,GACvB,GAAG,CAkJL"}

package/dist/function.js

@@ -1,89 +1,130 @@
-async function parseSSE(response, onMessage, signal) {
-    if (!response.body)
-        throw new Error("Missing response body");
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    while (true) {
-        const { value, done } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const chunks = buffer.split("\n\n");
-        buffer = chunks.pop() ?? "";
-        for (const chunk of chunks) {
-            let event = "message";
-            const dataLines = [];
-            for (const line of chunk.split("\n")) {
-                if (line.startsWith("event:")) {
-                    event = line.slice(6).trim();
-                }
-                if (line.startsWith("data:")) {
-                    dataLines.push(line.slice(5).trim());
-                }
-            }
-            if (dataLines.length === 0)
-                continue;
-            const raw = dataLines.join("\n");
-            let parsed = raw;
-            try {
-                parsed = JSON.parse(raw);
-            }
-            catch { }
-            onMessage({
-                event,
-                data: parsed,
-                raw,
-            });
-        }
-    }
-}
-export function createFunctionHandler(workspace) {
-    return new Proxy({}, {
-        get(_, fnName) {
-            return (...args) => {
-                const controller = new AbortController();
-                const url = ["api", "fn", workspace, fnName].join("/");
-                const body = args.length === 1 && args[0] instanceof FormData
-                    ? args[0]
-                    : JSON.stringify(args[0] ?? {});
+export function createFunctionHandler(workspace, functionsFolder) {
+    const handler = new Proxy({}, {
+        get(_, prop) {
+            return createNestedProxy([prop]);
+        },
+    });
+    function createNestedProxy(path) {
+        // Target function is just a placeholder
+        return new Proxy(() => { }, {
+            get(_, prop) {
+                return createNestedProxy([...path, prop]);
+            },
+            // 1. Remove 'async' here to prevent native Promise wrapping
+            apply(_, __, args) {
+                const url = ["api", "fn", workspace, ...path].join("/");
+                const isFormData = args != null && args.length === 1 && args[0] instanceof FormData;
+                const body = isFormData ? args[0] : JSON.stringify(args[0] ?? {});
                 const headers = {
                     Accept: "text/event-stream,application/json",
                 };
-                if (!(body instanceof FormData)) {
+                if (!isFormData)
                     headers["Content-Type"] = "application/json";
-                }
-                const request = fetch(url, {
+                // 2. Start the fetch properly (without await)
+                const requestPromise = fetch(url, {
                     method: "POST",
                     body,
                     headers,
                     credentials: "include",
-                    signal: controller.signal,
                 });
-                return {
-                    async onMessage(cb) {
-                        const res = await request;
-                        const type = res.headers.get("Content-Type") ?? "";
-                        if (!type.includes("text/event-stream")) {
-                            throw new Error("Response is not SSE");
-                        }
-                        await parseSSE(res, cb, controller.signal);
+                // 3. Return a custom "Thenable" object with full Promise interface
+                const thenable = {
+                    then(onFulfilled, onRejected) {
+                        requestPromise
+                            .then(async (response) => {
+                            const contentType = response.headers.get("Content-Type") || "";
+                            // ─────────────────────────────────────────────
+                            // SSE PATH
+                            // ─────────────────────────────────────────────
+                            if (contentType.includes("text/event-stream")) {
+                                if (!response.body) {
+                                    if (onRejected)
+                                        onRejected(new Error("Response body is null"));
+                                    return;
+                                }
+                                const reader = response.body.getReader();
+                                const decoder = new TextDecoder("utf-8");
+                                let buffer = "";
+                                try {
+                                    while (true) {
+                                        const { value, done } = await reader.read();
+                                        if (done)
+                                            break;
+                                        buffer += decoder.decode(value, { stream: true });
+                                        // Split by SSE message delimiter
+                                        const parts = buffer.split("\n\n");
+                                        buffer = parts.pop() || ""; // Keep incomplete chunk
+                                        for (const part of parts) {
+                                            if (!part.trim())
+                                                continue;
+                                            const lines = part.split("\n");
+                                            let eventName = "message"; // Default SSE event type
+                                            const dataLines = [];
+                                            for (const line of lines) {
+                                                if (line.startsWith("event: ")) {
+                                                    eventName = line.replace(/^event: /, "").trim();
+                                                }
+                                                else if (line.startsWith("data: ")) {
+                                                    dataLines.push(line.replace(/^data: /, ""));
+                                                }
+                                            }
+                                            const message = dataLines.join("\n");
+                                            if (message) {
+                                                try {
+                                                    // Emit parsed JSON along with the event name
+                                                    const parsedData = JSON.parse(message);
+                                                    onFulfilled({
+                                                        event: eventName,
+                                                        data: parsedData,
+                                                    });
+                                                }
+                                                catch {
+                                                    // Or emit raw string if parsing fails
+                                                    onFulfilled({
+                                                        event: eventName,
+                                                        data: message,
+                                                    });
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                catch (err) {
+                                    if (onRejected)
+                                        onRejected(err);
+                                }
+                            }
+                            // ─────────────────────────────────────────────
+                            // NORMAL JSON PATH
+                            // ─────────────────────────────────────────────
+                            else {
+                                const data = await response.json();
+                                onFulfilled(data.data ?? data);
+                            }
+                        })
+                            .catch((err) => {
+                            if (onRejected)
+                                onRejected(err);
+                        });
+                        // Return 'this' to allow chaining
+                        return thenable;
                     },
-                    abort() {
-                        controller.abort();
+                    catch(onRejected) {
+                        return thenable.then(() => { }, onRejected);
                     },
-                    async then(resolve, reject) {
-                        try {
-                            const res = await request;
-                            const json = await res.json();
-                            resolve(json.data ?? json);
-                        }
-                        catch (e) {
-                            reject?.(e);
-                        }
+                    finally(onFinally) {
+                        return thenable.then((value) => {
+                            onFinally?.();
+                            return value;
+                        }, (err) => {
+                            onFinally?.();
+                            throw err;
+                        });
                     },
                 };
-            };
-        },
-    });
+                return thenable;
+            },
+        });
+    }
+    return handler;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inflector/aura",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",