devflare 1.0.0-next.7 → 1.0.0-next.70

package/dist/types-wdcpnfvy.js

@@ -1,487 +0,0 @@
-import {
-  getDependencies
-} from "./index-1xpj0m4r.js";
-import {
-  discoverEntrypointsAsync,
-  resolvePackageSpecifier
-} from "./index-tk6ej9dj.js";
-import {
-  DEFAULT_DO_PATTERN,
-  DEFAULT_ENTRYPOINT_PATTERN,
-  findFiles
-} from "./index-rbht7m9r.js";
-import {
-  findDurableObjectClasses
-} from "./index-gz1gndna.js";
-import"./index-k7r18na8.js";
-import"./index-v8vvsn9x.js";
-import"./index-67qcae0f.js";
-import {
-  loadConfig,
-  normalizeDOBinding,
-  resolveConfigPath
-} from "./index-hcex3rgh.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/cli/commands/types.ts
-import { resolve, relative, dirname } from "pathe";
-var CONFIG_FILE_EXTENSIONS = [".ts", ".mts", ".js", ".mjs"];
-function hasKnownConfigExtension(filePath) {
-  return CONFIG_FILE_EXTENSIONS.some((extension) => filePath.endsWith(extension));
-}
-async function resolveConfigCandidatePath(candidatePath) {
-  const fs = await import("node:fs/promises");
-  const candidates = [candidatePath];
-  const getExistingFilePath = async (filePath) => {
-    try {
-      const stat = await fs.stat(filePath);
-      return stat.isFile() ? filePath : null;
-    } catch {
-      return null;
-    }
-  };
-  if (!hasKnownConfigExtension(candidatePath)) {
-    for (const extension of CONFIG_FILE_EXTENSIONS) {
-      candidates.push(`${candidatePath}${extension}`);
-    }
-  }
-  for (const candidate of candidates) {
-    const existingFilePath = await getExistingFilePath(candidate);
-    if (existingFilePath) {
-      return existingFilePath;
-    }
-  }
-  return await resolveConfigPath(candidatePath) ?? null;
-}
-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]
-      });
-    }
-  } catch {}
-  return { refs, serviceBindings, doBindings };
-}
-async function findInterfaceTypes(searchDirs) {
-  const fs = await import("node:fs/promises");
-  const interfaces = new Map;
-  for (const dir of 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 {}
-    }
-  }
-  return interfaces;
-}
-async function resolveReferencedConfigs(configPath, cwd) {
-  const referenced = [];
-  const { refs, serviceBindings, doBindings } = await parseConfigForRefs(configPath);
-  if (refs.length === 0) {
-    return referenced;
-  }
-  const configDir = dirname(configPath);
-  for (const ref of refs) {
-    const refImportPath = resolvePackageSpecifier(ref.importPath, configDir);
-    const refConfigPath = await resolveConfigCandidatePath(refImportPath);
-    if (!refConfigPath) {
-      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) => {
-        const info = {
-          bindingName: sb.bindingName,
-          entrypoint: sb.entrypoint
-        };
-        const lookupKey = sb.entrypoint || "__default__";
-        const interfaceInfo = interfaceMap.get(lookupKey) || sb.entrypoint && interfaceMap.get(sb.entrypoint);
-        if (interfaceInfo) {
-          info.interfaceImport = generateImportPath(cwd, interfaceInfo.filePath);
-          info.interfaceType = interfaceInfo.interfaceName;
-        }
-        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
-          };
-        }
-        return null;
-      }).filter((item) => item !== null);
-      referenced.push({
-        varName: ref.varName,
-        importPath: ref.importPath,
-        refDir,
-        entrypoints,
-        serviceBindings: bindings,
-        durableObjects: crossWorkerDOs
-      });
-    } catch {}
-  }
-  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;
-}
-function generateBindingMembers(config, doClassMap, crossWorkerDOMap, serviceBindingMap, cwd, indent) {
-  const lines = [];
-  const imports = [];
-  if (config.bindings) {
-    if (config.bindings.kv) {
-      for (const binding of Object.keys(config.bindings.kv)) {
-        lines.push(`${indent}${binding}: KVNamespace`);
-      }
-    }
-    if (config.bindings.d1) {
-      for (const binding of Object.keys(config.bindings.d1)) {
-        lines.push(`${indent}${binding}: D1Database`);
-      }
-    }
-    if (config.bindings.r2) {
-      for (const binding of Object.keys(config.bindings.r2)) {
-        lines.push(`${indent}${binding}: R2Bucket`);
-      }
-    }
-    if (config.bindings.durableObjects) {
-      for (const [binding, doConfig] of Object.entries(config.bindings.durableObjects)) {
-        const crossWorkerDO = crossWorkerDOMap.get(binding);
-        if (crossWorkerDO) {
-          const importPath = generateImportPath(cwd, crossWorkerDO.filePath);
-          lines.push(`${indent}${binding}: DurableObjectNamespace<Rpc.DurableObjectBranded & import('${importPath}').${crossWorkerDO.className}>`);
-          continue;
-        }
-        const className = doConfig.className;
-        if (className) {
-          const classInfo = doClassMap.get(className);
-          if (classInfo) {
-            lines.push(`${indent}${binding}: DurableObjectNamespace<Rpc.DurableObjectBranded & import('${classInfo.importPath}').${classInfo.className}>`);
-            continue;
-          }
-        }
-        lines.push(`${indent}${binding}: DurableObjectNamespace`);
-      }
-    }
-    if (config.bindings.queues?.producers) {
-      for (const binding of Object.keys(config.bindings.queues.producers)) {
-        lines.push(`${indent}${binding}: Queue`);
-      }
-    }
-    if (config.bindings.services) {
-      for (const binding of Object.keys(config.bindings.services)) {
-        const serviceInfo = serviceBindingMap.get(binding);
-        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`);
-        }
-      }
-    }
-    if (config.bindings.ai) {
-      lines.push(`${indent}${config.bindings.ai.binding}: Ai`);
-    }
-    if (config.bindings.vectorize) {
-      for (const binding of Object.keys(config.bindings.vectorize)) {
-        lines.push(`${indent}${binding}: VectorizeIndex`);
-      }
-    }
-    if (config.bindings.hyperdrive) {
-      for (const binding of Object.keys(config.bindings.hyperdrive)) {
-        lines.push(`${indent}${binding}: Hyperdrive`);
-      }
-    }
-    if (config.bindings.browser) {
-      lines.push(`${indent}${config.bindings.browser.binding}: Fetcher`);
-    }
-    if (config.bindings.analyticsEngine) {
-      for (const binding of Object.keys(config.bindings.analyticsEngine)) {
-        lines.push(`${indent}${binding}: AnalyticsEngineDataset`);
-      }
-    }
-  }
-  if (config.vars) {
-    for (const key of Object.keys(config.vars)) {
-      lines.push(`${indent}${key}: string`);
-    }
-  }
-  if (config.secrets) {
-    for (const secret of Object.keys(config.secrets)) {
-      lines.push(`${indent}${secret}: string`);
-    }
-  }
-  return { lines, imports };
-}
-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
-    });
-  }
-  const crossWorkerDOMap = new Map;
-  for (const ref of referencedConfigs) {
-    for (const doInfo of ref.durableObjects) {
-      crossWorkerDOMap.set(doInfo.bindingName, doInfo);
-    }
-  }
-  const serviceBindingMap = new Map;
-  for (const ref of referencedConfigs) {
-    for (const sb of ref.serviceBindings) {
-      serviceBindingMap.set(sb.bindingName, sb);
-    }
-  }
-  const usedTypes = new Set;
-  if (config.bindings) {
-    if (config.bindings.kv && Object.keys(config.bindings.kv).length > 0)
-      usedTypes.add("KVNamespace");
-    if (config.bindings.d1 && Object.keys(config.bindings.d1).length > 0)
-      usedTypes.add("D1Database");
-    if (config.bindings.r2 && Object.keys(config.bindings.r2).length > 0)
-      usedTypes.add("R2Bucket");
-    if (config.bindings.durableObjects && Object.keys(config.bindings.durableObjects).length > 0)
-      usedTypes.add("DurableObjectNamespace");
-    if (config.bindings.queues?.producers && Object.keys(config.bindings.queues.producers).length > 0)
-      usedTypes.add("Queue");
-    if (config.bindings.services) {
-      const hasUntypedServices = Object.keys(config.bindings.services).some((name) => !serviceBindingMap.get(name)?.interfaceType);
-      if (hasUntypedServices)
-        usedTypes.add("Fetcher");
-    }
-    if (config.bindings.ai)
-      usedTypes.add("Ai");
-    if (config.bindings.vectorize && Object.keys(config.bindings.vectorize).length > 0)
-      usedTypes.add("VectorizeIndex");
-    if (config.bindings.hyperdrive && Object.keys(config.bindings.hyperdrive).length > 0)
-      usedTypes.add("Hyperdrive");
-    if (config.bindings.browser)
-      usedTypes.add("Fetcher");
-    if (config.bindings.analyticsEngine && Object.keys(config.bindings.analyticsEngine).length > 0)
-      usedTypes.add("AnalyticsEngineDataset");
-  }
-  const lines = [
-    "// Generated by devflare - DO NOT EDIT",
-    "// Run `devflare types` to regenerate",
-    ""
-  ];
-  const hasLocalDOsWithClasses = 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) {
-    const sortedTypes = [...usedTypes].sort();
-    if (hasDOsWithClasses) {
-      lines.push(`import type { ${sortedTypes.join(", ")}, Rpc } from '@cloudflare/workers-types'`);
-    } else {
-      lines.push(`import type { ${sortedTypes.join(", ")} } from '@cloudflare/workers-types'`);
-    }
-    lines.push("");
-  }
-  const { lines: bindingMembers, imports: serviceImports } = generateBindingMembers(config, doClassMap, crossWorkerDOMap, serviceBindingMap, cwd, "\t\t");
-  const uniqueImports = [...new Set(serviceImports)];
-  if (uniqueImports.length > 0) {
-    lines.push(...uniqueImports);
-    lines.push("");
-  }
-  lines.push("declare global {");
-  lines.push("\tinterface DevflareEnv {");
-  lines.push(...bindingMembers);
-  lines.push("\t}");
-  lines.push("}");
-  lines.push("");
-  if (discoveredEntrypoints.length > 0) {
-    const entrypointNames = discoveredEntrypoints.map((ep) => `'${ep.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.");
-    lines.push(" */");
-    lines.push(`export type Entrypoints = ${entrypointNames}`);
-  } else {
-    lines.push("/**");
-    lines.push(" * Named entrypoints (none discovered - add ep.*.ts files to enable).");
-    lines.push(" * Use with defineConfig<Entrypoints>() for type-safe cross-worker references.");
-    lines.push(" */");
-    lines.push("export type Entrypoints = string");
-  }
-  lines.push("");
-  return lines.join(`
-`);
-}
-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...");
-  try {
-    const config = await loadConfig({ cwd, configFile: configPath });
-    const requestedConfigPath = configPath ? resolve(cwd, configPath) : cwd;
-    const actualConfigPath = await resolveConfigCandidatePath(requestedConfigPath);
-    if (!actualConfigPath) {
-      throw new Error("Could not resolve the loaded devflare config file path");
-    }
-    const doPattern = typeof config.files?.durableObjects === "string" ? config.files.durableObjects : DEFAULT_DO_PATTERN;
-    let discoveredDOs = [];
-    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}`);
-        }
-      }
-    }
-    if (config.bindings?.durableObjects) {
-      for (const [bindingName, doConfig] of Object.entries(config.bindings.durableObjects)) {
-        const normalized = normalizeDOBinding(doConfig);
-        const className = normalized.className;
-        if (!className)
-          continue;
-        const existing = discoveredDOs.find((d) => d.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({
-            className,
-            filePath,
-            bindingName
-          });
-        }
-      }
-    }
-    const epPattern = typeof config.files?.entrypoints === "string" ? config.files.entrypoints : DEFAULT_ENTRYPOINT_PATTERN;
-    let discoveredEntrypoints = [];
-    if (config.files?.entrypoints !== false) {
-      discoveredEntrypoints = await discoverEntrypointsAsync(cwd, epPattern);
-      if (discoveredEntrypoints.length > 0) {
-        logger.info(`Discovered ${discoveredEntrypoints.length} entrypoint class(es):`);
-        for (const ep of discoveredEntrypoints) {
-          logger.info(`  • ${ep.className}`);
-        }
-      }
-    }
-    const referencedConfigs = await resolveReferencedConfigs(actualConfigPath, cwd);
-    if (referencedConfigs.length > 0) {
-      logger.info(`Found ${referencedConfigs.length} referenced worker(s):`);
-      for (const ref of referencedConfigs) {
-        const typedBindings = ref.serviceBindings.filter((sb) => sb.interfaceType);
-        if (typedBindings.length > 0) {
-          logger.info(`  • ${ref.varName}: ${typedBindings.map((sb) => `${sb.bindingName} → ${sb.interfaceType}`).join(", ")}`);
-        }
-      }
-    }
-    const normalizedConfig = {
-      ...config,
-      bindings: config.bindings ? {
-        ...config.bindings,
-        durableObjects: config.bindings.durableObjects ? Object.fromEntries(Object.entries(config.bindings.durableObjects).map(([name, doConfig]) => {
-          const normalized = normalizeDOBinding(doConfig);
-          return [name, { className: normalized.className, scriptName: normalized.scriptName }];
-        })) : undefined
-      } : undefined
-    };
-    const types = generateBindingTypes(normalizedConfig, discoveredDOs, discoveredEntrypoints, referencedConfigs, cwd);
-    const { fs } = await getDependencies();
-    const fullPath = resolve(cwd, outputPath);
-    await fs.writeFile(fullPath, types, "utf-8");
-    logger.success(`Generated types: ${outputPath}`);
-    return { exitCode: 0 };
-  } catch (error) {
-    if (error instanceof Error) {
-      logger.error("Type generation failed:", error.message);
-      if (parsed.options.debug) {
-        logger.error(error.stack);
-      }
-    }
-    return { exitCode: 1 };
-  }
-}
-export {
-  runTypesCommand
-};

package/dist/worker-entrypoint-m9th0rg0.js

@@ -1,13 +0,0 @@
-import {
-  findExportedFunctions,
-  generateRpcInterface,
-  shouldTransformWorker,
-  transformWorkerEntrypoint
-} from "./index-z14anrqp.js";
-import"./index-37x76zdn.js";
-export {
-  transformWorkerEntrypoint,
-  shouldTransformWorker,
-  generateRpcInterface,
-  findExportedFunctions
-};