export-runtime 0.0.3 → 0.0.5

package/bin/generate-types.mjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+
+import { parseSync } from "oxc-parser";
+import fs from "fs";
+import path from "path";
+
+const cwd = process.cwd();
+
+// Read wrangler.toml to find user module path
+const wranglerPath = path.join(cwd, "wrangler.toml");
+if (!fs.existsSync(wranglerPath)) {
+  console.error("wrangler.toml not found in", cwd);
+  process.exit(1);
+}
+const wranglerContent = fs.readFileSync(wranglerPath, "utf8");
+const aliasMatch = wranglerContent.match(/"__USER_MODULE__"\s*=\s*"([^"]+)"/);
+if (!aliasMatch) {
+  console.error('Could not find __USER_MODULE__ alias in wrangler.toml');
+  process.exit(1);
+}
+
+const userModulePath = path.resolve(cwd, aliasMatch[1]);
+if (!fs.existsSync(userModulePath)) {
+  console.error("User module not found:", userModulePath);
+  process.exit(1);
+}
+
+const source = fs.readFileSync(userModulePath, "utf8");
+const isTS = userModulePath.endsWith(".ts") || userModulePath.endsWith(".tsx");
+const fileName = path.basename(userModulePath);
+const result = parseSync(fileName, source, { sourceType: "module" });
+const program = result.program;
+
+// --- Type extraction helpers ---
+
+function extractType(node) {
+  if (!node) return "any";
+  const ta = node.type === "TSTypeAnnotation" ? node.typeAnnotation : node;
+  switch (ta.type) {
+    case "TSStringKeyword": return "string";
+    case "TSNumberKeyword": return "number";
+    case "TSBooleanKeyword": return "boolean";
+    case "TSVoidKeyword": return "void";
+    case "TSAnyKeyword": return "any";
+    case "TSNullKeyword": return "null";
+    case "TSUndefinedKeyword": return "undefined";
+    case "TSNeverKeyword": return "never";
+    case "TSUnknownKeyword": return "unknown";
+    case "TSBigIntKeyword": return "bigint";
+    case "TSSymbolKeyword": return "symbol";
+    case "TSObjectKeyword": return "object";
+    case "TSArrayType":
+      return `${extractType(ta.elementType)}[]`;
+    case "TSTupleType":
+      return `[${(ta.elementTypes || []).map(e => extractType(e)).join(", ")}]`;
+    case "TSUnionType":
+      return ta.types.map(t => extractType(t)).join(" | ");
+    case "TSIntersectionType":
+      return ta.types.map(t => extractType(t)).join(" & ");
+    case "TSLiteralType": {
+      const lit = ta.literal;
+      if (lit.type === "StringLiteral") return JSON.stringify(lit.value);
+      if (lit.type === "NumericLiteral") return String(lit.value);
+      if (lit.type === "BooleanLiteral") return String(lit.value);
+      if (lit.type === "UnaryExpression") return `-${lit.argument.value}`;
+      return "any";
+    }
+    case "TSTypeReference": {
+      const name = ta.typeName?.name || ta.typeName?.right?.name || "any";
+      const typeArgs = ta.typeArguments || ta.typeParameters;
+      if (typeArgs?.params?.length) {
+        const args = typeArgs.params.map(p => extractType(p)).join(", ");
+        return `${name}<${args}>`;
+      }
+      return name;
+    }
+    case "TSFunctionType": {
+      const params = extractParams(ta.params);
+      const ret = ta.returnType ? extractType(ta.returnType) : "any";
+      return `(${params.join(", ")}) => ${ret}`;
+    }
+    case "TSTypeLiteral": {
+      const members = (ta.members || []).map(m => {
+        if (m.type === "TSPropertySignature") {
+          const key = m.key?.name || m.key?.value;
+          const type = m.typeAnnotation ? extractType(m.typeAnnotation) : "any";
+          const opt = m.optional ? "?" : "";
+          return `${key}${opt}: ${type}`;
+        }
+        return "";
+      }).filter(Boolean);
+      return `{ ${members.join("; ")} }`;
+    }
+    case "TSTypeAnnotation":
+      return extractType(ta.typeAnnotation);
+    default:
+      return "any";
+  }
+}
+
+function extractParams(params) {
+  return params.map(p => {
+    if (p.type === "AssignmentPattern") {
+      const name = p.left?.name || "arg";
+      const type = p.left?.typeAnnotation ? extractType(p.left.typeAnnotation) : "any";
+      return `${name}?: ${type}`;
+    }
+    const name = p.name || p.argument?.name || "arg";
+    const type = p.typeAnnotation ? extractType(p.typeAnnotation) : "any";
+    const opt = p.optional ? "?" : "";
+    const rest = p.type === "RestElement" ? "..." : "";
+    return `${rest}${name}${opt}: ${type}`;
+  });
+}
+
+// Wrap return type: all functions become async over the network
+function wrapReturnType(returnType, isAsync, isGenerator) {
+  if (isGenerator) {
+    // async generator → AsyncIterable<YieldType>
+    // extract inner type from AsyncGenerator<T> if present
+    if (returnType.startsWith("AsyncGenerator")) {
+      const inner = returnType.match(/^AsyncGenerator<(.+?)(?:,.*)?>/);
+      return `Promise<AsyncIterable<${inner ? inner[1] : "any"}>>`;
+    }
+    return `Promise<AsyncIterable<${returnType === "any" ? "any" : returnType}>>`;
+  }
+  // Already Promise<T> → keep as-is
+  if (returnType.startsWith("Promise<")) return returnType;
+  // ReadableStream<T> → Promise<ReadableStream<T>>
+  if (returnType.startsWith("ReadableStream")) return `Promise<${returnType}>`;
+  // Wrap in Promise
+  return `Promise<${returnType}>`;
+}
+
+// --- Generate .d.ts ---
+
+const lines = [
+  "// Auto-generated type definitions (oxc-parser)",
+  "// All functions are async over the network",
+  "",
+];
+
+for (const node of program.body) {
+  if (node.type !== "ExportNamedDeclaration" || !node.declaration) continue;
+  const decl = node.declaration;
+
+  if (decl.type === "FunctionDeclaration") {
+    const name = decl.id.name;
+    const params = extractParams(decl.params);
+    const rawRet = decl.returnType ? extractType(decl.returnType) : "any";
+    const ret = wrapReturnType(rawRet, decl.async, decl.generator);
+    lines.push(`export declare function ${name}(${params.join(", ")}): ${ret};`);
+    lines.push("");
+
+  } else if (decl.type === "ClassDeclaration") {
+    const name = decl.id.name;
+    lines.push(`export declare class ${name} {`);
+    for (const member of decl.body.body) {
+      if (member.type === "MethodDefinition") {
+        const mName = member.key.name || member.key.value;
+        if (member.kind === "constructor") {
+          const params = extractParams(member.value.params);
+          lines.push(`  constructor(${params.join(", ")});`);
+        } else {
+          const params = extractParams(member.value.params);
+          const rawRet = member.value.returnType ? extractType(member.value.returnType) : "any";
+          const ret = wrapReturnType(rawRet, member.value.async, member.value.generator);
+          lines.push(`  ${mName}(${params.join(", ")}): ${ret};`);
+        }
+      } else if (member.type === "PropertyDefinition") {
+        // Skip private members
+        if (member.accessibility === "private") continue;
+        const mName = member.key.name;
+        const type = member.typeAnnotation ? extractType(member.typeAnnotation) : "any";
+        lines.push(`  ${mName}: ${type};`);
+      }
+    }
+    lines.push(`  [Symbol.dispose](): Promise<void>;`);
+    lines.push(`  "[release]"(): Promise<void>;`);
+    lines.push(`}`);
+    lines.push("");
+
+  } else if (decl.type === "VariableDeclaration") {
+    for (const d of decl.declarations) {
+      const name = d.id.name;
+      if (d.init?.type === "ObjectExpression") {
+        lines.push(`export declare const ${name}: {`);
+        for (const prop of d.init.properties) {
+          if (prop.type === "SpreadElement") continue;
+          const key = prop.key?.name || prop.key?.value;
+          if (prop.value?.type === "FunctionExpression" || prop.value?.type === "ArrowFunctionExpression") {
+            const params = extractParams(prop.value.params);
+            const rawRet = prop.value.returnType ? extractType(prop.value.returnType) : "any";
+            const ret = wrapReturnType(rawRet, prop.value.async, prop.value.generator);
+            lines.push(`  ${key}(${params.join(", ")}): ${ret};`);
+          } else {
+            const type = d.id.typeAnnotation ? "any" : "any";
+            lines.push(`  ${key}: any;`);
+          }
+        }
+        lines.push(`};`);
+        lines.push("");
+      } else {
+        const type = d.id.typeAnnotation ? extractType(d.id.typeAnnotation) : "any";
+        lines.push(`export declare const ${name}: ${type};`);
+        lines.push("");
+      }
+    }
+  }
+}
+
+// Add createUploadStream helper type
+lines.push("export declare function createUploadStream(): Promise<{");
+lines.push("  stream: WritableStream<any>;");
+lines.push("  writableId: number;");
+lines.push("}>;");
+
+const typeDefinitions = lines.join("\n");
+
+// Write as a JS module that exports the string
+const outPath = path.join(cwd, ".export-types.js");
+fs.writeFileSync(outPath, `export default ${JSON.stringify(typeDefinitions)};\n`);
+console.log("Generated type definitions →", outPath);

