devflare 1.0.0-next.15 → 1.0.0-next.17

package/dist/{types-158m16vd.js → types-qjcd1jks.js}

@@ -1,13 +1,21 @@
 import {
   resolveConfigCandidatePath
-} from "./index-k8vh558d.js";
+} from "./index-v922fmsx.js";
 import {
   getDependencies
-} from "./index-1xpj0m4r.js";
+} from "./index-z9gy8w6b.js";
+import {
+  bold,
+  createCliTheme,
+  dim
+} from "./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
+import {
+  discoverEntrypointsAsync
+} from "./index-zt22fe2j.js";
 import {
-  discoverEntrypointsAsync,
   resolvePackageSpecifier
-} from "./index-2q3pmzrx.js";
+} from "./index-82f1z98k.js";
 import {
   DEFAULT_DO_PATTERN,
   DEFAULT_ENTRYPOINT_PATTERN,
@@ -16,91 +24,179 @@ import {
 import {
   findDurableObjectClasses
 } from "./index-9wt9x09k.js";
-import"./index-5s1bz1e0.js";
+import"./index-n8k8chde.js";
 import {
   loadConfig,
   normalizeDOBinding
-} from "./index-tksw7gpy.js";
-import"./index-v8vvsn9x.js";
-import"./index-xdq9ery1.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
+} from "./index-dmbdj6va.js";
+import"./index-nte9n8w9.js";
+import"./index-z9fjnwa8.js";
+import"./index-p296ban8.js";
+import"./index-tte89s31.js";
+import"./index-37x76zdn.js";
 
 // src/cli/commands/types.ts
-import { resolve, relative, dirname } from "pathe";
+import { resolve } from "pathe";
+
+// src/cli/commands/type-generation/discovery.ts
+import { readFile } from "node:fs/promises";
+import { dirname, relative } from "pathe";
+var DEFAULT_INTERFACE_LOOKUP_KEYS = new Set(["Worker", "Default", "MathService"]);
+var interfaceTypeCache = new Map;
+async function readFileIfAvailable(filePath) {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function getInterfaceSearchKey(searchDirs) {
+  return [...new Set(searchDirs)].sort((left, right) => left.localeCompare(right)).join("\x00");
+}
+function getPatternMatches(pattern, code) {
+  const matches = [];
+  pattern.lastIndex = 0;
+  let nextMatch = pattern.exec(code);
+  while (nextMatch !== null) {
+    matches.push(nextMatch);
+    nextMatch = pattern.exec(code);
+  }
+  return matches;
+}
+function getInterfaceBaseName(interfaceName) {
+  if (interfaceName.endsWith("Interface")) {
+    return interfaceName.slice(0, -9);
+  }
+  if (interfaceName.endsWith("Rpc")) {
+    return interfaceName.slice(0, -3);
+  }
+  return null;
+}
+function registerInterfaceType(interfaces, baseName, interfaceInfo) {
+  if (!interfaces.has(baseName)) {
+    interfaces.set(baseName, interfaceInfo);
+  }
+  if (!interfaces.has("__default__") && DEFAULT_INTERFACE_LOOKUP_KEYS.has(baseName)) {
+    interfaces.set("__default__", interfaceInfo);
+  }
+}
+async function collectInterfaceTypesFromFile(interfaces, filePath) {
+  const code = await readFileIfAvailable(filePath);
+  if (!code) {
+    return;
+  }
+  const interfacePattern = /export\s+interface\s+(\w+(?:Interface|Rpc))\s*\{/g;
+  for (const match of getPatternMatches(interfacePattern, code)) {
+    const interfaceName = match[1];
+    const baseName = getInterfaceBaseName(interfaceName);
+    if (!baseName) {
+      continue;
+    }
+    registerInterfaceType(interfaces, baseName, {
+      filePath,
+      interfaceName
+    });
+  }
+}
 async function parseConfigForRefs(configPath) {
-  const fs = await import("node:fs/promises");
   const refs = [];
   const serviceBindings = [];
   const doBindings = [];
-  try {
-    const code = await fs.readFile(configPath, "utf-8");
-    const refPattern = /const\s+(\w+)\s*=\s*ref\s*\(\s*(?:'[^']*'\s*,\s*)?(?:\(\s*\)\s*=>\s*)?import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    let match;
-    while ((match = refPattern.exec(code)) !== null) {
-      refs.push({
-        varName: match[1],
-        importPath: match[2]
-      });
-    }
-    const servicePattern = /(\w+)\s*:\s*(\w+)\.worker(?:\s*\(\s*['"](\w+)['"]\s*\))?/g;
-    while ((match = servicePattern.exec(code)) !== null) {
-      serviceBindings.push({
-        bindingName: match[1],
-        varName: match[2],
-        entrypoint: match[3]
-      });
-    }
-    const doPattern = /(\w+)\s*:\s*(\w+)\.([A-Z][A-Z0-9_]*)\s*[,\n\r}]/g;
-    while ((match = doPattern.exec(code)) !== null) {
-      if (match[3] === "worker")
-        continue;
-      doBindings.push({
-        bindingName: match[1],
-        varName: match[2],
-        doName: match[3]
-      });
+  const code = await readFileIfAvailable(configPath);
+  if (!code) {
+    return {
+      refs,
+      serviceBindings,
+      doBindings
+    };
+  }
+  const refPattern = /const\s+(\w+)\s*=\s*ref\s*\(\s*(?:'[^']*'\s*,\s*)?(?:\(\s*\)\s*=>\s*)?import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  for (const match of getPatternMatches(refPattern, code)) {
+    refs.push({
+      varName: match[1],
+      importPath: match[2]
+    });
+  }
+  const servicePattern = /(\w+)\s*:\s*(\w+)\.worker(?:\s*\(\s*['"](\w+)['"]\s*\))?/g;
+  for (const match of getPatternMatches(servicePattern, code)) {
+    serviceBindings.push({
+      bindingName: match[1],
+      varName: match[2],
+      entrypoint: match[3]
+    });
+  }
+  const doPattern = /(\w+)\s*:\s*(\w+)\.([A-Z][A-Z0-9_]*)\s*[,\n\r}]/g;
+  for (const match of getPatternMatches(doPattern, code)) {
+    if (match[3] === "worker") {
+      continue;
     }
-  } catch {}
-  return { refs, serviceBindings, doBindings };
+    doBindings.push({
+      bindingName: match[1],
+      varName: match[2],
+      doName: match[3]
+    });
+  }
+  return {
+    refs,
+    serviceBindings,
+    doBindings
+  };
 }
 async function findInterfaceTypes(searchDirs) {
-  const fs = await import("node:fs/promises");
   const interfaces = new Map;
-  for (const dir of searchDirs) {
+  for (const dir of [...new Set(searchDirs)]) {
     const typeFiles = await findFiles("**/*.types.ts", { cwd: dir });
     const srcFiles = await findFiles("src/**/*.ts", { cwd: dir });
     const allFiles = [...new Set([...typeFiles, ...srcFiles])];
     for (const filePath of allFiles) {
-      try {
-        const code = await fs.readFile(filePath, "utf-8");
-        const interfacePattern = /export\s+interface\s+(\w+(?:Interface|Rpc))\s*\{/g;
-        let match;
-        while ((match = interfacePattern.exec(code)) !== null) {
-          const interfaceName = match[1];
-          let baseName;
-          if (interfaceName.endsWith("Interface")) {
-            baseName = interfaceName.slice(0, -9);
-          } else if (interfaceName.endsWith("Rpc")) {
-            baseName = interfaceName.slice(0, -3);
-          } else {
-            continue;
-          }
-          if (!interfaces.has(baseName)) {
-            interfaces.set(baseName, { filePath, interfaceName });
-          }
-          if (!interfaces.has("__default__")) {
-            if (baseName === "Worker" || baseName === "Default" || baseName === "MathService") {
-              interfaces.set("__default__", { filePath, interfaceName });
-            }
-          }
-        }
-      } catch {}
+      await collectInterfaceTypesFromFile(interfaces, filePath);
     }
   }
   return interfaces;
 }
+async function getCachedInterfaceTypes(searchDirs) {
+  const cacheKey = getInterfaceSearchKey(searchDirs);
+  const cached = interfaceTypeCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const pending = findInterfaceTypes(searchDirs);
+  interfaceTypeCache.set(cacheKey, pending);
+  try {
+    return await pending;
+  } catch (error) {
+    interfaceTypeCache.delete(cacheKey);
+    throw error;
+  }
+}
+async function discoverDurableObjects(cwd, pattern = DEFAULT_DO_PATTERN) {
+  const discovered = [];
+  const files = await findFiles(pattern, { cwd });
+  for (const filePath of files) {
+    const code = await readFileIfAvailable(filePath);
+    if (!code) {
+      continue;
+    }
+    const classNames = findDurableObjectClasses(code);
+    for (const className of classNames) {
+      const bindingName = className.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
+      discovered.push({
+        className,
+        filePath,
+        bindingName
+      });
+    }
+  }
+  return discovered;
+}
+function generateImportPath(cwd, filePath) {
+  let relativePath = relative(cwd, filePath);
+  relativePath = relativePath.replace(/\.(ts|tsx|js|jsx)$/, "");
+  if (!relativePath.startsWith(".") && !relativePath.startsWith("/")) {
+    relativePath = `./${relativePath}`;
+  }
+  return relativePath;
+}
 async function resolveReferencedConfigs(configPath, cwd) {
   const referenced = [];
   const { refs, serviceBindings, doBindings } = await parseConfigForRefs(configPath);
@@ -108,6 +204,7 @@ async function resolveReferencedConfigs(configPath, cwd) {
     return referenced;
   }
   const configDir = dirname(configPath);
+  const referencedConfigDetailsByPath = new Map;
   for (const ref of refs) {
     const refImportPath = resolvePackageSpecifier(ref.importPath, configDir);
     const refConfigPath = await resolveConfigCandidatePath(refImportPath);
@@ -115,17 +212,32 @@ async function resolveReferencedConfigs(configPath, cwd) {
       continue;
     }
     try {
-      const refDir = dirname(refConfigPath);
-      const entrypoints = await discoverEntrypointsAsync(refDir, DEFAULT_ENTRYPOINT_PATTERN);
-      const refDOs = await discoverDurableObjects(refDir, DEFAULT_DO_PATTERN);
-      const interfaceMap = await findInterfaceTypes([configDir, refDir]);
-      const bindings = serviceBindings.filter((sb) => sb.varName === ref.varName).map((sb) => {
+      let referencedConfigDetails = referencedConfigDetailsByPath.get(refConfigPath);
+      if (!referencedConfigDetails) {
+        referencedConfigDetails = (async () => {
+          const refDir2 = dirname(refConfigPath);
+          return {
+            refDir: refDir2,
+            entrypoints: await discoverEntrypointsAsync(refDir2, DEFAULT_ENTRYPOINT_PATTERN),
+            refDOs: await discoverDurableObjects(refDir2, DEFAULT_DO_PATTERN),
+            interfaceMap: await getCachedInterfaceTypes([configDir, refDir2])
+          };
+        })();
+        referencedConfigDetailsByPath.set(refConfigPath, referencedConfigDetails);
+      }
+      const {
+        refDir,
+        entrypoints,
+        refDOs,
+        interfaceMap
+      } = await referencedConfigDetails;
+      const bindings = serviceBindings.filter((serviceBinding) => serviceBinding.varName === ref.varName).map((serviceBinding) => {
         const info = {
-          bindingName: sb.bindingName,
-          entrypoint: sb.entrypoint
+          bindingName: serviceBinding.bindingName,
+          entrypoint: serviceBinding.entrypoint
         };
-        const lookupKey = sb.entrypoint || "__default__";
-        const interfaceInfo = interfaceMap.get(lookupKey) || sb.entrypoint && interfaceMap.get(sb.entrypoint);
+        const lookupKey = serviceBinding.entrypoint || "__default__";
+        const interfaceInfo = interfaceMap.get(lookupKey) || (serviceBinding.entrypoint ? interfaceMap.get(serviceBinding.entrypoint) : undefined);
         if (interfaceInfo) {
           info.interfaceImport = generateImportPath(cwd, interfaceInfo.filePath);
           info.interfaceType = interfaceInfo.interfaceName;
@@ -133,16 +245,17 @@ async function resolveReferencedConfigs(configPath, cwd) {
         return info;
       });
       const crossWorkerDOs = doBindings.filter((doBinding) => doBinding.varName === ref.varName).map((doBinding) => {
-        const matchingDO = refDOs.find((do_) => do_.bindingName === doBinding.doName);
-        if (matchingDO) {
-          return {
-            bindingName: doBinding.bindingName,
-            doName: doBinding.doName,
-            className: matchingDO.className,
-            filePath: matchingDO.filePath
-          };
+        const matchingDO = refDOs.find((doInfo) => doInfo.bindingName === doBinding.doName);
+        if (!matchingDO) {
+          return null;
         }
-        return null;
+        const crossWorkerDO = {
+          bindingName: doBinding.bindingName,
+          doName: doBinding.doName,
+          className: matchingDO.className,
+          filePath: matchingDO.filePath
+        };
+        return crossWorkerDO;
       }).filter((item) => item !== null);
       referenced.push({
         varName: ref.varName,
@@ -156,34 +269,8 @@ async function resolveReferencedConfigs(configPath, cwd) {
   }
   return referenced;
 }
-async function discoverDurableObjects(cwd, pattern) {
-  const fs = await import("node:fs/promises");
-  const discovered = [];
-  const files = await findFiles(pattern, { cwd });
-  for (const filePath of files) {
-    try {
-      const code = await fs.readFile(filePath, "utf-8");
-      const classNames = findDurableObjectClasses(code);
-      for (const className of classNames) {
-        const bindingName = className.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
-        discovered.push({
-          className,
-          filePath,
-          bindingName
-        });
-      }
-    } catch {}
-  }
-  return discovered;
-}
-function generateImportPath(cwd, filePath) {
-  let relativePath = relative(cwd, filePath);
-  relativePath = relativePath.replace(/\.(ts|tsx|js|jsx)$/, "");
-  if (!relativePath.startsWith(".") && !relativePath.startsWith("/")) {
-    relativePath = "./" + relativePath;
-  }
-  return relativePath;
-}
+
+// src/cli/commands/type-generation/generator.ts
 function generateBindingMembers(config, doClassMap, crossWorkerDOMap, serviceBindingMap, cwd, indent) {
   const lines = [];
   const imports = [];
@@ -233,9 +320,9 @@ function generateBindingMembers(config, doClassMap, crossWorkerDOMap, serviceBin
         if (serviceInfo?.interfaceType && serviceInfo.interfaceImport) {
           imports.push(`import type { ${serviceInfo.interfaceType} } from '${serviceInfo.interfaceImport}'`);
           lines.push(`${indent}${binding}: ${serviceInfo.interfaceType}`);
-        } else {
-          lines.push(`${indent}${binding}: Fetcher`);
+          continue;
         }
+        lines.push(`${indent}${binding}: Fetcher`);
       }
     }
     if (config.bindings.ai) {
@@ -252,7 +339,9 @@ function generateBindingMembers(config, doClassMap, crossWorkerDOMap, serviceBin
       }
     }
     if (config.bindings.browser) {
-      lines.push(`${indent}${config.bindings.browser.binding}: Fetcher`);
+      for (const binding of Object.keys(config.bindings.browser)) {
+        lines.push(`${indent}${binding}: Fetcher`);
+      }
     }
     if (config.bindings.analyticsEngine) {
       for (const binding of Object.keys(config.bindings.analyticsEngine)) {
@@ -279,10 +368,10 @@ function generateBindingMembers(config, doClassMap, crossWorkerDOMap, serviceBin
 }
 function generateBindingTypes(config, discoveredDOs, discoveredEntrypoints, referencedConfigs, cwd) {
   const doClassMap = new Map;
-  for (const do_ of discoveredDOs) {
-    doClassMap.set(do_.className, {
-      importPath: generateImportPath(cwd, do_.filePath),
-      className: do_.className
+  for (const doInfo of discoveredDOs) {
+    doClassMap.set(doInfo.className, {
+      importPath: generateImportPath(cwd, doInfo.filePath),
+      className: doInfo.className
     });
   }
   const crossWorkerDOMap = new Map;
@@ -293,8 +382,8 @@ function generateBindingTypes(config, discoveredDOs, discoveredEntrypoints, refe
   }
   const serviceBindingMap = new Map;
   for (const ref of referencedConfigs) {
-    for (const sb of ref.serviceBindings) {
-      serviceBindingMap.set(sb.bindingName, sb);
+    for (const serviceBinding of ref.serviceBindings) {
+      serviceBindingMap.set(serviceBinding.bindingName, serviceBinding);
     }
   }
   const usedTypes = new Set;
@@ -320,7 +409,7 @@ function generateBindingTypes(config, discoveredDOs, discoveredEntrypoints, refe
       usedTypes.add("VectorizeIndex");
     if (config.bindings.hyperdrive && Object.keys(config.bindings.hyperdrive).length > 0)
       usedTypes.add("Hyperdrive");
-    if (config.bindings.browser)
+    if (config.bindings.browser && Object.keys(config.bindings.browser).length > 0)
       usedTypes.add("Fetcher");
     if (config.bindings.analyticsEngine && Object.keys(config.bindings.analyticsEngine).length > 0)
       usedTypes.add("AnalyticsEngineDataset");
@@ -332,7 +421,7 @@ function generateBindingTypes(config, discoveredDOs, discoveredEntrypoints, refe
     "// Run `devflare types` to regenerate",
     ""
   ];
-  const hasLocalDOsWithClasses = config.bindings?.durableObjects && Object.values(config.bindings.durableObjects).some((doConfig) => doConfig.className && doClassMap.has(doConfig.className));
+  const hasLocalDOsWithClasses = Boolean(config.bindings?.durableObjects && Object.values(config.bindings.durableObjects).some((doConfig) => doConfig.className && doClassMap.has(doConfig.className)));
   const hasCrossWorkerDOs = crossWorkerDOMap.size > 0;
   const hasDOsWithClasses = hasLocalDOsWithClasses || hasCrossWorkerDOs;
   if (usedTypes.size > 0) {
@@ -357,7 +446,7 @@ function generateBindingTypes(config, discoveredDOs, discoveredEntrypoints, refe
   lines.push("}");
   lines.push("");
   if (discoveredEntrypoints.length > 0) {
-    const entrypointNames = discoveredEntrypoints.map((ep) => `'${ep.className}'`).join(" | ");
+    const entrypointNames = discoveredEntrypoints.map((entrypoint) => `'${entrypoint.className}'`).join(" | ");
     lines.push("/**");
     lines.push(" * Named entrypoints discovered from ep.*.ts files.");
     lines.push(" * Use with defineConfig<Entrypoints>() for type-safe cross-worker references.");
@@ -374,11 +463,24 @@ function generateBindingTypes(config, discoveredDOs, discoveredEntrypoints, refe
   return lines.join(`
 `);
 }
+
+// src/cli/commands/types.ts
+function logTypesLine(logger, message = "") {
+  if (typeof logger.log === "function") {
+    logger.log(message);
+    return;
+  }
+  if (typeof logger.info === "function") {
+    logger.info(message);
+  }
+}
 async function runTypesCommand(parsed, logger, options) {
   const cwd = options.cwd || process.cwd();
   const configPath = parsed.options.config;
   const outputPath = parsed.options.output || "env.d.ts";
-  logger.info("Generating TypeScript types...");
+  const theme = createCliTheme(parsed.options);
+  logTypesLine(logger);
+  logTypesLine(logger, `${bold("types", theme)} ${dim("Generating TypeScript bindings", theme)}`);
   try {
     const config = await loadConfig({ cwd, configFile: configPath });
     const requestedConfigPath = configPath ? resolve(cwd, configPath) : cwd;
@@ -391,9 +493,9 @@ async function runTypesCommand(parsed, logger, options) {
     if (config.files?.durableObjects !== false) {
       discoveredDOs = await discoverDurableObjects(cwd, doPattern);
       if (discoveredDOs.length > 0) {
-        logger.info(`Discovered ${discoveredDOs.length} Durable Object class(es):`);
-        for (const do_ of discoveredDOs) {
-          logger.info(`  • ${do_.className} → ${do_.bindingName}`);
+        logTypesLine(logger, `Discovered ${discoveredDOs.length} Durable Object class(es):`);
+        for (const doInfo of discoveredDOs) {
+          logTypesLine(logger, `  • ${doInfo.className} → ${doInfo.bindingName}`);
         }
       }
     }
@@ -401,11 +503,13 @@ async function runTypesCommand(parsed, logger, options) {
       for (const [bindingName, doConfig] of Object.entries(config.bindings.durableObjects)) {
         const normalized = normalizeDOBinding(doConfig);
         const className = normalized.className;
-        if (!className)
+        if (!className) {
           continue;
-        const existing = discoveredDOs.find((d) => d.className === className);
-        if (existing)
+        }
+        const existing = discoveredDOs.find((doInfo) => doInfo.className === className);
+        if (existing) {
           continue;
+        }
         if (normalized.scriptName && (normalized.scriptName.endsWith(".ts") || normalized.scriptName.endsWith(".js"))) {
           const filePath = resolve(cwd, "src", normalized.scriptName);
           discoveredDOs.push({
@@ -416,24 +520,24 @@ async function runTypesCommand(parsed, logger, options) {
         }
       }
     }
-    const epPattern = typeof config.files?.entrypoints === "string" ? config.files.entrypoints : DEFAULT_ENTRYPOINT_PATTERN;
+    const entrypointPattern = typeof config.files?.entrypoints === "string" ? config.files.entrypoints : DEFAULT_ENTRYPOINT_PATTERN;
     let discoveredEntrypoints = [];
     if (config.files?.entrypoints !== false) {
-      discoveredEntrypoints = await discoverEntrypointsAsync(cwd, epPattern);
+      discoveredEntrypoints = await discoverEntrypointsAsync(cwd, entrypointPattern);
       if (discoveredEntrypoints.length > 0) {
-        logger.info(`Discovered ${discoveredEntrypoints.length} entrypoint class(es):`);
-        for (const ep of discoveredEntrypoints) {
-          logger.info(`  • ${ep.className}`);
+        logTypesLine(logger, `Discovered ${discoveredEntrypoints.length} entrypoint class(es):`);
+        for (const entrypoint of discoveredEntrypoints) {
+          logTypesLine(logger, `  • ${entrypoint.className}`);
         }
       }
     }
     const referencedConfigs = await resolveReferencedConfigs(actualConfigPath, cwd);
     if (referencedConfigs.length > 0) {
-      logger.info(`Found ${referencedConfigs.length} referenced worker(s):`);
+      logTypesLine(logger, `Found ${referencedConfigs.length} referenced worker(s):`);
       for (const ref of referencedConfigs) {
-        const typedBindings = ref.serviceBindings.filter((sb) => sb.interfaceType);
+        const typedBindings = ref.serviceBindings.filter((serviceBinding) => serviceBinding.interfaceType);
         if (typedBindings.length > 0) {
-          logger.info(`  • ${ref.varName}: ${typedBindings.map((sb) => `${sb.bindingName} → ${sb.interfaceType}`).join(", ")}`);
+          logTypesLine(logger, `  • ${ref.varName}: ${typedBindings.map((serviceBinding) => `${serviceBinding.bindingName} → ${serviceBinding.interfaceType}`).join(", ")}`);
         }
       }
     }