wrangler 2.4.1 → 2.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "2.4.1",
+	"version": "2.4.3",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",

package/src/__tests__/d1.test.ts

@@ -34,7 +34,10 @@ describe("d1", () => {
 		  -h, --help     Show help  [boolean]
 		  -v, --version  Show version number  [boolean]
 
-		🚧 'wrangler d1 <command>' is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose"
+		🚧 D1 is currently in open alpha and is not recommended for production data and traffic.
+		Please report any bugs to https://github.com/cloudflare/wrangler2/issues/new/choose.
+		To request features, visit https://community.cloudflare.com/c/developers/d1.
+		To give feedback, visit https://discord.gg/cloudflaredev"
 	`);
 	});
 
@@ -68,7 +71,10 @@ describe("d1", () => {
 		  -h, --help     Show help  [boolean]
 		  -v, --version  Show version number  [boolean]
 
-		🚧 'wrangler d1 <command>' is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose"
+		🚧 D1 is currently in open alpha and is not recommended for production data and traffic.
+		Please report any bugs to https://github.com/cloudflare/wrangler2/issues/new/choose.
+		To request features, visit https://community.cloudflare.com/c/developers/d1.
+		To give feedback, visit https://discord.gg/cloudflaredev"
 	`);
 	});
 });

package/src/__tests__/queues.test.ts

@@ -1,6 +1,11 @@
 import { type QueueResponse, type PostConsumerBody } from "../queues/client";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
+import {
+	createFetchResult,
+	setMockRawResponse,
+	setMockResponse,
+	unsetAllMocks,
+} from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
@@ -157,6 +162,35 @@ describe("wrangler", () => {
 			  `);
 				expect(requests.count).toEqual(1);
 			});
+
+			it("should show link to dash when not enabled", async () => {
+				const queueName = "testQueue";
+				setMockRawResponse(
+					"/accounts/:accountId/workers/queues",
+					([_url, accountId]) => {
+						expect(accountId).toEqual("some-account-id");
+						return createFetchResult(null, false, [
+							{ message: "workers.api.error.unauthorized", code: 10023 },
+						]);
+					}
+				);
+				await expect(
+					runWrangler(`queues create ${queueName}`)
+				).rejects.toThrowError();
+				expect(std.out).toMatchInlineSnapshot(`
+			"Creating queue testQueue.
+			Queues is not currently enabled on this account. Go to https://dash.cloudflare.com/some-account-id/workers/queues to enable it.
+
+			X [ERROR] A request to the Cloudflare API (/accounts/some-account-id/workers/queues) failed.
+
+			  workers.api.error.unauthorized [code: 10023]
+
+			  If you think this is a bug, please open an issue at:
+			  https://github.com/cloudflare/wrangler2/issues/new/choose
+
+			"
+		`);
+			});
 		});
 
 		describe("delete", () => {
@@ -309,6 +343,35 @@ describe("wrangler", () => {
 						Added consumer to queue testQueue."
 					`);
 				});
