wrangler 3.1.0 → 3.1.2

package/README.md

@@ -6,8 +6,6 @@
 <a href="https://discord.gg/CloudflareDev"><img alt="Discord" src="https://img.shields.io/discord/595317990191398933?color=%23F48120&style=flat-square"></a>
 </section>
 
-> This package is for wrangler v2.x, released first in May 2022. If you're looking for v1.x of the `@cloudflare/wrangler` package, visit https://www.npmjs.com/package/@cloudflare/wrangler / https://github.com/cloudflare/wrangler-legacy.
-
 `wrangler` is a command line tool for building [Cloudflare Workers](https://workers.cloudflare.com/).
 
 ## Quick Start
@@ -26,7 +24,7 @@ npx wrangler deploy index.js --name my-worker
 
 ```bash
 # Generate a new project
-npx wrangler init my-worker
+npx wrangler init my-worker --no-delegate-c3
 # try it out
 cd my-worker && npm run start
 # and then deploy it
@@ -43,15 +41,15 @@ $ npm install wrangler --save-dev
 
 Wrangler is configured via a `wrangler.toml` file in the project root. When utilizing the `wrangler init` command, a `wrangler.toml` file will be created for you.
 
-example:
+Example:
 
 ```toml
-main = "./src/index.ts" # init w/ TypeScript
 name = "my-worker"
-compatibility_date = "YYY-MM-DD"
+main = "./src/index.ts" # init w/ TypeScript
+compatibility_date = "YYYY-MM-DD"
 ```
 
-for more detailed information about configuration, see the [documentation](https://developers.cloudflare.com/workers/cli-wrangler/configuration)
+For more detailed information about configuration, refer to the [documentation](https://developers.cloudflare.com/workers/wrangler/configuration/).
 
 ## Commands
 
@@ -67,7 +65,7 @@ Start a local development server, with live reloading and devtools.
 
 Publish the given script to the worldwide Cloudflare network.
 
-For more commands and options, refer to the [documentation](https://developers.cloudflare.com/workers/cli-wrangler/commands).
+For more commands and options, refer to the [documentation](https://developers.cloudflare.com/workers/wrangler/commands/).
 
 ## Pages
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "3.1.0",
+	"version": "3.1.2",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",
@@ -53,17 +53,19 @@
 		"assert-git-version": "node -r esbuild-register scripts/assert-git-version.ts",
 		"build": "npm run clean && npm run bundle && npm run emit-types",
 		"bundle": "node -r esbuild-register scripts/bundle.ts",
-		"check:type": "node -r esbuild-register scripts/tsc-all.ts",
+		"check:lint": "eslint .",
+		"check:type": "tsc",
 		"clean": "rimraf wrangler-dist miniflare-dist emitted-types",
 		"dev": "npm run clean && concurrently -c black,blue --kill-others-on-fail false 'npm run bundle -- --watch' 'npm run check:type -- --watch --preserveWatchOutput'",
 		"emit-types": "tsc -p tsconfig.emit.json && node -r esbuild-register scripts/emit-types.ts",
 		"prepublishOnly": "SOURCEMAPS=false npm run build",
 		"start": "npm run bundle && cross-env NODE_OPTIONS=--enable-source-maps ./bin/wrangler.js",
 		"test": "npm run assert-git-version && jest",
-		"test-watch": "npm run test -- --runInBand --testTimeout=50000 --watch",
 		"test:ci": "npm run test -- --coverage",
 		"test:debug": "npm run test -- --silent=false --verbose=true",
-		"test:e2e": "vitest --single-thread ./e2e"
+		"test:e2e": "vitest --test-timeout 240000 --single-thread --dir ./e2e run",
+		"test:watch": "npm run test -- --runInBand --testTimeout=50000 --watch",
+		"type:tests": "tsc -p ./src/__tests__/tsconfig.json && tsc -p ./e2e/tsconfig.json"
 	},
 	"jest": {
 		"coverageReporters": [
@@ -81,7 +83,7 @@
 			"<rootDir>/src/__tests__/jest.setup.ts"
 		],
 		"testRegex": "src/__tests__/.*\\.(test|spec)\\.[jt]sx?$",
-		"testTimeout": 30000,
+		"testTimeout": 50000,
 		"transform": {
 			"^.+\\.c?(t|j)sx?$": [
 				"esbuild-jest",
@@ -101,7 +103,7 @@
 		"blake3-wasm": "^2.1.5",
 		"chokidar": "^3.5.3",
 		"esbuild": "0.16.3",
-		"miniflare": "^3.0.0",
+		"miniflare": "3.20230628.0",
 		"nanoid": "^3.3.3",
 		"path-to-regexp": "^6.2.0",
 		"selfsigned": "^2.0.1",
@@ -109,7 +111,9 @@
 		"xxhash-wasm": "^1.0.1"
 	},
 	"devDependencies": {
+		"@cloudflare/eslint-config-worker": "*",
 		"@cloudflare/types": "^6.18.4",
+		"@cloudflare/workers-tsconfig": "*",
 		"@cloudflare/workers-types": "^4.20230511.0",
 		"@iarna/toml": "^3.0.0",
 		"@microsoft/api-extractor": "^7.28.3",
@@ -168,7 +172,7 @@
 		"remove-accents-esm": "^0.0.1",
 		"semiver": "^1.1.0",
 		"serve-static": "^1.15.0",
-		"shellac": "^0.7.3",
+		"shellac": "^0.8.0",
 		"signal-exit": "^3.0.7",
 		"strip-ansi": "^7.0.1",
 		"supports-color": "^9.2.2",

package/templates/__tests__/tsconfig.json

@@ -1,5 +1,5 @@
 {
-	"extends": "../../tsconfig.json",
+	"extends": "@cloudflare/workers-tsconfig/tsconfig.json",
 	"compilerOptions": {
 		"types": ["node", "jest"]
 	},

package/templates/checked-fetch.js

@@ -1,6 +1,6 @@
 const urls = new Set();
 
-export function checkedFetch(request, init) {
+function checkURL(request, init) {
 	const url =
 		request instanceof URL
 			? request
@@ -19,5 +19,12 @@ export function checkedFetch(request, init) {
 			);
 		}
 	}
-	return globalThis.fetch(request, init);
 }
+
+globalThis.fetch = new Proxy(globalThis.fetch, {
+	apply(target, thisArg, argArray) {
+		const [request, init] = argArray;
+		checkURL(request, init);
+		return Reflect.apply(target, thisArg, argArray);
+	},
+});

package/templates/facade.d.ts

@@ -1,6 +1,9 @@
 declare module "__ENTRY_POINT__" {
 	import type { Middleware } from "./middleware/common";
-	const worker: ExportedHandler & { middleware?: Middleware[] };
+	const worker: ExportedHandler & {
+		middleware?: Middleware[];
+		envWrappers: ((env: Record<string, unknown>) => Record<string, unknown>)[];
+	};
 	export default worker;
 }
 

package/templates/middleware/loader-modules.ts

@@ -36,13 +36,54 @@ class __Facade_ScheduledController__ implements ScheduledController {
 	}
 }
 
-const __facade_modules_fetch__: Middleware = function (request, env, ctx) {
-	if (worker.fetch === undefined) throw new Error("No fetch handler!"); // TODO: proper error message
+const __facade_modules_fetch__: ExportedHandlerFetchHandler = function (
+	request,
+	env,
+	ctx
+) {
+	if (worker.fetch === undefined)
+		throw new Error("Handler does not export a fetch() function.");
 	return worker.fetch(request, env, ctx);
 };
 
-const facade: ExportedHandler<unknown> = {
-	fetch(request, env, ctx) {
+function getMaskedEnv(rawEnv: unknown) {
+	let env = rawEnv as Record<string, unknown>;
+	if (worker.envWrappers && worker.envWrappers.length > 0) {
+		for (const wrapFn of worker.envWrappers) {
+			env = wrapFn(env);
+		}
+	}
+	return env;
+}
+
+/**
+ * This type is here to cause a type error if a new export handler is added to
+ * `ExportHandler` without it being included in the `facade` below.
+ */
+type MissingExportHandlers = Omit<
+	Required<ExportedHandler>,
+	"tail" | "trace" | "scheduled" | "queue" | "test" | "fetch"
+>;
+
+const facade: ExportedHandler<unknown> & MissingExportHandlers = {
+	...(worker.tail && {
+		tail: maskHandlerEnv(worker.tail),
+	}),
+	...(worker.trace && {
+		trace: maskHandlerEnv(worker.trace),
+	}),
+	...(worker.scheduled && {
+		scheduled: maskHandlerEnv(worker.scheduled),
+	}),
+	...(worker.queue && {
+		queue: maskHandlerEnv(worker.queue),
+	}),
+	...(worker.test && {
+		test: maskHandlerEnv(worker.test),
+	}),
+
+	fetch(request, rawEnv, ctx) {
+		const env = getMaskedEnv(rawEnv);
 		// Get the chain of middleware from the worker object
 		if (worker.middleware && worker.middleware.length > 0) {
 			for (const middleware of worker.middleware) {
@@ -71,14 +112,16 @@ const facade: ExportedHandler<unknown> = {
 			// We didn't have any middleware so we can skip the invocation chain,
 			// and just call the fetch handler directly
 
-			// We "don't care" if this is undefined as we want to have the same behaviour
+			// We "don't care" if this is undefined as we want to have the same behavior
 			// as if the worker completely bypassed middleware.
-			return worker.fetch!(request, env, ctx);
+			return __facade_modules_fetch__(request, env, ctx);
 		}
 	},
-	scheduled: worker.scheduled,
-	queue: worker.queue,
-	trace: worker.trace,
 };
 
+type HandlerFn<D, R> = (data: D, env: unknown, ctx: ExecutionContext) => R;
+function maskHandlerEnv<D, R>(handler: HandlerFn<D, R>): HandlerFn<D, R> {
+	return (data, env, ctx) => handler(data, getMaskedEnv(env), ctx);
+}
+
 export default facade;

package/templates/middleware/middleware-d1-beta.d.ts

@@ -0,0 +1,3 @@
+declare module "config:middleware/d1-beta" {
+	export const D1_IMPORTS: string[];
+}

package/templates/{d1-beta-facade.js → middleware/middleware-d1-beta.ts}

@@ -1,13 +1,11 @@
-// src/shim.ts
-import worker, * as OTHER_EXPORTS from "__ENTRY_POINT__";
-export * from "__ENTRY_POINT__";
+/// <reference path="middleware-d1-beta.d.ts"/>
+
+import { D1_IMPORTS } from "config:middleware/d1-beta";
 
 // src/index.ts
-var D1Database = class {
-	constructor(binding) {
-		this.binding = binding;
-	}
-	prepare(query) {
+class D1Database {
+	constructor(readonly binding: Fetcher) {}
+	prepare(query: string) {
 		return new D1PreparedStatement(this, query);
 	}
 	async dump() {
@@ -19,19 +17,19 @@ var D1Database = class {
 		});
 		if (response.status !== 200) {
 			try {
-				const err = await response.json();
-				throw new Error("D1_DUMP_ERROR", {
+				const err = (await response.json()) as { error: string };
+				throw new Error(`D1_DUMP_ERROR: ${err.error}`, {
 					cause: new Error(err.error),
 				});
 			} catch (e) {
-				throw new Error("D1_DUMP_ERROR", {
+				throw new Error(`D1_DUMP_ERROR: Status + ${response.status}`, {
 					cause: new Error("Status " + response.status),
 				});
 			}
 		}
 		return await response.arrayBuffer();
 	}
-	async batch(statements) {
+	async batch(statements: D1PreparedStatement[]) {
 		const exec = await this._send(
 			"/query",
 			statements.map((s) => s.statement),
@@ -39,7 +37,7 @@ var D1Database = class {
 		);
 		return exec;
 	}
-	async exec(query) {
+	async exec(query: string) {
 		const lines = query.trim().split("\n");
 		const _exec = await this._send("/query", lines, [], false);
 		const exec = Array.isArray(_exec) ? _exec : [_exec];
@@ -49,26 +47,36 @@ var D1Database = class {
 			})
 			.indexOf(1);
 		if (error !== -1) {
-			throw new Error("D1_EXEC_ERROR", {
-				cause: new Error(
-					"Error in line " +
-						(error + 1) +
-						": " +
-						lines[error] +
-						": " +
-						exec[error].error
-				),
-			});
+			throw new Error(
+				`D1_EXEC_ERROR: Error in line ${error + 1}: ${lines[error]}: ${
+					exec[error].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;
+					return p + (c.meta.duration as number);
 				}, 0),
 			};
 		}
 	}
