export-runtime 0.0.2 → 0.0.4

package/client.js

@@ -162,12 +162,28 @@ __DEVALUE_PARSE__
 const ws = new WebSocket(__WS_URL__);
 const pending = new Map();
 let nextId = 1;
+let keepaliveInterval = null;
 
 const ready = new Promise((resolve, reject) => {
-  ws.onopen = () => resolve(undefined);
+  ws.onopen = () => {
+    // Start keepalive ping every 30 seconds
+    keepaliveInterval = setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(stringify({ type: "ping", id: 0 }));
+      }
+    }, 30000);
+    resolve(undefined);
+  };
   ws.onerror = (e) => reject(e);
 });
 
+ws.onclose = () => {
+  if (keepaliveInterval) {
+    clearInterval(keepaliveInterval);
+    keepaliveInterval = null;
+  }
+};
+
 const sendRequest = async (msg) => {
   await ready;
   const id = nextId++;
@@ -179,6 +195,10 @@ const sendRequest = async (msg) => {
 
 ws.onmessage = (event) => {
   const msg = parse(event.data);
+
+  // Ignore pong responses (keepalive)
+  if (msg.type === "pong") return;
+
   const resolver = pending.get(msg.id);
   if (!resolver) return;
 
@@ -201,6 +221,43 @@ ws.onmessage = (event) => {
         }
       };
       resolver.resolve(iteratorProxy);
+    } else if (msg.valueType === "readablestream") {
+      // Create a ReadableStream proxy that pulls from server
+      const streamId = msg.streamId;
+      const stream = new ReadableStream({
+        async pull(controller) {
+          try {
+            const result = await sendRequest({ type: "stream-read", streamId });
+            if (result.done) {
+              controller.close();
+            } else {
+              controller.enqueue(result.value);
+            }
+          } catch (err) {
+            controller.error(err);
+          }
+        },
+        async cancel() {
+          await sendRequest({ type: "stream-cancel", streamId });
+        }
+      });
+      resolver.resolve(stream);
+    } else if (msg.valueType === "writablestream") {
+      // Create a WritableStream proxy that pushes to server
+      const writableId = msg.writableId;
+      const stream = new WritableStream({
+        async write(chunk) {
+          const data = chunk instanceof Uint8Array ? Array.from(chunk) : chunk;
+          await sendRequest({ type: "writable-write", writableId, chunk: data });
+        },
+        async close() {
+          await sendRequest({ type: "writable-close", writableId });
+        },
+        async abort(reason) {
+          await sendRequest({ type: "writable-abort", writableId });
+        }
+      });
+      resolver.resolve(stream);
     } else {
       resolver.resolve(msg.value);
     }
@@ -208,6 +265,11 @@ ws.onmessage = (event) => {
   } else if (msg.type === "iterate-result") {
     resolver.resolve({ value: msg.value, done: msg.done });
     pending.delete(msg.id);
+  } else if (msg.type === "stream-result") {
+    // Convert array back to Uint8Array if it was serialized
+    const value = Array.isArray(msg.value) ? new Uint8Array(msg.value) : msg.value;
+    resolver.resolve({ value, done: msg.done });
+    pending.delete(msg.id);
   }
 };
 
@@ -249,5 +311,26 @@ const createProxy = (path = []) => new Proxy(function(){}, {
   }
 });
 
