nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/_chunks/_presets/cloudflare.mjs

@@ -0,0 +1,608 @@
+import { w as writeFile, d as defineNitroPreset } from './_utils.mjs';
+import { presetsDir } from 'nitro/runtime/meta';
+import { existsSync, promises } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { relative, dirname, extname, resolve as resolve$1 } from 'node:path';
+import { c as findNearestFile, d as readGitConfig, r as readPackageJSON, e as findFile } from '../_deps/pkg-types.mjs';
+import { defu } from 'defu';
+import { p } from '../_deps/std-env.mjs';
+import { g as glob } from '../_deps/tinyglobby.mjs';
+import { withoutLeadingSlash, withTrailingSlash, joinURL, withLeadingSlash, hasProtocol } from 'ufo';
+import { j as join, r as resolve } from '../_deps/pathe.mjs';
+import { Q, b as h } from '../_deps/confbox.mjs';
+import { h as fileURLToPath } from '../_deps/mlly.mjs';
+import { r as resolveModulePath } from '../_deps/exsolve.mjs';
+
+const builtnNodeModules = [
+  "node:_http_agent",
+  "node:_http_client",
+  "node:_http_common",
+  // Missing exports: CRLF, HTTPParser, freeParser, isLenient, parsers, prepareError
+  "node:_http_incoming",
+  // Missing exports: readStart, readStop
+  "node:_http_outgoing",
+  "node:_http_server",
+  "node:_stream_duplex",
+  "node:_stream_passthrough",
+  "node:_stream_readable",
+  "node:_stream_transform",
+  "node:_stream_writable",
+  "node:_tls_common",
+  "node:_tls_wrap",
+  // Missing exports: Server, createServer
+  "node:assert",
+  // Missing exports: Assert, CallTracker
+  "node:assert/strict",
+  // Missing exports: Assert, CallTracker
+  "node:async_hooks",
+  "node:buffer",
+  "node:constants",
+  // Missing exports: O_DIRECT, O_NOATIME, RTLD_DEEPBIND, SIGPOLL, SIGPWR, SIGSTKFLT, defaultCipherList
+  "node:crypto",
+  // Missing exports: argon2, argon2Sync, decapsulate, encapsulate
+  "node:diagnostics_channel",
+  "node:dns",
+  // Missing exports: resolveTlsa
+  "node:dns/promises",
+  // Missing exports: resolveTlsa
+  "node:events",
+  // Missing exports: captureRejections, init
+  "node:fs",
+  // Missing exports: Utf8Stream, mkdtempDisposableSync
+  "node:fs/promises",
+  // Missing exports: mkdtempDisposable
+  "node:http",
+  "node:http2",
+  "node:https",
+  "node:module",
+  "node:net",
+  "node:os",
+  "node:path",
+  "node:path/posix",
+  "node:path/win32",
+  "node:process",
+  "node:querystring",
+  "node:stream",
+  "node:stream/consumers",
+  "node:stream/promises",
+  "node:stream/web",
+  "node:string_decoder",
+  "node:test",
+  // Missing exports: after, afterEach, assert, before, beforeEach, describe, it, only, run, skip, snapshot, suite, test, todo
+  "node:timers",
+  "node:timers/promises",
+  "node:tls",
+  // Missing exports: getCACertificates, setDefaultCACertificates
+  "node:url",
+  // Missing exports: URLPattern, fileURLToPathBuffer
+  "node:util",
+  // Missing exports: diff, setTraceSigInt
+  "node:util/types",
+  "node:zlib"
+  // Missing exports: ZstdCompress, ZstdDecompress, createZstdCompress, createZstdDecompress, zstdCompress, zstdCompressSync, zstdDecompress, zstdDecompressSync
+];
+
+const unencCfNodeCompat = {
+  meta: {
+    name: "nitro:cloudflare-node-compat"
+  },
+  external: builtnNodeModules,
+  alias: {
+    ...Object.fromEntries(
+      builtnNodeModules.flatMap((m) => [
+        [m, m],
+        [m.replace("node:", ""), m]
+      ])
+    )
+  },
+  inject: {
+    global: "unenv/polyfill/globalthis",
+    process: "node:process",
+    clearImmediate: ["node:timers", "clearImmediate"],
+    setImmediate: ["node:timers", "setImmediate"],
+    Buffer: ["node:buffer", "Buffer"]
+  }
+};
+const unenvCfExternals = {
+  meta: {
+    name: "nitro:cloudflare-externals"
+  },
+  external: [
+    "cloudflare:email",
+    "cloudflare:sockets",
+    "cloudflare:workers",
+    "cloudflare:workflows"
+  ]
+};
+
+async function writeCFRoutes(nitro) {
+  const _cfPagesConfig = nitro.options.cloudflare?.pages || {};
+  const routes = {
+    version: _cfPagesConfig.routes?.version || 1,
+    include: _cfPagesConfig.routes?.include || ["/*"],
+    exclude: _cfPagesConfig.routes?.exclude || []
+  };
+  const writeRoutes = () => writeFile(
+    resolve(nitro.options.output.dir, "_routes.json"),
+    JSON.stringify(routes, void 0, 2),
+    true
+  );
+  if (_cfPagesConfig.defaultRoutes === false) {
+    await writeRoutes();
+    return;
+  }
+  const explicitPublicAssets = nitro.options.publicAssets.filter(
+    (dir, index, array) => {
+      if (dir.fallthrough || !dir.baseURL) {
+        return false;
+      }
+      const normalizedBase = withoutLeadingSlash(dir.baseURL);
+      return !array.some(
+        (otherDir, otherIndex) => otherIndex !== index && normalizedBase.startsWith(
+          withoutLeadingSlash(withTrailingSlash(otherDir.baseURL))
+        )
+      );
+    }
+  );
+  routes.exclude.push(
+    ...explicitPublicAssets.map((asset) => joinURL(nitro.options.baseURL, asset.baseURL || "/", "*")).sort(comparePaths)
+  );
+  const publicAssetFiles = await glob("**", {
+    cwd: nitro.options.output.dir,
+    absolute: false,
+    dot: true,
+    ignore: [
+      "_worker.js",
+      "_worker.js.map",
+      "nitro.json",
+      ...routes.exclude.map(
+        (path) => withoutLeadingSlash(path.replace(/\/\*$/, "/**"))
+      )
+    ]
+  });
+  routes.exclude.push(
+    ...publicAssetFiles.map(
+      (i) => withLeadingSlash(i).replace(/\/index\.html$/, "").replace(/\.html$/, "") || "/"
+    ).sort(comparePaths)
+  );
+  routes.exclude.splice(100 - routes.include.length);
+  await writeRoutes();
+}
+function comparePaths(a, b) {
+  return a.split("/").length - b.split("/").length || a.localeCompare(b);
+}
+async function writeCFHeaders(nitro, outdir) {
+  const headersPath = join(
+    outdir === "public" ? nitro.options.output.publicDir : nitro.options.output.dir,
+    "_headers"
+  );
+  const contents = [];
+  const rules = Object.entries(nitro.options.routeRules).sort(
+    (a, b) => b[0].split(/\/(?!\*)/).length - a[0].split(/\/(?!\*)/).length
+  );
+  for (const [path, routeRules] of rules.filter(
+    ([_, routeRules2]) => routeRules2.headers
+  )) {
+    const headers = [
+      joinURL(nitro.options.baseURL, path.replace("/**", "/*")),
+      ...Object.entries({ ...routeRules.headers }).map(
+        ([header, value]) => `  ${header}: ${value}`
+      )
+    ].join("\n");
+    contents.push(headers);
+  }
+  if (existsSync(headersPath)) {
+    const currentHeaders = await readFile(headersPath, "utf8");
+    if (/^\/\* /m.test(currentHeaders)) {
+      nitro.logger.info(
+        "Not adding Nitro fallback to `_headers` (as an existing fallback was found)."
+      );
+      return;
+    }
+    nitro.logger.info(
+      "Adding Nitro fallback to `_headers` to handle all unmatched routes."
+    );
+    contents.unshift(currentHeaders);
+  }
+  await writeFile(headersPath, contents.join("\n"), true);
+}
+async function writeCFPagesRedirects(nitro) {
+  const redirectsPath = join(nitro.options.output.dir, "_redirects");
+  const staticFallback = existsSync(
+    join(nitro.options.output.publicDir, "404.html")
+  ) ? `${joinURL(nitro.options.baseURL, "/*")} ${joinURL(nitro.options.baseURL, "/404.html")} 404` : "";
+  const contents = [staticFallback];
+  const rules = Object.entries(nitro.options.routeRules).sort(
+    (a, b) => a[0].split(/\/(?!\*)/).length - b[0].split(/\/(?!\*)/).length
+  );
+  for (const [key, routeRules] of rules.filter(
+    ([_, routeRules2]) => routeRules2.redirect
+  )) {
+    const code = routeRules.redirect.status;
+    const from = joinURL(nitro.options.baseURL, key.replace("/**", "/*"));
+    const to = hasProtocol(routeRules.redirect.to, { acceptRelative: true }) ? routeRules.redirect.to : joinURL(nitro.options.baseURL, routeRules.redirect.to);
+    contents.unshift(`${from}	${to}	${code}`);
+  }
+  if (existsSync(redirectsPath)) {
+    const currentRedirects = await readFile(redirectsPath, "utf8");
+    if (/^\/\* /m.test(currentRedirects)) {
+      nitro.logger.info(
+        "Not adding Nitro fallback to `_redirects` (as an existing fallback was found)."
+      );
+      return;
+    }
+    nitro.logger.info(
+      "Adding Nitro fallback to `_redirects` to handle all unmatched routes."
+    );
+    contents.unshift(currentRedirects);
+  }
+  await writeFile(redirectsPath, contents.join("\n"), true);
+}
+async function enableNodeCompat(nitro) {
+  nitro.options.cloudflare ??= {};
+  if (nitro.options.cloudflare.deployConfig === void 0 && p === "cloudflare_workers") {
+    nitro.options.cloudflare.deployConfig = true;
+  }
+  if (nitro.options.cloudflare.nodeCompat === void 0) {
+    const { config } = await readWranglerConfig(nitro);
+    const userCompatibilityFlags = new Set(config?.compatibility_flags || []);
+    if (userCompatibilityFlags.has("nodejs_compat") || userCompatibilityFlags.has("nodejs_compat_v2") || nitro.options.cloudflare.deployConfig) {
+      nitro.options.cloudflare.nodeCompat = true;
+    }
+  }
+  if (!nitro.options.cloudflare.nodeCompat) {
+    if (nitro.options.cloudflare.nodeCompat === void 0) {
+      nitro.logger.warn("[cloudflare] Node.js compatibility is not enabled.");
+    }
+    return;
+  }
+  nitro.options.unenv.push(unencCfNodeCompat);
+}
+const extensionParsers = {
+  ".json": h,
+  ".jsonc": h,
+  ".toml": Q
+};
+async function readWranglerConfig(nitro) {
+  const configPath = await findNearestFile(
+    ["wrangler.json", "wrangler.jsonc", "wrangler.toml"],
+    {
+      startingFrom: nitro.options.rootDir
+    }
+  ).catch(() => void 0);
+  if (!configPath) {
+    return {};
+  }
+  const userConfigText = await readFile(configPath, "utf8");
+  const parser = extensionParsers[extname(configPath)];
+  if (!parser) {
+    throw new Error(`Unsupported config file format: ${configPath}`);
+  }
+  const config = parser(userConfigText);
+  return { configPath, config };
+}
+async function writeWranglerConfig(nitro, cfTarget) {
+  if (!nitro.options.cloudflare?.deployConfig) {
+    return;
+  }
+  const wranglerConfigDir = nitro.options.output.serverDir;
+  const wranglerConfigPath = join(wranglerConfigDir, "wrangler.json");
+  const defaults = {};
+  const overrides = {};
+  defaults.compatibility_date = nitro.options.compatibilityDate.cloudflare || nitro.options.compatibilityDate.default;
+  if (cfTarget === "pages") {
+    overrides.pages_build_output_dir = relative(
+      wranglerConfigDir,
+      nitro.options.output.dir
+    );
+  } else {
+    overrides.main = relative(
+      wranglerConfigDir,
+      join(nitro.options.output.serverDir, "index.mjs")
+    );
+    overrides.assets = {
+      binding: "ASSETS",
+      directory: relative(
+        wranglerConfigDir,
+        resolve(
+          nitro.options.output.publicDir,
+          "..".repeat(nitro.options.baseURL.split("/").filter(Boolean).length)
+        )
+      )
+    };
+  }
+  const { config: userConfig = {} } = await readWranglerConfig(nitro);
+  const ctxConfig = nitro.options.cloudflare?.wrangler || {};
+  for (const key in overrides) {
+    if (key in userConfig || key in ctxConfig) {
+      nitro.logger.warn(
+        `[cloudflare] Wrangler config \`${key}\`${key in ctxConfig ? "set by config or modules" : ""} is overridden and will be ignored.`
+      );
+    }
+  }
+  const wranglerConfig = defu(
+    overrides,
+    ctxConfig,
+    userConfig,
+    defaults
+  );
+  if (!wranglerConfig.name) {
+    wranglerConfig.name = await generateWorkerName(nitro);
+    nitro.logger.info(
+      `Using auto generated worker name: \`${wranglerConfig.name}\``
+    );
+  }
+  const compatFlags = new Set(wranglerConfig.compatibility_flags || []);
+  if (nitro.options.cloudflare?.nodeCompat) {
+    if (compatFlags.has("nodejs_compat_v2") && compatFlags.has("no_nodejs_compat_v2")) {
+      nitro.logger.warn(
+        "[cloudflare] Wrangler config `compatibility_flags` contains both `nodejs_compat_v2` and `no_nodejs_compat_v2`. Ignoring `nodejs_compat_v2`."
+      );
+      compatFlags.delete("nodejs_compat_v2");
+    }
+    if (compatFlags.has("nodejs_compat_v2")) {
+      nitro.logger.warn(
+        "[cloudflare] Please consider replacing `nodejs_compat_v2` with `nodejs_compat` in your `compatibility_flags` or USE IT AT YOUR OWN RISK as it can cause issues with nitro."
+      );
+    } else {
+      compatFlags.add("nodejs_compat");
+      compatFlags.add("no_nodejs_compat_v2");
+    }
+  }
+  wranglerConfig.compatibility_flags = [...compatFlags];
+  await writeFile(
+    wranglerConfigPath,
+    JSON.stringify(wranglerConfig, null, 2),
+    true
+  );
+  const configPath = join(
+    nitro.options.rootDir,
+    ".wrangler/deploy/config.json"
+  );
+  await writeFile(
+    configPath,
+    JSON.stringify({
+      configPath: relative(dirname(configPath), wranglerConfigPath)
+    }),
+    true
+  );
+}
+async function generateWorkerName(nitro) {
+  const gitConfig = await readGitConfig(nitro.options.rootDir).catch(
+    () => void 0
+  );
+  const gitRepo = gitConfig?.remote?.origin?.url?.replace(/\.git$/, "").match(/[/:]([^/]+\/[^/]+)$/)?.[1];
+  const pkgJSON = await readPackageJSON(nitro.options.rootDir).catch(
+    () => void 0
+  );
+  const pkgName = pkgJSON?.name;
+  const subpath = relative(nitro.options.workspaceDir, nitro.options.rootDir);
+  return `${gitRepo || pkgName}/${subpath}`.toLowerCase().replace(/[^a-zA-Z0-9-]/g, "-").replace(/-$/, "");
+}
+
+async function cloudflareDevModule(nitro) {
+  if (!nitro.options.dev) {
+    return;
+  }
+  const wranglerPath = await resolveModulePath("wrangler", {
+    from: nitro.options.nodeModulesDirs,
+    try: true
+  });
+  if (!wranglerPath) {
+    nitro.logger.warn(
+      "Wrangler is not installed. Please install it using `npx nypm i wrangler` to enable dev emulation."
+    );
+    return;
+  }
+  const config = {
+    // compatibility with legacy nitro-cloudflare-dev module
+    ...nitro.options.cloudflareDev,
+    ...nitro.options.cloudflare?.dev
+  };
+  let configPath = config.configPath;
+  if (!configPath) {
+    configPath = await findFile(
+      ["wrangler.json", "wrangler.jsonc", "wrangler.toml"],
+      {
+        startingFrom: nitro.options.srcDir
+      }
+    ).catch(() => void 0);
+  }
+  const persistDir = resolve$1(
+    nitro.options.rootDir,
+    config.persistDir || ".wrangler/state/v3"
+  );
+  const gitIgnorePath = await findFile(".gitignore", {
+    startingFrom: nitro.options.rootDir
+  }).catch(() => void 0);
+  if (gitIgnorePath && persistDir === ".wrangler/state/v3") {
+    const gitIgnore = await promises.readFile(gitIgnorePath, "utf8");
+    if (!gitIgnore.includes(".wrangler/state/v3")) {
+      await promises.writeFile(gitIgnorePath, gitIgnore + "\n.wrangler/state/v3\n").catch(() => {
+      });
+    }
+  }
+  nitro.options.runtimeConfig.wrangler = {
+    ...nitro.options.runtimeConfig.wrangler,
+    configPath,
+    persistDir,
+    environment: config.environment
+  };
+  nitro.options.externals.inline = nitro.options.externals.inline || [];
+  nitro.options.externals.inline.push(
+    fileURLToPath(new URL("runtime/", import.meta.url))
+  );
+  nitro.options.plugins = nitro.options.plugins || [];
+  nitro.options.plugins.unshift(
+    resolveModulePath("./cloudflare/runtime/plugin.dev", {
+      from: presetsDir,
+      extensions: [".mjs", ".ts"]
+    })
+  );
+}
+
+const cloudflarePages = defineNitroPreset(
+  {
+    extends: "base-worker",
+    entry: "./cloudflare/runtime/cloudflare-pages",
+    exportConditions: ["workerd"],
+    commands: {
+      preview: "npx wrangler --cwd ./ pages dev",
+      deploy: "npx wrangler --cwd ./ pages deploy"
+    },
+    output: {
+      dir: "{{ rootDir }}/dist",
+      publicDir: "{{ output.dir }}/{{ baseURL }}",
+      serverDir: "{{ output.dir }}/_worker.js"
+    },
+    unenv: [unenvCfExternals],
+    alias: {
+      // Hotfix: Cloudflare appends /index.html if mime is not found and things like ico are not in standard lite.js!
+      // https://github.com/nitrojs/nitro/pull/933
+      _mime: "mime/index.js"
+    },
+    wasm: {
+      lazy: false,
+      esmImport: true
+    },
+    rollupConfig: {
+      output: {
+        entryFileNames: "index.js",
+        format: "esm",
+        inlineDynamicImports: false
+      }
+    },
+    hooks: {
+      "build:before": async (nitro) => {
+        await enableNodeCompat(nitro);
+      },
+      async compiled(nitro) {
+        await writeWranglerConfig(nitro, "pages");
+        await writeCFRoutes(nitro);
+        await writeCFHeaders(nitro, "output");
+        await writeCFPagesRedirects(nitro);
+      }
+    }
+  },
+  {
+    name: "cloudflare-pages",
+    stdName: "cloudflare_pages"
+  }
+);
+const cloudflarePagesStatic = defineNitroPreset(
+  {
+    extends: "static",
+    output: {
+      dir: "{{ rootDir }}/dist",
+      publicDir: "{{ output.dir }}/{{ baseURL }}"
+    },
+    commands: {
+      preview: "npx wrangler --cwd ./ pages dev",
+      deploy: "npx wrangler --cwd ./ pages deploy"
+    },
+    hooks: {
+      async compiled(nitro) {
+        await writeCFHeaders(nitro, "output");
+        await writeCFPagesRedirects(nitro);
+      }
+    }
+  },
+  {
+    name: "cloudflare-pages-static",
+    stdName: "cloudflare_pages",
+    static: true
+  }
+);
+const cloudflareDev = defineNitroPreset(
+  {
+    extends: "nitro-dev",
+    modules: [cloudflareDevModule],
+    esbuild: {
+      options: {
+        target: "es2022"
+      }
+    },
+    unenv: {
+      meta: {
+        name: "cloudflare-dev"
+      },
+      alias: {
+        "cloudflare:workers": resolve(
+          presetsDir,
+          "cloudflare/runtime/shims/workers.dev.mjs"
+        )
+      }
+    }
+  },
+  {
+    name: "cloudflare-dev",
+    aliases: ["cloudflare-module", "cloudflare-durable", "cloudflare-pages"],
+    compatibilityDate: "2025-07-13",
+    dev: true
+  }
+);
+const cloudflareModule = defineNitroPreset(
+  {
+    extends: "base-worker",
+    entry: "./cloudflare/runtime/cloudflare-module",
+    output: {
+      publicDir: "{{ output.dir }}/public/{{ baseURL }}"
+    },
+    exportConditions: ["workerd"],
+    commands: {
+      preview: "npx wrangler --cwd ./ dev",
+      deploy: "npx wrangler --cwd ./ deploy"
+    },
+    unenv: [unenvCfExternals],
+    rollupConfig: {
+      output: {
+        format: "esm",
+        exports: "named",
+        inlineDynamicImports: false
+      }
+    },
+    wasm: {
+      lazy: false,
+      esmImport: true
+    },
+    hooks: {
+      "build:before": async (nitro) => {
+        await enableNodeCompat(nitro);
+      },
+      async compiled(nitro) {
+        await writeWranglerConfig(nitro, "module");
+        await writeCFHeaders(nitro, "public");
+        await writeFile(
+          resolve(nitro.options.output.dir, "package.json"),
+          JSON.stringify({ private: true, main: "./server/index.mjs" }, null, 2)
+        );
+        await writeFile(
+          resolve(nitro.options.output.dir, "package-lock.json"),
+          JSON.stringify({ lockfileVersion: 1 }, null, 2)
+        );
+      }
+    }
+  },
+  {
+    name: "cloudflare-module",
+    stdName: "cloudflare_workers"
+  }
+);
+const cloudflareDurable = defineNitroPreset(
+  {
+    extends: "cloudflare-module",
+    entry: "./cloudflare/runtime/cloudflare-durable"
+  },
+  {
+    name: "cloudflare-durable"
+  }
+);
+const _cloudflare = [
+  cloudflarePages,
+  cloudflarePagesStatic,
+  cloudflareModule,
+  cloudflareDurable,
+  cloudflareDev
+];
+
+export { _cloudflare as _ };