-	async _send(endpoint, query, params, dothrow = true) {
+	async _send(
+		endpoint: string,
+		query: string | string[],
+		params: unknown[],
+		dothrow = true
+	) {
 		const body = JSON.stringify(
 			typeof query == "object"
 				? query.map((s, index) => {
@@ -87,75 +95,79 @@ var D1Database = class {
 			body,
 		});
 		try {
-			const answer = await response.json();
+			const answer = (await response.json()) as { error?: string };
 			if (answer.error && dothrow) {
 				const err = answer;
-				throw new Error("D1_ERROR", { cause: new Error(err.error) });
+				throw new Error(`D1_ERROR: ${err.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"),
+			const error = e as Error;
+			throw new Error(`D1_ERROR: ${error.cause || "Something went wrong"}`, {
+				cause: new Error(`${error.cause}` || "Something went wrong"),
 			});
 		}
 	}
-};
-var D1PreparedStatement = class {
-	constructor(database, statement, values) {
-		this.database = database;
-		this.statement = statement;
-		this.params = values || [];
-	}
-	bind(...values) {
+}
+
+class D1PreparedStatement {
+	constructor(
+		readonly database: D1Database,
+		readonly statement: string,
+		readonly params: unknown[] = []
+	) {}
+	bind(...values: unknown[]) {
 		for (var r in values) {
-			switch (typeof values[r]) {
+			const value = values[r];
+			switch (typeof value) {
 				case "number":
 				case "string":
 					break;
 				case "object":
-					if (values[r] == null) break;
+					if (value == null) break;
 					if (
-						Array.isArray(values[r]) &&
-						values[r]
+						Array.isArray(value) &&
+						value
 							.map((b) => {
 								return typeof b == "number" && b >= 0 && b < 256 ? 1 : 0;
 							})
 							.indexOf(0) == -1
 					)
 						break;
-					if (values[r] instanceof ArrayBuffer) {
-						values[r] = Array.from(new Uint8Array(values[r]));
+					if (value instanceof ArrayBuffer) {
+						values[r] = Array.from(new Uint8Array(value));
 						break;
 					}
-					if (ArrayBuffer.isView(values[r])) {
-						values[r] = Array.from(values[r]);
+					if (ArrayBuffer.isView(value)) {
+						values[r] = Array.from(new Uint8Array(value.buffer));
 						break;
 					}
 				default:
-					throw new Error("D1_TYPE_ERROR", {
-						cause: new Error(
-							"Type '" +
-								typeof values[r] +
-								"' not supported for value '" +
-								values[r] +
-								"'"
-						),
-					});
+					throw new Error(
+						`D1_TYPE_ERROR: Type '${typeof value}' not supported for value '${value}'`,
+						{
+							cause: new Error(
+								`Type '${typeof value}' not supported for value '${value}'`
+							),
+						}
+					);
 			}
 		}
 		return new D1PreparedStatement(this.database, this.statement, values);
 	}
-	async first(colName) {
+	async first(colName: string) {
 		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", {
+				throw new Error(`D1_COLUMN_NOTFOUND: Column not found (${colName})`, {
 					cause: new Error("Column not found"),
 				});
 			}
@@ -187,12 +199,12 @@ var D1PreparedStatement = class {
 		}
 		return raw;
 	}
-};
-function firstIfArray(results) {
+}
+function firstIfArray(results: unknown) {
 	return Array.isArray(results) ? results[0] : results;
 }
-function mapD1Result(result) {
-	let map = {
+function mapD1Result(result: Partial<D1Result>): D1Result {
+	let map: D1Result = {
 		results: result.results || [],
 		success: result.success === void 0 ? true : result.success,
 		meta: result.meta || {},
@@ -201,12 +213,17 @@ function mapD1Result(result) {
 	return map;
 }
 
+type D1Result = {
+	results: unknown[];
+	success: boolean;
+	meta: Record<string, unknown>;
+	error?: string;
+};
+
 // 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) {
+function getMaskedEnv(env: Record<string, Fetcher | D1Database>) {
 	if (envMap.has(env)) return envMap.get(env);
 	const newEnv = new Map(Object.entries(env));
 	D1_IMPORTS.filter((bindingName) =>
@@ -214,31 +231,14 @@ function getMaskedEnv(env) {
 	).forEach((bindingName) => {
 		newEnv.delete(bindingName);
 		const newName = bindingName.slice(D1_BETA_PREFIX.length);
-		const newBinding = !LOCAL_MODE
-			? new D1Database(env[bindingName])
-			: env[bindingName];
+		const newBinding = new D1Database(env[bindingName] as Fetcher);
 		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);
-	},
-	async email(message, env, ctx) {
-		return worker.email(message, getMaskedEnv(env), ctx);
-	},
-};
-export { shim_default as default };
+
+export function wrap(env: Record<string, D1Database | Fetcher>) {
+	return getMaskedEnv(env);
+}

package/templates/middleware/middleware-multiworker-dev.d.ts

@@ -0,0 +1,4 @@
+declare module "config:middleware/multiworker-dev" {
+	import type { WorkerRegistry } from "../../src/dev-registry";
+	export const workers: WorkerRegistry;
+}

package/templates/middleware/middleware-multiworker-dev.ts

@@ -0,0 +1,59 @@
+// @ts-nocheck
+/// <reference path="middleware-multiworker-dev.d.ts"/>
+
+import { workers } from "config:middleware/multiworker-dev";
+import type { WorkerRegistry } from "../../src/dev-registry";
+
+export function wrap(env: Record<string, unknown>) {
+	const facadeEnv = { ...env };
+	// For every Worker definition that's available,
+	// create a fetcher for it on the facade env.
+	// for const [name,  binding] of env
+	// if Workers[name]
+	// const details = Workers[name];
+
+	for (const [name, details] of Object.entries(workers as WorkerRegistry)) {
+		if (details) {
+			facadeEnv[name] = {
+				async fetch(...reqArgs: Parameters<Fetcher["fetch"]>) {
+					const reqFromArgs = new Request(...reqArgs);
+					if (details.headers) {
+						for (const [key, value] of Object.entries(details.headers)) {
+							// In remote mode, you need to add a couple of headers
+							// to make sure it's talking to the 'dev' preview session
+							// (much like wrangler dev already does via proxy.ts)
+							reqFromArgs.headers.set(key, value);
+						}
+						return (env[name] as Fetcher).fetch(reqFromArgs);
+					}
+
+					const url = new URL(reqFromArgs.url);
+					if (details.protocol !== undefined) {
+						url.protocol = details.protocol;
+					}
+					if (details.host !== undefined) {
+						url.host = details.host;
+					}
+					if (details.port !== undefined) {
+						url.port = details.port.toString();
+					}
+
+					const request = new Request(url.toString(), reqFromArgs);
+					return fetch(request);
+				},
+			};
+		} else {
+			// This means there's no dev binding available.
+			// Let's use whatever's available, or put a shim with a message.
+			facadeEnv[name] = facadeEnv[name] || {
+				async fetch() {
+					return new Response(
+						`You should start up wrangler dev --local on the ${name} worker`,
+						{ status: 404 }
+					);
+				},
+			};
+		}
+	}
+	return facadeEnv;
+}

package/templates/middleware/middleware-serve-static-assets.d.ts

@@ -0,0 +1,6 @@
+declare module "config:middleware/serve-static-assets" {
+	import type { CacheControl } from "@cloudflare/kv-asset-handler";
+
+	export const spaMode: boolean;
+	export const cacheControl: Partial<CacheControl>;
+}

package/templates/middleware/middleware-serve-static-assets.ts

@@ -0,0 +1,56 @@
+/// <reference path="middleware-serve-static-assets.d.ts"/>
+
+import {
+	getAssetFromKV,
+	NotFoundError,
+	MethodNotAllowedError,
+	serveSinglePageApp,
+} from "@cloudflare/kv-asset-handler";
+import type { Options } from "@cloudflare/kv-asset-handler";
+import { spaMode, cacheControl } from "config:middleware/serve-static-assets";
+import type * as kvAssetHandler from "@cloudflare/kv-asset-handler";
+import manifest from "__STATIC_CONTENT_MANIFEST";
+const ASSET_MANIFEST = JSON.parse(manifest);
+
+import type { Middleware } from "./common";
+
+const staticAssets: Middleware = async (request, env, _ctx, middlewareCtx) => {
+	let options: Partial<Options> = {
+		ASSET_MANIFEST,
+		ASSET_NAMESPACE: env.__STATIC_CONTENT,
+		cacheControl: cacheControl,
+		mapRequestToAsset: spaMode ? serveSinglePageApp : undefined,
+	};
+
+	try {
+		const page = await (getAssetFromKV as typeof kvAssetHandler.getAssetFromKV)(
+			{
+				request,
+				waitUntil(promise) {
+					return _ctx.waitUntil(promise);
+				},
+			},
+			options
+		);
+
+		// allow headers to be altered
+		const response = new Response(page.body, page);
+
+		response.headers.set("X-XSS-Protection", "1; mode=block");
+		response.headers.set("X-Content-Type-Options", "nosniff");
+		response.headers.set("X-Frame-Options", "DENY");
+		response.headers.set("Referrer-Policy", "unsafe-url");
+		response.headers.set("Feature-Policy", "none");
+
+		return response;
+	} catch (e) {
+		if (e instanceof NotFoundError || e instanceof MethodNotAllowedError) {
+			// if a known error is thrown then serve from actual worker
+			return await middlewareCtx.next(request, env);
+		}
+		// otherwise it's a real error, so throw it
+		throw e;
+	}
+};
+
+export default staticAssets;