+
+				it("should show link to dash when not enabled", async () => {
+					const queueName = "testQueue";
+					setMockRawResponse(
+						`/accounts/:accountId/workers/queues/${queueName}/consumers`,
+						([_url, accountId]) => {
+							expect(accountId).toEqual("some-account-id");
+							return createFetchResult(null, false, [
+								{ message: "workers.api.error.unauthorized", code: 10023 },
+							]);
+						}
+					);
+					await expect(
+						runWrangler(`queues consumer add ${queueName} testScript`)
+					).rejects.toThrowError();
+					expect(std.out).toMatchInlineSnapshot(`
+				"Adding consumer to queue testQueue.
+				Queues is not currently enabled on this account. Go to https://dash.cloudflare.com/some-account-id/workers/queues to enable it.
+
+				X [ERROR] A request to the Cloudflare API (/accounts/some-account-id/workers/queues/testQueue/consumers) failed.
+
+				  workers.api.error.unauthorized [code: 10023]
+
+				  If you think this is a bug, please open an issue at:
+				  https://github.com/cloudflare/wrangler2/issues/new/choose
+
+				"
+			`);
+				});
 			});
 
 			describe("delete", () => {

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

@@ -216,8 +216,9 @@ describe("generateTypes()", () => {
 
 		await runWrangler("types");
 		expect(std.out).toMatchInlineSnapshot(`
-		"declare global {
-			testing_unsafe: any;
+		"export {};
+		declare global {
+			const testing_unsafe: any;
 		}
 		"
 	`);

package/src/bundle.ts

@@ -28,6 +28,19 @@ type StaticAssetsConfig =
 	  })
 	| undefined;
 
+/**
+ * When applying the middleware facade for service workers, we need to inject
+ * some code at the top of the final output bundle. Applying an inject too early
+ * will allow esbuild to reorder the code. Additionally, we need to make sure
+ * user code is bundled in the final esbuild step with `watch` correctly
+ * configured, so code changes are detected.
+ *
+ * This type is used as the return type for the `MiddlewareFn` type representing
+ * a facade-applying function. Returned injects should be injected with the
+ * final esbuild step.
+ */
+type EntryWithInject = Entry & { inject?: string[] };
+
 /**
  * RegExp matching against esbuild's error text when it is unable to resolve
  * a Node built-in module. If we detect this when node_compat is disabled,
@@ -97,6 +110,7 @@ export async function bundleWorker(
 		targetConsumer: "dev" | "publish";
 		local: boolean;
 		testScheduled?: boolean;
+		experimentalLocal?: boolean;
 		inject?: string[];
 		loader?: Record<string, string>;
 		sourcemap?: esbuild.CommonOptions["sourcemap"];
@@ -124,6 +138,7 @@ export async function bundleWorker(
 		firstPartyWorkerDevFacade,
 		targetConsumer,
 		testScheduled,
+		experimentalLocal,
 		inject: injectOption,
 		loader,
 		sourcemap,
@@ -197,8 +212,29 @@ export async function bundleWorker(
 			path: "templates/middleware/middleware-scheduled.ts",
 		});
 	}
+	if (experimentalLocal) {
+		// In Miniflare 3, we bind the user's worker as a service binding in a
+		// special entry worker that handles things like injecting `Request.cf`,
+		// live-reload, and the pretty-error page.
+		//
+		// Unfortunately, due to a bug in `workerd`, errors thrown asynchronously by
+		// native APIs don't have `stack`s. This means Miniflare can't extract the
+		// `stack` trace from dispatching to the user worker service binding by
+		// `try/catch`.
+		//
+		// As a stop-gap solution, if the `MF-Experimental-Error-Stack` header is
+		// truthy on responses, the body will be interpreted as a JSON-error of the
+		// form `{ message?: string, name?: string, stack?: string }`.
+		//
+		// This middleware wraps the user's worker in a `try/catch`, and rewrites
+		// errors in this format so a pretty-error page can be shown.
+		middlewareToLoad.push({
+			path: "templates/middleware/middleware-miniflare3-json-error.ts",
+			dev: true,
+		});
+	}
 
-	type MiddlewareFn = (arg0: Entry) => Promise<Entry>;
+	type MiddlewareFn = (currentEntry: Entry) => Promise<EntryWithInject>;
 	const middleware: (false | undefined | MiddlewareFn)[] = [
 		// serve static assets
 		serveAssetsFromWorker &&
@@ -259,23 +295,22 @@ export async function bundleWorker(
 						(m) =>
 							(targetConsumer === "dev" && m.dev !== false) ||
 							(m.publish && targetConsumer === "publish")
-					),
-					moduleCollector.plugin
+					)
 				);
 			}),
 	].filter(Boolean);
 
-	let inputEntry = entry;
+	const inject: string[] = injectOption ?? [];
+	if (checkFetch) inject.push(checkedFetchFileToInject);
 
+	let inputEntry: EntryWithInject = entry;
 	for (const middlewareFn of middleware as MiddlewareFn[]) {
 		inputEntry = await middlewareFn(inputEntry);
+		if (inputEntry.inject !== undefined) inject.push(...inputEntry.inject);
 	}
 
 	// At this point, inputEntry points to the entry point we want to build.
 
-	const inject: string[] = injectOption ?? [];
-	if (checkFetch) inject.push(checkedFetchFileToInject);
-
 	const buildOptions: esbuild.BuildOptions & { metafile: true } = {
 		entryPoints: [inputEntry.file],
 		bundle: true,
@@ -315,11 +350,7 @@ export async function bundleWorker(
 			...(loader || {}),
 		},
 		plugins: [
-			// We run the moduleCollector plugin for service workers as part of the middleware loader
-			// so we only run here for modules or with no middleware to load
-			...(entry.format === "modules" || middlewareToLoad.length === 0
-				? [moduleCollector.plugin]
-				: []),
+			moduleCollector.plugin,
 			...(nodeCompat
 				? [NodeGlobalsPolyfills({ buffer: true }), NodeModulesPolyfills()]
 				: []),
@@ -456,14 +487,16 @@ interface MiddlewareLoader {
 async function applyMiddlewareLoaderFacade(
 	entry: Entry,
 	tmpDirPath: string,
-	middleware: MiddlewareLoader[], // a list of paths to middleware files
-	moduleCollectorPlugin: esbuild.Plugin
-): Promise<Entry> {
+	middleware: MiddlewareLoader[] // a list of paths to middleware files
+): Promise<EntryWithInject> {
 	// Firstly we need to insert the middleware array into the project,
 	// and then we load the middleware - this insertion and loading is
 	// different for each format.
 
-	// STEP 1: Insert the middleware
+	// Make sure we resolve all files relative to the actual temporary directory,
+	// otherwise we'll have issues with source maps
+	tmpDirPath = fs.realpathSync(tmpDirPath);
+
 	const targetPathInsertion = path.join(
 		tmpDirPath,
 		"middleware-insertion.entry.js"
@@ -506,7 +539,7 @@ async function applyMiddlewareLoaderFacade(
 		);
 
 		await esbuild.build({
-			entryPoints: [path.resolve(getBasePath(), dynamicFacadePath)],
+			entryPoints: [dynamicFacadePath],
 			bundle: true,
 			sourcemap: true,
 			format: "esm",
@@ -523,98 +556,80 @@ async function applyMiddlewareLoaderFacade(
 			],
 			outfile: targetPathInsertion,
 		});
-	} else {
-		// We handle service workers slightly differently as we have to overwrite
-		// the event listeners and reimplement them
 
+		let targetPathLoader = path.join(tmpDirPath, path.basename(entry.file));
+		if (path.extname(entry.file) === "") targetPathLoader += ".js";
+		const loaderPath = path.resolve(
+			getBasePath(),
+			"templates/middleware/loader-modules.ts"
+		);
 		await esbuild.build({
-			entryPoints: [entry.file],
+			entryPoints: [loaderPath],
 			bundle: true,
 			sourcemap: true,
-			define: {
-				"process.env.NODE_ENV": `"${process.env["NODE_ENV" + ""]}"`,
-			},
 			format: "esm",
-			outfile: targetPathInsertion,
-			plugins: [moduleCollectorPlugin],
+			plugins: [
+				esbuildAliasExternalPlugin({
+					__ENTRY_POINT__: targetPathInsertion,
+					"./common": path.resolve(
+						getBasePath(),
+						"templates/middleware/common.ts"
+					),
+				}),
+			],
+			outfile: targetPathLoader,
 		});
-
+		return {
+			...entry,
+			file: targetPathLoader,
+		};
+	} else {
 		const imports = middlewareIdentifiers
-			.map(
-				(m, i) =>
-					`import ${m} from "${toUrlPath(
-						path.resolve(getBasePath(), middleware[i].path)
-					)}";`
-			)
+			.map((m) => `import ${m} from "${m}";`)
 			.join("\n");
-
-		// We add the new modules with imports and then register using the
-		// addMiddleware function (which gets rewritten in the next build step)
-
-		// We choose to run middleware inserted in wrangler before user inserted
-		// middleware in the stack
-		// To do this, we either need to execute the addMiddleware function first
-		// before any user middleware, or use a separate handling function.
-		// We choose to do the latter as to prepend, we would have to load the entire
-		// script into memory as a prepend function doesn't exist or work in the same
-		// way that an append function does.
-
-		fs.copyFileSync(targetPathInsertion, dynamicFacadePath);
-		fs.appendFileSync(
-			dynamicFacadePath,
-			`
+		const contents = `import { __facade_registerInternal__ } from "__LOADER__";
 			${imports}
-			addMiddlewareInternal([${middlewareIdentifiers.join(",")}])
-		`
-		);
-	}
-
-	// STEP 2: Load the middleware
-	// We want to get the filename of the orginal entry point
-	let targetPathLoader = path.join(tmpDirPath, path.basename(entry.file));
-	if (path.extname(entry.file) === "") targetPathLoader += ".js";
-
-	const loaderPath =
-		entry.format === "modules"
-			? path.resolve(getBasePath(), "templates/middleware/loader-modules.ts")
-			: dynamicFacadePath;
+			__facade_registerInternal__([${middlewareIdentifiers.join(",")}]);`;
+		fs.writeFileSync(dynamicFacadePath, contents);
 
-	await esbuild.build({
-		entryPoints: [loaderPath],
-		bundle: true,
-		sourcemap: true,
-		format: "esm",
-		...(entry.format === "service-worker"
-			? {
-					inject: [
-						path.resolve(getBasePath(), "templates/middleware/loader-sw.ts"),
-					],
-					define: {
-						addEventListener: "__facade_addEventListener__",
-						removeEventListener: "__facade_removeEventListener__",
-						dispatchEvent: "__facade_dispatchEvent__",
-						addMiddleware: "__facade_register__",
-						addMiddlewareInternal: "__facade_registerInternal__",
-					},
-			  }
-			: {
-					plugins: [
-						esbuildAliasExternalPlugin({
-							__ENTRY_POINT__: targetPathInsertion,
-							"./common": path.resolve(
+		await esbuild.build({
+			entryPoints: [dynamicFacadePath],
+			bundle: true,
+			sourcemap: true,
+			format: "iife",
+			plugins: [
+				{
+					name: "dynamic-facade-imports",
+					setup(build) {
+						build.onResolve({ filter: /^__LOADER__$/ }, () => {
+							const loaderPath = path.resolve(
 								getBasePath(),
-								"templates/middleware/common.ts"
-							),
-						}),
-					],
-			  }),
-		outfile: targetPathLoader,
-	});
-
-	return {
-		...entry,
-		file: targetPathLoader,
-	};
+								"templates/middleware/loader-sw.ts"
+							);
+							return { path: loaderPath };
+						});
+						const middlewareFilter = /^__MIDDLEWARE_(\d+)__$/;
+						build.onResolve({ filter: middlewareFilter }, (args) => {
+							const match = middlewareFilter.exec(args.path);
+							assert(match !== null);
+							const middlewareIndex = parseInt(match[1]);
+							return {
+								path: path.resolve(
+									getBasePath(),
+									middleware[middlewareIndex].path
+								),
+							};
+						});
+					},
+				},
+			],
+			outfile: targetPathInsertion,
+		});
+		return {
+			...entry,
+			inject: [targetPathInsertion],
+		};
+	}
 }
 
 /**

package/src/config/validation.ts

@@ -1814,7 +1814,7 @@ const validateD1Binding: ValidatorFn = (diagnostics, field, value) => {
 	}
 	if (isValid && !process.env.NO_D1_WARNING) {
 		diagnostics.warnings.push(
-			`D1 Bindings are currently in beta to allow the API to evolve before general availability.\nPlease report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose\nNote: set NO_D1_WARNING=true to hide this message`
+			`D1 Bindings are currently in alpha to allow the API to evolve before general availability.\nPlease report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose\nNote: set NO_D1_WARNING=true to hide this message`
 		);
 	}
 	return isValid;

package/src/d1/migrations/apply.tsx

@@ -0,0 +1,183 @@
+import fs from "node:fs";
+import path from "path";
+import { Box, render, Text } from "ink";
+import Table from "ink-table";
+import React from "react";
+import { withConfig } from "../../config";
+import { confirm } from "../../dialogs";
+import { logger } from "../../logger";
+import { requireAuth } from "../../user";
+import { createBackup } from "../backups";
+import { executeSql } from "../execute";
+import { Database } from "../options";
+import { d1BetaWarning, getDatabaseInfoFromConfig } from "../utils";
+import {
+	getMigrationsPath,
+	getUnappliedMigrations,
+	initMigrationsTable,
+} from "./helpers";
+import type { ParseError } from "../../parse";
+import type { BaseSqlExecuteArgs } from "../execute";
+import type { Argv } from "yargs";
+
+export function ApplyOptions(yargs: Argv): Argv<BaseSqlExecuteArgs> {
+	return Database(yargs);
+}
+
+export const ApplyHandler = withConfig<BaseSqlExecuteArgs>(
+	async ({ config, database, local, persistTo }): Promise<void> => {
+		const accountId = await requireAuth({});
+		logger.log(d1BetaWarning);
+
+		const databaseInfo = await getDatabaseInfoFromConfig(config, database);
+		if (!databaseInfo) {
+			throw new Error(
+				`Can't find a DB with name/binding '${database}' in local config. Check info in wrangler.toml...`
+			);
+		}
+
+		if (!config.configPath) {
+			return;
+		}
+
+		const migrationsPath = await getMigrationsPath(
+			path.dirname(config.configPath),
+			databaseInfo.migrationsFolderPath,
+			false
+		);
+		await initMigrationsTable(
+			databaseInfo.migrationsTableName,
+			local,
+			config,
+			database,
+			persistTo
+		);
+
+		const unappliedMigrations = (
+			await getUnappliedMigrations(
+				databaseInfo.migrationsTableName,
+				migrationsPath,
+				local,
+				config,
+				database,
+				persistTo
+			)
+		)
+			.map((migration) => {
+				return {
+					Name: migration,
+					Status: "🕒️",
+				};
+			})
+			.sort((a, b) => {
+				const migrationNumberA = parseInt(a.Name.split("_")[0]);
+				const migrationNumberB = parseInt(b.Name.split("_")[0]);
+				if (migrationNumberA < migrationNumberB) {
+					return -1;
+				}
+				if (migrationNumberA > migrationNumberB) {
+					return 1;
+				}
+
+				// numbers must be equal
+				return 0;
+			});
+
+		if (unappliedMigrations.length === 0) {
+			render(<Text>✅ No migrations to apply!</Text>);
+			return;
+		}
+
+		const isInteractive = process.stdout.isTTY;
+		if (isInteractive) {
+			const ok = await confirm(
+				`About to apply ${unappliedMigrations.length} migration(s)\n` +
+					"Your database may not be available to serve requests during the migration, continue?",
+				<Box flexDirection="column">
+					<Text>Migrations to be applied:</Text>
+					<Table data={unappliedMigrations} columns={["Name"]}></Table>
+				</Box>
+			);
+			if (!ok) return;
+		}
+
+		render(<Text>🕒 Creating backup...</Text>);
+		await createBackup(accountId, databaseInfo.uuid);
+
+		for (const migration of unappliedMigrations) {
+			let query = fs.readFileSync(
+				`${migrationsPath}/${migration.Name}`,
+				"utf8"
+			);
+			query += `
+								INSERT INTO ${databaseInfo.migrationsTableName} (name)
+								values ('${migration.Name}');
+						`;
+
+			let success = true;
+			let errorNotes: Array<string> = [];
+			try {
+				const response = await executeSql(
+					local,
+					config,
+					database,
+					undefined,
+					persistTo,
+					undefined,
+					query
+				);
+
+				if (response === null) {
+					// TODO:  return error
+					return;
+				}
+
+				for (const result of response) {
+					// When executing more than 1 statement, response turns into an array of QueryResult
+					if (Array.isArray(result)) {
+						for (const subResult of result) {
+							if (!subResult.success) {
+								success = false;
+							}
+						}
+					} else {
+						if (!result.success) {
+							success = false;
+						}
+					}
+				}
+			} catch (e) {
+				const err = e as ParseError;
+
+				success = false;
+				errorNotes = err.notes.map((msg) => msg.text);
+			}
+
+			migration.Status = success ? "✅" : "❌";
+
+			render(
+				<Box flexDirection="column">
+					<Table
+						data={unappliedMigrations}
+						columns={["Name", "Status"]}
+					></Table>
+					{errorNotes.length > 0 && (
+						<Box flexDirection="column">
+							<Text>&nbsp;</Text>
+							<Text>
+								❌ Migration {migration.Name} failed with following Errors
+							</Text>
+							<Table
+								data={errorNotes.map((err) => {
+									return { Error: err };
+								})}
+							></Table>
+						</Box>
+					)}
+				</Box>
+			);
+
+			if (errorNotes.length > 0) return;
+		}
+	}
+);