devflare 1.0.0-next.3 → 1.0.0-next.30

package/dist/{index-z14anrqp.js → index-aqrwyy57.js}

@@ -1,6 +1,26 @@
 // src/transform/worker-entrypoint.ts
 import ts from "typescript";
 import MagicString from "magic-string";
+
+// src/worker-entry/extensions.ts
+var SUPPORTED_WORKER_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".mjs",
+  ".cts",
+  ".cjs",
+  ".js",
+  ".jsx"
+];
+var TS_WORKER_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts"
+];
+
+// src/transform/worker-entrypoint.ts
 function findExportedFunctions(code) {
   const functions = [];
   const sourceFile = ts.createSourceFile("worker.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
@@ -79,8 +99,14 @@ function findExportedFunctions(code) {
   visit(sourceFile);
   return functions;
 }
+function shouldEmitTsSyntax(filename) {
+  const lower = filename.toLowerCase();
+  return TS_WORKER_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
 function shouldTransformWorker(code, filePath) {
-  if (!filePath.endsWith("worker.ts") && !filePath.endsWith("worker.js")) {
+  const lower = filePath.toLowerCase();
+  const isWorkerFile = SUPPORTED_WORKER_EXTENSIONS.some((ext) => lower.endsWith(`worker${ext}`));
+  if (!isWorkerFile) {
     return false;
   }
   const functions = findExportedFunctions(code);
@@ -89,63 +115,98 @@ function shouldTransformWorker(code, filePath) {
 function transformWorkerEntrypoint(code, id, options = {}) {
   const className = options.className ?? "Worker";
   const injectContext = options.injectContext ?? true;
+  const emitTs = shouldEmitTsSyntax(id);
   const functions = findExportedFunctions(code);
   if (functions.length === 0) {
     return null;
   }
   const fetchFn = functions.find((f) => f.name === "fetch");
   const rpcMethods = functions.filter((f) => f.name !== "fetch");
+  const needsFetchHelpers = Boolean(fetchFn);
   const s = new MagicString(code);
   const importStatement = `import { WorkerEntrypoint } from 'cloudflare:workers'
 `;
-  if (injectContext) {
-    s.prepend(`import { runWithContext } from 'devflare/runtime'
+  if (needsFetchHelpers) {
+    const runtimeImports = ["createFetchEvent", "invokeFetchHandler"];
+    if (injectContext) {
+      runtimeImports.push("runWithEventContext");
+    }
+    s.prepend(`import { ${runtimeImports.join(", ")} } from 'devflare/runtime'
 `);
   }
   s.prepend(importStatement);
-  for (const fn of functions) {
-    const fnCode = code.substring(fn.start, fn.end);
-    const internalName = fn.name === "fetch" ? "__originalFetch" : `__original_${fn.name}`;
-    if (fn.isDefault) {
-      const replacement = fnCode.replace(/^export\s+default\s+(async\s+)?function\s*/, (_, asyncKw) => `const ${internalName} = ${asyncKw || ""}function `);
-      s.overwrite(fn.start, fn.end, replacement);
-    } else if (fnCode.startsWith("export function") || fnCode.startsWith("export async function")) {
-      const replacement = fnCode.replace(/^export\s+(async\s+)?function\s+\w+/, (_, asyncKw) => `${asyncKw || ""}function ${internalName}`);
-      s.overwrite(fn.start, fn.end, replacement);
-    } else if (fnCode.startsWith("export const")) {
-      const replacement = fnCode.replace(/^export\s+const\s+\w+/, () => `const ${internalName}`);
-      s.overwrite(fn.start, fn.end, replacement);
+  const sourceFile = ts.createSourceFile("worker.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const internalNameFor = (name) => name === "fetch" ? "__originalFetch" : `__original_${name}`;
+  function visit(node) {
+    if (ts.isFunctionDeclaration(node)) {
+      const modifiers = ts.getModifiers(node);
+      const exportMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      const defaultMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+      const asyncMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
+      if (exportMod) {
+        const isDefault = Boolean(defaultMod);
+        const logicalName = isDefault ? "fetch" : node.name?.text;
+        if (logicalName) {
+          const internal = internalNameFor(logicalName);
+          if (isDefault && !node.name) {
+            const funcKeyword = node.getChildren(sourceFile).find((c) => c.kind === ts.SyntaxKind.FunctionKeyword);
+            if (funcKeyword) {
+              const asyncKw = asyncMod ? "async " : "";
+              s.overwrite(node.getStart(sourceFile), funcKeyword.getStart(sourceFile), `const ${internal} = ${asyncKw}`);
+            }
+          } else if (node.name) {
+            s.remove(exportMod.getStart(sourceFile), exportMod.getEnd());
+            if (defaultMod) {
+              s.remove(defaultMod.getStart(sourceFile), defaultMod.getEnd());
+            }
+            s.overwrite(node.name.getStart(sourceFile), node.name.getEnd(), internal);
+          }
+        }
+      }
+    } else if (ts.isVariableStatement(node)) {
+      const modifiers = ts.getModifiers(node);
+      const exportMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      if (exportMod) {
+        let rewroteAny = false;
+        for (const decl of node.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name) && decl.initializer && (ts.isFunctionExpression(decl.initializer) || ts.isArrowFunction(decl.initializer))) {
+            const internal = internalNameFor(decl.name.text);
+            s.overwrite(decl.name.getStart(sourceFile), decl.name.getEnd(), internal);
+            rewroteAny = true;
+          }
+        }
+        if (rewroteAny) {
+          s.remove(exportMod.getStart(sourceFile), exportMod.getEnd());
+        }
+      }
     }
+    ts.forEachChild(node, visit);
   }
+  visit(sourceFile);
   let classBody = `
 
 // ============ Devflare WorkerEntrypoint ============
 class ${className} extends WorkerEntrypoint {
 `;
   if (fetchFn) {
-    if (injectContext) {
-      classBody += `	async fetch(request: Request): Promise<Response> {
-`;
-      classBody += `		return runWithContext(
+    const fetchSig = emitTs ? "async fetch(request: Request): Promise<Response>" : "async fetch(request)";
+    classBody += `	${fetchSig} {
 `;
-      classBody += `			this.env,
+    classBody += `		const __devflareEvent = createFetchEvent(request, this.env, this.ctx)
 `;
-      classBody += `			this.ctx,
-`;
-      classBody += `			request,
+    if (injectContext) {
+      classBody += `		return runWithEventContext(
 `;
-      classBody += `			() => __originalFetch(request, this.env, this.ctx),
+      classBody += `			__devflareEvent,
 `;
-      classBody += `			'fetch'
+      classBody += `			() => invokeFetchHandler(__originalFetch, __devflareEvent)
 `;
       classBody += `		)
 `;
       classBody += `	}
 `;
     } else {
-      classBody += `	async fetch(request: Request): Promise<Response> {
-`;
-      classBody += `		return __originalFetch(request, this.env, this.ctx)
+      classBody += `		return invokeFetchHandler(__originalFetch, __devflareEvent)
 `;
       classBody += `	}
 `;
@@ -153,10 +214,11 @@ class ${className} extends WorkerEntrypoint {
   }
   for (const fn of rpcMethods) {
     const asyncPrefix = fn.isAsync ? "async " : "";
-    const returnType = fn.returnType ? `: ${fn.returnType}` : "";
     const paramNames = extractParamNames(fn.params);
+    const signatureParams = emitTs ? fn.params : paramNames;
+    const returnType = emitTs && fn.returnType ? `: ${fn.returnType}` : "";
     classBody += `
-	${asyncPrefix}${fn.name}(${fn.params})${returnType} {
+	${asyncPrefix}${fn.name}(${signatureParams})${returnType} {
 `;
     classBody += `		return __original_${fn.name}(${paramNames})
 `;
@@ -223,4 +285,4 @@ function generateRpcInterface(functions, interfaceName) {
   return output;
 }
 
-export { findExportedFunctions, shouldTransformWorker, transformWorkerEntrypoint, generateRpcInterface };
+export { SUPPORTED_WORKER_EXTENSIONS, findExportedFunctions, shouldEmitTsSyntax, shouldTransformWorker, transformWorkerEntrypoint, generateRpcInterface };

package/dist/index-c4jmfzz7.js

@@ -0,0 +1,109 @@
+import {
+  bundleWorkerEntry
+} from "./index-0gtmnw0m.js";
+import {
+  DEFAULT_WORKFLOW_PATTERN,
+  findFiles
+} from "./index-qwgr4q7s.js";
+import {
+  normalizeWorkflowBinding
+} from "./index-2sc756r1.js";
+
+// src/workflows/local-workflow-entrypoints.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative, resolve } from "pathe";
+function findExportedClasses(code) {
+  const classes = [];
+  const classPattern = /export\s+class\s+(\w+)/g;
+  let match;
+  while ((match = classPattern.exec(code)) !== null) {
+    classes.push(match[1]);
+  }
+  return classes;
+}
+function toImportSpecifier(fromDir, filePath) {
+  const relativePath = relative(fromDir, filePath).replace(/\\/g, "/");
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+async function discoverWorkflowClasses(config, configDir) {
+  const classToFilePath = new Map;
+  const workflowPatternConfig = config.files?.workflows;
+  const workflowPattern = typeof workflowPatternConfig === "string" ? workflowPatternConfig : DEFAULT_WORKFLOW_PATTERN;
+  if (workflowPatternConfig === false) {
+    return classToFilePath;
+  }
+  const files = await findFiles(workflowPattern, { cwd: configDir });
+  for (const filePath of files) {
+    try {
+      const code = await readFile(filePath, "utf-8");
+      for (const className of findExportedClasses(code)) {
+        classToFilePath.set(className, filePath);
+      }
+    } catch {}
+  }
+  return classToFilePath;
+}
+async function resolveLocalWorkflowEntrypoints(config, configDir) {
+  const workflows = config.bindings?.workflows;
+  if (!workflows || Object.keys(workflows).length === 0) {
+    return [];
+  }
+  const classToFilePath = await discoverWorkflowClasses(config, configDir);
+  const entrypoints = [];
+  for (const [bindingName, binding] of Object.entries(workflows)) {
+    const normalized = normalizeWorkflowBinding(binding);
+    if (normalized.scriptName) {
+      continue;
+    }
+    const scriptPath = classToFilePath.get(normalized.className);
+    if (!scriptPath) {
+      throw new Error(`Workflow binding ${bindingName} (className: '${normalized.className}') not found.
+` + `Either set files.workflows to match the workflow source file, or set scriptName when the workflow lives in another worker.`);
+    }
+    entrypoints.push({
+      bindingName,
+      className: normalized.className,
+      scriptPath
+    });
+  }
+  return entrypoints;
+}
+function buildWorkflowVirtualEntry(entrypoints, entryDir) {
+  const imports = entrypoints.map((entrypoint, index) => {
+    const importName = `__DevflareWorkflow${index}`;
+    const importPath = toImportSpecifier(entryDir, entrypoint.scriptPath);
+    return {
+      importName,
+      className: entrypoint.className,
+      line: `import { ${entrypoint.className} as ${importName} } from '${importPath}'`
+    };
+  });
+  const exports = imports.map((entrypoint) => {
+    return `export { ${entrypoint.importName} as ${entrypoint.className} }`;
+  });
+  return [...imports.map((entrypoint) => entrypoint.line), "", ...exports].join(`
+`);
+}
+async function bundleWorkflowEntrypointScript(config, configDir, options = {}) {
+  const entrypoints = await resolveLocalWorkflowEntrypoints(config, configDir);
+  if (entrypoints.length === 0) {
+    return "";
+  }
+  const entryDir = resolve(configDir, ".devflare", "workflow-entrypoints");
+  const entryPath = join(entryDir, "__entry.ts");
+  const outFile = join(entryDir, "index.js");
+  await mkdir(entryDir, { recursive: true });
+  await writeFile(entryPath, buildWorkflowVirtualEntry(entrypoints, entryDir));
+  await bundleWorkerEntry({
+    cwd: configDir,
+    inputFile: entryPath,
+    outFile,
+    rolldownOptions: config.rolldown?.options,
+    sourcemap: config.rolldown?.sourcemap,
+    minify: config.rolldown?.minify,
+    logger: options.logger
+  });
+  return await readFile(outFile, "utf-8");
+}
+
+export { bundleWorkflowEntrypointScript };