wrangler 0.0.0-e41c7e41 → 0.0.0-e42f3207

package/src/miniflare-cli/index.ts

@@ -1,213 +0,0 @@
-import { fetch } from "@miniflare/core";
-import {
-	DurableObjectNamespace,
-	DurableObjectStub,
-} from "@miniflare/durable-objects";
-import {
-	Log as MiniflareLog,
-	LogLevel as MiniflareLogLevel,
-	Miniflare,
-	Request as MiniflareRequest,
-	Response as MiniflareResponse,
-} from "miniflare";
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import { FatalError } from "../errors";
-import generateASSETSBinding from "./assets";
-import { getRequestContextCheckOptions } from "./request-context";
-import type { LoggerLevel } from "../logger";
-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 MiniflareNoOpLog extends MiniflareLog {
-	log(): void {}
-
-	error(message: Error): void {
-		throw message;
-	}
-}
-
-async function main() {
-	const args = await yargs(hideBin(process.argv)).help(false).version(false)
-		.argv;
-
-	const requestContextCheckOptions = await getRequestContextCheckOptions();
-	const config = {
-		...JSON.parse((args._[0] as string) ?? "{}"),
-		...requestContextCheckOptions,
-	};
-
-	let logLevelString: Uppercase<LoggerLevel> = config.logLevel.toUpperCase();
-	if (logLevelString === "LOG") logLevelString = "INFO";
-	const logLevel = MiniflareLogLevel[logLevelString];
-
-	config.log =
-		logLevel === MiniflareLogLevel.NONE
-			? new MiniflareNoOpLog()
-			: new MiniflareLog(logLevel, config.logOptions);
-
-	if (logLevel === MiniflareLogLevel.DEBUG) {
-		console.log("MINIFLARE OPTIONS:\n", JSON.stringify(config, null, 2));
-	}
-
-	config.bindings = {
-		...config.bindings,
-		...(config.externalDurableObjects &&
-			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
-		const mfServer = await mf.startServer();
-		const mfPort = (mfServer.address() as AddressInfo).port;
-		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({
-					mfPort: mfPort,
-					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

@@ -1,40 +0,0 @@
-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,267 +0,0 @@
-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";
-
-function flipObject<
-	K extends string | number | symbol,
-	V extends string | number | symbol
->(obj: Record<K, V>): Record<V, K> {
-	return Object.fromEntries(Object.entries(obj).map(([k, v]) => [v, k]));
-}
-
-const RuleTypeToModuleType: Record<ConfigModuleRuleType, CfModuleType> = {
-	ESModule: "esm",
-	CommonJS: "commonjs",
-	CompiledWasm: "compiled-wasm",
-	Data: "buffer",
-	Text: "text",
-};
-
-export const ModuleTypeToRuleType = flipObject(RuleTypeToModuleType);
-
-// 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 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 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) {
-					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

@@ -1,17 +0,0 @@
-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");
-	});
-}