devflare 1.0.0-next.23 → 1.0.0-next.24

package/dist/index-myfjejs0.js

@@ -0,0 +1,185 @@
+import {
+  resolveConfigForEnvironment
+} from "./index-cna43592.js";
+
+// src/cli/commands/previews-support/family.ts
+function compareConfiguredWorkerFamilies(left, right) {
+  if (left.role === "primary" && right.role !== "primary") {
+    return -1;
+  }
+  if (left.role !== "primary" && right.role === "primary") {
+    return 1;
+  }
+  return left.baseName.localeCompare(right.baseName);
+}
+function comparePreviewScopeRows(left, right) {
+  const leftTime = left.updatedAt?.getTime() ?? 0;
+  const rightTime = right.updatedAt?.getTime() ?? 0;
+  if (rightTime !== leftTime) {
+    return rightTime - leftTime;
+  }
+  return left.scope.localeCompare(right.scope);
+}
+function collectConfiguredWorkerFamilies(config, environment) {
+  const resolvedConfig = resolveConfigForEnvironment(config, environment);
+  const families = new Map;
+  families.set(resolvedConfig.name, {
+    baseName: resolvedConfig.name,
+    roleLabel: "primary",
+    role: "primary"
+  });
+  for (const [bindingName, binding] of Object.entries(resolvedConfig.bindings?.services ?? {})) {
+    const existing = families.get(binding.service);
+    if (existing) {
+      continue;
+    }
+    families.set(binding.service, {
+      baseName: binding.service,
+      roleLabel: bindingName,
+      role: "service"
+    });
+  }
+  return Array.from(families.values()).sort(compareConfiguredWorkerFamilies);
+}
+function getWorkerUrl(workerName, workersSubdomain) {
+  if (!workersSubdomain) {
+    return;
+  }
+  return `https://${workerName}.${workersSubdomain}.workers.dev`;
+}
+function getWorkerScopeSuffix(workerName, baseName) {
+  if (!workerName.startsWith(`${baseName}-`)) {
+    return;
+  }
+  const suffix = workerName.slice(baseName.length + 1).trim();
+  return suffix || undefined;
+}
+function buildStableWorkerRowsFromLiveWorkers(families, workers, workersSubdomain) {
+  const workersByName = new Map(workers.map((worker) => [worker.name, worker]));
+  return families.map((family) => {
+    const worker = workersByName.get(family.baseName);
+    const status = worker ? "active" : "missing";
+    return {
+      workerName: family.baseName,
+      role: family.roleLabel,
+      status,
+      updatedAt: worker?.modifiedOn,
+      url: worker ? getWorkerUrl(family.baseName, workersSubdomain) : undefined
+    };
+  });
+}
+function getDedicatedPreviewFamilyNamesFromWorkers(families, workers) {
+  const familyNames = new Set;
+  const workerNames = workers.map((worker) => worker.name);
+  for (const family of families) {
+    if (family.role === "primary") {
+      familyNames.add(family.baseName);
+      continue;
+    }
+    if (workerNames.some((workerName) => Boolean(getWorkerScopeSuffix(workerName, family.baseName)))) {
+      familyNames.add(family.baseName);
+    }
+  }
+  return familyNames;
+}
+function buildPreviewScopeRowsFromLiveWorkers(families, workers, workersSubdomain) {
+  const workersByName = new Map(workers.map((worker) => [worker.name, worker]));
+  const previewFamilyNames = getDedicatedPreviewFamilyNamesFromWorkers(families, workers);
+  const expectedFamilies = families.filter((family) => previewFamilyNames.has(family.baseName));
+  const workerCandidatesByScope = buildPreviewWorkerCandidatesByScope(families, workers);
+  return Array.from(workerCandidatesByScope.keys()).map((scope) => {
+    const resolvedFamilies = expectedFamilies.map((family) => ({
+      family,
+      worker: workersByName.get(`${family.baseName}-${scope}`)
+    }));
+    const presentFamilies = resolvedFamilies.filter((entry) => entry.worker);
+    const updatedAt = presentFamilies.reduce((latest, entry) => {
+      const currentDate = entry.worker?.modifiedOn;
+      if (!currentDate) {
+        return latest;
+      }
+      if (!latest || currentDate.getTime() > latest.getTime()) {
+        return currentDate;
+      }
+      return latest;
+    }, undefined);
+    const primaryEntry = resolvedFamilies.find((entry) => entry.family.role === "primary");
+    const entryWorker = primaryEntry?.worker ?? presentFamilies[0]?.worker;
+    const missingLabels = resolvedFamilies.filter((entry) => !entry.worker).map((entry) => entry.family.role === "primary" ? "primary" : entry.family.roleLabel);
+    const notes = [];
+    if (missingLabels.length > 0) {
+      notes.push(`missing ${missingLabels.join(", ")}`);
+    }
+    const strategy = "dedicated workers";
+    const status = presentFamilies.length === resolvedFamilies.length ? "ready" : "partial";
+    return {
+      scope,
+      strategy,
+      workersLabel: `${presentFamilies.length}/${resolvedFamilies.length}`,
+      status,
+      updatedAt,
+      notes: notes.length > 0 ? notes.join(" · ") : undefined,
+      entryUrl: entryWorker ? getWorkerUrl(entryWorker.name, workersSubdomain) : undefined
+    };
+  }).sort(comparePreviewScopeRows);
+}
+function buildPreviewWorkerCandidatesByScope(families, workers) {
+  const candidates = new Map;
+  for (const worker of workers) {
+    for (const family of families) {
+      const scope = getWorkerScopeSuffix(worker.name, family.baseName);
+      if (!scope) {
+        continue;
+      }
+      const names = candidates.get(scope) ?? new Set;
+      names.add(worker.name);
+      candidates.set(scope, names);
+    }
+  }
+  return new Map(Array.from(candidates.entries()).map(([scope, workerNames]) => {
+    return [scope, Array.from(workerNames).sort((left, right) => left.localeCompare(right))];
+  }));
+}
+function orderPreviewWorkerNamesForDeletion(workerNames, scope, families) {
+  const familyPriority = new Map;
+  for (const family of families) {
+    familyPriority.set(family.baseName, {
+      priority: family.role === "primary" ? 0 : 1,
+      roleLabel: family.roleLabel
+    });
+  }
+  const resolveFamilyForWorker = (workerName) => {
+    for (const family of families) {
+      if (getWorkerScopeSuffix(workerName, family.baseName) === scope) {
+        const resolved = familyPriority.get(family.baseName);
+        if (resolved) {
+          return {
+            priority: resolved.priority,
+            roleLabel: resolved.roleLabel,
+            baseName: family.baseName
+          };
+        }
+      }
+    }
+    return {
+      priority: 2,
+      roleLabel: workerName
+    };
+  };
+  return [...workerNames].sort((left, right) => {
+    const leftFamily = resolveFamilyForWorker(left);
+    const rightFamily = resolveFamilyForWorker(right);
+    if (leftFamily.priority !== rightFamily.priority) {
+      return leftFamily.priority - rightFamily.priority;
+    }
+    if (leftFamily.roleLabel !== rightFamily.roleLabel) {
+      return leftFamily.roleLabel.localeCompare(rightFamily.roleLabel);
+    }
+    if (leftFamily.baseName && rightFamily.baseName && leftFamily.baseName !== rightFamily.baseName) {
+      return leftFamily.baseName.localeCompare(rightFamily.baseName);
+    }
+    return left.localeCompare(right);
+  });
+}
+
+export { collectConfiguredWorkerFamilies, buildStableWorkerRowsFromLiveWorkers, buildPreviewScopeRowsFromLiveWorkers, buildPreviewWorkerCandidatesByScope, orderPreviewWorkerNamesForDeletion };

package/dist/index-qkfvd3cs.js

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