wrangler 2.4.2 → 2.4.3

package/src/d1/migrations/helpers.ts

@@ -0,0 +1,145 @@
+import fs from "node:fs";
+import path from "path";
+import { confirm } from "../../dialogs";
+import { logger } from "../../logger";
+import { DEFAULT_MIGRATION_PATH } from "../constants";
+import { executeSql } from "../execute";
+import type { ConfigFields, DevConfig, Environment } from "../../config";
+import type { QueryResult } from "../execute";
+import type { Migration } from "../types";
+
+export async function getMigrationsPath(
+	projectPath: string,
+	migrationsFolderPath: string,
+	createIfMissing: boolean
+): Promise<string> {
+	const dir = path.resolve(projectPath, migrationsFolderPath);
+	if (fs.existsSync(dir)) return dir;
+
+	const warning = `No migrations folder found.${
+		migrationsFolderPath === DEFAULT_MIGRATION_PATH
+			? " Set `migrations_dir` in wrangler.toml to choose a different path."
+			: ""
+	}`;
+
+	if (createIfMissing && (await confirm(`${warning}\nOk to create ${dir}?`))) {
+		fs.mkdirSync(dir, { recursive: true });
+		return dir;
+	} else {
+		logger.warn(warning);
+	}
+
+	throw new Error(`No migrations present at ${dir}.`);
+}
+
+export async function getUnappliedMigrations(
+	migrationsTableName: string,
+	migrationsPath: string,
+	local: undefined | boolean,
+	config: ConfigFields<DevConfig> & Environment,
+	name: string,
+	persistTo: undefined | string
+): Promise<Array<string>> {
+	const appliedMigrations = (
+		await listAppliedMigrations(
+			migrationsTableName,
+			local,
+			config,
+			name,
+			persistTo
+		)
+	).map((migration) => {
+		return migration.name;
+	});
+	const projectMigrations = getMigrationNames(migrationsPath);
+
+	const unappliedMigrations: Array<string> = [];
+
+	for (const migration of projectMigrations) {
+		if (!appliedMigrations.includes(migration)) {
+			unappliedMigrations.push(migration);
+		}
+	}
+
+	return unappliedMigrations;
+}
+
+const listAppliedMigrations = async (
+	migrationsTableName: string,
+	local: undefined | boolean,
+	config: ConfigFields<DevConfig> & Environment,
+	name: string,
+	persistTo: undefined | string
+): Promise<Migration[]> => {
+	const Query = `SELECT *
+									 FROM ${migrationsTableName}
+									 ORDER BY id`;
+
+	const response: QueryResult[] | null = await executeSql(
+		local,
+		config,
+		name,
+		undefined,
+		persistTo,
+		undefined,
+		Query
+	);
+
+	if (!response || response[0].results.length === 0) return [];
+
+	return response[0].results as Migration[];
+};
+
+function getMigrationNames(migrationsPath: string): Array<string> {
+	const migrations = [];
+
+	const dir = fs.opendirSync(migrationsPath);
+
+	let dirent;
+	while ((dirent = dir.readSync()) !== null) {
+		if (dirent.name.endsWith(".sql")) migrations.push(dirent.name);
+	}
+
+	dir.closeSync();
+
+	return migrations;
+}
+
+export function getNextMigrationNumber(migrationsPath: string): number {
+	let highestMigrationNumber = -1;
+
+	for (const migration in getMigrationNames(migrationsPath)) {
+		const migrationNumber = parseInt(migration.split("_")[0]);
+
+		if (migrationNumber > highestMigrationNumber) {
+			highestMigrationNumber = migrationNumber;
+		}
+	}
+
+	return highestMigrationNumber + 1;
+}
+
+export const initMigrationsTable = async (
+	migrationsTableName: string,
+	local: undefined | boolean,
+	config: ConfigFields<DevConfig> & Environment,
+	name: string,
+	persistTo: undefined | string
+) => {
+	return executeSql(
+		local,
+		config,
+		name,
+		undefined,
+		persistTo,
+		undefined,
+		`
+						CREATE TABLE IF NOT EXISTS ${migrationsTableName}
+						(
+								id         INTEGER PRIMARY KEY AUTOINCREMENT,
+								name       TEXT UNIQUE,
+								applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
+						);
+				`
+	);
+};

