devflare 1.0.0-next.10 → 1.0.0-next.12

package/dist/index-1xqeptt2.js

@@ -0,0 +1,623 @@
+import {
+  findFiles
+} from "./index-rbht7m9r.js";
+import {
+  findDurableObjectClasses,
+  transformDurableObject
+} from "./index-9wt9x09k.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/bundler/worker-bundler.ts
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "pathe";
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function matchesExternalPattern(pattern, id) {
+  if (pattern instanceof RegExp) {
+    pattern.lastIndex = 0;
+    return pattern.test(id);
+  }
+  return pattern === id;
+}
+function matchesExternalOption(option, id, parentId, isResolved) {
+  if (!option) {
+    return false;
+  }
+  if (typeof option === "function") {
+    return option(id, parentId, isResolved) ?? false;
+  }
+  return toArray(option).some((pattern) => matchesExternalPattern(pattern, id));
+}
+function mergeExternalOptions(base, user) {
+  if (!base) {
+    return user;
+  }
+  if (!user) {
+    return base;
+  }
+  if (typeof base !== "function" && typeof user !== "function") {
+    return [...toArray(base), ...toArray(user)];
+  }
+  return (id, parentId, isResolved) => {
+    return matchesExternalOption(base, id, parentId, isResolved) || matchesExternalOption(user, id, parentId, isResolved) || false;
+  };
+}
+function mergePluginOptions(base, user) {
+  if (!base) {
+    return user;
+  }
+  if (!user) {
+    return base;
+  }
+  return [base, user];
+}
+function mergeResolveOptions(base, user) {
+  if (!base) {
+    return user;
+  }
+  if (!user) {
+    return base;
+  }
+  return {
+    ...user,
+    ...base,
+    alias: {
+      ...user.alias ?? {},
+      ...base.alias ?? {}
+    }
+  };
+}
+async function ensureDebugShim(outDir) {
+  const fs = await import("node:fs/promises");
+  const debugShimCode = `
+// Debug module shim for local development
+const createDebug = (namespace) => {
+	const logger = (...args) => {
+		if (createDebug.enabled) console.debug(\`[\${namespace}]\`, ...args)
+	}
+	logger.enabled = false
+	logger.namespace = namespace
+	logger.extend = (sub) => createDebug(\`\${namespace}:\${sub}\`)
+	return logger
+}
+createDebug.enabled = false
+createDebug.formatters = {}
+export default createDebug
+`;
+  const debugShimPath = resolve(outDir, "_debug_shim.js");
+  await fs.writeFile(debugShimPath, debugShimCode, "utf-8");
+  return debugShimPath;
+}
+async function resolveInternalModuleEntry(relativeCandidates) {
+  const fs = await import("node:fs/promises");
+  const currentFileDir = dirname(fileURLToPath(import.meta.url));
+  for (const candidate of relativeCandidates) {
+    const absolutePath = resolve(currentFileDir, candidate);
+    try {
+      await fs.access(absolutePath);
+      return absolutePath;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function resolveInternalAliasMap(outDir) {
+  const debugShimPath = await ensureDebugShim(outDir);
+  const runtimeEntry = await resolveInternalModuleEntry([
+    "../runtime/index.ts",
+    "../runtime/index.js"
+  ]);
+  const packageEntry = await resolveInternalModuleEntry([
+    "../index.ts",
+    "../index.js"
+  ]);
+  return {
+    debug: debugShimPath,
+    ...runtimeEntry ? { "devflare/runtime": runtimeEntry } : {},
+    ...packageEntry ? { devflare: packageEntry } : {}
+  };
+}
+function resolveWorkerRolldownConfig(options) {
+  const {
+    output: userOutputOptions,
+    input: _ignoredInput,
+    cwd: _ignoredCwd,
+    platform: _ignoredPlatform,
+    target: userTarget,
+    watch: _ignoredWatch,
+    external: userExternal,
+    plugins: userPlugins,
+    resolve: userResolve,
+    tsconfig: userTsconfig,
+    ...userInputOptions
+  } = options.rolldownOptions ?? {};
+  const {
+    codeSplitting: _ignoredCodeSplitting,
+    dir: _ignoredDir,
+    file: _ignoredFile,
+    format: _ignoredFormat,
+    inlineDynamicImports: _ignoredInlineDynamicImports,
+    ...safeUserOutputOptions
+  } = userOutputOptions ?? {};
+  const defaultExternalModules = [
+    /^cloudflare:/,
+    /^node:/,
+    "buffer",
+    "crypto",
+    "events",
+    "http",
+    "https",
+    "net",
+    "os",
+    "path",
+    "stream",
+    "tls",
+    "url",
+    "util",
+    "zlib",
+    "fs",
+    "child_process",
+    "async_hooks",
+    "querystring",
+    "string_decoder",
+    "assert",
+    "dns"
+  ];
+  return {
+    inputOptions: {
+      ...userInputOptions,
+      input: options.inputFile,
+      cwd: options.cwd,
+      platform: "browser",
+      target: userTarget ?? options.target,
+      tsconfig: userTsconfig ?? resolve(options.cwd, "tsconfig.json"),
+      external: mergeExternalOptions(defaultExternalModules, userExternal),
+      plugins: mergePluginOptions(undefined, userPlugins),
+      resolve: mergeResolveOptions({
+        alias: options.alias
+      }, userResolve)
+    },
+    outputOptions: {
+      ...safeUserOutputOptions,
+      file: options.outFile,
+      format: "esm",
+      sourcemap: safeUserOutputOptions.sourcemap ?? options.sourcemap ?? false,
+      minify: safeUserOutputOptions.minify ?? options.minify,
+      codeSplitting: false
+    }
+  };
+}
+async function bundleWorkerEntry(options) {
+  const { rolldown } = await import("rolldown");
+  const fs = await import("node:fs/promises");
+  const outDir = dirname(options.outFile);
+  await fs.mkdir(outDir, { recursive: true });
+  await fs.rm(options.outFile, { force: true });
+  await fs.rm(`${options.outFile}.map`, { force: true });
+  const alias = await resolveInternalAliasMap(outDir);
+  const { inputOptions, outputOptions } = resolveWorkerRolldownConfig({
+    cwd: options.cwd,
+    inputFile: options.inputFile,
+    outFile: options.outFile,
+    alias,
+    rolldownOptions: options.rolldownOptions,
+    sourcemap: options.sourcemap,
+    minify: options.minify,
+    target: options.target
+  });
+  options.logger?.debug(`Bundling main worker → ${options.outFile}`);
+  const bundle = await rolldown(inputOptions);
+  try {
+    await bundle.write(outputOptions);
+  } finally {
+    await bundle.close();
+  }
+  return options.outFile;
+}
+
+// src/bundler/do-bundler.ts
+import { resolve as resolve2, dirname as dirname2, relative } from "pathe";
+import picomatch from "picomatch";
+function classToBindingName(className) {
+  return className.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
+}
+async function discoverDOs(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) {
+        discovered.push({
+          filePath,
+          className,
+          bindingName: classToBindingName(className)
+        });
+      }
+    } catch {}
+  }
+  return discovered;
+}
+function stripDecoratorSyntax(code) {
+  let result = code;
+  result = result.replace(/@durableObject\s*\([^)]*\)\s*\n?\s*(?=export\s+class)/g, "");
+  result = result.replace(/import\s*\{([^}]*)\bdurableObject\b[^}]*\}\s*from\s*['"]devflare\/runtime['"]\s*;?/g, (match, imports) => {
+    const cleanedImports = imports.split(",").map((s) => s.trim()).filter((s) => !s.startsWith("durableObject")).join(", ");
+    if (cleanedImports.trim() === "") {
+      return "";
+    }
+    return `import { ${cleanedImports} } from 'devflare/runtime'`;
+  });
+  return result;
+}
+function toArray2(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function matchesExternalPattern2(pattern, id) {
+  if (pattern instanceof RegExp) {
+    pattern.lastIndex = 0;
+    return pattern.test(id);
+  }
+  return pattern === id;
+}
+function matchesExternalOption2(option, id, parentId, isResolved) {
+  if (!option) {
+    return false;
+  }
+  if (typeof option === "function") {
+    return option(id, parentId, isResolved) ?? false;
+  }
+  return toArray2(option).some((pattern) => matchesExternalPattern2(pattern, id));
+}
+function mergeExternalOptions2(base, user) {
+  if (!base) {
+    return user;
+  }
+  if (!user) {
+    return base;
+  }
+  if (typeof base !== "function" && typeof user !== "function") {
+    return [...toArray2(base), ...toArray2(user)];
+  }
+  return (id, parentId, isResolved) => {
+    return matchesExternalOption2(base, id, parentId, isResolved) || matchesExternalOption2(user, id, parentId, isResolved) || false;
+  };
+}
+function mergePluginOptions2(base, user) {
+  if (!base) {
+    return user;
+  }
+  if (!user) {
+    return base;
+  }
+  return [base, user];
+}
+function mergeResolveOptions2(base, user) {
+  if (!base) {
+    return user;
+  }
+  if (!user) {
+    return base;
+  }
+  return {
+    ...user,
+    ...base,
+    alias: {
+      ...user.alias ?? {},
+      ...base.alias ?? {}
+    }
+  };
+}
+function resolveDOBundleRolldownConfig(options) {
+  const {
+    output: userOutputOptions,
+    input: _ignoredInput,
+    cwd: _ignoredCwd,
+    platform: _ignoredPlatform,
+    watch: _ignoredWatch,
+    external: userExternal,
+    plugins: userPlugins,
+    resolve: userResolve,
+    tsconfig: userTsconfig,
+    ...userInputOptions
+  } = options.rolldownOptions ?? {};
+  const {
+    codeSplitting: _ignoredCodeSplitting,
+    dir: _ignoredDir,
+    file: _ignoredFile,
+    format: _ignoredFormat,
+    inlineDynamicImports: _ignoredInlineDynamicImports,
+    ...safeUserOutputOptions
+  } = userOutputOptions ?? {};
+  const defaultExternalModules = [
+    /^cloudflare:/,
+    /^node:/,
+    "buffer",
+    "crypto",
+    "events",
+    "http",
+    "https",
+    "net",
+    "os",
+    "path",
+    "stream",
+    "tls",
+    "url",
+    "util",
+    "zlib",
+    "fs",
+    "child_process",
+    "async_hooks",
+    "querystring",
+    "string_decoder",
+    "assert",
+    "dns"
+  ];
+  return {
+    inputOptions: {
+      ...userInputOptions,
+      input: options.inputFile,
+      cwd: options.cwd,
+      platform: "neutral",
+      tsconfig: userTsconfig ?? resolve2(options.cwd, "tsconfig.json"),
+      external: mergeExternalOptions2(defaultExternalModules, userExternal),
+      plugins: mergePluginOptions2(undefined, userPlugins),
+      resolve: mergeResolveOptions2({
+        alias: {
+          debug: options.debugShimPath
+        }
+      }, userResolve)
+    },
+    outputOptions: {
+      ...safeUserOutputOptions,
+      file: options.outFile,
+      format: "esm",
+      sourcemap: safeUserOutputOptions.sourcemap ?? options.sourcemap ?? false,
+      minify: safeUserOutputOptions.minify ?? options.minify,
+      codeSplitting: false
+    }
+  };
+}
+async function bundleDOFile(sourcePath, className, outDir, cwd, bundleOptions) {
+  const { rolldown } = await import("rolldown");
+  const fs = await import("node:fs/promises");
+  await fs.mkdir(outDir, { recursive: true });
+  const sourceCode = await fs.readFile(sourcePath, "utf-8");
+  const transformedCode = (await transformDurableObject(sourceCode, sourcePath))?.code ?? stripDecoratorSyntax(sourceCode);
+  const entryCode = `${transformedCode}
+
+// Default export for worker (required by Miniflare)
+export default {
+	async fetch(request) {
+		return new Response('DO Worker for ${className}', { status: 200 });
+	}
+};
+`;
+  const tempFilePath = resolve2(dirname2(sourcePath), `.devflare-temp-${className}.ts`);
+  await fs.writeFile(tempFilePath, entryCode, "utf-8");
+  const classOutDir = resolve2(outDir, className);
+  try {
+    await fs.rm(classOutDir, { recursive: true, force: true });
+  } catch {}
+  await fs.mkdir(classOutDir, { recursive: true });
+  const debugShimCode = `
+// Debug module shim for local development
+const createDebug = (namespace) => {
+	const logger = (...args) => {
+		if (createDebug.enabled) console.debug(\`[\${namespace}]\`, ...args)
+	}
+	logger.enabled = false
+	logger.namespace = namespace
+	logger.extend = (sub) => createDebug(\`\${namespace}:\${sub}\`)
+	return logger
+}
+createDebug.enabled = false
+createDebug.formatters = {}
+export default createDebug
+`;
+  const debugShimPath = resolve2(outDir, "_debug_shim.js");
+  await fs.writeFile(debugShimPath, debugShimCode, "utf-8");
+  const outFile = resolve2(classOutDir, "index.js");
+  const { inputOptions, outputOptions } = resolveDOBundleRolldownConfig({
+    cwd,
+    inputFile: tempFilePath,
+    outFile,
+    debugShimPath,
+    rolldownOptions: bundleOptions?.rolldownOptions,
+    sourcemap: bundleOptions?.sourcemap,
+    minify: bundleOptions?.minify
+  });
+  const bundle = await rolldown(inputOptions);
+  await bundle.write(outputOptions);
+  await bundle.close();
+  try {
+    await fs.unlink(tempFilePath);
+  } catch {}
+  return resolve2(classOutDir, "index.js");
+}
+async function bundleAllDOs(discovered, outDir, cwd, logger, bundleOptions) {
+  const fs = await import("node:fs/promises");
+  const bundles = new Map;
+  const classes = new Map;
+  const sourceFiles = new Map;
+  const errors = [];
+  for (const do_ of discovered) {
+    const existing = sourceFiles.get(do_.filePath) || [];
+    existing.push(do_.className);
+    sourceFiles.set(do_.filePath, existing);
+  }
+  for (const do_ of discovered) {
+    try {
+      logger?.debug(`Bundling ${do_.className} from ${do_.filePath}`);
+      const outFile = await bundleDOFile(do_.filePath, do_.className, outDir, cwd, bundleOptions);
+      bundles.set(do_.bindingName, outFile);
+      classes.set(do_.bindingName, do_.className);
+      logger?.debug(`  → ${outFile}`);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      errors.push(err);
+      logger?.error(`Failed to bundle ${do_.className}:`, err.message);
+    }
+  }
+  return { bundles, classes, sourceFiles, errors };
+}
+function createDOBundler(options) {
+  const { cwd, pattern, outDir, logger, onRebuild, rolldownOptions, sourcemap, minify } = options;
+  let result = {
+    bundles: new Map,
+    classes: new Map,
+    sourceFiles: new Map,
+    errors: []
+  };
+  let watcher = null;
+  let chokidarWatcher = null;
+  async function build() {
+    const discovered = await discoverDOs(cwd, pattern);
+    if (discovered.length === 0) {
+      logger?.debug("No DOs found matching pattern:", pattern);
+      return result;
+    }
+    logger?.info(`Found ${discovered.length} Durable Object(s)`);
+    for (const do_ of discovered) {
+      logger?.info(`  • ${do_.className} → ${do_.bindingName}`);
+    }
+    result = await bundleAllDOs(discovered, outDir, cwd, logger, {
+      rolldownOptions,
+      sourcemap,
+      minify
+    });
+    if (result.errors.length === 0) {
+      logger?.success(`Bundled ${result.bundles.size} DO(s) to ${outDir}`);
+    }
+    return result;
+  }
+  async function watch() {
+    const chokidar = await import("chokidar");
+    const files = await findFiles(pattern, { cwd });
+    let dirsToWatch;
+    if (files.length > 0) {
+      dirsToWatch = [...new Set(files.map((f) => dirname2(f)))];
+    } else {
+      const patternDir = dirname2(pattern);
+      const absolutePatternDir = resolve2(cwd, patternDir === "." ? "" : patternDir) || cwd;
+      dirsToWatch = [absolutePatternDir];
+      logger?.debug(`No DO files yet, watching pattern directory: ${absolutePatternDir}`);
+    }
+    logger?.info(`Watching ${files.length} DO file(s) in ${dirsToWatch.length} director(ies)...`);
+    const isWindows = process.platform === "win32";
+    chokidarWatcher = chokidar.watch(dirsToWatch, {
+      ignoreInitial: true,
+      usePolling: isWindows,
+      interval: isWindows ? 300 : undefined,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50
+      },
+      depth: 0
+    });
+    const normalizePath = (p) => {
+      let normalized = p.replace(/\\/g, "/");
+      if (isWindows && /^[a-zA-Z]:/.test(normalized)) {
+        normalized = normalized[0].toLowerCase() + normalized.slice(1);
+      }
+      return normalized;
+    };
+    const isMatch = picomatch(pattern, {
+      cwd,
+      dot: true,
+      matchBase: false
+    });
+    const matchesPattern = (filePath) => {
+      const normalizedPath = normalizePath(filePath);
+      const relativePath = relative(normalizePath(cwd), normalizedPath);
+      return isMatch(relativePath);
+    };
+    let isRebuilding = false;
+    let pendingRebuild = null;
+    let rebuildTimeout = null;
+    const scheduleRebuild = (changedPath) => {
+      if (rebuildTimeout) {
+        clearTimeout(rebuildTimeout);
+      }
+      rebuildTimeout = setTimeout(() => {
+        triggerRebuild(changedPath);
+      }, 150);
+    };
+    const triggerRebuild = async (changedPath) => {
+      if (isRebuilding) {
+        pendingRebuild = changedPath;
+        logger?.debug(`Rebuild already in progress, queuing: ${changedPath}`);
+        return;
+      }
+      isRebuilding = true;
+      try {
+        logger?.info(`DO file changed: ${changedPath}`);
+        logger?.info("Rebuilding DOs...");
+        const startTime = Date.now();
+        result = await build();
+        const elapsed = Date.now() - startTime;
+        logger?.success(`DO rebuild complete (${elapsed}ms)`);
+        await onRebuild?.(result);
+      } catch (error) {
+        logger?.error("DO rebuild failed:", error);
+      } finally {
+        isRebuilding = false;
+        if (pendingRebuild) {
+          const nextPath = pendingRebuild;
+          pendingRebuild = null;
+          triggerRebuild(nextPath);
+        }
+      }
+    };
+    chokidarWatcher.on("change", (filePath) => {
+      if (matchesPattern(filePath)) {
+        logger?.debug(`File changed: ${filePath}`);
+        scheduleRebuild(filePath);
+      }
+    });
+    chokidarWatcher.on("add", (filePath) => {
+      if (matchesPattern(filePath)) {
+        logger?.debug(`File added: ${filePath}`);
+        scheduleRebuild(filePath);
+      }
+    });
+    chokidarWatcher.on("unlink", (filePath) => {
+      if (matchesPattern(filePath)) {
+        logger?.debug(`File removed: ${filePath}`);
+        scheduleRebuild(filePath);
+      }
+    });
+    chokidarWatcher.on("ready", () => {
+      logger?.info("DO file watcher ready");
+    });
+    chokidarWatcher.on("error", (error) => {
+      logger?.error("DO file watcher error:", error);
+    });
+  }
+  async function close() {
+    if (watcher) {
+      await watcher.close();
+      watcher = null;
+    }
+    if (chokidarWatcher) {
+      await chokidarWatcher.close();
+      chokidarWatcher = null;
+    }
+  }
+  function getResult() {
+    return result;
+  }
+  return {
+    build,
+    watch,
+    close,
+    getResult
+  };
+}
+export { createDOBundler, bundleWorkerEntry };

