wrangler 0.0.0-e6733a3 → 0.0.0-e88a54e

package/src/miniflare-cli/index.ts

@@ -0,0 +1,37 @@
+import { Log, LogLevel, Miniflare } from "miniflare";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { enumKeys } from "./enum-keys";
+
+async function main() {
+  const args = await yargs(hideBin(process.argv))
+    .help(false)
+    .version(false)
+    .option("log", {
+      choices: enumKeys(LogLevel),
+    }).argv;
+
+  const logLevel = LogLevel[args.log ?? "INFO"];
+  const config = {
+    ...JSON.parse((args._[0] as string) ?? "{}"),
+    log: new Log(logLevel),
+  };
+
+  if (logLevel > LogLevel.INFO) {
+    console.log("OPTIONS:\n", JSON.stringify(config, null, 2));
+  }
+
+  const mf = new Miniflare(config);
+
+  try {
+    // Start Miniflare development server
+    await mf.startServer();
+  } catch (e) {
+    mf.log.error(e as Error);
+    process.exitCode = 1;
+    // Unmount any mounted workers
+    await mf.dispose();
+  }
+}
+
+await main();

package/src/module-collection.ts

@@ -1,21 +1,96 @@
-import type { CfModule } from "./api/worker";
-import type esbuild from "esbuild";
-import path from "node:path";
-import { readFile } from "node:fs/promises";
 import crypto from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import globToRegExp from "glob-to-regexp";
+import type { Config, ConfigModuleRuleType } from "./config";
+import type { CfModule, CfModuleType, CfScriptFormat } from "./worker";
+import type esbuild from "esbuild";
+
+const RuleTypeToModuleType: Record<ConfigModuleRuleType, CfModuleType> = {
+  ESModule: "esm",
+  CommonJS: "commonjs",
+  CompiledWasm: "compiled-wasm",
+  Data: "buffer",
+  Text: "text",
+};
 
 // This is a combination of an esbuild plugin and a mutable array
 // that we use to collect module references from source code.
 // There will be modules that _shouldn't_ be inlined directly into
 // the bundle. (eg. wasm modules, some text files, etc). We can include
-// those files as modules in the multi part forker form upload. This
+// those files as modules in the multi part worker form upload. This
 // plugin+array is used to collect references to these modules, reference
 // them correctly in the bundle, and add them to the form upload.
 