package/src/d1/migrations/index.tsx

@@ -0,0 +1,3 @@
+export { ApplyHandler, ApplyOptions } from "./apply";
+export { CreateHandler, CreateOptions } from "./create";
+export { ListHandler, ListOptions } from "./list";

package/src/d1/migrations/list.tsx

@@ -0,0 +1,79 @@
+import path from "path";
+import { Box, render, Text } from "ink";
+import Table from "ink-table";
+import React from "react";
+import { withConfig } from "../../config";
+import { logger } from "../../logger";
+import { requireAuth } from "../../user";
+import { Database } from "../options";
+import { d1BetaWarning, getDatabaseInfoFromConfig } from "../utils";
+import {
+	getMigrationsPath,
+	getUnappliedMigrations,
+	initMigrationsTable,
+} from "./helpers";
+import type { BaseSqlExecuteArgs } from "../execute";
+import type { Argv } from "yargs";
+
+export function ListOptions(yargs: Argv): Argv<BaseSqlExecuteArgs> {
+	return Database(yargs);
+}
+
+export const ListHandler = withConfig<BaseSqlExecuteArgs>(
+	async ({ config, database, local, persistTo }): Promise<void> => {
+		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 { migrationsTableName, migrationsFolderPath } = databaseInfo;
+
+		const migrationsPath = await getMigrationsPath(
+			path.dirname(config.configPath),
+			migrationsFolderPath,
+			false
+		);
+		await initMigrationsTable(
+			migrationsTableName,
+			local,
+			config,
+			database,
+			persistTo
+		);
+
+		const unappliedMigrations = (
+			await getUnappliedMigrations(
+				migrationsTableName,
+				migrationsPath,
+				local,
+				config,
+				database,
+				persistTo
+			)
+		).map((migration) => {
+			return {
+				Name: migration,
+			};
+		});
+
+		if (unappliedMigrations.length === 0) {
+			render(<Text>✅ No migrations to apply!</Text>);
+			return;
+		}
+
+		render(
+			<Box flexDirection="column">
+				<Text>Migrations to be applied:</Text>
+				<Table data={unappliedMigrations} columns={["Name"]}></Table>
+			</Box>
+		);
+	}
+);

package/src/d1/utils.ts

@@ -45,4 +45,4 @@ export const getDatabaseByNameOrBinding = async (
 
 export const d1BetaWarning = process.env.NO_D1_WARNING
 	? ""
-	: "🚧 '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.\nPlease report any bugs to https://github.com/cloudflare/wrangler2/issues/new/choose.\nTo request features, visit https://community.cloudflare.com/c/developers/d1.\nTo give feedback, visit https://discord.gg/cloudflaredev";

package/src/dev/dev.tsx

@@ -288,6 +288,7 @@ function DevSession(props: DevSessionProps) {
 		// Enable the bundling to know whether we are using dev or publish
 		targetConsumer: "dev",
 		testScheduled: props.testScheduled ?? false,
+		experimentalLocal: props.experimentalLocal,
 	});
 
 	// TODO(queues) support remote wrangler dev

package/src/dev/local.tsx

