wrangler 2.1.6 → 2.1.8

package/src/__tests__/worker-namespace.test.ts

@@ -1,6 +1,7 @@
+import { rest } from "msw";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
+import { msw } from "./helpers/msw";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 
@@ -10,10 +11,6 @@ describe("dispatch-namespace", () => {
 	mockAccountId();
 	mockApiToken();
 
-	afterEach(() => {
-		unsetAllMocks();
-	});
-
 	it("should should display a list of available subcommands, for dispatch-namespace with no subcommand", async () => {
 		await runWrangler("dispatch-namespace");
 
@@ -45,31 +42,30 @@ describe("dispatch-namespace", () => {
 	});
 
 	describe("create namespace", () => {
-		function mockCreateRequest(expectedName: string) {
-			const requests = { count: 0 };
-			setMockResponse(
-				"/accounts/:accountId/workers/dispatch/namespaces",
-				([_url], init) => {
-					requests.count += 1;
-
-					const incomingText = init.body?.toString() || "";
-					const { name: namespace_name } = JSON.parse(incomingText);
-
-					expect(init.method).toBe("POST");
-					expect(namespace_name).toEqual(expectedName);
-
-					return {
-						namespace_id: "some-namespace-id",
-						namespace_name: "namespace-name",
-						created_on: "2022-06-29T14:30:08.16152Z",
-						created_by: "1fc1df98cc4420fe00367c3ab68c1639",
-						modified_on: "2022-06-29T14:30:08.16152Z",
-						modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
-					};
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.post(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, cxt) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(
+						cxt.status(200),
+						cxt.json({
+							namespace_id: "some-namespace-id",
+							namespace_name: "namespace-name",
+							created_on: "2022-06-29T14:30:08.16152Z",
+							created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							modified_on: "2022-06-29T14:30:08.16152Z",
+							modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+						})
+					);
 				}
-			);
-			return requests;
-		}
+			)
+		);
 
 		it("should display help for create", async () => {
 			await expect(
@@ -95,10 +91,7 @@ describe("dispatch-namespace", () => {
 		});
 
 		it("should attempt to create the given namespace", async () => {
-			const namespaceName = "my-namespace";
-			const requests = mockCreateRequest(namespaceName);
 			await runWrangler(`dispatch-namespace create ${namespaceName}`);
-			expect(requests.count).toEqual(1);
 
 			expect(std.out).toMatchInlineSnapshot(
 				`"Created dispatch namespace \\"my-namespace\\" with ID \\"some-namespace-id\\""`
@@ -107,21 +100,20 @@ describe("dispatch-namespace", () => {
 	});
 
 	describe("delete namespace", () => {
-		function mockDeleteRequest(expectedName: string) {
-			const requests = { count: 0 };
-			setMockResponse(
-				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceName",
-				([_url, _, namespaceName], init) => {
-					requests.count += 1;
-
-					expect(init.method).toBe("DELETE");
-					expect(namespaceName).toEqual(expectedName);
-
-					return null;
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.delete(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, cxt) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(cxt.status(200), cxt.json(null));
 				}
-			);
-			return requests;
-		}
+			)
+		);
 
 		it("should display help for delete", async () => {
 			await expect(
@@ -147,10 +139,7 @@ describe("dispatch-namespace", () => {
 		});
 
 		it("should try to delete the given namespace", async () => {
-			const namespaceName = "my-namespace";
-			const requests = mockDeleteRequest(namespaceName);
 			await runWrangler(`dispatch-namespace delete ${namespaceName}`);
-			expect(requests.count).toBe(1);
 
 			expect(std.out).toMatchInlineSnapshot(
 				`"Deleted dispatch namespace \\"my-namespace\\""`
@@ -159,27 +148,30 @@ describe("dispatch-namespace", () => {
 	});
 
 	describe("get namespace", () => {
-		function mockInfoRequest(expectedName: string) {
-			const requests = { count: 0 };
-			setMockResponse(
-				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceName",
-				([_url, _, namespaceName], _init) => {
-					requests.count += 1;
-
-					expect(namespaceName).toEqual(expectedName);
-
-					return {
-						namespace_id: "some-namespace-id",
-						namespace_name: "namespace-name",
-						created_on: "2022-06-29T14:30:08.16152Z",
-						created_by: "1fc1df98cc4420fe00367c3ab68c1639",
-						modified_on: "2022-06-29T14:30:08.16152Z",
-						modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
-					};
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.get(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, cxt) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(
+						cxt.status(200),
+						cxt.json({
+							namespace_id: "some-namespace-id",
+							namespace_name: "namespace-name",
+							created_on: "2022-06-29T14:30:08.16152Z",
+							created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							modified_on: "2022-06-29T14:30:08.16152Z",
+							modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+						})
+					);
 				}
-			);
-			return requests;
-		}
+			)
+		);
 
 		it("should display help for get", async () => {
 			await expect(
@@ -205,10 +197,7 @@ describe("dispatch-namespace", () => {
 		});
 
 		it("should attempt to get info for the given namespace", async () => {
-			const namespaceName = "my-namespace";
-			const requests = mockInfoRequest(namespaceName);
 			await runWrangler(`dispatch-namespace get ${namespaceName}`);
-			expect(requests.count).toBe(1);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			"{
@@ -224,32 +213,33 @@ describe("dispatch-namespace", () => {
 	});
 
 	describe("list namespaces", () => {
-		function mockListRequest() {
-			const requests = { count: 0 };
-			setMockResponse(
-				"/accounts/:accountId/workers/dispatch/namespaces",
-				([_url, _, _page, _perPage], _init) => {
-					requests.count += 1;
-
-					return [
-						{
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.get(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, cxt) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(
+						cxt.status(200),
+						cxt.json({
 							namespace_id: "some-namespace-id",
 							namespace_name: "namespace-name",
 							created_on: "2022-06-29T14:30:08.16152Z",
 							created_by: "1fc1df98cc4420fe00367c3ab68c1639",
 							modified_on: "2022-06-29T14:30:08.16152Z",
 							modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
-						},
-					];
+						})
+					);
 				}
-			);
-			return requests;
-		}
+			)
+		);
 
 		it("should list all namespaces", async () => {
-			const requests = mockListRequest();
 			await runWrangler("dispatch-namespace list");
-			expect(requests.count).toBe(1);
 			expect(std.out).toMatchInlineSnapshot(`
 			"[
 			  {
@@ -266,28 +256,30 @@ describe("dispatch-namespace", () => {
 	});
 
 	describe("rename namespace", () => {
-		function mockRenameRequest(expectedName: string) {
-			const requests = { count: 0 };
-			setMockResponse(
-				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceName",
-				([_url, _, namespaceName], init) => {
-					requests.count += 1;
-
-					expect(init.method).toEqual("PUT");
-					expect(namespaceName).toEqual(expectedName);
-
-					return {
-						namespace_id: "some-namespace-id",
-						namespace_name: "namespace-name",
-						created_on: "2022-06-29T14:30:08.16152Z",
-						created_by: "1fc1df98cc4420fe00367c3ab68c1639",
-						modified_on: "2022-06-29T14:30:08.16152Z",
-						modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
-					};
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.put(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, cxt) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(
+						cxt.status(200),
+						cxt.json({
+							namespace_id: "some-namespace-id",
+							namespace_name: "namespace-name",
+							created_on: "2022-06-29T14:30:08.16152Z",
+							created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							modified_on: "2022-06-29T14:30:08.16152Z",
+							modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+						})
+					);
 				}
-			);
-			return requests;
-		}
+			)
+		);
 
 		it("should display help for rename", async () => {
 			await expect(
@@ -314,13 +306,11 @@ describe("dispatch-namespace", () => {
 		});
 
 		it("should attempt to rename the given namespace", async () => {
-			const namespaceName = "my-namespace";
 			const newName = "new-namespace";
-			const requests = mockRenameRequest(namespaceName);
 			await runWrangler(
 				`dispatch-namespace rename ${namespaceName} ${newName}`
 			);
-			expect(requests.count).toBe(1);
+
 			expect(std.out).toMatchInlineSnapshot(
 				`"Renamed dispatch namespace \\"my-namespace\\" to \\"new-namespace\\""`
 			);

package/src/api/dev.ts

@@ -2,6 +2,7 @@ import { fetch, Request } from "undici";
 import { startApiDev, startDev } from "../dev";
 import { logger } from "../logger";
 
+import type { Environment } from "../config";
 import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli";
 import type { RequestInit, Response, RequestInfo } from "undici";
 
@@ -10,7 +11,7 @@ interface DevOptions {
 	env?: string;
 	ip?: string;
 	port?: number;
-	noBundle?: boolean;
+	bundle?: boolean;
 	inspectorPort?: number;
 	localProtocol?: "http" | "https";
 	assets?: string;
@@ -43,8 +44,9 @@ interface DevOptions {
 		bucket_name: string;
 		preview_bucket_name?: string;
 	}[];
+	d1Databases?: Environment["d1_databases"];
 	showInteractiveDevSession?: boolean;
-	logLevel?: "none" | "error" | "log" | "warn" | "debug";
+	logLevel?: "none" | "info" | "error" | "log" | "warn" | "debug";
 	logPrefix?: string;
 	inspect?: boolean;
 	forceLocal?: boolean;
@@ -60,25 +62,20 @@ interface DevApiOptions {
 }
 
 export interface UnstableDevWorker {
+	port: number;
+	address: string;
 	stop: () => Promise<void>;
-	fetch: (
-		input?: RequestInfo,
-		init?: RequestInit
-	) => Promise<Response | undefined>;
+	fetch: (input?: RequestInfo, init?: RequestInit) => Promise<Response>;
 	waitUntilExit: () => Promise<void>;
 }
 /**
  *  unstable_dev starts a wrangler dev server, and returns a promise that resolves with utility functions to interact with it.
- *  @param {string} script
- *  @param {DevOptions} options
- *  @param {DevApiOptions} apiOptions
- * @returns {Promise<UnstableDev>}
  */
 export async function unstable_dev(
 	script: string,
 	options?: DevOptions,
 	apiOptions?: DevApiOptions
-) {
+): Promise<UnstableDevWorker> {
 	const { testMode = true, disableExperimentalWarning = false } =
 		apiOptions || {};
 	if (!disableExperimentalWarning) {
@@ -116,6 +113,8 @@ export async function unstable_dev(
 				// now that the inner promise has resolved, we can resolve the outer promise
 				// with an object that lets you fetch and stop the dev server
 				resolve({
+					port: readyPort,
+					address: readyAddress,
 					stop: devServer.stop,
 					fetch: async (input?: RequestInfo, init?: RequestInit) => {
 						return await fetch(
@@ -144,7 +143,6 @@ export async function unstable_dev(
 				const devServer = startDev({
 					script: script,
 					inspect: false,
-					logLevel: "none",
 					showInteractiveDevSession: false,
 					_: [],
 					$0: "",
@@ -158,6 +156,8 @@ export async function unstable_dev(
 				});
 			}).then((devServer) => {
 				resolve({
+					port: readyPort,
+					address: readyAddress,
 					stop: devServer.stop,
 					fetch: async (input?: RequestInfo, init?: RequestInit) => {
 						return await fetch(

package/src/bundle.ts

@@ -63,6 +63,7 @@ export async function bundleWorker(
 	options: {
 		serveAssetsFromWorker: boolean;
 		assets: StaticAssetsConfig;
+		betaD1Shims?: string[];
 		jsxFactory: string | undefined;
 		jsxFragment: string | undefined;
 		rules: Config["rules"];
@@ -76,11 +77,14 @@ export async function bundleWorker(
 		workerDefinitions: WorkerRegistry | undefined;
 		firstPartyWorkerDevFacade: boolean | undefined;
 		targetConsumer: "dev" | "publish";
+		local: boolean;
 		testScheduled?: boolean | undefined;
+		experimentalLocalStubCache: boolean | undefined;
 	}
 ): Promise<BundleResult> {
 	const {
 		serveAssetsFromWorker,
+		betaD1Shims,
 		jsxFactory,
 		jsxFragment,
 		rules,
@@ -89,12 +93,14 @@ export async function bundleWorker(
 		minify,
 		nodeCompat,
 		checkFetch,
+		local,
 		assets,
 		workerDefinitions,
 		services,
 		firstPartyWorkerDevFacade,
 		targetConsumer,
 		testScheduled,
+		experimentalLocalStubCache,
 	} = options;
 
 	// We create a temporary directory for any oneoff files we
@@ -188,6 +194,12 @@ export async function bundleWorker(
 				return applyFirstPartyWorkerDevFacade(currentEntry, tmpDir.path);
 			}),
 
+		Array.isArray(betaD1Shims) &&
+			betaD1Shims.length > 0 &&
+			((currentEntry: Entry) => {
+				return applyD1BetaFacade(currentEntry, tmpDir.path, betaD1Shims, local);
+			}),
+
 		// Middleware loader: to add middleware, we add the path to the middleware
 		// Currently for demonstration purposes we have two example middlewares
 		// Middlewares are togglable by changing the `publish` (default=false) and `dev` (default=true) options
@@ -223,12 +235,20 @@ export async function bundleWorker(
 
 	// At this point, inputEntry points to the entry point we want to build.
 
+	const inject: string[] = [];
+	if (checkFetch) inject.push(checkedFetchFileToInject);
+	if (experimentalLocalStubCache) {
+		inject.push(
+			path.resolve(getBasePath(), "templates/experimental-local-cache-stubs.js")
+		);
+	}
+
 	const result = await esbuild.build({
 		entryPoints: [inputEntry.file],
 		bundle: true,
 		absWorkingDir: entry.directory,
 		outdir: destination,
-		inject: checkFetch ? [checkedFetchFileToInject] : [],
+		inject,
 		external: ["__STATIC_CONTENT_MANIFEST"],
 		format: entry.format === "modules" ? "esm" : "iife",
 		target: "es2020",
@@ -686,6 +706,44 @@ async function applyFirstPartyWorkerDevFacade(
 	};
 }
 
+/**
+ * A middleware that injects the beta D1 API in JS.
+ *
+ * This code be removed from here when the API is in Workers core,
+ * but moved inside Miniflare for simulating D1.
+ */
+
+async function applyD1BetaFacade(
+	entry: Entry,
+	tmpDirPath: string,
+	betaD1Shims: string[],
+	local: boolean
+): Promise<Entry> {
+	const targetPath = path.join(tmpDirPath, "d1-beta-facade.entry.js");
+
+	await esbuild.build({
+		entryPoints: [path.resolve(getBasePath(), "templates/d1-beta-facade.js")],
+		bundle: true,
+		format: "esm",
+		sourcemap: true,
+		plugins: [
+			esbuildAliasExternalPlugin({
+				__ENTRY_POINT__: entry.file,
+			}),
+		],
+		define: {
+			__D1_IMPORTS__: JSON.stringify(betaD1Shims),
+			__LOCAL_MODE__: JSON.stringify(local),
+		},
+		outfile: targetPath,
+	});
+
+	return {
+		...entry,
+		file: targetPath,
+	};
+}
+
 /**
  * Generate a string that describes the entry-points that were identified by esbuild.
  */

package/src/cfetch/internal.ts

@@ -19,21 +19,18 @@ export const getCloudflareAPIBaseURL = getEnvironmentVariableFactory({
 	defaultValue: "https://api.cloudflare.com/client/v4",
 });
 
-/**
- * Make a fetch request to the Cloudflare API.
- *
- * This function handles acquiring the API token and logging the caller in, as necessary.
- *
- * Check out https://api.cloudflare.com/ for API docs.
- *
- * This function should not be used directly, instead use the functions in `cfetch/index.ts`.
- */
-export async function fetchInternal<ResponseType>(
+/*
+ * performApiFetch does everything required to make a CF API request,
+ * but doesn't parse the response as JSON. For normal V4 API responses,
+ * use `fetchInternal`
+ * */
+export async function performApiFetch(
 	resource: string,
 	init: RequestInit = {},
 	queryParams?: URLSearchParams,
 	abortSignal?: AbortSignal
-): Promise<ResponseType> {
+) {
+	const method = init.method ?? "GET";
 	assert(
 		resource.startsWith("/"),
 		`CF API fetch - resource path must start with a "/" but got "${resource}"`
@@ -45,22 +42,41 @@ export async function fetchInternal<ResponseType>(
 	addUserAgent(headers);
 
 	const queryString = queryParams ? `?${queryParams.toString()}` : "";
-	const method = init.method ?? "GET";
-
 	logger.debug(
 		`-- START CF API REQUEST: ${method} ${getCloudflareAPIBaseURL()}${resource}${queryString}`
 	);
 	logger.debug("HEADERS:", JSON.stringify(headers, null, 2));
 	logger.debug("INIT:", JSON.stringify(init, null, 2));
 	logger.debug("-- END CF API REQUEST");
-	const response = await fetch(
-		`${getCloudflareAPIBaseURL()}${resource}${queryString}`,
-		{
-			method,
-			...init,
-			headers,
-			signal: abortSignal,
-		}
+	return await fetch(`${getCloudflareAPIBaseURL()}${resource}${queryString}`, {
+		method,
+		...init,
+		headers,
+		signal: abortSignal,
+	});
+}
+
+/**
+ * Make a fetch request to the Cloudflare API.
+ *
+ * This function handles acquiring the API token and logging the caller in, as necessary.
+ *
+ * Check out https://api.cloudflare.com/ for API docs.
+ *
+ * This function should not be used directly, instead use the functions in `cfetch/index.ts`.
+ */
+export async function fetchInternal<ResponseType>(
+	resource: string,
+	init: RequestInit = {},
+	queryParams?: URLSearchParams,
+	abortSignal?: AbortSignal
+): Promise<ResponseType> {
+	const method = init.method ?? "GET";
+	const response = await performApiFetch(
+		resource,
+		init,
+		queryParams,
+		abortSignal
 	);
 	const jsonText = await response.text();
 	logger.debug(

package/src/config/environment.ts

@@ -343,6 +343,26 @@ interface EnvironmentNonInheritable {
 		preview_bucket_name?: string;
 	}[];
 
+	/**
+	 * Specifies D1 databases that are bound to this Worker environment.
+	 *
+	 * NOTE: This field is not automatically inherited from the top level environment,
+	 * and so must be specified in every named environment.
+	 *
+	 * @default `[]`
+	 * @nonInheritable
+	 */
+	d1_databases: {
+		/** The binding name used to refer to the D1 database in the worker. */
+		binding: string;
+		/** The name of this D1 database. */
+		database_name: string;
+		/** The UUID of this D1 database (not required). */
+		database_id: string;
+		/** The UUID of this D1 database for Wrangler Dev (if specified). */
+		preview_database_id?: string;
+	}[];
+
 	/**
 	 * Specifies service bindings (worker-to-worker) that are bound to this Worker environment.
 	 *

package/src/config/index.ts

@@ -1,9 +1,11 @@
 import { findUpSync } from "find-up";
 import { logger } from "../logger";
 import { parseTOML, readFileSync } from "../parse";
+import { removeD1BetaPrefix } from "../worker";
 import { normalizeAndValidateConfig } from "./validation";
 import type { CfWorkerInit } from "../worker";
 import type { Config, RawConfig } from "./config";
+import type { CamelCaseKey } from "yargs";
 
 export type {
 	Config,
@@ -84,6 +86,7 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		data_blobs,
 		durable_objects,
 		kv_namespaces,
+		d1_databases,
 		r2_buckets,
 		logfwdr,
 		services,
@@ -138,6 +141,20 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (d1_databases !== undefined && d1_databases.length > 0) {
+		output.push({
+			type: "D1 Databases",
+			entries: d1_databases.map(({ binding, database_name, database_id }) => {
+				return {
+					key: removeD1BetaPrefix(binding),
+					value: database_name
+						? `${database_name} (${database_id})`
+						: database_id,
+				};
+			}),
+		});
+	}
+
 	if (r2_buckets !== undefined && r2_buckets.length > 0) {
 		output.push({
 			type: "R2 Buckets",
@@ -249,3 +266,18 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 
 	logger.log(message);
 }
+
+type CamelCase<T> = {
+	[key in keyof T as key | CamelCaseKey<key>]: T[key];
+};
+
+export function withConfig<T extends { config?: string }>(
+	handler: (
+		t: Omit<CamelCase<T>, "config"> & { config: Config }
+	) => Promise<void>
+) {
+	return (t: CamelCase<T>) => {
+		const { config: configPath, ...rest } = t;
+		return handler({ ...rest, config: readConfig(configPath, rest) });
+	};
+}