wrangler 2.2.0 → 2.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "2.2.0",
+	"version": "2.2.2",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",
@@ -114,6 +114,7 @@
 		"xxhash-wasm": "^1.0.1"
 	},
 	"devDependencies": {
+		"@cloudflare/types": "^6.18.4",
 		"@databases/split-sql-query": "^1.0.3",
 		"@databases/sql": "^3.2.0",
 		"@iarna/toml": "^3.0.0",

package/src/__tests__/deployments.test.ts

@@ -66,7 +66,7 @@ describe("deployments", () => {
 		Created on: 2021-01-01T00:00:00.000000Z
 		Author: Jean-Luc-Picard@federation.org
 		Source: Wrangler
-		🟩Active"
+		🟩 Active"
 	`);
 	});
 
@@ -85,7 +85,7 @@ describe("deployments", () => {
 		Created on: 2021-01-01T00:00:00.000000Z
 		Author: Jean-Luc-Picard@federation.org
 		Source: Wrangler
-		🟩Active"
+		🟩 Active"
 	`);
 	});
 });

package/src/__tests__/pages.test.ts

@@ -401,6 +401,17 @@ describe("pages", () => {
 				}
 			);
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await runWrangler("pages publish . --project-name=foo");
 
 			expect(std.out).toMatchInlineSnapshot(`
@@ -470,6 +481,17 @@ describe("pages", () => {
 				}
 			);
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await runWrangler("pages publish . --project-name=foo");
 
 			// Assert two identical requests
@@ -564,6 +586,17 @@ describe("pages", () => {
 				}
 			);
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await runWrangler("pages publish . --project-name=foo");
 
 			// Assert two requests
@@ -658,6 +691,17 @@ describe("pages", () => {
 				}
 			);
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await runWrangler("pages publish . --project-name=foo");
 
 			// We have 3 buckets, so expect 3 uploads
@@ -772,6 +816,17 @@ describe("pages", () => {
 				}
 			);
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await runWrangler(`pages publish public --project-name=foo`);
 
 			// We have 3 buckets, so expect 3 uploads
@@ -886,6 +941,17 @@ describe("pages", () => {
 				}
 			);
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			chdir("public");
 			await runWrangler(`pages publish . --project-name=foo`);
 
@@ -988,6 +1054,17 @@ describe("pages", () => {
 				})
 			);
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await runWrangler("pages publish . --project-name=foo");
 
 			expect(std.err).toMatchInlineSnapshot(`""`);
@@ -1132,6 +1209,17 @@ describe("pages", () => {
 				}
 			);
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await runWrangler("pages publish public --project-name=foo");
 
 			expect(std.out).toMatchInlineSnapshot(`
@@ -1238,6 +1326,17 @@ describe("pages", () => {
 				}
 			);
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await runWrangler("pages publish public --project-name=foo");
 
 			expect(std.out).toMatchInlineSnapshot(`
@@ -1389,6 +1488,17 @@ describe("pages", () => {
 				}
 			);
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await runWrangler("pages publish public --project-name=foo");
 
 			expect(std.out).toMatchInlineSnapshot(`
@@ -1475,6 +1585,17 @@ describe("pages", () => {
 				});
 			});
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await expect(runWrangler("pages publish public --project-name=foo"))
 				.rejects
 				.toThrow(`Invalid _routes.json file found at: public/_routes.json
@@ -1627,6 +1748,17 @@ and that at least one include rule is provided.
 				}
 			);
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await runWrangler("pages publish public --project-name=foo");
 
 			expect(std.out).toMatchInlineSnapshot(`
@@ -1712,6 +1844,17 @@ and that at least one include rule is provided.
 				});
 			});
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await expect(runWrangler("pages publish public --project-name=foo"))
 				.rejects
 				.toThrow(`Invalid _routes.json file found at: public/_routes.json
@@ -1829,6 +1972,17 @@ and that at least one include rule is provided.
 				}
 			);
 
+			setMockResponse(
+				"/accounts/:accountId/pages/projects/foo",
+				"GET",
+				async ([_url, accountId]) => {
+					assertLater(() => {
+						expect(accountId).toEqual("some-account-id");
+					});
+					return { deployment_configs: { production: {}, preview: {} } };
+				}
+			);
+
 			await runWrangler("pages publish public --project-name=foo");
 
 			expect(std.out).toMatchInlineSnapshot(`
@@ -1957,29 +2111,37 @@ and that at least one include rule is provided.
 			assertLater(() => {
 				expect(requests.length).toBe(3);
 
-				expect(requests[0].headers).toMatchObject({
+				const sortedRequests = requests.sort((a, b) => {
+					return (JSON.parse(a.body as string)[0].key as string).localeCompare(
+						JSON.parse(b.body as string)[0].key as string
+					);
+				});
+
+				expect(sortedRequests[0].headers).toMatchObject({
 					Authorization: "Bearer <<funfetti-auth-jwt>>",
 				});
 
 				let body = JSON.parse(
-					requests[0].body as string
+					sortedRequests[0].body as string
 				) as UploadPayloadFile[];
 				expect(body).toMatchObject([
 					{
-						key: "95dedb64e6d4940fc2e0f11f711cc2f4",
-						value: Buffer.from("headersfile").toString("base64"),
+						key: "09a79777abda8ccc8bdd51dd3ff8e9e9",
+						value: Buffer.from("func").toString("base64"),
 						metadata: {
-							contentType: "application/octet-stream",
+							contentType: "application/javascript",
 						},
 						base64: true,
 					},
 				]);
 
-				expect(requests[1].headers).toMatchObject({
+				expect(sortedRequests[1].headers).toMatchObject({
 					Authorization: "Bearer <<funfetti-auth-jwt>>",
 				});
 
-				body = JSON.parse(requests[1].body as string) as UploadPayloadFile[];
+				body = JSON.parse(
+					sortedRequests[1].body as string
+				) as UploadPayloadFile[];
 				expect(body).toMatchObject([
 					{
 						key: "2082190357cfd3617ccfe04f340c6247",
@@ -1991,17 +2153,19 @@ and that at least one include rule is provided.
 					},
 				]);
 
-				expect(requests[2].headers).toMatchObject({
+				expect(sortedRequests[2].headers).toMatchObject({
 					Authorization: "Bearer <<funfetti-auth-jwt>>",
 				});
 
-				body = JSON.parse(requests[2].body as string) as UploadPayloadFile[];
+				body = JSON.parse(
+					sortedRequests[2].body as string
+				) as UploadPayloadFile[];
 				expect(body).toMatchObject([
 					{
-						key: "09a79777abda8ccc8bdd51dd3ff8e9e9",
-						value: Buffer.from("func").toString("base64"),
+						key: "95dedb64e6d4940fc2e0f11f711cc2f4",
+						value: Buffer.from("headersfile").toString("base64"),
 						metadata: {
-							contentType: "application/javascript",
+							contentType: "application/octet-stream",
 						},
 						base64: true,
 					},

package/src/__tests__/publish.test.ts

@@ -7607,7 +7607,7 @@ function mockGetQueueMissing(expectedQueueName: string) {
 		`/accounts/:accountId/workers/queues/${expectedQueueName}`,
 		"GET",
 		([_url, _accountId]) => {
-			throw { code: 100123 };
+			throw { code: 11000 };
 		}
 	);
 	return requests;

package/src/__tests__/r2.test.ts

@@ -1,5 +1,7 @@
 import * as fs from "node:fs";
 import { rest } from "msw";
+import prettyBytes from "pretty-bytes";
+import { MAX_UPLOAD_SIZE } from "../r2/constants";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { msw, mswSuccessR2handlers } from "./helpers/msw";
@@ -276,7 +278,7 @@ describe("r2", () => {
 		`);
 		});
 
-		it("should upload R2 object from bucket", async () => {
+		it("should upload R2 object to bucket", async () => {
 			fs.writeFileSync("wormhole-img.png", "passageway");
 			await runWrangler(
 				`r2 object put bucketName-object-test/wormhole-img.png --file ./wormhole-img.png`
@@ -288,6 +290,21 @@ describe("r2", () => {
 		`);
 		});
 
+		it("should fail to upload R2 object to bucket if too large", async () => {
+			const TOO_BIG_FILE_SIZE = MAX_UPLOAD_SIZE + 1024 * 1024;
+			fs.writeFileSync("wormhole-img.png", Buffer.alloc(TOO_BIG_FILE_SIZE));
+			await expect(
+				runWrangler(
+					`r2 object put bucketName-object-test/wormhole-img.png --file ./wormhole-img.png`
+				)
+			).rejects.toThrowErrorMatchingInlineSnapshot(`
+			"Error: Wrangler only supports uploading files up to ${prettyBytes(
+				MAX_UPLOAD_SIZE
+			)} in size
+			wormhole-img.png is ${prettyBytes(TOO_BIG_FILE_SIZE)} in size"
+		`);
+		});
+
 		it("should pass all fetch option flags into requestInit & check request inputs", async () => {
 			msw.use(
 				rest.put(

package/src/__tests__/type-generation.test.ts

@@ -100,8 +100,8 @@ describe("generateTypes()", () => {
 		expect(std.out).toMatchInlineSnapshot(`
 		"interface Env {
 			TEST_KV_NAMESPACE: KVNamespace;
-			SOMETHING: asdasdfasdf;
-			ANOTHER: thing;
+			SOMETHING: \\"asdasdfasdf\\";
+			ANOTHER: \\"thing\\";
 			OBJECT_VAR: {\\"enterprise\\":\\"1701-D\\",\\"activeDuty\\":true,\\"captian\\":\\"Picard\\"};
 			DURABLE_TEST1: DurableObjectNamespace;
 			DURABLE_TEST2: DurableObjectNamespace;

package/src/bundle.ts

@@ -13,7 +13,7 @@ import type { WorkerRegistry } from "./dev-registry";
 import type { Entry } from "./entry";
 import type { CfModule } from "./worker";
 
-type BundleResult = {
+export type BundleResult = {
 	modules: CfModule[];
 	dependencies: esbuild.Metafile["outputs"][string]["inputs"];
 	resolvedEntryPointPath: string;
@@ -80,24 +80,31 @@ export async function bundleWorker(
 	destination: string,
 	options: {
 		serveAssetsFromWorker: boolean;
-		assets: StaticAssetsConfig;
+		assets?: StaticAssetsConfig;
 		betaD1Shims?: string[];
-		jsxFactory: string | undefined;
-		jsxFragment: string | undefined;
+		jsxFactory?: string;
+		jsxFragment?: string;
 		rules: Config["rules"];
-		watch?: esbuild.WatchMode;
-		tsconfig: string | undefined;
-		minify: boolean | undefined;
-		nodeCompat: boolean | undefined;
+		watch?: esbuild.WatchMode | boolean;
+		tsconfig?: string;
+		minify?: boolean;
+		nodeCompat?: boolean;
 		define: Config["define"];
 		checkFetch: boolean;
-		services: Config["services"] | undefined;
-		workerDefinitions: WorkerRegistry | undefined;
-		firstPartyWorkerDevFacade: boolean | undefined;
+		services?: Config["services"];
+		workerDefinitions?: WorkerRegistry;
+		firstPartyWorkerDevFacade?: boolean;
 		targetConsumer: "dev" | "publish";
 		local: boolean;
-		testScheduled?: boolean | undefined;
-		experimentalLocalStubCache: boolean | undefined;
+		testScheduled?: boolean;
+		experimentalLocalStubCache?: boolean;
+		inject?: string[];
+		loader?: Record<string, string>;
+		sourcemap?: esbuild.CommonOptions["sourcemap"];
+		plugins?: esbuild.Plugin[];
+		// TODO: Rip these out https://github.com/cloudflare/wrangler2/issues/2153
+		disableModuleCollection?: boolean;
+		isOutfile?: boolean;
 	}
 ): Promise<BundleResult> {
 	const {
@@ -119,6 +126,12 @@ export async function bundleWorker(
 		targetConsumer,
 		testScheduled,
 		experimentalLocalStubCache,
+		inject: injectOption,
+		loader,
+		sourcemap,
+		plugins,
+		disableModuleCollection,
+		isOutfile,
 	} = options;
 
 	// We create a temporary directory for any oneoff files we
@@ -127,7 +140,7 @@ export async function bundleWorker(
 	const tmpDir = await tmp.dir({ unsafeCleanup: true });
 
 	const entryDirectory = path.dirname(entry.file);
-	const moduleCollector = createModuleCollector({
+	let moduleCollector = createModuleCollector({
 		wrangler1xlegacyModuleReferences: {
 			rootDirectory: entryDirectory,
 			fileNames: new Set(
@@ -143,6 +156,15 @@ export async function bundleWorker(
 		format: entry.format,
 		rules,
 	});
+	if (disableModuleCollection) {
+		moduleCollector = {
+			modules: [],
+			plugin: {
+				name: moduleCollector.plugin.name,
+				setup: () => {},
+			},
+		};
+	}
 
 	// In dev, we want to patch `fetch()` with a special version that looks
 	// for bad usages and can warn the user about them; so we inject
@@ -253,7 +275,7 @@ export async function bundleWorker(
 
 	// At this point, inputEntry points to the entry point we want to build.
 
-	const inject: string[] = [];
+	const inject: string[] = injectOption ?? [];
 	if (checkFetch) inject.push(checkedFetchFileToInject);
 	if (experimentalLocalStubCache) {
 		inject.push(
@@ -266,11 +288,17 @@ export async function bundleWorker(
 		bundle: true,
 		absWorkingDir: entry.directory,
 		outdir: destination,
+		...(isOutfile
+			? {
+					outdir: undefined,
+					outfile: destination,
+			  }
+			: {}),
 		inject,
 		external: ["__STATIC_CONTENT_MANIFEST"],
 		format: entry.format === "modules" ? "esm" : "iife",
 		target: "es2020",
-		sourcemap: true,
+		sourcemap: sourcemap ?? true, // this needs to use ?? to accept false
 		// Include a reference to the output folder in the sourcemap.
 		// This is omitted by default, but we need it to properly resolve source paths in error output.
 		sourceRoot: destination,
@@ -291,6 +319,7 @@ export async function bundleWorker(
 			".js": "jsx",
 			".mjs": "jsx",
 			".cjs": "jsx",
+			...(loader || {}),
 		},
 		plugins: [
 			// We run the moduleCollector plugin for service workers as part of the middleware loader
@@ -301,6 +330,7 @@ export async function bundleWorker(
 			...(nodeCompat
 				? [NodeGlobalsPolyfills({ buffer: true }), NodeModulesPolyfills()]
 				: []),
+			...(plugins || []),
 		],
 		...(jsxFactory && { jsxFactory }),
 		...(jsxFragment && { jsxFragment }),

package/src/deployments.ts

@@ -52,7 +52,7 @@ Author: ${versions.metadata.author_email}
 Source: ${sourceStr(versions.metadata.source)}\n`
 	);
 
-	versionMessages[0] += "🟩Active";
+	versionMessages[0] += "🟩 Active";
 	logger.log(...versionMessages.reverse());
 }
 

package/src/pages/build.tsx

@@ -1,6 +1,6 @@
 import { writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { FatalError } from "../errors";
 import { logger } from "../logger";
 import * as metrics from "../metrics";
@@ -81,6 +81,13 @@ export function Options(yargs: Argv) {
 				type: "boolean",
 				hidden: true,
 			},
+			bindings: {
+				type: "string",
+				describe:
+					"Bindings used in Functions (used to register beta product shims)",
+				deprecated: true,
+				hidden: true,
+			},
 		})
 		.epilogue(pagesBetaWarning);
 }
@@ -97,6 +104,7 @@ export const Handler = async ({
 	plugin,
 	buildOutputDirectory,
 	nodeCompat,
+	bindings,
 }: PagesBuildArgs) => {
 	if (!isInPagesCI) {
 		// Beta message for `wrangler pages <commands>` usage
@@ -109,6 +117,16 @@ export const Handler = async ({
 		);
 	}
 
+	let d1Databases: string[] | undefined = undefined;
+	if (bindings) {
+		try {
+			const decodedBindings = JSON.parse(bindings);
+			d1Databases = Object.keys(decodedBindings?.d1_databases || {});
+		} catch {
+			throw new FatalError("Could not parse a valid set of 'bindings'.", 1);
+		}
+	}
+
 	buildOutputDirectory ??= dirname(outfile);
 	try {
 		await buildFunctions({
@@ -123,6 +141,8 @@ export const Handler = async ({
 			buildOutputDirectory,
 			nodeCompat,
 			routesOutputPath,
+			local: false,
+			d1Databases,
 		});
 	} catch (e) {
 		if (e instanceof FunctionsNoRoutesError) {
@@ -154,6 +174,8 @@ export async function buildFunctions({
 	buildOutputDirectory,
 	routesOutputPath,
 	nodeCompat,
+	local,
+	d1Databases,
 }: Partial<
 	Pick<
 		PagesBuildArgs,
@@ -171,6 +193,8 @@ export async function buildFunctions({
 	onEnd?: () => void;
 	outfile: Required<PagesBuildArgs>["outfile"];
 	routesOutputPath?: PagesBuildArgs["outputRoutesPath"];
+	local: boolean;
+	d1Databases?: string[];
 }) {
 	RUNNING_BUILDERS.forEach(
 		(runningBuilder) => runningBuilder.stop && runningBuilder.stop()
@@ -208,6 +232,8 @@ export async function buildFunctions({
 		outfile: routesModule,
 	});
 
+	const absoluteFunctionsDirectory = resolve(functionsDirectory);
+
 	if (plugin) {
 		RUNNING_BUILDERS.push(
 			await buildPlugin({
@@ -217,6 +243,9 @@ export async function buildFunctions({
 				sourcemap,
 				watch,
 				nodeCompat,
+				functionsDirectory: absoluteFunctionsDirectory,
+				local,
+				betaD1Shims: d1Databases,
 				onEnd,
 			})
 		);
@@ -229,6 +258,9 @@ export async function buildFunctions({
 				sourcemap,
 				fallbackService,
 				watch,
+				functionsDirectory: absoluteFunctionsDirectory,
+				local,
+				betaD1Shims: d1Databases,
 				onEnd,
 				buildOutputDirectory,
 				nodeCompat,