wrangler 0.0.0-e3e3243 → 0.0.0-e41c7e41

package/src/zones.ts

@@ -0,0 +1,191 @@
+import { fetchListResult } from "./cfetch";
+import type { Route } from "./config/environment";
+
+/**
+ * An object holding information about a zone for publishing.
+ */
+export interface Zone {
+	id: string;
+	host: string;
+}
+
+/**
+ * Get the hostname on which to run a Worker.
+ *
+ * The most accurate place is usually
+ * `route.pattern`, as that includes any subdomains. For example:
+ * ```js
+ * {
+ * 	pattern: foo.example.com
+ * 	zone_name: example.com
+ * }
+ * ```
+ * However, in the case of patterns that _can't_ be parsed as a hostname
+ * (primarily the pattern `*/ /*`), we fall back to the `zone_name`
+ * (and in the absence of that throw an error).
+ * @param route
+ */
+export function getHostFromRoute(route: Route): string | undefined {
+	if (typeof route === "string") {
+		return getHostFromUrl(route);
+	} else if (typeof route === "object") {
+		try {
+			return getHostFromUrl(route.pattern);
+		} catch (e) {
+			if (
+				(e as { code: string }).code === "ERR_INVALID_URL" &&
+				"zone_name" in route
+			) {
+				return getHostFromUrl(route.zone_name);
+			}
+			throw e;
+		}
+	}
+}
+
+/**
+ * Try to compute the a zone ID and host name for one or more routes.
+ *
+ * When we're given a route, we do 2 things:
+ * - We try to extract a host from it
+ * - We try to get a zone id from the host
+ */
+export async function getZoneForRoute(route: Route): Promise<Zone | undefined> {
+	const host = getHostFromRoute(route);
+	const id =
+		typeof route === "object" && "zone_id" in route
+			? route.zone_id
+			: host
+			? await getZoneIdFromHost(host)
+			: undefined;
+	return id && host ? { id, host } : undefined;
+}
+
+/**
+ * Given something that resembles a URL, try to extract a host from it.
+ */
+export function getHostFromUrl(urlLike: string): string | undefined {
+	// strip leading * / *.
+	urlLike = urlLike.replace(/\*(\.)?/g, "");
+
+	if (!(urlLike.startsWith("http://") || urlLike.startsWith("https://"))) {
+		urlLike = "http://" + urlLike;
+	}
+	return new URL(urlLike).host;
+}
+
+/**
+ * Given something that resembles a host, try to infer a zone id from it.
+ *
+ * It's hard to get a 'valid' domain from a string, so we don't even try to validate TLDs, etc.
+ * For each domain-like part of the host (e.g. w.x.y.z) try to get a zone id for it by
+ * lopping off subdomains until we get a hit from the API.
+ */
+export async function getZoneIdFromHost(host: string): Promise<string> {
+	const hostPieces = host.split(".");
+
+	while (hostPieces.length > 1) {
+		const zones = await fetchListResult<{ id: string }>(
+			`/zones`,
+			{},
+			new URLSearchParams({ name: hostPieces.join(".") })
+		);
+		if (zones.length > 0) {
+			return zones[0].id;
+		}
+		hostPieces.shift();
+	}
+
+	throw new Error(`Could not find zone for ${host}`);
+}
+
+/**
+ * An object holding information about an assigned worker route, returned from the API
+ */
+interface WorkerRoute {
+	id: string;
+	pattern: string;
+	script: string;
+}
+
+/**
+ * Given a zone within the user's account, return a list of all assigned worker routes
+ */
+export async function getRoutesForZone(zone: string): Promise<WorkerRoute[]> {
+	const routes = await fetchListResult<WorkerRoute>(
+		`/zones/${zone}/workers/routes`
+	);
+	return routes;
+}
+
+/**
+ * Given two strings, return the levenshtein distance between them as a simple text match heuristic
+ */
+function distanceBetween(a: string, b: string, cache = new Map()): number {
+	if (cache.has(`${a}|${b}`)) {
+		return cache.get(`${a}|${b}`);
+	}
+	let result;
+	if (b == "") {
+		result = a.length;
+	} else if (a == "") {
+		result = b.length;
+	} else if (a[0] === b[0]) {
+		result = distanceBetween(a.slice(1), b.slice(1), cache);
+	} else {
+		result =
+			1 +
+			Math.min(
+				distanceBetween(a.slice(1), b, cache),
+				distanceBetween(a, b.slice(1), cache),
+				distanceBetween(a.slice(1), b.slice(1), cache)
+			);
+	}
+	cache.set(`${a}|${b}`, result);
+	return result;
+}
+
+/**
+ * Given an invalid route, sort the valid routes by closeness to the invalid route (levenstein distance)
+ */
+export function findClosestRoute(
+	providedRoute: string,
+	assignedRoutes: WorkerRoute[]
+): WorkerRoute[] {
+	return assignedRoutes.sort((a, b) => {
+		const distanceA = distanceBetween(providedRoute, a.pattern);
+		const distanceB = distanceBetween(providedRoute, b.pattern);
+		return distanceA - distanceB;
+	});
+}
+
+/**
+ * Given a route (must be assigned and within the correct zone), return the name of the worker assigned to it
+ */
+export async function getWorkerForZone(worker: string) {
+	const zone = await getZoneForRoute(worker);
+	if (!zone) {
+		throw new Error(
+			`The route '${worker}' is not part of one of your zones. Either add this zone from the Cloudflare dashboard, or try using a route within one of your existing zones.`
+		);
+	}
+	const routes = await getRoutesForZone(zone.id);
+
+	const scriptName = routes.find((route) => route.pattern === worker)?.script;
+
+	if (!scriptName) {
+		const closestRoute = findClosestRoute(worker, routes)?.[0];
+
+		if (!closestRoute) {
+			throw new Error(
+				`The route '${worker}' has no workers assigned. You can assign a worker to it from wrangler.toml or the Cloudflare dashboard`
+			);
+		} else {
+			throw new Error(
+				`The route '${worker}' has no workers assigned. Did you mean to tail the route '${closestRoute.pattern}'?`
+			);
+		}
+	}
+
+	return scriptName;
+}

