devflare 1.0.0-next.20 → 1.0.0-next.21

package/dist/index-aqrwyy57.js

@@ -0,0 +1,288 @@
+// 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);
+  function visit(node) {
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      const modifiers = ts.getModifiers(node);
+      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+      if (isExported) {
+        const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        const funcName = isDefault ? "fetch" : node.name.text;
+        const params = node.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
+        const returnType = node.type ? code.substring(node.type.getStart(sourceFile), node.type.getEnd()) : undefined;
+        functions.push({
+          name: funcName,
+          isAsync,
+          params,
+          returnType,
+          start: node.getStart(sourceFile),
+          end: node.getEnd(),
+          isDefault
+        });
+      }
+    }
+    if (ts.isFunctionDeclaration(node) && !node.name) {
+      const modifiers = ts.getModifiers(node);
+      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+      if (isExported && isDefault) {
+        const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        const params = node.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
+        const returnType = node.type ? code.substring(node.type.getStart(sourceFile), node.type.getEnd()) : undefined;
+        functions.push({
+          name: "fetch",
+          isAsync,
+          params,
+          returnType,
+          start: node.getStart(sourceFile),
+          end: node.getEnd(),
+          isDefault: true
+        });
+      }
+    }
+    if (ts.isVariableStatement(node)) {
+      const modifiers = ts.getModifiers(node);
+      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      if (isExported) {
+        for (const decl of node.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name) && decl.initializer) {
+            let funcExpr;
+            if (ts.isFunctionExpression(decl.initializer)) {
+              funcExpr = decl.initializer;
+            } else if (ts.isArrowFunction(decl.initializer)) {
+              funcExpr = decl.initializer;
+            }
+            if (funcExpr) {
+              const modifiersArr = ts.getModifiers(funcExpr);
+              const isAsync = modifiersArr?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? (ts.isArrowFunction(funcExpr) && funcExpr.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) ?? false;
+              const params = funcExpr.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
+              const returnType = funcExpr.type ? code.substring(funcExpr.type.getStart(sourceFile), funcExpr.type.getEnd()) : undefined;
+              functions.push({
+                name: decl.name.text,
+                isAsync,
+                params,
+                returnType,
+                start: node.getStart(sourceFile),
+                end: node.getEnd()
+              });
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return functions;
+}
+function shouldEmitTsSyntax(filename) {
+  const lower = filename.toLowerCase();
+  return TS_WORKER_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+function shouldTransformWorker(code, filePath) {
+  const lower = filePath.toLowerCase();
+  const isWorkerFile = SUPPORTED_WORKER_EXTENSIONS.some((ext) => lower.endsWith(`worker${ext}`));
+  if (!isWorkerFile) {
+    return false;
+  }
+  const functions = findExportedFunctions(code);
+  return functions.length > 0;
+}
+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 (needsFetchHelpers) {
+    const runtimeImports = ["createFetchEvent", "invokeFetchHandler"];
+    if (injectContext) {
+      runtimeImports.push("runWithEventContext");
+    }
+    s.prepend(`import { ${runtimeImports.join(", ")} } from 'devflare/runtime'
+`);
+  }
+  s.prepend(importStatement);
+  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) {
+    const fetchSig = emitTs ? "async fetch(request: Request): Promise<Response>" : "async fetch(request)";
+    classBody += `	${fetchSig} {
+`;
+    classBody += `		const __devflareEvent = createFetchEvent(request, this.env, this.ctx)
+`;
+    if (injectContext) {
+      classBody += `		return runWithEventContext(
+`;
+      classBody += `			__devflareEvent,
+`;
+      classBody += `			() => invokeFetchHandler(__originalFetch, __devflareEvent)
+`;
+      classBody += `		)
+`;
+      classBody += `	}
+`;
+    } else {
+      classBody += `		return invokeFetchHandler(__originalFetch, __devflareEvent)
+`;
+      classBody += `	}
+`;
+    }
+  }
+  for (const fn of rpcMethods) {
+    const asyncPrefix = fn.isAsync ? "async " : "";
+    const paramNames = extractParamNames(fn.params);
+    const signatureParams = emitTs ? fn.params : paramNames;
+    const returnType = emitTs && fn.returnType ? `: ${fn.returnType}` : "";
+    classBody += `
+	${asyncPrefix}${fn.name}(${signatureParams})${returnType} {
+`;
+    classBody += `		return __original_${fn.name}(${paramNames})
+`;
+    classBody += `	}
+`;
+  }
+  classBody += `}
+
+`;
+  classBody += `export { ${className} }
+`;
+  classBody += `export { ${className} as default }
+`;
+  classBody += `// ============ End Devflare WorkerEntrypoint ============
+`;
+  s.append(classBody);
+  return {
+    code: s.toString(),
+    map: s.generateMap({
+      source: id,
+      file: id + ".map",
+      includeContent: true
+    }),
+    rpcMethods: rpcMethods.map((fn) => fn.name),
+    className
+  };
+}
+function extractParamNames(params) {
+  if (!params.trim())
+    return "";
+  const tempCode = `function f(${params}) {}`;
+  const sourceFile = ts.createSourceFile("temp.ts", tempCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const names = [];
+  function visit(node) {
+    if (ts.isFunctionDeclaration(node)) {
+      for (const param of node.parameters) {
+        if (ts.isIdentifier(param.name)) {
+          names.push(param.name.text);
+        } else if (ts.isObjectBindingPattern(param.name) || ts.isArrayBindingPattern(param.name)) {
+          names.push(tempCode.substring(param.name.getStart(sourceFile), param.name.getEnd()));
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return names.join(", ");
+}
+function generateRpcInterface(functions, interfaceName) {
+  const rpcMethods = functions.filter((f) => f.name !== "fetch");
+  if (rpcMethods.length === 0) {
+    return "";
+  }
+  let output = `export interface ${interfaceName} {
+`;
+  for (const fn of rpcMethods) {
+    const returnType = fn.returnType ?? "unknown";
+    const promiseReturn = returnType.startsWith("Promise<") ? returnType : `Promise<${returnType}>`;
+    output += `	${fn.name}(${fn.params}): ${promiseReturn}
+`;
+  }
+  output += `}
+`;
+  return output;
+}
+
+export { SUPPORTED_WORKER_EXTENSIONS, findExportedFunctions, shouldEmitTsSyntax, shouldTransformWorker, transformWorkerEntrypoint, generateRpcInterface };

package/dist/index-bj5avaba.js

@@ -0,0 +1,109 @@
+import {
+  bundleWorkerEntry
+} from "./index-666tdx14.js";
+import {
+  DEFAULT_WORKFLOW_PATTERN,
+  findFiles
+} from "./index-qwgr4q7s.js";
+import {
+  normalizeWorkflowBinding
+} from "./index-syscwrjp.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 };