package/entry.js

@@ -1,4 +1,5 @@
 import * as userExports from "__USER_MODULE__";
+import generatedTypes from "__GENERATED_TYPES__";
 import { createHandler } from "./handler.js";
 
-export default createHandler(userExports);
+export default createHandler(userExports, generatedTypes);

package/handler.js

@@ -19,7 +19,79 @@ const isReadableStream = (value) =>
 const isClass = (fn) =>
   typeof fn === "function" && /^class\s/.test(Function.prototype.toString.call(fn));
 
-export const createHandler = (exports) => {
+// 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, generatedTypes) => {
   const exportKeys = Object.keys(exports);
   const iteratorStore = new Map();
   const instanceStore = new Map();
@@ -280,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 = generatedTypes || 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)}]);`)
@@ -291,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.3",
+  "version": "0.0.5",
   "description": "Cloudflare Workers ESM Export Framework Runtime",
   "keywords": [
     "cloudflare",
@@ -22,12 +22,17 @@
   "exports": {
     ".": "./entry.js"
   },
+  "bin": {
+    "generate-export-types": "./bin/generate-types.mjs"
+  },
   "files": [
     "entry.js",
     "handler.js",
-    "client.js"
+    "client.js",
+    "bin/generate-types.mjs"
   ],
   "dependencies": {
-    "devalue": "^5.1.1"
+    "devalue": "^5.1.1",
+    "oxc-parser": "^0.121.0"
   }
 }