wrangler 0.0.0-e178d6fb → 0.0.0-e1c2f5b9

package/src/config/validation.ts

@@ -102,6 +102,14 @@ export function normalizeAndValidateConfig(
 		"boolean"
 	);
 
+	validateOptionalProperty(
+		diagnostics,
+		"",
+		"keep_vars",
+		rawConfig.keep_vars,
+		"boolean"
+	);
+
 	// TODO: set the default to false to turn on service environments as the default
 	const isLegacyEnv =
 		(args as { "legacy-env": boolean | undefined })["legacy-env"] ??
@@ -182,6 +190,7 @@ export function normalizeAndValidateConfig(
 		configPath,
 		legacy_env: isLegacyEnv,
 		send_metrics: rawConfig.send_metrics,
+		keep_vars: rawConfig.keep_vars,
 		...activeEnv,
 		dev: normalizeAndValidateDev(diagnostics, rawConfig.dev ?? {}),
 		migrations: normalizeAndValidateMigrations(
@@ -357,8 +366,9 @@ function normalizeAndValidateDev(
 	rawDev: RawDevConfig
 ): DevConfig {
 	const {
-		ip = "localhost",
+		ip = "0.0.0.0",
 		port,
+		inspector_port,
 		local_protocol = "http",
 		upstream_protocol = "https",
 		host,
@@ -368,6 +378,13 @@ function normalizeAndValidateDev(
 
 	validateOptionalProperty(diagnostics, "dev", "ip", ip, "string");
 	validateOptionalProperty(diagnostics, "dev", "port", port, "number");
+	validateOptionalProperty(
+		diagnostics,
+		"dev",
+		"inspector_port",
+		inspector_port,
+		"number"
+	);
 	validateOptionalProperty(
 		diagnostics,
 		"dev",
@@ -385,7 +402,7 @@ function normalizeAndValidateDev(
 		["http", "https"]
 	);
 	validateOptionalProperty(diagnostics, "dev", "host", host, "string");
-	return { ip, port, local_protocol, upstream_protocol, host };
+	return { ip, port, inspector_port, local_protocol, upstream_protocol, host };
 }
 
 /**
@@ -590,25 +607,68 @@ function normalizeAndValidateAssets(
 	diagnostics: Diagnostics,
 	configPath: string | undefined,
 	rawConfig: RawConfig
-) {
-	if (
-		typeof rawConfig?.assets === "string" ||
-		rawConfig?.assets === undefined
-	) {
-		return rawConfig?.assets;
+): Config["assets"] {
+	// Even though the type doesn't say it,
+	// we allow for a string input in the config,
+	// so let's normalise it
+	if (typeof rawConfig?.assets === "string") {
+		return {
+			bucket: rawConfig.assets,
+			include: [],
+			exclude: [],
+			browser_TTL: undefined,
+			serve_single_page_app: false,
+		};
+	}
+
+	if (rawConfig?.assets === undefined) {
+		return undefined;
 	}
 
-	const { bucket, include = [], exclude = [], ...rest } = rawConfig.assets;
+	if (typeof rawConfig.assets !== "object") {
+		diagnostics.errors.push(
+			`Expected the \`assets\` field to be a string or an object, but got ${typeof rawConfig.assets}.`
+		);
+		return undefined;
+	}
+
+	const {
+		bucket,
+		include = [],
+		exclude = [],
+		browser_TTL,
+		serve_single_page_app,
+		...rest
+	} = rawConfig.assets;
 
 	validateAdditionalProperties(diagnostics, "assets", Object.keys(rest), []);
+
 	validateRequiredProperty(diagnostics, "assets", "bucket", bucket, "string");
 	validateTypedArray(diagnostics, "assets.include", include, "string");
 	validateTypedArray(diagnostics, "assets.exclude", exclude, "string");
 
+	validateOptionalProperty(
+		diagnostics,
+		"assets",
+		"browser_TTL",
+		browser_TTL,
+		"number"
+	);
+
+	validateOptionalProperty(
+		diagnostics,
+		"assets",
+		"serve_single_page_app",
+		serve_single_page_app,
+		"boolean"
+	);
+
 	return {
 		bucket,
 		include,
 		exclude,
+		browser_TTL,
+		serve_single_page_app,
 	};
 }
 
@@ -822,6 +882,13 @@ function normalizeAndValidateEnvironment(
 	isLegacyEnv?: boolean,
 	rawConfig?: RawConfig | undefined
 ): Environment {
+	deprecated(
+		diagnostics,
+		rawEnv,
+		"kv-namespaces",
+		`The "kv-namespaces" field is no longer supported, please rename to "kv_namespaces"`,
+		true
+	);
 	deprecated(
 		diagnostics,
 		rawEnv,
@@ -831,6 +898,7 @@ function normalizeAndValidateEnvironment(
 	);
 
 	// The field "experimental_services" doesn't exist anymore in the config, but we still want to error about any older usage.
+
 	deprecated(
 		diagnostics,
 		rawEnv,
@@ -841,7 +909,6 @@ function normalizeAndValidateEnvironment(
 
 	experimental(diagnostics, rawEnv, "unsafe");
 	experimental(diagnostics, rawEnv, "services");
-	experimental(diagnostics, rawEnv, "worker_namespaces");
 
 	const route = normalizeAndValidateRoute(diagnostics, topLevelEnv, rawEnv);
 
@@ -1007,6 +1074,16 @@ function normalizeAndValidateEnvironment(
 			validateBindingArray(envName, validateKVBinding),
 			[]
 		),
+		queues: notInheritable(
+			diagnostics,
+			topLevelEnv,
+			rawConfig,
+			rawEnv,
+			envName,
+			"queues",
+			validateQueues(envName),
+			{ producers: [], consumers: [] }
+		),
 		r2_buckets: notInheritable(
 			diagnostics,
 			topLevelEnv,
@@ -1017,6 +1094,16 @@ function normalizeAndValidateEnvironment(
 			validateBindingArray(envName, validateR2Binding),
 			[]
 		),
+		d1_databases: notInheritable(
+			diagnostics,
+			topLevelEnv,
+			rawConfig,
+			rawEnv,
+			envName,
+			"d1_databases",
+			validateBindingArray(envName, validateD1Binding),
+			[]
+		),
 		services: notInheritable(
 			diagnostics,
 			topLevelEnv,
@@ -1027,16 +1114,37 @@ function normalizeAndValidateEnvironment(
 			validateBindingArray(envName, validateServiceBinding),
 			[]
 		),
-		worker_namespaces: notInheritable(
+		analytics_engine_datasets: notInheritable(
+			diagnostics,
+			topLevelEnv,
+			rawConfig,
+			rawEnv,
+			envName,
+			"analytics_engine_datasets",
+			validateBindingArray(envName, validateAnalyticsEngineBinding),
+			[]
+		),
+		dispatch_namespaces: notInheritable(
 			diagnostics,
 			topLevelEnv,
 			rawConfig,
 			rawEnv,
 			envName,
-			"worker_namespaces",
+			"dispatch_namespaces",
 			validateBindingArray(envName, validateWorkerNamespaceBinding),
 			[]
 		),
+		logfwdr: inheritable(
+			diagnostics,
+			topLevelEnv,
+			rawEnv,
+			"logfwdr",
+			validateBindingsProperty(envName, validateCflogfwdrBinding),
+			{
+				schema: undefined,
+				bindings: [],
+			}
+		),
 		unsafe: notInheritable(
 			diagnostics,
 			topLevelEnv,
@@ -1074,6 +1182,22 @@ function normalizeAndValidateEnvironment(
 			isBoolean,
 			undefined
 		),
+		first_party_worker: inheritable(
+			diagnostics,
+			topLevelEnv,
+			rawEnv,
+			"first_party_worker",
+			isBoolean,
+			undefined
+		),
+		logpush: inheritable(
+			diagnostics,
+			topLevelEnv,
+			rawEnv,
+			"logpush",
+			isBoolean,
+			undefined
+		),
 	};
 
 	return environment;
@@ -1410,6 +1534,30 @@ const validateDurableObjectBinding: ValidatorFn = (
 	return isValid;
 };
 
+const validateCflogfwdrBinding: ValidatorFn = (diagnostics, field, value) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`Expected "${field}" to be an object but got ${JSON.stringify(value)}`
+		);
+		return false;
+	}
+
+	let isValid = true;
+	if (!isRequiredProperty(value, "name", "string")) {
+		diagnostics.errors.push(`binding should have a string "name" field.`);
+		isValid = false;
+	}
+
+	if (!isRequiredProperty(value, "destination", "string")) {
+		diagnostics.errors.push(
+			`binding should have a string "destination" field.`
+		);
+		isValid = false;
+	}
+
+	return isValid;
+};
+
 /**
  * Check that the given field is a valid "unsafe" binding object.
  *
@@ -1438,8 +1586,10 @@ const validateUnsafeBinding: ValidatorFn = (diagnostics, field, value) => {
 			"text_blob",
 			"kv_namespace",
 			"durable_object_namespace",
+			"d1_database",
 			"r2_bucket",
 			"service",
+			"logfwdr",
 		];
 
 		if (safeBindings.includes(value.type)) {
@@ -1528,7 +1678,10 @@ const validateKVBinding: ValidatorFn = (diagnostics, field, value) => {
 		);
 		isValid = false;
 	}
-	if (!isRequiredProperty(value, "id", "string")) {
+	if (
+		!isRequiredProperty(value, "id", "string") ||
+		(value as { id: string }).id.length === 0
+	) {
 		diagnostics.errors.push(
 			`"${field}" bindings should have a string "id" field but got ${JSON.stringify(
 				value
@@ -1547,6 +1700,47 @@ const validateKVBinding: ValidatorFn = (diagnostics, field, value) => {
 	return isValid;
 };
 
+const validateQueueBinding: ValidatorFn = (diagnostics, field, value) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`"queue" bindings should be objects, but got ${JSON.stringify(value)}`
+		);
+		return false;
+	}
+
+	if (
+		!validateAdditionalProperties(diagnostics, field, Object.keys(value), [
+			"binding",
+			"queue",
+		])
+	) {
+		return false;
+	}
+
+	// Queue bindings must have a binding and queue.
+	let isValid = true;
+	if (!isRequiredProperty(value, "binding", "string")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (
+		!isRequiredProperty(value, "queue", "string") ||
+		(value as { queue: string }).queue.length === 0
+	) {
+		diagnostics.errors.push(
+			`"${field}" bindings should have a string "queue" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	return isValid;
+};
+
 const validateR2Binding: ValidatorFn = (diagnostics, field, value) => {
 	if (typeof value !== "object" || value === null) {
 		diagnostics.errors.push(
@@ -1566,7 +1760,10 @@ const validateR2Binding: ValidatorFn = (diagnostics, field, value) => {
 		);
 		isValid = false;
 	}
-	if (!isRequiredProperty(value, "bucket_name", "string")) {
+	if (
+		!isRequiredProperty(value, "bucket_name", "string") ||
+		(value as { bucket_name: string }).bucket_name.length === 0
+	) {
 		diagnostics.errors.push(
 			`"${field}" bindings should have a string "bucket_name" field but got ${JSON.stringify(
 				value
@@ -1585,6 +1782,53 @@ const validateR2Binding: ValidatorFn = (diagnostics, field, value) => {
 	return isValid;
 };
 
+const validateD1Binding: ValidatorFn = (diagnostics, field, value) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`"d1_databases" bindings should be objects, but got ${JSON.stringify(
+				value
+			)}`
+		);
+		return false;
+	}
+	let isValid = true;
+	// D1 databases must have a binding and either a database_name or database_id.
+	if (!isRequiredProperty(value, "binding", "string")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (
+		// TODO: allow name only, where we look up the ID dynamically
+		// !isOptionalProperty(value, "database_name", "string") &&
+		!isRequiredProperty(value, "database_id", "string")
+	) {
+		diagnostics.errors.push(
+			`"${field}" bindings must have a "database_id" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (!isOptionalProperty(value, "preview_database_id", "string")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should, optionally, have a string "preview_database_id" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (isValid && !process.env.NO_D1_WARNING) {
+		diagnostics.warnings.push(
+			`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;
+};
+
 /**
  * Check that bindings whose names might conflict, don't.
  *
@@ -1599,6 +1843,7 @@ const validateBindingsHaveUniqueNames = (
 		durable_objects,
 		kv_namespaces,
 		r2_buckets,
+		analytics_engine_datasets,
 		text_blobs,
 		unsafe,
 		vars,
@@ -1613,6 +1858,7 @@ const validateBindingsHaveUniqueNames = (
 		"Durable Object": getBindingNames(durable_objects),
 		"KV Namespace": getBindingNames(kv_namespaces),
 		"R2 Bucket": getBindingNames(r2_buckets),
+		"Analytics Engine Dataset": getBindingNames(analytics_engine_datasets),
 		"Text Blob": getBindingNames(text_blobs),
 		Unsafe: getBindingNames(unsafe),
 		"Environment Variable": getBindingNames(vars),
@@ -1721,6 +1967,43 @@ const validateServiceBinding: ValidatorFn = (diagnostics, field, value) => {
 	return isValid;
 };
 
+const validateAnalyticsEngineBinding: ValidatorFn = (
+	diagnostics,
+	field,
+	value
+) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`"analytics_engine" bindings should be objects, but got ${JSON.stringify(
+				value
+			)}`
+		);
+		return false;
+	}
+	let isValid = true;
+	// Service bindings must have a binding and optional dataset.
+	if (!isRequiredProperty(value, "binding", "string")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (
+		!isOptionalProperty(value, "dataset", "string") ||
+		(value as { dataset: string }).dataset?.length === 0
+	) {
+		diagnostics.errors.push(
+			`"${field}" bindings should, optionally, have a string "dataset" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	return isValid;
+};
+
 const validateWorkerNamespaceBinding: ValidatorFn = (
 	diagnostics,
 	field,
@@ -1752,3 +2035,117 @@ const validateWorkerNamespaceBinding: ValidatorFn = (
 	}
 	return isValid;
 };
+
+function validateQueues(envName: string): ValidatorFn {
+	return (diagnostics, field, value, config) => {
+		const fieldPath =
+			config === undefined ? `${field}` : `env.${envName}.${field}`;
+
+		if (typeof value !== "object" || Array.isArray(value) || value === null) {
+			diagnostics.errors.push(
+				`The field "${fieldPath}" should be an object but got ${JSON.stringify(
+					value
+				)}.`
+			);
+			return false;
+		}
+
+		let isValid = true;
+		if (
+			!validateAdditionalProperties(
+				diagnostics,
+				fieldPath,
+				Object.keys(value),
+				["consumers", "producers"]
+			)
+		) {
+			isValid = false;
+		}
+
+		if (hasProperty(value, "consumers")) {
+			const consumers = value.consumers;
+			if (!Array.isArray(consumers)) {
+				diagnostics.errors.push(
+					`The field "${fieldPath}.consumers" should be an array but got ${JSON.stringify(
+						consumers
+					)}.`
+				);
+				isValid = false;
+			}
+
+			for (let i = 0; i < consumers.length; i++) {
+				const consumer = consumers[i];
+				const consumerPath = `${fieldPath}.consumers[${i}]`;
+				if (!validateConsumer(diagnostics, consumerPath, consumer, config)) {
+					isValid = false;
+				}
+			}
+		}
+
+		if (hasProperty(value, "producers")) {
+			if (
+				!validateBindingArray(envName, validateQueueBinding)(
+					diagnostics,
+					`${field}.producers`,
+					value.producers,
+					config
+				)
+			) {
+				isValid = false;
+			}
+		}
+		return isValid;
+	};
+}
+
+const validateConsumer: ValidatorFn = (diagnostics, field, value, _config) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`"${field}" should be a objects, but got ${JSON.stringify(value)}`
+		);
+		return false;
+	}
+
+	let isValid = true;
+	if (
+		!validateAdditionalProperties(diagnostics, field, Object.keys(value), [
+			"queue",
+			"max_batch_size",
+			"max_batch_timeout",
+			"max_retries",
+			"dead_letter_queue",
+		])
+	) {
+		isValid = false;
+	}
+
+	if (!isRequiredProperty(value, "queue", "string")) {
+		diagnostics.errors.push(
+			`"${field}" should have a string "queue" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+	}
+
+	const options: {
+		key: string;
+		type: "number" | "string";
+	}[] = [
+		{ key: "max_batch_size", type: "number" },
+		{ key: "max_batch_timeout", type: "number" },
+		{ key: "max_retries", type: "number" },
+		{ key: "dead_letter_queue", type: "string" },
+	];
+	for (const optionalOpt of options) {
+		if (!isOptionalProperty(value, optionalOpt.key, optionalOpt.type)) {
+			diagnostics.errors.push(
+				`"${field}" should, optionally, have a ${optionalOpt.type} "${
+					optionalOpt.key
+				}" field but got ${JSON.stringify(value)}.`
+			);
+			isValid = false;
+		}
+	}
+
+	return isValid;
+};

package/src/config-cache.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import * as path from "path";
 import { findUpSync } from "find-up";
+import { CI } from "./is-ci";
 import isInteractive from "./is-interactive";
 import { logger } from "./logger";
 
@@ -29,9 +30,9 @@ const arrayFormatter = new Intl.ListFormat("en", {
 });
 
 function showCacheMessage(fields: string[], folder: string) {
-	if (!cacheMessageShown && isInteractive()) {
+	if (!cacheMessageShown && isInteractive() && !CI.isCI()) {
 		if (fields.length > 0) {
-			logger.log(
+			logger.debug(
 				`Retrieving cached values for ${arrayFormatter.format(
 					fields
 				)} from ${path.relative(process.cwd(), folder)}`

package/src/create-worker-preview.ts

@@ -3,7 +3,10 @@ import { fetch } from "undici";
 import { fetchResult } from "./cfetch";
 import { createWorkerUploadForm } from "./create-worker-upload-form";
 import { logger } from "./logger";
+import { parseJSON } from "./parse";
+import { getAccessToken } from "./user/access";
 import type { CfAccount, CfWorkerContext, CfWorkerInit } from "./worker";
+import type { HeadersInit } from "undici";
 
 /**
  * A Preview Session on the edge
@@ -125,9 +128,26 @@ export async function createPreviewSession(
 		undefined,
 		abortSignal
 	);
-	const { inspector_websocket, prewarm, token } = (await (
-		await fetch(exchange_url, { signal: abortSignal })
-	).json()) as { inspector_websocket: string; token: string; prewarm: string };
+
+	logger.debug(`-- START EXCHANGE API REQUEST: GET ${exchange_url}`);
+	logger.debug("-- END EXCHANGE API REQUEST");
+	const exchangeResponse = await fetch(exchange_url, { signal: abortSignal });
+	const bodyText = await exchangeResponse.text();
+	logger.debug(
+		"-- START EXCHANGE API RESPONSE:",
+		exchangeResponse.statusText,
+		exchangeResponse.status
+	);
+	logger.debug("HEADERS:", JSON.stringify(exchangeResponse.headers, null, 2));
+	logger.debug("RESPONSE:", bodyText);
+	logger.debug("-- END EXCHANGE API RESPONSE");
+
+	const { inspector_websocket, prewarm, token } = parseJSON<{
+		inspector_websocket: string;
+		token: string;
+		prewarm: string;
+	}>(bodyText);
+
 	const { host } = new URL(inspector_websocket);
 	const query = `cf_workers_preview_token=${token}`;
 
@@ -233,13 +253,18 @@ export async function createWorkerPreview(
 		session,
 		abortSignal
 	);
+	const accessToken = await getAccessToken(token.prewarmUrl.hostname);
+
+	const headers: HeadersInit = { "cf-workers-preview-token": token.value };
+	if (accessToken) {
+		headers.cookie = `CF_Authorization=${accessToken}`;
+	}
+
 	// fire and forget the prewarm call
 	fetch(token.prewarmUrl.href, {
 		method: "POST",
 		signal: abortSignal,
-		headers: {
-			"cf-workers-preview-token": token.value,
-		},
+		headers,
 	}).then(
 		(response) => {
 			if (!response.ok) {