@@ -839,17 +839,19 @@ export async function transformMf2OptionsToMf3Options({
 		const root = path.dirname(bundle.path);
 
 		assert.strictEqual(bundle.type, "esm");
+		// Required for source mapped paths to resolve correctly
+		options.modulesRoot = root;
 		options.modules = [
 			// Entrypoint
 			{
 				type: "ESModule",
-				path: path.relative(root, bundle.path),
+				path: bundle.path,
 				contents: await readFile(bundle.path, "utf-8"),
 			},
 			// Misc (WebAssembly, etc, ...)
 			...bundle.modules.map((module) => ({
 				type: ModuleTypeToRuleType[module.type ?? "esm"],
-				path: module.name,
+				path: path.resolve(root, module.name),
 				contents: module.content,
 			})),
 		];

package/src/dev/start-server.ts

@@ -99,6 +99,8 @@ export async function startDevServer(
 			services: props.bindings.services,
 			firstPartyWorkerDevFacade: props.firstPartyWorker,
 			testScheduled: props.testScheduled,
+			local: props.local,
+			experimentalLocal: props.experimentalLocal,
 		});
 
 		if (props.local) {
@@ -206,6 +208,8 @@ async function runEsbuild({
 	services,
 	firstPartyWorkerDevFacade,
 	testScheduled,
+	local,
+	experimentalLocal,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -224,6 +228,8 @@ async function runEsbuild({
 	workerDefinitions: WorkerRegistry;
 	firstPartyWorkerDevFacade: boolean | undefined;
 	testScheduled?: boolean;
+	local: boolean;
+	experimentalLocal: boolean | undefined;
 }): Promise<EsbuildBundle | undefined> {
 	if (!destination) return;
 
@@ -262,8 +268,9 @@ async function runEsbuild({
 				services,
 				firstPartyWorkerDevFacade,
 				targetConsumer: "dev", // We are starting a dev server
-				local: true,
 				testScheduled,
+				local,
+				experimentalLocal,
 		  });
 
 	return {

package/src/dev/use-esbuild.ts

@@ -41,6 +41,7 @@ export function useEsbuild({
 	local,
 	targetConsumer,
 	testScheduled,
+	experimentalLocal,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -62,6 +63,7 @@ export function useEsbuild({
 	local: boolean;
 	targetConsumer: "dev" | "publish";
 	testScheduled: boolean;
+	experimentalLocal: boolean | undefined;
 }): EsbuildBundle | undefined {
 	const [bundle, setBundle] = useState<EsbuildBundle>();
 	const { exit } = useApp();
@@ -134,6 +136,7 @@ export function useEsbuild({
 						local,
 						targetConsumer,
 						testScheduled,
+						experimentalLocal,
 				  });
 
 			// Capture the `stop()` method to use as the `useEffect()` destructor.
@@ -195,6 +198,7 @@ export function useEsbuild({
 		local,
 		targetConsumer,
 		testScheduled,
+		experimentalLocal,
 	]);
 	return bundle;
 }

package/src/index.tsx

@@ -445,6 +445,11 @@ export function createCLIParser(argv: string[]) {
 				.option("scopes-list", {
 					describe: "List all the available OAuth scopes with descriptions",
 				})
+				.option("browser", {
+					default: true,
+					type: "boolean",
+					describe: "Automatically open the OAuth link in a browser",
+				})
 				.option("scopes", {
 					describe: "Pick the set of applicable OAuth scopes when logging in",
 					array: true,
@@ -471,10 +476,10 @@ export function createCLIParser(argv: string[]) {
 						`One of ${args.scopes} is not a valid authentication scope. Run "wrangler login --list-scopes" to see the valid scopes.`
 					);
 				}
-				await login({ scopes: args.scopes });
+				await login({ scopes: args.scopes, browser: args.browser });
 				return;
 			}
-			await login();
+			await login({ browser: args.browser });
 			const config = readConfig(args.config as ConfigPath, args);
 			await metrics.sendMetricsEvent("login user", {
 				sendMetrics: config.send_metrics,

package/src/pages/functions/buildPlugin.ts

@@ -101,6 +101,7 @@ export function buildPlugin({
 			checkFetch: local,
 			targetConsumer: local ? "dev" : "publish",
 			local,
+			experimentalLocal: false,
 		}
 	);
 }

package/src/pages/functions/buildWorker.ts

@@ -160,6 +160,7 @@ export function buildWorker({
 			checkFetch: local,
 			targetConsumer: local ? "dev" : "publish",
 			local,
+			experimentalLocal: false,
 		}
 	);
 }

package/src/publish/publish.ts

@@ -487,6 +487,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 						// This could potentially cause issues as we no longer have identical behaviour between dev and publish?
 						targetConsumer: "publish",
 						local: false,
+						experimentalLocal: false,
 					}
 			  );
 

package/src/queues/cli/commands/index.ts

@@ -1,5 +1,6 @@
 import { type BuilderCallback } from "yargs";
 import { type CommonYargsOptions } from "../../../yargs-types";
+import { HandleUnauthorizedError } from "../../utils";
 import { consumers } from "./consumer";
 
 import { options as createOptions, handler as createHandler } from "./create";
@@ -30,4 +31,6 @@ export const queues: BuilderCallback<CommonYargsOptions, unknown> = (yargs) => {
 			await consumers(consumersYargs);
 		}
 	);
+
+	yargs.fail(HandleUnauthorizedError);
 };

package/src/queues/utils.ts

@@ -0,0 +1,18 @@
+import { logger } from "../logger";
+import { type ParseError } from "../parse";
+import { getAccountId } from "../user";
+
+const isFetchError = (err: unknown): err is ParseError => err instanceof Error;
+
+export const HandleUnauthorizedError = async (_msg: string, err: Error) => {
+	//@ts-expect-error non-standard property on Error
+	if (isFetchError(err) && err.code === 10023) {
+		const accountId = await getAccountId();
+		if (accountId) {
+			return logger.log(
+				`Queues is not currently enabled on this account. Go to https://dash.cloudflare.com/${accountId}/workers/queues to enable it.`
+			);
+		}
+	}
+	throw err;
+};

package/src/user/user.tsx

@@ -875,6 +875,7 @@ export function readAuthConfigFile(): UserAuthConfig {
 
 type LoginProps = {
 	scopes?: Scope[];
+	browser: boolean;
 };
 
 export async function loginOrRefreshIfRequired(): Promise<boolean> {
@@ -901,7 +902,9 @@ export async function loginOrRefreshIfRequired(): Promise<boolean> {
 	}
 }
 
-export async function login(props?: LoginProps): Promise<boolean> {
+export async function login(
+	props: LoginProps = { browser: true }
+): Promise<boolean> {
 	logger.log("Attempting to login via OAuth...");
 	const urlToOpen = await getAuthURL(props?.scopes);
 	let server: http.Server;
@@ -914,7 +917,7 @@ export async function login(props?: LoginProps): Promise<boolean> {
 			server.close();
 			clearTimeout(loginTimeoutHandle);
 			resolve(false);
-		}, 60000); // wait for 60 seconds for the user to authorize
+		}, 120000); // wait for 120 seconds for the user to authorize
 	});
 
 	const loginPromise = new Promise<boolean>((resolve, reject) => {
@@ -986,9 +989,12 @@ export async function login(props?: LoginProps): Promise<boolean> {
 
 		server.listen(8976);
 	});
-
-	logger.log(`Opening a link in your default browser: ${urlToOpen}`);
-	await openInBrowser(urlToOpen);
+	if (props?.browser) {
+		logger.log(`Opening a link in your default browser: ${urlToOpen}`);
+		await openInBrowser(urlToOpen);
+	} else {
+		logger.log(`Visit this link to authenticate: ${urlToOpen}`);
+	}
 
 	return Promise.race([timerPromise, loginPromise]);
 }

package/templates/middleware/loader-sw.ts

@@ -1,8 +1,15 @@
-import { Awaitable, Dispatcher, Middleware, __facade_invoke__ } from "./common";
-export { __facade_register__, __facade_registerInternal__ } from "./common";
-
-// Miniflare's `EventTarget` follows the spec and doesn't allow exceptions to
-// be caught by `dispatchEvent`. Instead it has a custom`ThrowingEventTarget`
+import {
+	Awaitable,
+	Dispatcher,
+	Middleware,
+	__facade_invoke__,
+	__facade_register__,
+	__facade_registerInternal__,
+} from "./common";
+export { __facade_register__, __facade_registerInternal__ };
+
+// Miniflare 2's `EventTarget` follows the spec and doesn't allow exceptions to
+// be caught by `dispatchEvent`. Instead it has a custom `ThrowingEventTarget`
 // class that rethrows errors from event listeners in `dispatchEvent`.
 // We'd like errors to be propagated to the top-level `addEventListener`, so
 // we'd like to use `ThrowingEventTarget`. Unfortunately, `ThrowingEventTarget`
@@ -15,45 +22,52 @@ if ((globalThis as any).MINIFLARE) {
 	__FACADE_EVENT_TARGET__ = new EventTarget();
 }
 
-declare global {
-	var __facade_addEventListener__: (
-		type: string,
-		listener: EventListenerOrEventListenerObject,
-		options?: EventTargetAddEventListenerOptions | boolean
-	) => void;
-	var __facade_removeEventListener__: (
-		type: string,
-		listener: EventListenerOrEventListenerObject,
-		options?: EventTargetEventListenerOptions | boolean
-	) => void;
-	var __facade_dispatchEvent__: (event: Event) => void;
-}
-
-function __facade_isSpecialEvent__(type: string) {
+function __facade_isSpecialEvent__(
+	type: string
+): type is "fetch" | "scheduled" {
 	return type === "fetch" || type === "scheduled";
 }
-globalThis.__facade_addEventListener__ = function (type, listener, options) {
+const __facade__originalAddEventListener__ = globalThis.addEventListener;
+const __facade__originalRemoveEventListener__ = globalThis.removeEventListener;
+const __facade__originalDispatchEvent__ = globalThis.dispatchEvent;
+
+globalThis.addEventListener = function (type, listener, options) {
 	if (__facade_isSpecialEvent__(type)) {
-		__FACADE_EVENT_TARGET__.addEventListener(type, listener, options);
+		__FACADE_EVENT_TARGET__.addEventListener(
+			type,
+			listener as EventListenerOrEventListenerObject,
+			options
+		);
 	} else {
-		globalThis.addEventListener(type as any, listener, options);
+		__facade__originalAddEventListener__(type, listener, options);
 	}
 };
-globalThis.__facade_removeEventListener__ = function (type, listener, options) {
+globalThis.removeEventListener = function (type, listener, options) {
 	if (__facade_isSpecialEvent__(type)) {
-		__FACADE_EVENT_TARGET__.removeEventListener(type, listener, options);
+		__FACADE_EVENT_TARGET__.removeEventListener(
+			type,
+			listener as EventListenerOrEventListenerObject,
+			options
+		);
 	} else {
-		globalThis.removeEventListener(type as any, listener, options);
+		__facade__originalRemoveEventListener__(type, listener, options);
 	}
 };
-globalThis.__facade_dispatchEvent__ = function (event) {
+globalThis.dispatchEvent = function (event) {
 	if (__facade_isSpecialEvent__(event.type)) {
-		__FACADE_EVENT_TARGET__.dispatchEvent(event);
+		return __FACADE_EVENT_TARGET__.dispatchEvent(event);
 	} else {
-		globalThis.dispatchEvent(event as any);
+		return __facade__originalDispatchEvent__(event);
 	}
 };
 
+declare global {
+	var addMiddleware: typeof __facade_register__;
+	var addMiddlewareInternal: typeof __facade_registerInternal__;
+}
+globalThis.addMiddleware = __facade_register__;
+globalThis.addMiddlewareInternal = __facade_registerInternal__;
+
 const __facade_waitUntil__ = Symbol("__facade_waitUntil__");
 const __facade_response__ = Symbol("__facade_response__");
 const __facade_dispatched__ = Symbol("__facade_dispatched__");
@@ -154,7 +168,7 @@ class __Facade_ScheduledEvent__ extends __Facade_ExtendableEvent__ {
 	}
 }
 
-globalThis.addEventListener("fetch", (event) => {
+__facade__originalAddEventListener__("fetch", (event) => {
 	const ctx: ExecutionContext = {
 		waitUntil: event.waitUntil.bind(event),
 		passThroughOnException: event.passThroughOnException.bind(event),
@@ -201,7 +215,7 @@ globalThis.addEventListener("fetch", (event) => {
 	);
 });
 
-globalThis.addEventListener("scheduled", (event) => {
+__facade__originalAddEventListener__("scheduled", (event) => {
 	const facadeEvent = new __Facade_ScheduledEvent__("scheduled", {
 		scheduledTime: event.scheduledTime,
 		cron: event.cron,

package/templates/middleware/middleware-miniflare3-json-error.ts

@@ -0,0 +1,20 @@
+import type { Middleware } from "./common";
+
+// See comment in `bundle.ts` for details on why this is needed
+const jsonError: Middleware = async (request, env, _ctx, middlewareCtx) => {
+	try {
+		return await middlewareCtx.next(request, env);
+	} catch (e: any) {
+		const error = {
+			name: e?.name,
+			message: e?.message ?? String(e),
+			stack: e?.stack,
+		};
+		return Response.json(error, {
+			status: 500,
+			headers: { "MF-Experimental-Error-Stack": "true" },
+		});
+	}
+};
+
+export default jsonError;