wrangler 0.0.0-fb43821 → 0.0.0-fbfc24d7

package/src/miniflare-cli/index.ts

@@ -0,0 +1,207 @@
+import { fetch } from "@miniflare/core";
+import {
+	DurableObjectNamespace,
+	DurableObjectStub,
+} from "@miniflare/durable-objects";
+import {
+	Log,
+	LogLevel,
+	Miniflare,
+	Response as MiniflareResponse,
+	Request as MiniflareRequest,
+} from "miniflare";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { FatalError } from "../errors";
+import generateASSETSBinding from "./assets";
+import { enumKeys } from "./enum-keys";
+import { getRequestContextCheckOptions } from "./request-context";
+import type { Options } from "./assets";
+import type { AddressInfo } from "net";
+
+export interface EnablePagesAssetsServiceBindingOptions {
+	proxyPort?: number;
+	directory?: string;
+}
+
+// miniflare defines this but importing it throws:
+// Dynamic require of "path" is not supported
+class NoOpLog extends Log {
+	log(): void {}
+
+	error(message: Error): void {
+		throw message;
+	}
+}
+
+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 requestContextCheckOptions = await getRequestContextCheckOptions();
+	const config = {
+		...JSON.parse((args._[0] as string) ?? "{}"),
+		...requestContextCheckOptions,
+	};
+	//miniflare's logLevel 0 still logs routes, so lets override the logger
+	config.log = config.disableLogs
+		? new NoOpLog()
+		: new Log(logLevel, config.logOptions);
+
+	if (logLevel > LogLevel.INFO) {
+		console.log("OPTIONS:\n", JSON.stringify(config, null, 2));
+	}
+
+	config.bindings = {
+		...config.bindings,
+		...Object.fromEntries(
+			Object.entries(
+				config.externalDurableObjects as Record<
+					string,
+					{ name: string; host: string; port: number }
+				>
+			).map(([binding, { name, host, port }]) => {
+				const factory = () => {
+					throw new FatalError(
+						"An external Durable Object instance's state has somehow been attempted to be accessed.",
+						1
+					);
+				};
+				const namespace = new DurableObjectNamespace(name as string, factory);
+				namespace.get = (id) => {
+					const stub = new DurableObjectStub(factory, id);
+					stub.fetch = (...reqArgs) => {
+						const requestFromArgs = new MiniflareRequest(...reqArgs);
+						const url = new URL(requestFromArgs.url);
+						url.host = host;
+						if (port !== undefined) url.port = port.toString();
+						const request = new MiniflareRequest(
+							url.toString(),
+							requestFromArgs
+						);
+						request.headers.set("x-miniflare-durable-object-name", name);
+						request.headers.set("x-miniflare-durable-object-id", id.toString());
+
+						return fetch(request);
+					};
+					return stub;
+				};
+				return [binding, namespace];
+			})
+		),
+	};
+
+	let mf: Miniflare | undefined;
+	let durableObjectsMf: Miniflare | undefined = undefined;
+	let durableObjectsMfPort: number | undefined = undefined;
+
+	try {
+		if (args._[1]) {
+			const opts: EnablePagesAssetsServiceBindingOptions = JSON.parse(
+				args._[1] as string
+			);
+
+			if (isNaN(opts.proxyPort || NaN) && !opts.directory) {
+				throw new Error(
+					"MiniflareCLIOptions: built in service bindings set to true, but no port or directory provided"
+				);
+			}
+
+			const options: Options = {
+				log: config.log,
+				proxyPort: opts.proxyPort,
+				directory: opts.directory,
+			};
+
+			config.serviceBindings = {
+				...config.serviceBindings,
+				ASSETS: await generateASSETSBinding(options),
+			};
+		}
+		mf = new Miniflare(config);
+		// Start Miniflare development server
+		await mf.startServer();
+		await mf.startScheduler();
+
+		const internalDurableObjectClassNames = Object.values(
+			config.durableObjects as Record<string, string>
+		);
+
+		if (internalDurableObjectClassNames.length > 0) {
+			durableObjectsMf = new Miniflare({
+				host: config.host,
+				port: 0,
+				script: `
+				export default {
+					fetch(request, env) {
+						return env.DO.fetch(request)
+					}
+				}`,
+				serviceBindings: {
+					DO: async (request: MiniflareRequest) => {
+						request = new MiniflareRequest(request);
+
+						const name = request.headers.get("x-miniflare-durable-object-name");
+						const idString = request.headers.get(
+							"x-miniflare-durable-object-id"
+						);
+						request.headers.delete("x-miniflare-durable-object-name");
+						request.headers.delete("x-miniflare-durable-object-id");
+
+						if (!name || !idString) {
+							return new MiniflareResponse(
+								"[durable-object-proxy-err] Missing `x-miniflare-durable-object-name` or `x-miniflare-durable-object-id` headers.",
+								{ status: 400 }
+							);
+						}
+
+						const namespace = await mf?.getDurableObjectNamespace(name);
+						const id = namespace?.idFromString(idString);
+
+						if (!id) {
+							return new MiniflareResponse(
+								"[durable-object-proxy-err] Could not generate an ID. Possibly due to a mismatched DO name and ID?",
+								{ status: 500 }
+							);
+						}
+
+						const stub = namespace?.get(id);
+
+						if (!stub) {
+							return new MiniflareResponse(
+								"[durable-object-proxy-err] Could not generate a stub. Possibly due to a mismatched DO name and ID?",
+								{ status: 500 }
+							);
+						}
+
+						return stub.fetch(request);
+					},
+				},
+				modules: true,
+			});
+			const server = await durableObjectsMf.startServer();
+			durableObjectsMfPort = (server.address() as AddressInfo).port;
+		}
+
+		process.send &&
+			process.send(
+				JSON.stringify({
+					ready: true,
+					durableObjectsPort: durableObjectsMfPort,
+				})
+			);
+	} catch (e) {
+		mf?.log.error(e as Error);
+		process.exitCode = 1;
+		// Unmount any mounted workers
+		await mf?.dispose();
+		await durableObjectsMf?.dispose();
+	}
+}
+
+await main();

