wrangler 2.0.29 → 2.1.0

package/src/dev/start-server.ts

@@ -177,6 +177,7 @@ async function runEsbuild({
 				services: undefined,
 				workerDefinitions: undefined,
 				firstPartyWorkerDevFacade: undefined,
+				targetConsumer: "dev", // We are starting a dev server
 		  });
 
 	return {
@@ -237,11 +238,14 @@ export async function startLocalServer({
 		if (!bundle || !format) return;
 
 		// port for the worker
-		await waitForPortToBeAvailable(port, {
-			retryPeriod: 200,
-			timeout: 2000,
-			abortSignal: abortController.signal,
-		});
+
+		if (port !== 0) {
+			await waitForPortToBeAvailable(port, {
+				retryPeriod: 200,
+				timeout: 2000,
+				abortSignal: abortController.signal,
+			});
+		}
 
 		if (bindings.services && bindings.services.length > 0) {
 			throw new Error(
@@ -327,7 +331,7 @@ export async function startLocalServer({
 					await registerWorker(workerName, {
 						protocol: localProtocol,
 						mode: "local",
-						port,
+						port: message.mfPort,
 						host: ip,
 						durableObjects: internalDurableObjects.map((binding) => ({
 							name: binding.name,
@@ -341,7 +345,7 @@ export async function startLocalServer({
 							: {}),
 					});
 				}
-				onReady?.();
+				onReady?.(ip, message.mfPort);
 			}
 		});
 

package/src/dev/use-esbuild.ts

@@ -36,6 +36,7 @@ export function useEsbuild({
 	services,
 	durableObjects,
 	firstPartyWorkerDevFacade,
+	targetConsumer,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -53,6 +54,7 @@ export function useEsbuild({
 	workerDefinitions: WorkerRegistry;
 	durableObjects: Config["durable_objects"];
 	firstPartyWorkerDevFacade: boolean | undefined;
+	targetConsumer: "dev" | "publish";
 }): EsbuildBundle | undefined {
 	const [bundle, setBundle] = useState<EsbuildBundle>();
 	const { exit } = useApp();
@@ -116,6 +118,7 @@ export function useEsbuild({
 						workerDefinitions,
 						services,
 						firstPartyWorkerDevFacade,
+						targetConsumer,
 				  });
 
 			// Capture the `stop()` method to use as the `useEffect()` destructor.
@@ -173,6 +176,7 @@ export function useEsbuild({
 		durableObjects,
 		workerDefinitions,
 		firstPartyWorkerDevFacade,
+		targetConsumer,
 	]);
 	return bundle;
 }

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
 			);
 

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,
+	};
+}