wrangler 2.2.0 → 2.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "2.2.0",
+	"version": "2.2.1",
 	"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__/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/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/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,

package/src/pages/dev.tsx

@@ -256,6 +256,8 @@ export const Handler = async ({
 				await esbuild.build({
 					entryPoints: [scriptPath],
 					write: false,
+					// we need it to be bundled so that any imports that are used are affected by the blocker plugin
+					bundle: true,
 					plugins: [blockWorkerJsImports],
 				});
 			} catch {}
@@ -270,7 +272,7 @@ export const Handler = async ({
 		});
 	} else if (usingFunctions) {
 		// Try to use Functions
-		const outfile = join(tmpdir(), `./functionsWorker-${Math.random()}.js`);
+		const outfile = join(tmpdir(), `./functionsWorker-${Math.random()}.mjs`);
 		scriptPath = outfile;
 
 		if (nodeCompat) {
@@ -290,6 +292,8 @@ export const Handler = async ({
 				onEnd,
 				buildOutputDirectory: directory,
 				nodeCompat,
+				local: true,
+				d1Databases: d1s.map((binding) => binding.toString()),
 			});
 			await metrics.sendMetricsEvent("build pages functions");
 
@@ -307,6 +311,8 @@ export const Handler = async ({
 						onEnd,
 						buildOutputDirectory: directory,
 						nodeCompat,
+						local: true,
+						d1Databases: d1s.map((binding) => binding.toString()),
 					});
 					await metrics.sendMetricsEvent("build pages functions");
 				} catch (e) {
@@ -477,8 +483,8 @@ export const Handler = async ({
 					.map((binding) => binding.toString().split("="))
 					.map(([key, ...values]) => [key, values.join("=")])
 			),
-			kv: kvs.map((val) => ({
-				binding: val.toString(),
+			kv: kvs.map((binding) => ({
+				binding: binding.toString(),
 				id: "",
 			})),
 			durableObjects: durableObjects
@@ -520,7 +526,7 @@ export const Handler = async ({
 			persist,
 			persistTo,
 			showInteractiveDevSession: undefined,
-			inspect: true,
+			inspect: undefined,
 			logPrefix: "pages",
 			logLevel: logLevel ?? "warn",
 		},
@@ -680,14 +686,23 @@ async function spawnProxyProcess({
 	return port;
 }
 
+// TODO: Kill this once we have https://github.com/cloudflare/wrangler2/issues/2153
 const blockWorkerJsImports: esbuild.Plugin = {
 	name: "block-worker-js-imports",
-	setup(build: esbuild.PluginBuild) {
-		build.onResolve({ filter: /.*/g }, (_args) => {
+	setup(build) {
+		build.onResolve({ filter: /.*/g }, (args) => {
+			// If it's the entrypoint, let it be as is
+			if (args.kind === "entry-point") {
+				return {
+					path: args.path,
+				};
+			}
+			// Otherwise, block any imports that the file is requesting
 			logger.error(
 				`_worker.js is importing from another file. This will throw an error if deployed.\nYou should bundle your Worker or remove the import if it is unused.`
 			);
-			return null;
+			// Miniflare will error with this briefly down the line -- there's no point in continuing.
+			process.exit(1);
 		});
 	},
 };