devflare 1.0.0-next.3 → 1.0.0-next.31

package/dist/index-627srx16.js

@@ -0,0 +1,45 @@
+// src/cli/package-metadata.ts
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "pathe";
+var packageMetadataPromise = null;
+async function loadPackageMetadata() {
+  let currentDir = dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const packageJsonPath = resolve(currentDir, "package.json");
+    try {
+      const packageJson = await readFile(packageJsonPath, "utf8");
+      const metadata = JSON.parse(packageJson);
+      if (metadata.name === "devflare") {
+        return metadata;
+      }
+    } catch {}
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      throw new Error("Could not resolve the devflare package.json file");
+    }
+    currentDir = parentDir;
+  }
+}
+async function getPackageMetadata() {
+  if (!packageMetadataPromise) {
+    packageMetadataPromise = loadPackageMetadata();
+  }
+  return packageMetadataPromise;
+}
+async function getPackageVersion() {
+  return (await getPackageMetadata()).version ?? "0.0.0";
+}
+async function getInitDependencyVersions() {
+  const metadata = await getPackageMetadata();
+  const dependencies = metadata.dependencies ?? {};
+  const devDependencies = metadata.devDependencies ?? {};
+  return {
+    devflare: `^${metadata.version ?? "0.0.0"}`,
+    typescript: devDependencies.typescript ?? "^5.7.0",
+    wrangler: dependencies.wrangler ?? devDependencies.wrangler ?? "^4.85.0",
+    workersTypes: devDependencies["@cloudflare/workers-types"] ?? "^4.20250109.0"
+  };
+}
+
+export { getPackageVersion, getInitDependencyVersions };

package/dist/index-62b3gt2g.js

@@ -0,0 +1,12 @@
+// src/workerName.ts
+var workerName = (() => {
+  if (typeof __DEVFLARE_WORKER_NAME__ !== "undefined") {
+    return __DEVFLARE_WORKER_NAME__;
+  }
+  if (typeof process !== "undefined" && process.env?.DEVFLARE_WORKER_NAME) {
+    return process.env.DEVFLARE_WORKER_NAME;
+  }
+  return "unknown";
+})();
+
+export { workerName };

package/dist/index-67gr49zr.js

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