devflare 1.0.0-next.21 → 1.0.0-next.22

package/dist/index-xp0qkkxf.js

@@ -0,0 +1,68 @@
+import {
+  bridgeEnv,
+  getContextOrNull
+} from "./index-c1cj9085.js";
+
+// src/env.ts
+var testContextEnv = null;
+var testContextDispose = null;
+function __setTestContext(envBindings, dispose) {
+  testContextEnv = envBindings;
+  testContextDispose = dispose;
+}
+function __clearTestContext() {
+  testContextEnv = null;
+  testContextDispose = null;
+}
+var env = new Proxy({}, {
+  get(_target, prop) {
+    if (prop === "dispose") {
+      return async () => {
+        if (testContextDispose) {
+          await testContextDispose();
+          __clearTestContext();
+        }
+      };
+    }
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return ctx.env[prop];
+    }
+    if (testContextEnv) {
+      return testContextEnv[prop];
+    }
+    return bridgeEnv[prop];
+  },
+  has(_target, prop) {
+    if (prop === "dispose")
+      return true;
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return prop in ctx.env;
+    }
+    if (testContextEnv) {
+      return prop in testContextEnv;
+    }
+    return prop in bridgeEnv;
+  },
+  ownKeys(_target) {
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return Reflect.ownKeys(ctx.env);
+    }
+    if (testContextEnv) {
+      return Reflect.ownKeys(testContextEnv);
+    }
+    return Reflect.ownKeys(bridgeEnv);
+  },
+  getOwnPropertyDescriptor(_target, prop) {
+    if (prop === "dispose") {
+      return { configurable: true, enumerable: false, writable: false };
+    }
+    const ctx = getContextOrNull();
+    const source = ctx?.env ?? testContextEnv ?? bridgeEnv;
+    return Reflect.getOwnPropertyDescriptor(source, prop);
+  }
+});
+
+export { __setTestContext, __clearTestContext, env };

package/dist/index-zawn5tte.js

@@ -0,0 +1,109 @@
+import {
+  bundleWorkerEntry
+} from "./index-w36q6819.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 };