wrangler 0.0.0-e928f94 → 0.0.0-e9307365

package/src/module-collection.ts

@@ -1,64 +1,258 @@
-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 { logger } from "./logger";
+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(): {
-  modules: CfModule[];
-  plugin: esbuild.Plugin;
+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 modules: CfModule[] = [];
-  return {
-    modules,
-    plugin: {
-      name: "wrangler-module-collector",
-      setup(build) {
-        build.onStart(() => {
-          // reset the moduels collection
-          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",
-            });
-
-            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
-            };
-          }
-        );
-      },
-    },
-  };
+	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) {
+					logger.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 {
+					logger.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,
+		plugin: {
+			name: "wrangler-module-collector",
+			setup(build) {
+				build.onStart(() => {
+					// reset the module collection array
+					modules.splice(0);
+				});
+
+				// ~ 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 {
+							regex,
+							rule,
+						};
+					});
+				});
+
+				if (props.wrangler1xlegacyModuleReferences.fileNames.size > 0) {
+					build.onResolve(
+						{
+							filter: new RegExp(
+								"^(" +
+									[...props.wrangler1xlegacyModuleReferences.fileNames]
+										.map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+										.join("|") +
+									")$"
+							),
+						},
+						async (args: esbuild.OnResolveArgs) => {
+							if (
+								args.kind !== "import-statement" &&
+								args.kind !== "require-call"
+							) {
+								return;
+							}
+							// In the future, this will simply throw an error
+							logger.warn(
+								`Deprecation: 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]/[data_blobs]. This identifier has to be a valid
+										// JS identifier, so we replace all non alphanumeric characters
+										// with an underscore.
+										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,17 @@
+import open from "open";
+import { logger } from "./logger";
+
+/**
+ * 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
+ */
+export default async function openInBrowser(url: string): Promise<void> {
+	const childProcess = await open(url);
+	childProcess.on("error", () => {
+		logger.warn("Failed to open");
+	});
+}

package/src/package-manager.ts

@@ -0,0 +1,219 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { env } from "node:process";
+import { execa, execaCommandSync } from "execa";
+import { logger } from "./logger";
+
+export interface PackageManager {
+	cwd: string;
+	type: "npm" | "yarn" | "pnpm";
+	addDevDeps(...packages: string[]): Promise<void>;
+	install(): Promise<void>;
+}
+
+export async function getPackageManager(cwd: string): Promise<PackageManager> {
+	const [hasYarn, hasNpm, hasPnpm] = await Promise.all([
+		supportsYarn(),
+		supportsNpm(),
+		supportsPnpm(),
+	]);
+	const hasYarnLock = existsSync(join(cwd, "yarn.lock"));
+	const hasNpmLock = existsSync(join(cwd, "package-lock.json"));
+	const hasPnpmLock = existsSync(join(cwd, "pnpm-lock.yaml"));
+	const userAgent = sniffUserAgent();
+
+	// check for lockfiles
+	if (hasNpmLock) {
+		if (hasNpm) {
+			logger.log(
+				"Using npm as package manager, as there is already a package-lock.json file."
+			);
+			return { ...NpmPackageManager, cwd };
+		} else if (hasYarn) {
+			logger.log("Using yarn as package manager.");
+			logger.warn(
+				"There is already a package-lock.json file but could not find npm on the PATH."
+			);
+			return { ...YarnPackageManager, cwd };
+		}
+	} else if (hasPnpmLock) {
+		if (hasPnpm) {
+			logger.log(
+				"Using pnpm as package manager, as there is already a pnpm-lock.yaml file."
+			);
+			return { ...PnpmPackageManager, cwd };
+		} else {
+			logger.warn(
+				"There is already a pnpm-lock.yaml file but could not find pnpm on the PATH."
+			);
+			// will simply fallback to the first found of [npm, yaml, pnpm] in the next if round.
+		}
+	} else if (hasYarnLock) {
+		if (hasYarn) {
+			logger.log(
+				"Using yarn as package manager, as there is already a yarn.lock file."
+			);
+			return { ...YarnPackageManager, cwd };
+		} else if (hasNpm) {
+			logger.log("Using npm as package manager.");
+			logger.warn(
+				"There is already a yarn.lock file but could not find yarn on the PATH."
+			);
+			return { ...NpmPackageManager, cwd };
+		}
+	}
+
+	// check the user agent
+	if (userAgent === "npm" && hasNpm) {
+		logger.log("Using npm as package manager.");
+		return { ...NpmPackageManager, cwd };
+	} else if (userAgent === "pnpm" && hasPnpm) {
+		logger.log("Using pnpm as package manager.");
+		return { ...PnpmPackageManager, cwd };
+	} else if (userAgent === "yarn" && hasYarn) {
+		logger.log("Using yarn as package manager.");
+		return { ...YarnPackageManager, cwd };
+	}
+
+	// lastly, check what's installed
+	if (hasNpm) {
+		logger.log("Using npm as package manager.");
+		return { ...NpmPackageManager, cwd };
+	} else if (hasYarn) {
+		logger.log("Using yarn as package manager.");
+		return { ...YarnPackageManager, cwd };
+	} else if (hasPnpm) {
+		logger.log("Using pnpm as package manager.");
+		return { ...PnpmPackageManager, cwd };
+	} else {
+		throw new Error(
+			"Unable to find a package manager. Supported managers are: npm, yarn, and pnpm."
+		);
+	}
+}
+
+/**
+ * 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 pnpm
+ */
+const PnpmPackageManager: PackageManager = {
+	cwd: process.cwd(),
+	type: "pnpm",
+	/** Add and install a new devDependency into the local package.json. */
+	async addDevDeps(...packages: string[]): Promise<void> {
+		await execa("pnpm", ["install", ...packages, "--save-dev"], {
+			stdio: "inherit",
+			cwd: this.cwd,
+		});
+	},
+
+	/** Install all the dependencies in the local package.json. */
+	async install(): Promise<void> {
+		await execa("pnpm", ["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");
+}
+
+function supportsPnpm(): Promise<boolean> {
+	return supports("pnpm");
+}
+
+/**
+ * The environment variable `npm_config_user_agent` can be used to
+ * guess the package manager that was used to execute wrangler.
+ * It's imperfect (just like regular user agent sniffing!)
+ * but the package managers we support all set this property:
+ *
+ * - [npm](https://github.com/npm/cli/blob/1415b4bdeeaabb6e0ba12b6b1b0cc56502bd64ab/lib/utils/config/definitions.js#L1945-L1979)
+ * - [pnpm](https://github.com/pnpm/pnpm/blob/cd4f9341e966eb8b411462b48ff0c0612e0a51a7/packages/plugin-commands-script-runners/src/makeEnv.ts#L14)
+ * - [yarn](https://yarnpkg.com/advanced/lifecycle-scripts#environment-variables)
+ */
+function sniffUserAgent(): "npm" | "pnpm" | "yarn" | undefined {
+	const userAgent = env.npm_config_user_agent;
+	if (userAgent === undefined) {
+		return undefined;
+	}
+
+	if (userAgent.includes("yarn")) {
+		return "yarn";
+	}
+
+	if (userAgent.includes("pnpm")) {
+		return "pnpm";
+	}
+
+	if (userAgent.includes("npm")) {
+		return "npm";
+	}
+}