wrangler 2.0.29 → 2.1.2

package/src/dev.tsx

@@ -3,7 +3,6 @@ import { watch } from "chokidar";
 import getPort from "get-port";
 import { render } from "ink";
 import React from "react";
-import { fetch } from "undici";
 import { findWranglerToml, printBindings, readConfig } from "./config";
 import Dev from "./dev/dev";
 import { getVarsForDev } from "./dev/dev-vars";
@@ -30,7 +29,6 @@ import type { Config } from "./config";
 import type { Route } from "./config/environment";
 import type { EnablePagesAssetsServiceBindingOptions } from "./miniflare-cli";
 import type { CfWorkerInit } from "./worker";
-import type { RequestInit } from "undici";
 import type { Argv, ArgumentsCamelCase } from "yargs";
 
 interface DevArgs {
@@ -69,7 +67,7 @@ interface DevArgs {
 	"node-compat"?: boolean;
 	"experimental-enable-local-persistence"?: boolean;
 	"live-reload"?: boolean;
-	onReady?: () => void;
+	onReady?: (ip: string, port: number) => void;
 	logLevel?: "none" | "error" | "log" | "warn" | "debug";
 	logPrefix?: string;
 	showInteractiveDevSession?: boolean;
@@ -430,12 +428,6 @@ export async function startDev(args: StartDevOptions) {
 				devReactElement.unmount();
 				await watcher?.close();
 			},
-			fetch: async (init?: RequestInit) => {
-				const port = args.port || config.dev.port || (await getLocalPort());
-				const address = args.ip || config.dev.ip || "localhost";
-
-				return await fetch(`http://${address}:${port}/`, init);
-			},
 		};
 	} finally {
 		await watcher?.close();
@@ -506,7 +498,11 @@ export async function startApiDev(args: StartDevOptions) {
 			accountId: configParam.account_id || getAccountFromCache()?.id,
 			assetPaths: assetPaths,
 			assetsConfig: configParam.assets,
-			port: args.port || configParam.dev.port || (await getLocalPort()),
+			//port can be 0, which means to use a random port
+			port:
+				args.port === 0
+					? args.port
+					: args.port || configParam.dev.port || (await getLocalPort()),
 			ip: args.ip || configParam.dev.ip,
 			inspectorPort:
 				args["inspector-port"] ||
@@ -544,12 +540,6 @@ export async function startApiDev(args: StartDevOptions) {
 		stop: async () => {
 			await devServer.stop();
 		},
-		fetch: async (init?: RequestInit) => {
-			const port = args.port || config.dev.port || (await getLocalPort());
-			const address = args.ip || config.dev.ip || "localhost";
-
-			return await fetch(`http://${address}:${port}/`, init);
-		},
 	};
 }
 /**

package/src/dialogs.tsx

@@ -133,3 +133,15 @@ export function select(
 		);
 	});
 }
+
+export async function fromDashMessagePrompt(
+	deploySource: string
+): Promise<boolean | void> {
+	if (deploySource === "dash") {
+		logger.warn(
+			`You are about to publish a Workers Service that was last published via the Cloudflare Dashboard.
+		Edits that have been made via the dashboard will be overridden by your local code and config.`
+		);
+		return await confirm("Would you like to continue?");
+	}
+}

package/src/index.tsx

@@ -99,6 +99,9 @@ const proxy =
 
 if (proxy) {
 	setGlobalDispatcher(new ProxyAgent(proxy));
+	logger.log(
+		`Proxy environment variables detected. We'll use your proxy for fetch requests.`
+	);
 }
 
 export function getRules(config: Config): Config["rules"] {
@@ -741,15 +744,13 @@ function createCLIParser(argv: string[]) {
 				clientIp: args.ip,
 			};
 
-			const filters = translateCLICommandToFilterMessage(
-				cliFilters,
-				args.debug
-			);
+			const filters = translateCLICommandToFilterMessage(cliFilters);
 
 			const { tail, expiration, deleteTail } = await createTail(
 				accountId,
 				scriptName,
 				filters,
+				args.debug,
 				!isLegacyEnv(config) ? args.env : undefined
 			);
 
@@ -1162,6 +1163,96 @@ function createCLIParser(argv: string[]) {
 		}
 	);
 
+	wrangler.command(
+		"secret:bulk <json>",
+		"🗄️ Bulk upload secrets for a Worker",
+		(yargs) => {
+			return yargs
+				.positional("json", {
+					describe: `The JSON file of key-value pairs to upload, in form {"key": value, ...}`,
+					type: "string",
+					demandOption: "true",
+				})
+				.option("name", {
+					describe: "Name of the Worker",
+					type: "string",
+					requiresArg: true,
+				})
+				.option("env", {
+					type: "string",
+					requiresArg: true,
+					describe:
+						"Binds the secret to the Worker of the specific environment.",
+					alias: "e",
+				});
+		},
+		async (secretBulkArgs) => {
+			await printWranglerBanner();
+			const config = readConfig(
+				secretBulkArgs.config as ConfigPath,
+				secretBulkArgs
+			);
+
+			const scriptName = getLegacyScriptName(secretBulkArgs, config);
+			if (!scriptName) {
+				throw new Error(
+					"Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with `--name <worker-name>`"
+				);
+			}
+
+			const accountId = await requireAuth(config);
+
+			logger.log(
+				`🌀 Creating the secrets for the Worker "${scriptName}" ${
+					secretBulkArgs.env && !isLegacyEnv(config)
+						? `(${secretBulkArgs.env})`
+						: ""
+				}`
+			);
+			const jsonFilePath = path.resolve(secretBulkArgs.json);
+			const content = parseJSON<Record<string, string>>(
+				readFileSync(jsonFilePath),
+				jsonFilePath
+			);
+			for (const key in content) {
+				if (typeof content[key] !== "string") {
+					throw new Error(
+						`The value for ${key} in ${jsonFilePath} is not a string.`
+					);
+				}
+			}
+
+			const url =
+				!secretBulkArgs.env || isLegacyEnv(config)
+					? `/accounts/${accountId}/workers/scripts/${scriptName}/secrets`
+					: `/accounts/${accountId}/workers/services/${scriptName}/environments/${secretBulkArgs.env}/secrets`;
+			// Until we have a bulk route for secrets, we need to make a request for each key/value pair
+			await Promise.allSettled(
+				Object.entries(content).map(async ([key, value]) => {
+					return fetchResult(url, {
+						method: "PUT",
+						headers: { "Content-Type": "application/json" },
+						body: JSON.stringify({
+							name: key,
+							text: value,
+							type: "secret_text",
+						}),
+					})
+						.then(() => {
+							logger.log(`✨ Successfully created secret for key: ${key}`);
+						})
+						.catch((e) => {
+							logger.error(
+								`🚨 Error uploading secret for key: ${key}:
+										${e.message}`
+							);
+						});
+				})
+			);
+			return logger.log("✨ Finished processing secrets JSON file");
+		}
+	);
+
 	// kv
 	// :namespace
 	wrangler.command(

package/src/init.ts

@@ -5,6 +5,7 @@ import TOML from "@iarna/toml";
 import { findUp } from "find-up";
 import { version as wranglerVersion } from "../package.json";
 
+import { fetchResult } from "./cfetch";
 import { fetchDashboardScript } from "./cfetch/internal";
 import { readConfig } from "./config";
 import { confirm, select } from "./dialogs";
@@ -15,6 +16,10 @@ import { parsePackageJSON, parseTOML, readFileSync } from "./parse";
 import { getBasePath } from "./paths";
 import { requireAuth } from "./user";
 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 { Argv, ArgumentsCamelCase } from "yargs";
 
@@ -56,6 +61,53 @@ interface InitArgs {
 	yes?: boolean;
 }
 
+export type ServiceMetadataRes = {
+	id: string;
+	default_environment: {
+		environment: string;
+		created_on: string;
+		modified_on: string;
+		script: {
+			id: string;
+			tag: string;
+			etag: string;
+			handlers: string[];
+			modified_on: string;
+			created_on: string;
+			migration_tag: string;
+			usage_model: "bundled" | "unbound";
+			compatibility_date: string;
+			last_deployed_from?: "wrangler" | "dash" | "api";
+		};
+	};
+	created_on: string;
+	modified_on: string;
+	usage_model: "bundled" | "unbound";
+	environments: [
+		{
+			environment: string;
+			created_on: string;
+			modified_on: string;
+		}
+	];
+};
+
+export type RawSimpleRoute = { pattern: string };
+export type RawRoutes = (RawSimpleRoute | Exclude<Route, SimpleRoute>) & {
+	id: string;
+};
+export type RoutesRes = RawRoutes[];
+
+export type CronTriggersRes = {
+	schedules: [
+		{
+			cron: string;
+			created_on: Date;
+			modified_on: Date;
+		}
+	];
+};
+
 export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 	await printWranglerBanner();
 	if (args.type) {
@@ -457,17 +509,23 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 				path.join(creationDirectory, "./src/index.ts")
 			);
 			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.`
+				);
 				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;
+				// I want the default environment, assuming it's the most up to date code.
 				const dashScript = await fetchDashboardScript(
-					`/accounts/${accountId}/workers/scripts/${fromDashScriptName}`,
-					{
-						method: "GET",
-					}
+					`/accounts/${accountId}/workers/services/${fromDashScriptName}/environments/${defaultEnvironment}/content`
 				);
 
 				await writeFile(
@@ -480,7 +538,11 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 					justCreatedWranglerToml,
 					pathToPackageJson,
 					"src/index.ts",
-					{}
+
+					(await getWorkerConfig(accountId, fromDashScriptName, {
+						defaultEnvironment,
+						environments: serviceMetaData.environments,
+					})) as TOML.JsonMap
 				);
 			} else {
 				const newWorkerType = yesFlag
@@ -523,17 +585,25 @@ 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.`
+				);
 				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;
+
+				// I want the default environment, assuming it's the most up to date code.
 				const dashScript = await fetchDashboardScript(
-					`/accounts/${accountId}/workers/scripts/${fromDashScriptName}`,
-					{
-						method: "GET",
-					}
+					`/accounts/${accountId}/workers/services/${fromDashScriptName}/environments/${defaultEnvironment}/content`
 				);
 
 				await writeFile(
@@ -546,7 +616,11 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 					justCreatedWranglerToml,
 					pathToPackageJson,
 					"src/index.ts",
-					{}
+					//? Should we have Environment argument for `wrangler init --from-dash` - Jacob
+					(await getWorkerConfig(accountId, fromDashScriptName, {
+						defaultEnvironment,
+						environments: serviceMetaData.environments,
+					})) as TOML.JsonMap
 				);
 			} else {
 				const newWorkerType = yesFlag
@@ -620,3 +694,204 @@ async function findPath(
 		});
 	}
 }
+
+async function getWorkerConfig(
+	accountId: string,
+	fromDashScriptName: string,
+	{
+		defaultEnvironment,
+		environments,
+	}: {
+		defaultEnvironment: string;
+		environments: ServiceMetadataRes["environments"];
+	}
+): Promise<RawConfig> {
+	const [bindings, routes, serviceEnvMetadata, cronTriggers] =
+		await Promise.all([
+			fetchResult<WorkerMetadata["bindings"]>(
+				`/accounts/${accountId}/workers/services/${fromDashScriptName}/environments/${defaultEnvironment}/bindings`
+			),
+			fetchResult<RoutesRes>(
+				`/accounts/${accountId}/workers/services/${fromDashScriptName}/environments/${defaultEnvironment}/routes`
+			),
+			fetchResult<ServiceMetadataRes["default_environment"]>(
+				`/accounts/${accountId}/workers/services/${fromDashScriptName}/environments/${defaultEnvironment}`
+			),
+			fetchResult<CronTriggersRes>(
+				`/accounts/${accountId}/workers/scripts/${fromDashScriptName}/schedules`
+			),
+		]).catch((e) => {
+			throw new Error(
+				`Error Occurred ${e}: Unable to fetch bindings, routes, or services metadata from the dashboard. Please try again later.`
+			);
+		});
+
+	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 ?? {}),
+							name: binding.name,
+							text: 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 durableObjectClassNames = bindings
+		.filter((binding) => binding.type === "durable_object_namespace")
+		.map(
+			(durableObject) => (durableObject as { class_name: string }).class_name
+		);
+
+	const routeOrRoutes = routes.map((rawRoute) => {
+		const { id: _id, ...route } = rawRoute;
+		if (Object.keys(route).length === 1) {
+			return route.pattern;
+		} else {
+			return route as Route;
+		}
+	});
+	const routeOrRoutesToConfig =
+		routeOrRoutes.length > 1
+			? { routes: routeOrRoutes }
+			: { route: routeOrRoutes[0] };
+
+	return {
+		compatibility_date: serviceEnvMetadata.script.compatibility_date,
+		...routeOrRoutesToConfig,
+		usage_model: serviceEnvMetadata.script.usage_model,
+		migrations: [
+			{
+				tag: serviceEnvMetadata.script.migration_tag,
+				new_classes: durableObjectClassNames,
+			},
+		],
+		triggers: {
+			crons: cronTriggers.schedules.map((scheduled) => scheduled.cron),
+		},
+		env: environments
+			.filter((env) => env.environment !== "production")
+			// `env` can have multiple Environments, with different configs.
+			.reduce((envObj, { environment }) => {
+				return { ...envObj, [environment]: {} };
+				// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			}, {} as RawConfig["env"]),
+		...mappedBindings,
+	};
+}