package/src/miniflare-cli/request-context.ts

@@ -0,0 +1,40 @@
+import type { MiniflareOptions } from "miniflare";
+
+/**
+ * Certain runtime APIs are only available to workers during the "request context",
+ * which is any code that returns after receiving a request and before returning
+ * a response.
+ *
+ * Miniflare emulates this behavior by using an [`AsyncLocalStorage`](https://nodejs.org/api/async_context.html#class-asynclocalstorage) and
+ * [checking at runtime](https://github.com/cloudflare/miniflare/blob/master/packages/shared/src/context.ts#L21-L36)
+ * to see if you're using those APIs during the request context.
+ *
+ * In certain environments `AsyncLocalStorage` is unavailable, such as in a
+ * [webcontainer](https://github.com/stackblitz/webcontainer-core).
+ * This function figures out if we're able to run those "request context" checks
+ * and returns [a set of options](https://miniflare.dev/core/standards#global-functionality-limits)
+ * that indicate to miniflare whether to run the checks or not.
+ */
+export const getRequestContextCheckOptions = async (): Promise<
+	Pick<MiniflareOptions, "globalAsyncIO" | "globalTimers" | "globalRandom">
+> => {
+	// check that there's an implementation of AsyncLocalStorage
+	let hasAsyncLocalStorage = true;
+	try {
+		// ripped from  the example here https://nodejs.org/api/async_context.html#class-asynclocalstorage
+		const { AsyncLocalStorage } = await import("node:async_hooks");
+		const storage = new AsyncLocalStorage<string>();
+
+		hasAsyncLocalStorage = storage.run("some-value", () => {
+			return storage.getStore() === "some-value";
+		});
+	} catch (e) {
+		hasAsyncLocalStorage = false;
+	}
+
+	return {
+		globalAsyncIO: hasAsyncLocalStorage,
+		globalRandom: hasAsyncLocalStorage,
+		globalTimers: hasAsyncLocalStorage,
+	};
+};

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");
+	});
+}