package/dist/{index-pwgyy2q9.js → index-dr6sbp8d.js}

@@ -1,6 +1,6 @@
 import {
   resolveConfigPath
-} from "./index-1phx14av.js";
+} from "./index-wyf3s77s.js";
 
 // src/cli/config-path.ts
 import { stat } from "node:fs/promises";

package/dist/{index-6v3wjg1r.js → index-rfhx0yd5.js}

@@ -1,17 +1,22 @@
 import {
   normalizeDOBinding
-} from "./index-1phx14av.js";
+} from "./index-wyf3s77s.js";
 import {
   __require
 } from "./index-37x76zdn.js";
 
-// src/config/compiler.ts
+// src/config/resolve.ts
 import { defu } from "defu";
-function compileConfig(config, environment) {
-  let mergedConfig = config;
+function resolveConfigForEnvironment(config, environment) {
   if (environment && config.env?.[environment]) {
-    mergedConfig = defu(config.env[environment], config);
+    return defu(config.env[environment], config);
   }
+  return config;
+}
+
+// src/config/compiler.ts
+function compileConfig(config, environment) {
+  const mergedConfig = resolveConfigForEnvironment(config, environment);
   const result = {
     name: mergedConfig.name,
     compatibility_date: mergedConfig.compatibilityDate
@@ -194,5 +199,4 @@ async function writeWranglerConfig(cwd, config, filename = "wrangler.jsonc") {
   await fs.writeFile(wranglerPath, content, "utf-8");
   return wranglerPath;
 }
-
-export { compileConfig, compileToProgrammaticConfig, stringifyConfig, writeWranglerConfig };
+export { resolveConfigForEnvironment, compileConfig, compileToProgrammaticConfig, stringifyConfig, writeWranglerConfig };

package/dist/{index-05fyzwne.js → index-twpgq9k9.js}

@@ -160,23 +160,23 @@ async function runInit(parsed, logger, options) {
   return runInitCommand(parsed, logger, options);
 }
 async function runDev(parsed, logger, options) {
-  const { runDevCommand } = await import("./dev-rk8p6pse.js");
+  const { runDevCommand } = await import("./dev-d4wabqyf.js");
   return runDevCommand(parsed, logger, options);
 }
 async function runBuild(parsed, logger, options) {
-  const { runBuildCommand } = await import("./build-k36xrzvy.js");
+  const { runBuildCommand } = await import("./build-rfh8cgh3.js");
   return runBuildCommand(parsed, logger, options);
 }
 async function runDeploy(parsed, logger, options) {
-  const { runDeployCommand } = await import("./deploy-dbvfq8vq.js");
+  const { runDeployCommand } = await import("./deploy-k0fcgt3d.js");
   return runDeployCommand(parsed, logger, options);
 }
 async function runTypes(parsed, logger, options) {
-  const { runTypesCommand } = await import("./types-x9q7t491.js");
+  const { runTypesCommand } = await import("./types-sffr9681.js");
   return runTypesCommand(parsed, logger, options);
 }
 async function runDoctor(parsed, logger, options) {
-  const { runDoctorCommand } = await import("./doctor-06y8nxd4.js");
+  const { runDoctorCommand } = await import("./doctor-z4ffybce.js");
   return runDoctorCommand(parsed, logger, options);
 }
 async function runAccount(parsed, logger, options) {

package/dist/{index-1phx14av.js → index-wyf3s77s.js}

@@ -17,7 +17,7 @@ var filesSchema = z.object({
   entrypoints: z.union([z.string(), z.literal(false)]).optional(),
   workflows: z.union([z.string(), z.literal(false)]).optional(),
   routes: z.union([routesConfigSchema, z.literal(false)]).optional(),
-  transport: z.string().optional()
+  transport: z.union([z.string(), z.null()]).optional()
 }).optional();
 var durableObjectBindingSchema = z.custom((val) => {
   if (typeof val === "string")