wrangler 0.0.0-ecc8b172 → 0.0.0-ecded1af1

package/src/miniflare-cli/assets.ts

@@ -1,215 +0,0 @@
-import { existsSync, lstatSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { createMetadataObject } from "@cloudflare/pages-shared/metadata-generator/createMetadataObject";
-import { parseHeaders } from "@cloudflare/pages-shared/metadata-generator/parseHeaders";
-import { parseRedirects } from "@cloudflare/pages-shared/metadata-generator/parseRedirects";
-import { fetch as miniflareFetch } from "@miniflare/core";
-import {
-	Response as MiniflareResponse,
-	Request as MiniflareRequest,
-} from "@miniflare/core";
-import { watch } from "chokidar";
-import { getType } from "mime";
-import { hashFile } from "../pages/hash";
-import type { Metadata } from "@cloudflare/pages-shared/asset-server/metadata";
-import type {
-	fetch,
-	Request,
-} from "@cloudflare/pages-shared/environment-polyfills/types";
-import type {
-	ParsedRedirects,
-	ParsedHeaders,
-} from "@cloudflare/pages-shared/metadata-generator/types";
-import type { RequestInfo, RequestInit, FetcherFetch } from "@miniflare/core";
-import type { Log } from "miniflare";
-
-export interface Options {
-	log: Log;
-	proxyPort?: number;
-	directory?: string;
-}
-
-export default async function generateASSETSBinding(options: Options) {
-	const assetsFetch =
-		options.directory !== undefined
-			? await generateAssetsFetch(options.directory, options.log)
-			: invalidAssetsFetch;
-
-	return async function (miniflareRequest: MiniflareRequest) {
-		if (options.proxyPort) {
-			try {
-				const url = new URL(miniflareRequest.url);
-				url.host = `localhost:${options.proxyPort}`;
-				return await miniflareFetch(url, miniflareRequest);
-			} catch (thrown) {
-				options.log.error(new Error(`Could not proxy request: ${thrown}`));
-
-				// TODO: Pretty error page
-				return new MiniflareResponse(
-					`[wrangler] Could not proxy request: ${thrown}`,
-					{
-						status: 502,
-					}
-				);
-			}
-		} else {
-			try {
-				return await assetsFetch(miniflareRequest);
-			} catch (thrown) {
-				options.log.error(new Error(`Could not serve static asset: ${thrown}`));
-
-				// TODO: Pretty error page
-				return new MiniflareResponse(
-					`[wrangler] Could not serve static asset: ${thrown}`,
-					{ status: 502 }
-				);
-			}
-		}
-	} as FetcherFetch;
-}
-
-async function generateAssetsFetch(
-	directory: string,
-	log: Log
-): Promise<typeof fetch> {
-	// Defer importing miniflare until we really need it
-	await import("@cloudflare/pages-shared/environment-polyfills/miniflare");
-
-	const { generateHandler, parseQualityWeightedList } = await import(
-		"@cloudflare/pages-shared/asset-server/handler"
-	);
-
-	const headersFile = join(directory, "_headers");
-	const redirectsFile = join(directory, "_redirects");
-	const workerFile = join(directory, "_worker.js");
-
-	const ignoredFiles = [headersFile, redirectsFile, workerFile];
-
-	let redirects: ParsedRedirects | undefined;
-	if (existsSync(redirectsFile)) {
-		const contents = readFileSync(redirectsFile, "utf-8");
-		redirects = parseRedirects(contents);
-	}
-
-	let headers: ParsedHeaders | undefined;
-	if (existsSync(headersFile)) {
-		const contents = readFileSync(headersFile, "utf-8");
-		headers = parseHeaders(contents);
-	}
-
-	let metadata = createMetadataObject({
-		redirects,
-		headers,
-		logger: log.warn.bind(log),
-	});
-
-	watch([headersFile, redirectsFile], { persistent: true }).on(
-		"change",
-		(path) => {
-			switch (path) {
-				case headersFile: {
-					log.log("_headers modified. Re-evaluating...");
-					const contents = readFileSync(headersFile).toString();
-					headers = parseHeaders(contents);
-					break;
-				}
-				case redirectsFile: {
-					log.log("_redirects modified. Re-evaluating...");
-					const contents = readFileSync(redirectsFile).toString();
-					redirects = parseRedirects(contents);
-					break;
-				}
-			}
-
-			metadata = createMetadataObject({
-				redirects,
-				headers,
-				logger: log.warn,
-			});
-		}
-	);
-
-	const generateResponse = async (request: Request) => {
-		const assetKeyEntryMap = new Map<string, string>();
-
-		return await generateHandler<string>({
-			request,
-			metadata: metadata as Metadata,
-			xServerEnvHeader: "dev",
-			logError: console.error,
-			findAssetEntryForPath: async (path) => {
-				const filepath = join(directory, path);
-
-				if (
-					existsSync(filepath) &&
-					lstatSync(filepath).isFile() &&
-					!ignoredFiles.includes(filepath)
-				) {
-					const hash = hashFile(filepath);
-					assetKeyEntryMap.set(hash, filepath);
-					return hash;
-				}
-
-				return null;
-			},
-			getAssetKey: (assetEntry) => {
-				return assetEntry;
-			},
-			negotiateContent: (contentRequest) => {
-				let rawAcceptEncoding: string | undefined;
-				if (
-					contentRequest.cf &&
-					"clientAcceptEncoding" in contentRequest.cf &&
-					contentRequest.cf.clientAcceptEncoding
-				) {
-					rawAcceptEncoding = contentRequest.cf.clientAcceptEncoding as string;
-				} else {
-					rawAcceptEncoding =
-						contentRequest.headers.get("Accept-Encoding") || undefined;
-				}
-
-				const acceptEncoding = parseQualityWeightedList(rawAcceptEncoding);
-
-				if (
-					acceptEncoding["identity"] === 0 ||
-					(acceptEncoding["*"] === 0 &&
-						acceptEncoding["identity"] === undefined)
-				) {
-					throw new Error("No acceptable encodings available");
-				}
-
-				return { encoding: null };
-			},
-			fetchAsset: async (assetKey) => {
-				const filepath = assetKeyEntryMap.get(assetKey);
-				if (!filepath) {
-					throw new Error(
-						"Could not fetch asset. Please file an issue on GitHub (https://github.com/cloudflare/wrangler2/issues/new/choose) with reproduction steps."
-					);
-				}
-				const body = readFileSync(filepath) as unknown as ReadableStream;
-
-				let contentType = getType(filepath) || "application/octet-stream";
-				if (
-					contentType.startsWith("text/") &&
-					!contentType.includes("charset")
-				) {
-					contentType = `${contentType}; charset=utf-8`;
-				}
-
-				return { body, contentType };
-			},
-		});
-	};
-
-	return async (input: RequestInfo, init?: RequestInit) => {
-		const request = new MiniflareRequest(input, init);
-		return await generateResponse(request as unknown as Request);
-	};
-}
-
-const invalidAssetsFetch: typeof fetch = () => {
-	throw new Error(
-		"Trying to fetch assets directly when there is no `directory` option specified."
-	);
-};

package/src/miniflare-cli/index.ts

@@ -1,208 +0,0 @@
-import { fetch } from "@miniflare/core";
-import {
-	DurableObjectNamespace,
-	DurableObjectStub,
-} from "@miniflare/durable-objects";
-import {
-	Log,
-	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 { 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)
-		.argv;
-
-	const requestContextCheckOptions = await getRequestContextCheckOptions();
-	const config = {
-		...JSON.parse((args._[0] as string) ?? "{}"),
-		...requestContextCheckOptions,
-	};
-	const logLevel = config.logLevel.toUpperCase();
-
-	config.log =
-		config.logLevel === "none"
-			? new NoOpLog()
-			: new Log(logLevel, config.logOptions);
-
-	if (logLevel === "DEBUG" || logLevel === "VERBOSE") {
-		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,
-	};
-};