-export default function makeModuleCollector(): {
+export const DEFAULT_MODULE_RULES: Config["rules"] = [
+  { type: "Text", globs: ["**/*.txt", "**/*.html"] },
+  { type: "Data", globs: ["**/*.bin"] },
+  { type: "CompiledWasm", globs: ["**/*.wasm"] },
+];
+
+export default function createModuleCollector(props: {
+  format: CfScriptFormat;
+  rules?: Config["rules"];
+  // a collection of "legacy" style module references, which are just file names
+  // we will eventually deprecate this functionality, hence the verbose greppable name
+  wrangler1xlegacyModuleReferences: {
+    rootDirectory: string;
+    fileNames: Set<string>;
+  };
+}): {
   modules: CfModule[];
   plugin: esbuild.Plugin;
 } {
+  const rules: Config["rules"] = [
+    ...(props.rules || []),
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    ...DEFAULT_MODULE_RULES!,
+  ];
+
+  // First, we want to add some validations to the module rules
+  // We want to warn if rules are accidentally configured in such a way that
+  // subsequent rules will never match because `fallthrough` hasn't been set
+
+  const completedRuleLocations: Record<string, number> = {};
+  let index = 0;
+  const rulesToRemove: Config["rules"] = [];
+  for (const rule of rules) {
+    if (rule.type in completedRuleLocations) {
+      if (rules[completedRuleLocations[rule.type]].fallthrough !== false) {
+        if (index < (props.rules || []).length) {
+          console.warn(
+            `The module rule at position ${index} (${JSON.stringify(
+              rule
+            )}) has the same type as a previous rule (at position ${
+              completedRuleLocations[rule.type]
+            }, ${JSON.stringify(
+              rules[completedRuleLocations[rule.type]]
+            )}). This rule will be ignored. To the previous rule, add \`fallthrough = true\` to allow this one to also be used, or \`fallthrough = false\` to silence this warning.`
+          );
+        } else {
+          console.warn(
+            `The default module rule ${JSON.stringify(
+              rule
+            )} has the same type as a previous rule (at position ${
+              completedRuleLocations[rule.type]
+            }, ${JSON.stringify(
+              rules[completedRuleLocations[rule.type]]
+            )}). This rule will be ignored. To the previous rule, add \`fallthrough = true\` to allow the default one to also be used, or \`fallthrough = false\` to silence this warning.`
+          );
+        }
+      }
+
+      rulesToRemove.push(rule);
+    }
+    if (!(rule.type in completedRuleLocations) && rule.fallthrough !== true) {
+      completedRuleLocations[rule.type] = index;
+    }
+    index++;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  rulesToRemove.forEach((rule) => rules!.splice(rules!.indexOf(rule), 1));
+
   const modules: CfModule[] = [];
   return {
     modules,
@@ -23,41 +98,160 @@ export default function makeModuleCollector(): {
       name: "wrangler-module-collector",
       setup(build) {
         build.onStart(() => {
-          // reset the moduels collection
+          // reset the module collection array
           modules.splice(0);
         });
 
-        build.onResolve(
-          // filter on "known" file types,
-          // we can expand this list later
-          { filter: /.*\.(pem|txt|html|wasm)$/ },
-          async (args: esbuild.OnResolveArgs) => {
-            // take the file and massage it to a
-            // transportable/manageable format
-            const fileExt = path.extname(args.path);
-            const filePath = path.join(args.resolveDir, args.path);
-            const fileContent = await readFile(filePath);
-            const fileHash = crypto
-              .createHash("sha1")
-              .update(fileContent)
-              .digest("hex");
-            const fileName = `${fileHash}-${path.basename(args.path)}`;
-
-            // add the module to the array
-            modules.push({
-              name: fileName,
-              content: fileContent,
-              type: fileExt === ".wasm" ? "compiled-wasm" : "text",
-            });
+        // ~ start  legacy module specifier support ~
+
+        // This section detects usage of "legacy" 1.x style module specifiers
+        // and modifies them so they "work" in wrangler v2, but with a warning
 
+        const rulesMatchers = rules.flatMap((rule) => {
+          return rule.globs.map((glob) => {
+            const regex = globToRegExp(glob);
             return {
-              path: fileName, // change the reference to the changed module
-              external: true, // mark it as external in the bundle
-              namespace: "wrangler-module-collector-ns", // just a tag, this isn't strictly necessary
-              watchFiles: [filePath], // we also add the file to esbuild's watch list
+              regex,
+              rule,
             };
-          }
-        );
+          });
+        });
+
+        if (props.wrangler1xlegacyModuleReferences.fileNames.size > 0) {
+          build.onResolve(
+            {
+              filter: new RegExp(
+                "^(" +
+                  [...props.wrangler1xlegacyModuleReferences.fileNames].join(
+                    "|"
+                  ) +
+                  ")$"
+              ),
+            },
+            async (args: esbuild.OnResolveArgs) => {
+              if (
+                args.kind !== "import-statement" &&
+                args.kind !== "require-call"
+              ) {
+                return;
+              }
+              // In the future, this will simply throw an error
+              console.warn(
+                `Deprecation warning: detected a legacy module import in "./${path.relative(
+                  process.cwd(),
+                  args.importer
+                )}". This will stop working in the future. Replace references to "${
+                  args.path
+                }" with "./${args.path}";`
+              );
+
+              // take the file and massage it to a
+              // transportable/manageable format
+              const filePath = path.join(
+                props.wrangler1xlegacyModuleReferences.rootDirectory,
+                args.path
+              );
+              const fileContent = await readFile(filePath);
+              const fileHash = crypto
+                .createHash("sha1")
+                .update(fileContent)
+                .digest("hex");
+              const fileName = `./${fileHash}-${path.basename(args.path)}`;
+
+              const { rule } =
+                rulesMatchers.find(({ regex }) => regex.test(fileName)) || {};
+              if (rule) {
+                // add the module to the array
+                modules.push({
+                  name: fileName,
+                  content: fileContent,
+                  type: RuleTypeToModuleType[rule.type],
+                });
+                return {
+                  path: fileName, // change the reference to the changed module
+                  external: props.format === "modules", // mark it as external in the bundle
+                  namespace: `wrangler-module-${rule.type}`, // just a tag, this isn't strictly necessary
+                  watchFiles: [filePath], // we also add the file to esbuild's watch list
+                };
+              }
+            }
+          );
+        }
+
+        // ~ end legacy module specifier support ~
+
+        rules?.forEach((rule) => {
+          if (rule.type === "ESModule" || rule.type === "CommonJS") return; // TODO: we should treat these as js files, and use the jsx loader
+
+          rule.globs.forEach((glob) => {
+            build.onResolve(
+              { filter: globToRegExp(glob) },
+              async (args: esbuild.OnResolveArgs) => {
+                // take the file and massage it to a
+                // transportable/manageable format
+
+                const filePath = path.join(args.resolveDir, args.path);
+                const fileContent = await readFile(filePath);
+                const fileHash = crypto
+                  .createHash("sha1")
+                  .update(fileContent)
+                  .digest("hex");
+                const fileName = `./${fileHash}-${path.basename(args.path)}`;
+
+                // add the module to the array
+                modules.push({
+                  name: fileName,
+                  content: fileContent,
+                  type: RuleTypeToModuleType[rule.type],
+                });
+
+                return {
+                  path: fileName, // change the reference to the changed module
+                  external: props.format === "modules", // mark it as external in the bundle
+                  namespace: `wrangler-module-${rule.type}`, // just a tag, this isn't strictly necessary
+                  watchFiles: [filePath], // we also add the file to esbuild's watch list
+                };
+              }
+            );
+
+            if (props.format === "service-worker") {
+              build.onLoad(
+                { filter: globToRegExp(glob) },
+                async (args: esbuild.OnLoadArgs) => {
+                  return {
+                    // We replace the the module with an identifier
+                    // that we'll separately add to the form upload
+                    // as part of [wasm_modules]/[text_blobs]. This identifier has to be a valid
+                    // JS identifier, so we replace all non alphanumeric characters
+                    // with an underscore.
+                    // TODO: what of "Data"?
+                    contents: `export default ${args.path.replace(
+                      /[^a-zA-Z0-9_$]/g,
+                      "_"
+                    )};`,
+                  };
+                }
+              );
+            }
+          });
+        });
+
+        rulesToRemove.forEach((rule) => {
+          rule.globs.forEach((glob) => {
+            build.onResolve(
+              { filter: globToRegExp(glob) },
+              async (args: esbuild.OnResolveArgs) => {
+                throw new Error(
+                  `The file ${
+                    args.path
+                  } matched a module rule in your configuration (${JSON.stringify(
+                    rule
+                  )}), but was ignored because a previous rule with the same type was not marked as \`fallthrough = true\`.`
+                );
+              }
+            );
+          });
+        });
       },
     },
   };

package/src/open-in-browser.ts

@@ -0,0 +1,25 @@
+import open from "open";
+
+/**
+ * An extremely simple wrapper around the open command.
+ * Specifically, it adds an 'error' event handler so that when this function
+ * is called in environments where we can't open the browser (e.g. github codespaces,
+ * stackblitz, remote servers), it doesn't just crash the process.
+ *
+ * @param url the URL to point the browser at
+ * @param options open a chromium-based browser instead of the default
+ */
+export default async function openInBrowser(
+  url: string,
+  { forceChromium }: { forceChromium: boolean } = { forceChromium: false }
+): Promise<void> {
+  const options: open.Options | undefined = forceChromium
+    ? {
+        app: [{ name: open.apps.chrome }, { name: open.apps.edge }],
+      }
+    : undefined;
+  const childProcess = await open(url, options);
+  childProcess.on("error", () => {
+    console.warn(`Failed to open ${url} in a browser`);
+  });
+}

package/src/package-manager.ts

@@ -0,0 +1,126 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { execa, execaCommandSync } from "execa";
+
+export interface PackageManager {
+  cwd: string;
+  type: "npm" | "yarn";
+  addDevDeps(...packages: string[]): Promise<void>;
+  install(): Promise<void>;
+}
+
+export async function getPackageManager(cwd: string): Promise<PackageManager> {
+  const [hasYarn, hasNpm] = await Promise.all([supportsYarn(), supportsNpm()]);
+  const hasYarnLock = existsSync(join(cwd, "yarn.lock"));
+  const hasNpmLock = existsSync(join(cwd, "package-lock.json"));
+
+  if (hasNpmLock) {
+    if (hasNpm) {
+      console.log(
+        "Using npm as package manager, as there is already a package-lock.json file."
+      );
+      return { ...NpmPackageManager, cwd };
+    } else if (hasYarn) {
+      console.log("Using yarn as package manager.");
+      console.warn(
+        "There is already a package-lock.json file but could not find npm on the PATH."
+      );
+      return { ...YarnPackageManager, cwd };
+    }
+  } else if (hasYarnLock) {
+    if (hasYarn) {
+      console.log(
+        "Using yarn as package manager, as there is already a yarn.lock file."
+      );
+      return { ...YarnPackageManager, cwd };
+    } else if (hasNpm) {
+      console.log("Using npm as package manager.");
+      console.warn(
+        "There is already a yarn.lock file but could not find yarn on the PATH."
+      );
+      return { ...NpmPackageManager, cwd };
+    }
+  }
+
+  if (hasNpm) {
+    console.log("Using npm as package manager.");
+    return { ...NpmPackageManager, cwd };
+  } else if (hasYarn) {
+    console.log("Using yarn as package manager.");
+    return { ...YarnPackageManager, cwd };
+  } else {
+    throw new Error(
+      "Unable to find a package manager. Supported managers are: npm and yarn."
+    );
+  }
+}
+
+/**
+ * Get the name of the given `packageManager`.
+ */
+export function getPackageManagerName(packageManager: PackageManager): string {
+  return packageManager.type ?? "unknown";
+}
+
+/**
+ * Manage packages using npm
+ */
+const NpmPackageManager: PackageManager = {
+  cwd: process.cwd(),
+  type: "npm",
+  /** Add and install a new devDependency into the local package.json. */
+  async addDevDeps(...packages: string[]): Promise<void> {
+    await execa("npm", ["install", ...packages, "--save-dev"], {
+      stdio: "inherit",
+      cwd: this.cwd,
+    });
+  },
+
+  /** Install all the dependencies in the local package.json. */
+  async install(): Promise<void> {
+    await execa("npm", ["install"], {
+      stdio: "inherit",
+      cwd: this.cwd,
+    });
+  },
+};
+
+/**
+ * Manage packages using yarn
+ */
+const YarnPackageManager: PackageManager = {
+  cwd: process.cwd(),
+  type: "yarn",
+  /** Add and install a new devDependency into the local package.json. */
+  async addDevDeps(...packages: string[]): Promise<void> {
+    await execa("yarn", ["add", ...packages, "--dev"], {
+      stdio: "inherit",
+      cwd: this.cwd,
+    });
+  },
+
+  /** Install all the dependencies in the local package.json. */
+  async install(): Promise<void> {
+    await execa("yarn", ["install"], {
+      stdio: "inherit",
+      cwd: this.cwd,
+    });
+  },
+};
+
+async function supports(name: string): Promise<boolean> {
+  try {
+    execaCommandSync(`${name} --version`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function supportsYarn(): Promise<boolean> {
+  return supports("yarn");
+}
+
+function supportsNpm(): Promise<boolean> {
+  return supports("npm");
+}

package/src/pages.tsx

@@ -1,28 +1,28 @@
 /* eslint-disable no-shadow */
 
-import assert from "assert";
-import type { BuilderCallback } from "yargs";
-import { join } from "path";
-import { tmpdir } from "os";
-import { existsSync, lstatSync, readFileSync, writeFileSync } from "fs";
-import { execSync, spawn } from "child_process";
-import { URL } from "url";
-import { getType } from "mime";
-import open from "open";
+import { execSync, spawn } from "node:child_process";
+import { existsSync, lstatSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { URL } from "node:url";
 import { watch } from "chokidar";
-import type { BuildResult } from "esbuild";
+import { getType } from "mime";
 import { buildWorker } from "../pages/functions/buildWorker";
-import type { Config } from "../pages/functions/routes";
-import { writeRoutesModule } from "../pages/functions/routes";
 import { generateConfigFromFileTree } from "../pages/functions/filepath-routing";
+import { writeRoutesModule } from "../pages/functions/routes";
+import openInBrowser from "./open-in-browser";
+import { toUrlPath } from "./paths";
+import type { Config } from "../pages/functions/routes";
+import type { Headers, Request, fetch } from "@miniflare/core";
+import type { BuildResult } from "esbuild";
+import type { MiniflareOptions } from "miniflare";
+import type { BuilderCallback } from "yargs";
 
 // Defer importing miniflare until we really need it. This takes ~0.5s
 // and also modifies some `stream/web` and `undici` prototypes, so we
 // don't want to do this if pages commands aren't being called.
-import type { Headers, Request, fetch } from "@miniflare/core";
-import type { MiniflareOptions } from "miniflare";
 
-const EXIT_CALLBACKS = [];
+const EXIT_CALLBACKS: (() => void)[] = [];
 const EXIT = (message?: string, code?: number) => {
   if (message) console.log(message);
   if (code) process.exitCode = code;
@@ -122,7 +122,9 @@ async function spawnProxyProcess({
       },
     }
   );
-  EXIT_CALLBACKS.push(() => proxy.kill());
+  EXIT_CALLBACKS.push(() => {
+    proxy.kill();
+  });
 
   proxy.stdout.on("data", (data) => {
     console.log(`[proxy]: ${data}`);
@@ -664,16 +666,17 @@ async function buildFunctions({
   );
 
   const routesModule = join(tmpdir(), "./functionsRoutes.mjs");
+  const baseURL = toUrlPath("/");
 
   const config: Config = await generateConfigFromFileTree({
     baseDir: functionsDirectory,
-    baseURL: "/",
+    baseURL,
   });
 
   if (outputConfigPath) {
     writeFileSync(
       outputConfigPath,
-      JSON.stringify({ ...config, baseURL: "/" }, null, 2)
+      JSON.stringify({ ...config, baseURL }, null, 2)
     );
   }
 
@@ -768,7 +771,7 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
         kv: kvs = [],
         do: durableObjects = [],
         "live-reload": liveReload,
-        "--": remaining = [],
+        _: [_pages, _dev, ...remaining],
       }) => {
         if (!local) {
           console.error("Only local mode is supported at the moment.");
@@ -792,8 +795,8 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
 
         let miniflareArgs: MiniflareOptions = {};
 
-        let scriptReadyResolve;
-        const scriptReadyPromise = new Promise(
+        let scriptReadyResolve: () => void;
+        const scriptReadyPromise = new Promise<void>(
           (resolve) => (scriptReadyResolve = resolve)
         );
 
@@ -802,13 +805,15 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
 
           console.log(`Compiling worker to "${scriptPath}"...`);
 
-          await buildFunctions({
-            scriptPath,
-            functionsDirectory,
-            sourcemap: true,
-            watch: true,
-            onEnd: () => scriptReadyResolve(),
-          });
+          try {
+            await buildFunctions({
+              scriptPath,
+              functionsDirectory,
+              sourcemap: true,
+              watch: true,
+              onEnd: () => scriptReadyResolve(),
+            });
+          } catch {}
 
           watch([functionsDirectory], {
             persistent: true,
@@ -827,6 +832,9 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
             scriptPath,
           };
         } else {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          scriptReadyResolve!();
+
           const scriptPath =
             directory !== undefined
               ? join(directory, singleWorkerScriptPath)
@@ -862,11 +870,13 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
         // internally just waits for that promise to resolve.
         await scriptReadyPromise;
 
-        // Should only be called if no proxyPort, using `assert.fail()` here
-        // means the type of `assetsFetch` is still `typeof fetch`
-        const assetsFetch = proxyPort
-          ? () => assert.fail()
-          : await generateAssetsFetch(directory);
+        // `assetsFetch()` will only be called if there is `proxyPort` defined.
+        // We only define `proxyPort`, above, when there is no `directory` defined.
+        const assetsFetch =
+          directory !== undefined
+            ? await generateAssetsFetch(directory)
+            : invalidAssetsFetch;
+
         const miniflare = new Miniflare({
           port,
           watch: true,
@@ -887,17 +897,17 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
           // User bindings
           bindings: {
             ...Object.fromEntries(
-              bindings.map((binding) => binding.toString().split("="))
+              bindings.map((binding) => binding.toString().split("=", 1))
             ),
           },
 
           // env.ASSETS.fetch
           serviceBindings: {
-            async ASSETS(request) {
+            async ASSETS(request: Request) {
               if (proxyPort) {
                 try {
                   const url = new URL(request.url);
-                  url.host = `127.0.0.1:${proxyPort}`;
+                  url.host = `localhost:${proxyPort}`;
                   return await fetch(url, request);
                 } catch (thrown) {
                   console.error(`Could not proxy request: ${thrown}`);
@@ -935,12 +945,10 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
         try {
           // `startServer` might throw if user code contains errors
           const server = await miniflare.startServer();
-          console.log(`Serving at http://127.0.0.1:${port}/`);
+          console.log(`Serving at http://localhost:${port}/`);
 
           if (process.env.BROWSER !== "none") {
-            try {
-              await open(`http://127.0.0.1:${port}/`);
-            } catch {}
+            await openInBrowser(`http://localhost:${port}/`);
           }
 
           if (directory !== undefined && liveReload) {
@@ -957,12 +965,14 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
             miniflare.dispose().catch((err) => miniflare.log.error(err));
           });
         } catch (e) {
-          miniflare.log.error(e);
+          miniflare.log.error(e as Error);
           EXIT("Could not start Miniflare.", 1);
         }
       }
     )
-    .command("functions", "Cloudflare Pages Functions", (yargs) =>
+    .command("functions", false, (yargs) =>
+      // we hide this command from help output because
+      // it's not meant to be used directly right now
       yargs.command(
         "build [directory]",
         "Compile a folder of Cloudflare Pages Functions into a single Worker",
@@ -1029,3 +1039,9 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
       )
     );
 };
+
+const invalidAssetsFetch: typeof fetch = () => {
+  throw new Error(
+    "Trying to fetch assets directly when there is no `directory` option specified, and not in `local` mode."
+  );
+};