+// Helper to create a client-side WritableStream that can be passed to server functions
+export const createUploadStream = async () => {
+  const result = await sendRequest({ type: "writable-create" });
+  const writableId = result.writableId;
+
+  const stream = new WritableStream({
+    async write(chunk) {
+      const data = chunk instanceof Uint8Array ? Array.from(chunk) : chunk;
+      await sendRequest({ type: "writable-write", writableId, chunk: data });
+    },
+    async close() {
+      return sendRequest({ type: "writable-close", writableId });
+    },
+    async abort(reason) {
+      await sendRequest({ type: "writable-abort", writableId });
+    }
+  });
+
+  return { stream, writableId };
+};
+
 __NAMED_EXPORTS__
 `;

package/handler.js

@@ -13,15 +13,93 @@ const getByPath = (obj, path) => {
 const isAsyncIterable = (value) =>
   value != null && typeof value[Symbol.asyncIterator] === "function";
 
+const isReadableStream = (value) =>
+  value != null && typeof value.getReader === "function" && typeof value.pipeTo === "function";
+
 const isClass = (fn) =>
   typeof fn === "function" && /^class\s/.test(Function.prototype.toString.call(fn));
 
+// Generate TypeScript type definitions from exports
+const generateTypeDefinitions = (exports, exportKeys) => {
+  const lines = [
+    "// Auto-generated type definitions",
+    "// All functions are async over the network",
+    "",
+  ];
+
+  const generateType = (value, name, indent = "") => {
+    if (isClass(value)) {
+      // Extract class method names
+      const proto = value.prototype;
+      const methodNames = Object.getOwnPropertyNames(proto).filter(
+        (n) => n !== "constructor" && typeof proto[n] === "function"
+      );
+
+      lines.push(`${indent}export declare class ${name} {`);
+      lines.push(`${indent}  constructor(...args: any[]);`);
+      for (const method of methodNames) {
+        lines.push(`${indent}  ${method}(...args: any[]): Promise<any>;`);
+      }
+      lines.push(`${indent}  [Symbol.dispose](): Promise<void>;`);
+      lines.push(`${indent}  "[release]"(): Promise<void>;`);
+      lines.push(`${indent}}`);
+    } else if (typeof value === "function") {
+      // Check if it's an async generator
+      const fnStr = Function.prototype.toString.call(value);
+      if (fnStr.startsWith("async function*") || fnStr.includes("async *")) {
+        lines.push(
+          `${indent}export declare function ${name}(...args: any[]): Promise<AsyncIterable<any>>;`
+        );
+      } else if (fnStr.includes("ReadableStream")) {
+        lines.push(
+          `${indent}export declare function ${name}(...args: any[]): Promise<ReadableStream<any>>;`
+        );
+      } else {
+        lines.push(
+          `${indent}export declare function ${name}(...args: any[]): Promise<any>;`
+        );
+      }
+    } else if (typeof value === "object" && value !== null) {
+      // Nested object with methods
+      const keys = Object.keys(value);
+      lines.push(`${indent}export declare const ${name}: {`);
+      for (const key of keys) {
+        const v = value[key];
+        if (typeof v === "function") {
+          lines.push(`${indent}  ${key}(...args: any[]): Promise<any>;`);
+        } else {
+          lines.push(`${indent}  ${key}: any;`);
+        }
+      }
+      lines.push(`${indent}};`);
+    } else {
+      lines.push(`${indent}export declare const ${name}: any;`);
+    }
+  };
+
+  for (const key of exportKeys) {
+    generateType(exports[key], key);
+    lines.push("");
+  }
+
+  // Add createUploadStream helper type
+  lines.push("export declare function createUploadStream(): Promise<{");
+  lines.push("  stream: WritableStream<any>;");
+  lines.push("  writableId: number;");
+  lines.push("}>;");
+
+  return lines.join("\n");
+};
+
 export const createHandler = (exports) => {
   const exportKeys = Object.keys(exports);
   const iteratorStore = new Map();
   const instanceStore = new Map();
+  const streamStore = new Map();
+  const writableStreamStore = new Map();
   let nextIteratorId = 1;
   let nextInstanceId = 1;
+  let nextStreamId = 1;
 
   const send = (ws, data) => {
     ws.send(stringify(data));
@@ -43,6 +121,12 @@ export const createHandler = (exports) => {
             const msg = parse(event.data);
             const { type, id, path = [], args = [], iteratorId, instanceId } = msg;
 
+            // Keepalive ping/pong
+            if (type === "ping") {
+              send(server, { type: "pong", id });
+              return;
+            }
+
             if (type === "construct") {
               // Class instantiation
               try {
@@ -86,7 +170,11 @@ export const createHandler = (exports) => {
                 // Await result to support both sync and async functions
                 const result = await target.apply(thisArg, args);
 
-                if (isAsyncIterable(result)) {
+                if (isReadableStream(result)) {
+                  const streamId = nextStreamId++;
+                  streamStore.set(streamId, { stream: result, reader: null });
+                  send(server, { type: "result", id, streamId, valueType: "readablestream" });
+                } else if (isAsyncIterable(result)) {
                   const iterId = nextIteratorId++;
                   iteratorStore.set(iterId, result[Symbol.asyncIterator]());
                   send(server, { type: "result", id, iteratorId: iterId, valueType: "asynciterator" });
@@ -152,6 +240,99 @@ export const createHandler = (exports) => {
               if (iter?.return) await iter.return(undefined);
               iteratorStore.delete(iteratorId);
               send(server, { type: "iterate-result", id, value: undefined, done: true });
+            } else if (type === "stream-read") {
+              // ReadableStream chunk read
+              const { streamId } = msg;
+              const entry = streamStore.get(streamId);
+              if (!entry) {
+                send(server, { type: "error", id, error: "Stream not found" });
+                return;
+              }
+              try {
+                // Get or create reader for this stream
+                let reader = entry.reader;
+                if (!reader) {
+                  reader = entry.stream.getReader();
+                  entry.reader = reader;
+                }
+                const { value, done } = await reader.read();
+                if (done) {
+                  streamStore.delete(streamId);
+                }
+                // Convert Uint8Array to array for devalue serialization
+                const serializedValue = value instanceof Uint8Array ? Array.from(value) : value;
+                send(server, { type: "stream-result", id, value: serializedValue, done: !!done });
+              } catch (err) {
+                streamStore.delete(streamId);
+                send(server, { type: "error", id, error: String(err) });
+              }
+            } else if (type === "stream-cancel") {
+              // Cancel ReadableStream
+              const { streamId } = msg;
+              const entry = streamStore.get(streamId);
+              if (entry) {
+                try {
+                  if (entry.reader) {
+                    await entry.reader.cancel();
+                  } else {
+                    await entry.stream.cancel();
+                  }
+                } catch (e) { /* ignore */ }
+                streamStore.delete(streamId);
+              }
+              send(server, { type: "result", id, value: true });
+            } else if (type === "writable-create") {
+              // Create a WritableStream on server side
+              const { targetPath, targetInstanceId } = msg;
+              let chunks = [];
+              const writableId = nextStreamId++;
+
+              const writable = new WritableStream({
+                write(chunk) {
+                  chunks.push(chunk);
+                },
+                close() {
+                  // Resolve with all chunks when stream closes
+                },
+                abort(reason) {
+                  chunks = [];
+                }
+              });
+
+              writableStreamStore.set(writableId, { writable, chunks, targetPath, targetInstanceId });
+              send(server, { type: "result", id, writableId, valueType: "writablestream" });
+            } else if (type === "writable-write") {
+              // Write chunk to WritableStream
+              const { writableId, chunk } = msg;
+              const entry = writableStreamStore.get(writableId);
+              if (!entry) {
+                send(server, { type: "error", id, error: "WritableStream not found" });
+                return;
+              }
+              try {
+                // Convert array back to Uint8Array if needed
+                const data = Array.isArray(chunk) ? new Uint8Array(chunk) : chunk;
+                entry.chunks.push(data);
+                send(server, { type: "result", id, value: true });
+              } catch (err) {
+                send(server, { type: "error", id, error: String(err) });
+              }
+            } else if (type === "writable-close") {
+              // Close WritableStream and return collected chunks
+              const { writableId } = msg;
+              const entry = writableStreamStore.get(writableId);
+              if (!entry) {
+                send(server, { type: "error", id, error: "WritableStream not found" });
+                return;
+              }
+              writableStreamStore.delete(writableId);
+              // Return the collected data
+              send(server, { type: "result", id, value: entry.chunks });
+            } else if (type === "writable-abort") {
+              // Abort WritableStream
+              const { writableId } = msg;
+              writableStreamStore.delete(writableId);
+              send(server, { type: "result", id, value: true });
             }
           } catch (err) {
             console.error("WebSocket message error:", err);
@@ -161,6 +342,8 @@ export const createHandler = (exports) => {
         server.addEventListener("close", () => {
           iteratorStore.clear();
           instanceStore.clear();
+          streamStore.clear();
+          writableStreamStore.clear();
         });
 
         return new Response(null, { status: 101, webSocket: client });
@@ -169,6 +352,18 @@ export const createHandler = (exports) => {
       const wsProtocol = url.protocol === "https:" ? "wss:" : "ws:";
       const wsUrl = `${wsProtocol}//${url.host}${url.pathname}`;
 
