wrangler 0.0.0-e7a0cd5b → 0.0.0-e7cf0caa

package/src/init.ts

@@ -19,13 +19,18 @@ import { CommandLineArgsError, printWranglerBanner } from "./index";
 
 import type { RawConfig } from "./config";
 import type { Route, SimpleRoute } from "./config/environment";
-import type { WorkerMetadata } from "./create-worker-upload-form";
-import type { ConfigPath } from "./index";
+import type {
+	WorkerMetadata,
+	WorkerMetadataBinding,
+} from "./create-worker-upload-form";
 import type { PackageManager } from "./package-manager";
-import type { CommonYargsOptions } from "./yargs-types";
-import type { Argv, ArgumentsCamelCase } from "yargs";
+import type { PackageJSON } from "./parse";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "./yargs-types";
 
-export async function initOptions(yargs: Argv<CommonYargsOptions>) {
+export function initOptions(yargs: CommonYargsArgv) {
 	return yargs
 		.positional("name", {
 			describe: "The name of your worker",
@@ -49,18 +54,14 @@ export async function initOptions(yargs: Argv<CommonYargsOptions>) {
 			alias: "y",
 		})
 		.option("from-dash", {
-			describe: "Download script from the dashboard for local development",
+			describe:
+				"The name of the Worker you wish to download from the Cloudflare dashboard for local development.",
 			type: "string",
 			requiresArg: true,
 		});
 }
 
-interface InitArgs {
-	name: string;
-	type?: string;
-	site?: boolean;
-	yes?: boolean;
-}
+type InitArgs = StrictYargsOptionsToInterface<typeof initOptions>;
 
 export type ServiceMetadataRes = {
 	id: string;
@@ -109,7 +110,7 @@ export type CronTriggersRes = {
 	];
 };
 
-export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
+export async function initHandler(args: InitArgs) {
 	await printWranglerBanner();
 	if (args.type) {
 		let message = "The --type option is no longer supported.";
@@ -124,7 +125,7 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 	const devDepsToInstall: string[] = [];
 	const instructions: string[] = [];
 	let shouldRunPackageManagerInstall = false;
-	const fromDashScriptName = args["from-dash"] as string;
+	const fromDashScriptName = args.fromDash;
 	const creationDirectory = path.resolve(
 		process.cwd(),
 		(args.name ? args.name : fromDashScriptName) ?? ""
@@ -165,6 +166,27 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 	);
 	let justCreatedWranglerToml = false;
 
+	let accountId = "";
+	let serviceMetadata: undefined | ServiceMetadataRes;
+
+	// If --from-dash, check that script actually exists
+	if (fromDashScriptName) {
+		const config = readConfig(args.config, args);
+		accountId = await requireAuth(config);
+		try {
+			serviceMetadata = await fetchResult<ServiceMetadataRes>(
+				`/accounts/${accountId}/workers/services/${fromDashScriptName}`
+			);
+		} catch (err) {
+			if ((err as { code?: number }).code === 10090) {
+				throw new Error(
+					"wrangler couldn't find a Worker script with that name in your account.\nRun `wrangler whoami` to confirm you're logged into the correct account."
+				);
+			}
+			throw err;
+		}
+	}
+
 	if (fs.existsSync(wranglerTomlDestination)) {
 		let shouldContinue = false;
 		logger.warn(
@@ -309,7 +331,7 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 			isTypescriptProject = true;
 			await writeFile(
 				path.join(creationDirectory, "./tsconfig.json"),
-				readFileSync(path.join(getBasePath(), "templates/tsconfig.json"))
+				readFileSync(path.join(getBasePath(), "templates/tsconfig.init.json"))
 			);
 			devDepsToInstall.push("@cloudflare/workers-types");
 			devDepsToInstall.push("typescript");
@@ -411,7 +433,7 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 								: `wrangler publish ${scriptPath}`,
 							...(isAddingTestScripts && { test: testRunner }),
 						},
-					},
+					} as PackageJSON,
 					null,
 					2
 				) + "\n"
@@ -449,19 +471,15 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 			);
 			if (fromDashScriptName) {
 				logger.warn(
-					`After running "wrangler init --from-dash", modifying your worker via the Cloudflare dashboard is discouraged.
-					Edits made via the Dashboard will not be synchronized locally and will be overridden by your local code and config when you publish.`
+					"After running `wrangler init --from-dash`, modifying your worker via the Cloudflare dashboard is discouraged.\nEdits made via the Dashboard will not be synchronized locally and will be overridden by your local code and config when you publish."
 				);
-				const config = readConfig(args.config as ConfigPath, args);
-				const accountId = await requireAuth(config);
+
 				await mkdir(path.join(creationDirectory, "./src"), {
 					recursive: true,
 				});
-				const serviceMetaData = await fetchResult<ServiceMetadataRes>(
-					`/accounts/${accountId}/workers/services/${fromDashScriptName}`
-				);
+
 				const defaultEnvironment =
-					serviceMetaData.default_environment.environment;
+					serviceMetadata?.default_environment.environment;
 				// I want the default environment, assuming it's the most up to date code.
 				const dashScript = await fetchDashboardScript(
 					`/accounts/${accountId}/workers/services/${fromDashScriptName}/environments/${defaultEnvironment}/content`
@@ -479,7 +497,7 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 					scriptPath: "src/index.ts",
 					extraToml: (await getWorkerConfig(accountId, fromDashScriptName, {
 						defaultEnvironment,
-						environments: serviceMetaData.environments,
+						environments: serviceMetadata?.environments,
 					})) as TOML.JsonMap,
 				});
 			} else {
@@ -493,6 +511,7 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 					await mkdir(path.join(creationDirectory, "./src"), {
 						recursive: true,
 					});
+
 					await writeFile(
 						path.join(creationDirectory, "./src/index.ts"),
 						readFileSync(path.join(getBasePath(), `templates/${template}`))
@@ -505,10 +524,43 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 						)}`
 					);
 
+					shouldCreateTests =
+						yesFlag ||
+						(await confirm(
+							"Would you like us to write your first test with Vitest?"
+						));
+
+					if (shouldCreateTests) {
+						if (yesFlag) {
+							logger.info("Your project will use Vitest to run your tests.");
+						}
+
+						newWorkerTestType = "vitest";
+						devDepsToInstall.push(newWorkerTestType);
+
+						await writeFile(
+							path.join(creationDirectory, "./src/index.test.ts"),
+							readFileSync(
+								path.join(
+									getBasePath(),
+									`templates/init-tests/test-${newWorkerTestType}-new-worker.ts`
+								)
+							)
+						);
+						logger.log(
+							`✨ Created ${path.relative(
+								process.cwd(),
+								path.join(creationDirectory, "./src/index.test.ts")
+							)}`
+						);
+					}
+
 					await writePackageJsonScriptsAndUpdateWranglerToml({
 						isWritingScripts: shouldWritePackageJsonScripts,
+						isAddingTests: shouldCreateTests,
 						isCreatingWranglerToml: justCreatedWranglerToml,
 						packagePath: pathToPackageJson,
+						testRunner: newWorkerTestType,
 						scriptPath: "src/index.ts",
 						extraToml: getNewWorkerToml(newWorkerType),
 					});
@@ -524,20 +576,15 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 
 			if (fromDashScriptName) {
 				logger.warn(
-					`After running "wrangler init --from-dash", modifying your worker via the Cloudflare dashboard is discouraged.
-					Edits made via the Dashboard will not be synchronized locally and will be overridden by your local code and config when you publish.`
+					"After running `wrangler init --from-dash`, modifying your worker via the Cloudflare dashboard is discouraged.\nEdits made via the Dashboard will not be synchronized locally and will be overridden by your local code and config when you publish."
 				);
-				const config = readConfig(args.config as ConfigPath, args);
-				const accountId = await requireAuth(config);
+
 				await mkdir(path.join(creationDirectory, "./src"), {
 					recursive: true,
 				});
 
-				const serviceMetaData = await fetchResult<ServiceMetadataRes>(
-					`/accounts/${accountId}/workers/services/${fromDashScriptName}`
-				);
 				const defaultEnvironment =
-					serviceMetaData.default_environment.environment;
+					serviceMetadata?.default_environment.environment;
 
 				// I want the default environment, assuming it's the most up to date code.
 				const dashScript = await fetchDashboardScript(
@@ -553,11 +600,11 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 					isWritingScripts: shouldWritePackageJsonScripts,
 					isCreatingWranglerToml: justCreatedWranglerToml,
 					packagePath: pathToPackageJson,
-					scriptPath: "src/index.ts",
+					scriptPath: "src/index.js",
 					//? Should we have Environment argument for `wrangler init --from-dash` - Jacob
 					extraToml: (await getWorkerConfig(accountId, fromDashScriptName, {
 						defaultEnvironment,
-						environments: serviceMetaData.environments,
+						environments: serviceMetadata?.environments,
 					})) as TOML.JsonMap,
 				});
 			} else {
@@ -588,7 +635,7 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 						(await confirm("Would you like us to write your first test?"));
 
 					if (shouldCreateTests) {
-						newWorkerTestType = await getNewWorkerTestType();
+						newWorkerTestType = await getNewWorkerTestType(yesFlag);
 						devDepsToInstall.push(newWorkerTestType);
 						await writeFile(
 							path.join(creationDirectory, "./src/index.test.js"),
@@ -678,41 +725,41 @@ async function installPackages(
 }
 
 async function getNewWorkerType(newWorkerFilename: string) {
-	return select(
-		`Would you like to create a Worker at ${newWorkerFilename}?`,
-		[
+	return select(`Would you like to create a Worker at ${newWorkerFilename}?`, {
+		choices: [
 			{
 				value: "none",
-				label: "None",
+				title: "None",
 			},
 			{
 				value: "fetch",
-				label: "Fetch handler",
+				title: "Fetch handler",
 			},
 			{
 				value: "scheduled",
-				label: "Scheduled handler",
+				title: "Scheduled handler",
 			},
 		],
-		1
-	) as Promise<"none" | "fetch" | "scheduled">;
+		defaultOption: 1,
+	});
 }
 
-async function getNewWorkerTestType() {
-	return select(
-		`Which test runner would you like to use?`,
-		[
-			{
-				value: "vitest",
-				label: "Vitest",
-			},
-			{
-				value: "jest",
-				label: "Jest",
-			},
-		],
-		1
-	) as Promise<"jest" | "vitest">;
+async function getNewWorkerTestType(yesFlag?: boolean) {
+	return yesFlag
+		? "jest"
+		: select(`Which test runner would you like to use?`, {
+				choices: [
+					{
+						value: "vitest",
+						title: "Vitest",
+					},
+					{
+						value: "jest",
+						title: "Jest",
+					},
+				],
+				defaultOption: 1,
+		  });
 }
 
 function getNewWorkerTemplate(
@@ -770,8 +817,8 @@ async function getWorkerConfig(
 		defaultEnvironment,
 		environments,
 	}: {
-		defaultEnvironment: string;
-		environments: ServiceMetadataRes["environments"];
+		defaultEnvironment: string | undefined;
+		environments: ServiceMetadataRes["environments"] | undefined;
 	}
 ): Promise<RawConfig> {
 	const [bindings, routes, serviceEnvMetadata, cronTriggers] =
@@ -794,131 +841,7 @@ async function getWorkerConfig(
 			);
 		});
 
-	const mappedBindings = bindings
-		.filter((binding) => (binding.type as string) !== "secret_text")
-		// Combine the same types into {[type]: [binding]}
-		.reduce((configObj, binding) => {
-			// Some types have different names in wrangler.toml
-			// I want the type safety of the binding being destructured after the case narrowing the union but type is unused
-
-			switch (binding.type) {
-				case "plain_text":
-					{
-						configObj.vars = {
-							...(configObj.vars ?? {}),
-							[binding.name]: binding.text,
-						};
-					}
-					break;
-				case "json":
-					{
-						configObj.vars = {
-							...(configObj.vars ?? {}),
-							name: binding.name,
-							json: binding.json,
-						};
-					}
-					break;
-				case "kv_namespace":
-					{
-						configObj.kv_namespaces = [
-							...(configObj.kv_namespaces ?? []),
-							{ id: binding.namespace_id, binding: binding.name },
-						];
-					}
-					break;
-				case "durable_object_namespace":
-					{
-						configObj.durable_objects = {
-							bindings: [
-								...(configObj.durable_objects?.bindings ?? []),
-								{
-									name: binding.name,
-									class_name: binding.class_name,
-									script_name: binding.script_name,
-									environment: binding.environment,
-								},
-							],
-						};
-					}
-					break;
-				case "r2_bucket":
-					{
-						configObj.r2_buckets = [
-							...(configObj.r2_buckets ?? []),
-							{ binding: binding.name, bucket_name: binding.bucket_name },
-						];
-					}
-					break;
-				case "service":
-					{
-						configObj.services = [
-							...(configObj.services ?? []),
-							{
-								binding: binding.name,
-								service: binding.service,
-								environment: binding.environment,
-							},
-						];
-					}
-					break;
-				case "namespace":
-					{
-						configObj.dispatch_namespaces = [
-							...(configObj.dispatch_namespaces ?? []),
-							{ binding: binding.name, namespace: binding.namespace },
-						];
-					}
-					break;
-				case "logfwdr":
-					{
-						configObj.logfwdr = {
-							// TODO: Messaging about adding schema file path
-							schema: "",
-							bindings: [
-								...(configObj.logfwdr?.bindings ?? []),
-								{ name: binding.name, destination: binding.destination },
-							],
-						};
-					}
-					break;
-				case "wasm_module":
-					{
-						configObj.wasm_modules = {
-							...(configObj.wasm_modules ?? {}),
-							[binding.name]: binding.part,
-						};
-					}
-					break;
-				case "text_blob":
-					{
-						configObj.text_blobs = {
-							...(configObj.text_blobs ?? {}),
-							[binding.name]: binding.part,
-						};
-					}
-					break;
-				case "data_blob":
-					{
-						configObj.data_blobs = {
-							...(configObj.data_blobs ?? {}),
-							[binding.name]: binding.part,
-						};
-					}
-					break;
-				default: {
-					// If we don't know what the type is, its an unsafe binding
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					if (!(binding as any)?.type) break;
-					configObj.unsafe = {
-						bindings: [...(configObj.unsafe?.bindings ?? []), binding],
-					};
-				}
-			}
-
-			return configObj;
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		}, {} as RawConfig);
+	const mappedBindings = mapBindings(bindings);
 
 	const durableObjectClassNames = bindings
 		.filter((binding) => binding.type === "durable_object_namespace")
@@ -959,7 +882,7 @@ async function getWorkerConfig(
 			crons: cronTriggers.schedules.map((scheduled) => scheduled.cron),
 		},
 		env: environments
-			.filter((env) => env.environment !== "production")
+			?.filter((env) => env.environment !== "production")
 			// `env` can have multiple Environments, with different configs.
 			.reduce((envObj, { environment }) => {
 				return { ...envObj, [environment]: {} };
@@ -968,3 +891,142 @@ async function getWorkerConfig(
 		...mappedBindings,
 	};
 }
+
+export function mapBindings(bindings: WorkerMetadataBinding[]): RawConfig {
+	return (
+		bindings
+			.filter((binding) => (binding.type as string) !== "secret_text")
+			// Combine the same types into {[type]: [binding]}
+			.reduce((configObj, binding) => {
+				// Some types have different names in wrangler.toml
+				// I want the type safety of the binding being destructured after the case narrowing the union but type is unused
+
+				switch (binding.type) {
+					case "plain_text":
+						{
+							configObj.vars = {
+								...(configObj.vars ?? {}),
+								[binding.name]: binding.text,
+							};
+						}
+						break;
+					case "json":
+						{
+							configObj.vars = {
+								...(configObj.vars ?? {}),
+								name: binding.name,
+								json: binding.json,
+							};
+						}
+						break;
+					case "kv_namespace":
+						{
+							configObj.kv_namespaces = [
+								...(configObj.kv_namespaces ?? []),
+								{ id: binding.namespace_id, binding: binding.name },
+							];
+						}
+						break;
+					case "durable_object_namespace":
+						{
+							configObj.durable_objects = {
+								bindings: [
+									...(configObj.durable_objects?.bindings ?? []),
+									{
+										name: binding.name,
+										class_name: binding.class_name,
+										script_name: binding.script_name,
+										environment: binding.environment,
+									},
+								],
+							};
+						}
+						break;
+					case "r2_bucket":
+						{
+							configObj.r2_buckets = [
+								...(configObj.r2_buckets ?? []),
+								{ binding: binding.name, bucket_name: binding.bucket_name },
+							];
+						}
+						break;
+					case "service":
+						{
+							configObj.services = [
+								...(configObj.services ?? []),
+								{
+									binding: binding.name,
+									service: binding.service,
+									environment: binding.environment,
+								},
+							];
+						}
+						break;
+					case "analytics_engine":
+						{
+							configObj.analytics_engine_datasets = [
+								...(configObj.analytics_engine_datasets ?? []),
+								{ binding: binding.name, dataset: binding.dataset },
+							];
+						}
+						break;
+					case "dispatch_namespace":
+						{
+							configObj.dispatch_namespaces = [
+								...(configObj.dispatch_namespaces ?? []),
+								{ binding: binding.name, namespace: binding.namespace },
+							];
+						}
+						break;
+					case "logfwdr":
+						{
+							configObj.logfwdr = {
+								// TODO: Messaging about adding schema file path
+								schema: "",
+								bindings: [
+									...(configObj.logfwdr?.bindings ?? []),
+									{ name: binding.name, destination: binding.destination },
+								],
+							};
+						}
+						break;
+					case "wasm_module":
+						{
+							configObj.wasm_modules = {
+								...(configObj.wasm_modules ?? {}),
+								[binding.name]: binding.part,
+							};
+						}
+						break;
+					case "text_blob":
+						{
+							configObj.text_blobs = {
+								...(configObj.text_blobs ?? {}),
+								[binding.name]: binding.part,
+							};
+						}
+						break;
+					case "data_blob":
+						{
+							configObj.data_blobs = {
+								...(configObj.data_blobs ?? {}),
+								[binding.name]: binding.part,
+							};
+						}
+						break;
+					default: {
+						// If we don't know what the type is, its an unsafe binding
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						if (!(binding as any)?.type) break;
+						configObj.unsafe = {
+							bindings: [...(configObj.unsafe?.bindings ?? []), binding],
+							metadata: configObj.unsafe?.metadata ?? undefined,
+						};
+					}
+				}
+
+				return configObj;
+				// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			}, {} as RawConfig)
+	);
+}

package/src/inspect.ts

@@ -151,6 +151,18 @@ export default function useInspector(props: InspectorProps) {
 			);
 			ws.close(1013, "Too many clients; only one can be connected at a time");
 		} else {
+			// Since Wrangler proxies the inspector, reloading Chrome DevTools won't trigger debugger initialisation events (because it's connecting to an extant session).
+			// This sends a `Debugger.disable` message to the remote when a new WebSocket connection is initialised,
+			// with the assumption that the new connection will shortly send a `Debugger.enable` event and trigger re-initialisation.
+			// The key initialisation messages that are needed are the `Debugger.scriptParsed events`.
+			remoteWebSocket?.send(
+				JSON.stringify({
+					// This number is arbitrary, and is chosen to be high so as not to conflict with messages that DevTools might actually send.
+					// For completeness, these options don't work: 0, -1, or Number.MAX_SAFE_INTEGER
+					id: 100_000_000,
+					method: "Debugger.disable",
+				})
+			);
 			// As promised, save the created websocket in a state hook
 			setLocalWebSocket(ws);
 
@@ -733,7 +745,7 @@ function logConsoleMessage(evt: Protocol.Runtime.ConsoleAPICalledEvent): void {
  * Opens the chrome debugger
  */
 export const openInspector = async (inspectorPort: number) => {
-	const url = `https://built-devtools.pages.dev/js_app?experiments=true&v8only=true&ws=localhost:${inspectorPort}/ws`;
+	const url = `https://devtools.devprod.cloudflare.dev/js_app?theme=systemPreferred&ws=localhost:${inspectorPort}/ws`;
 	const errorMessage =
 		"Failed to open inspector.\nInspector depends on having a Chromium-based browser installed, maybe you need to install one?";
 
@@ -759,6 +771,9 @@ export const openInspector = async (inspectorPort: number) => {
 			{
 				name: open.apps.edge,
 			},
+			{
+				name: open.apps.firefox,
+			},
 		],
 	});
 	childProcess.on("error", () => {

package/src/jest.d.ts

@@ -0,0 +1,4 @@
+declare global {
+	const jest: unknown;
+}
+export {};