package/templates/__tests__/pages-dev-util.test.ts

@@ -0,0 +1,128 @@
+import { isRoutingRuleMatch } from "../pages-dev-util";
+
+describe("isRoutingRuleMatch", () => {
+	it("should match rules referencing root level correctly", () => {
+		const routingRule = "/";
+
+		expect(isRoutingRuleMatch("/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeFalsy();
+	});
+
+	it("should match include-all rules correctly", () => {
+		const routingRule = "/*";
+
+		expect(isRoutingRuleMatch("/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/baz", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/baz/", routingRule)).toBeTruthy();
+	});
+
+	it("should match `/*` suffix-ed rules correctly", () => {
+		let routingRule = "/foo/*";
+
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foobar", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/baz", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/bar/foo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/bar/foo/baz", routingRule)).toBeFalsy();
+
+		routingRule = "/foo/bar/*";
+
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/baz", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/barfoo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("baz/foo/bar", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("baz/foo/bar/", routingRule)).toBeFalsy();
+	});
+
+	it("should match `/` suffix-ed rules correctly", () => {
+		let routingRule = "/foo/";
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeTruthy();
+
+		routingRule = "/foo/bar/";
+		expect(isRoutingRuleMatch("/foo/bar/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+	});
+
+	it("should match `*` suffix-ed rules correctly", () => {
+		let routingRule = "/foo*";
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foobar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/barfoo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/bar/foo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/bar/foobar", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/bar/baz", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/bar/foo/baz", routingRule)).toBeFalsy();
+
+		routingRule = "/foo/bar*";
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/barfoo", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/bar/foo/barfoo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/bar/baz", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/bar/foo/bar/baz", routingRule)).toBeFalsy();
+	});
+
+	it("should match rules without wildcards correctly", () => {
+		let routingRule = "/foo";
+
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/bar/foo", routingRule)).toBeFalsy();
+
+		routingRule = "/foo/bar";
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/baz", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/baz/foo/bar", routingRule)).toBeFalsy();
+	});
+
+	it("should throw an error if pathname or routing rule params are missing", () => {
+		// MISSING PATHNAME
+		expect(() =>
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore: sanity check
+			isRoutingRuleMatch(undefined, "/*")
+		).toThrow("Pathname is undefined.");
+
+		expect(() =>
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore: sanity check
+			isRoutingRuleMatch(null, "/*")
+		).toThrow("Pathname is undefined.");
+
+		expect(() => isRoutingRuleMatch("", "/*")).toThrow(
+			"Pathname is undefined."
+		);
+
+		// MISSING ROUTING RULE
+		expect(() =>
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore: sanity check
+			isRoutingRuleMatch("/foo", undefined)
+		).toThrow("Routing rule is undefined.");
+
+		expect(() =>
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore: sanity check
+			isRoutingRuleMatch("/foo", null)
+		).toThrow("Routing rule is undefined.");
+
+		expect(() => isRoutingRuleMatch("/foo", "")).toThrow(
+			"Routing rule is undefined."
+		);
+	});
+});

package/templates/checked-fetch.js

@@ -0,0 +1,17 @@
+const urls = new Set();
+
+export function checkedFetch(request, init) {
+	const url = new URL(
+		(typeof request === "string" ? new Request(request, init) : request).url
+	);
+	if (url.port && url.port !== "443" && url.protocol === "https:") {
+		if (!urls.has(url.toString())) {
+			urls.add(url.toString());
+			console.warn(
+				`WARNING: known issue with \`fetch()\` requests to custom HTTPS ports in published Workers:\n` +
+					` - ${url.toString()} - the custom port will be ignored when the Worker is published using the \`wrangler publish\` command.\n`
+			);
+		}
+	}
+	return globalThis.fetch(request, init);
+}

package/templates/d1-beta-facade.js

@@ -0,0 +1,205 @@
+// src/shim.ts
+import worker from "__ENTRY_POINT__";
+export * from "__ENTRY_POINT__";
+
+// src/index.ts
+var D1Database = class {
+	constructor(binding) {
+		this.binding = binding;
+	}
+	prepare(query) {
+		return new D1PreparedStatement(this, query);
+	}
+	async dump() {
+		const response = await this.binding.fetch("/dump", {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+			},
+		});
+		if (response.status !== 200) {
+			try {
+				const err = await response.json();
+				throw new Error("D1_DUMP_ERROR", {
+					cause: new Error(err.error),
+				});
+			} catch (e) {
+				throw new Error("D1_DUMP_ERROR", {
+					cause: new Error("Status " + response.status),
+				});
+			}
+		}
+		return await response.arrayBuffer();
+	}
+	async batch(statements) {
+		const exec = await this._send(
+			"/query",
+			statements.map((s) => s.statement),
+			statements.map((s) => s.params)
+		);
+		return exec;
+	}
+	async exec(query) {
+		const lines = query.trim().split("\n");
+		const _exec = await this._send("/query", lines, [], false);
+		const exec = Array.isArray(_exec) ? _exec : [_exec];
+		const error = exec
+			.map((r) => {
+				return r.error ? 1 : 0;
+			})
+			.indexOf(1);
+		if (error !== -1) {
+			throw new Error("D1_EXEC_ERROR", {
+				cause: new Error(
+					"Error in line " +
+						(error + 1) +
+						": " +
+						lines[error] +
+						": " +
+						exec[error].error
+				),
+			});
+		} else {
+			return {
+				count: exec.length,
+				duration: exec.reduce((p, c) => {
+					return p + c.meta.duration;
+				}, 0),
+			};
+		}
+	}
+	async _send(endpoint, query, params, dothrow = true) {
+		const body = JSON.stringify(
+			typeof query == "object"
+				? query.map((s, index) => {
+						return { sql: s, params: params[index] };
+				  })
+				: {
+						sql: query,
+						params,
+				  }
+		);
+		const response = await this.binding.fetch(endpoint, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+			},
+			body,
+		});
+		try {
+			const answer = await response.json();
+			if (answer.error && dothrow) {
+				const err = answer;
+				throw new Error("D1_ERROR", { cause: new Error(err.error) });
+			} else {
+				return Array.isArray(answer)
+					? answer.map((r) => mapD1Result(r))
+					: mapD1Result(answer);
+			}
+		} catch (e) {
+			throw new Error("D1_ERROR", {
+				cause: new Error(e.cause || "Something went wrong"),
+			});
+		}
+	}
+};
+var D1PreparedStatement = class {
+	constructor(database, statement, values) {
+		this.database = database;
+		this.statement = statement;
+		this.params = values || [];
+	}
+	bind(...values) {
+		return new D1PreparedStatement(this.database, this.statement, values);
+	}
+	async first(colName) {
+		const info = firstIfArray(
+			await this.database._send("/query", this.statement, this.params)
+		);
+		const results = info.results;
+		if (colName !== void 0) {
+			if (results.length > 0 && results[0][colName] === void 0) {
+				throw new Error("D1_COLUMN_NOTFOUND", {
+					cause: new Error("Column not found"),
+				});
+			}
+			return results.length < 1 ? null : results[0][colName];
+		} else {
+			return results.length < 1 ? null : results[0];
+		}
+	}
+	async run() {
+		return firstIfArray(
+			await this.database._send("/execute", this.statement, this.params)
+		);
+	}
+	async all() {
+		return firstIfArray(
+			await this.database._send("/query", this.statement, this.params)
+		);
+	}
+	async raw() {
+		const s = firstIfArray(
+			await this.database._send("/query", this.statement, this.params)
+		);
+		const raw = [];
+		for (var r in s.results) {
+			const entry = Object.keys(s.results[r]).map((k) => {
+				return s.results[r][k];
+			});
+			raw.push(entry);
+		}
+		return raw;
+	}
+};
+function firstIfArray(results) {
+	return Array.isArray(results) ? results[0] : results;
+}
+function mapD1Result(result) {
+	let map = {
+		results: result.results || [],
+		success: result.success === void 0 ? true : result.success,
+		meta: result.meta || {},
+	};
+	result.error && (map.error = result.error);
+	return map;
+}
+
+// src/shim.ts
+var D1_IMPORTS = __D1_IMPORTS__;
+var LOCAL_MODE = __LOCAL_MODE__;
+var D1_BETA_PREFIX = `__D1_BETA__`;
+var envMap = /* @__PURE__ */ new Map();
+function getMaskedEnv(env) {
+	if (envMap.has(env)) return envMap.get(env);
+	const newEnv = new Map(Object.entries(env));
+	D1_IMPORTS.filter((bindingName) =>
+		bindingName.startsWith(D1_BETA_PREFIX)
+	).forEach((bindingName) => {
+		newEnv.delete(bindingName);
+		const newName = bindingName.slice(D1_BETA_PREFIX.length);
+		const newBinding = !LOCAL_MODE
+			? new D1Database(env[bindingName])
+			: env[bindingName];
+		newEnv.set(newName, newBinding);
+	});
+	const newEnvObj = Object.fromEntries(newEnv.entries());
+	envMap.set(env, newEnvObj);
+	return newEnvObj;
+}
+var shim_default = {
+	...worker,
+	async fetch(request, env, ctx) {
+		return worker.fetch(request, getMaskedEnv(env), ctx);
+	},
+	async queue(batch, env, ctx) {
+		return worker.queue(batch, getMaskedEnv(env), ctx);
+	},
+	async scheduled(controller, env, ctx) {
+		return worker.scheduled(controller, getMaskedEnv(env), ctx);
+	},
+	async trace(traces, env, ctx) {
+		return worker.trace(traces, getMaskedEnv(env), ctx);
+	},
+};
+export { shim_default as default };

package/templates/first-party-worker-module-facade.ts

@@ -0,0 +1,18 @@
+// @ts-ignore entry point will get replaced
+import worker from "__ENTRY_POINT__";
+// @ts-ignore entry point will get replaced
+export * from "__ENTRY_POINT__";
+
+type Env = {
+	// TODO: type this
+};
+
+/**
+ * Setup globals/vars as required
+ */
+
+export default {
+	async fetch(request: Request, env: Env, ctx: ExecutionContext) {
+		return worker.fetch(request, env, ctx);
+	},
+};

package/templates/format-dev-errors.ts

@@ -0,0 +1,32 @@
+// @ts-expect-error We'll swap in the entry point during build
+import Worker from "__ENTRY_POINT__";
+
+// @ts-expect-error
+export * from "__ENTRY_POINT__";
+
+export default {
+	async fetch(req: Request, env: unknown, ctx: ExecutionContext) {
+		try {
+			return await Worker.fetch(req, env, ctx);
+		} catch (err) {
+			return new Response(
+				`<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="utf-8" />
+		<title>Error</title>
+	</head>
+	<body>
+		<pre>${(err as Error).stack}</pre>
+	</body>
+</html>`,
+				{
+					status: 500,
+					headers: {
+						"Content-Type": "text/html",
+					},
+				}
+			);
+		}
+	},
+};