+      // Serve TypeScript type definitions
+      if (url.searchParams.has("types") || url.pathname.endsWith(".d.ts")) {
+        const typeDefinitions = generateTypeDefinitions(exports, exportKeys);
+        return new Response(typeDefinitions, {
+          headers: {
+            "Content-Type": "application/typescript; charset=utf-8",
+            "Access-Control-Allow-Origin": "*",
+            "Cache-Control": "no-cache",
+          },
+        });
+      }
+
       // Generate named exports
       const namedExports = exportKeys
         .map((key) => `export const ${key} = createProxy([${JSON.stringify(key)}]);`)
@@ -180,11 +375,15 @@ export const createHandler = (exports) => {
         .replace("__DEVALUE_PARSE__", DEVALUE_PARSE)
         .replace("__NAMED_EXPORTS__", namedExports);
 
+      // Build types URL for X-TypeScript-Types header
+      const typesUrl = `${url.protocol}//${url.host}${url.pathname}?types`;
+
       return new Response(clientCode, {
         headers: {
           "Content-Type": "application/javascript; charset=utf-8",
           "Access-Control-Allow-Origin": "*",
           "Cache-Control": "no-cache",
+          "X-TypeScript-Types": typesUrl,
         },
       });
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "export-runtime",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Cloudflare Workers ESM Export Framework Runtime",
   "keywords": [
     "cloudflare",