wrangler 0.0.0-e7a0cd5b → 0.0.0-e87ad068

package/src/config/index.ts

@@ -2,12 +2,12 @@ import fs from "node:fs";
 import dotenv from "dotenv";
 import { findUpSync } from "find-up";
 import { logger } from "../logger";
-import { parseTOML, readFileSync } from "../parse";
+import { parseJSONC, parseTOML, readFileSync } from "../parse";
 import { removeD1BetaPrefix } from "../worker";
 import { normalizeAndValidateConfig } from "./validation";
 import type { CfWorkerInit } from "../worker";
-import type { Config, RawConfig } from "./config";
-import type { CamelCaseKey } from "yargs";
+import type { CommonYargsOptions } from "../yargs-types";
+import type { Config, OnlyCamelCase, RawConfig } from "./config";
 
 export type {
 	Config,
@@ -25,18 +25,21 @@ export type {
 /**
  * Get the Wrangler configuration; read it from the give `configPath` if available.
  */
-export function readConfig(
+
+export function readConfig<CommandArgs>(
 	configPath: string | undefined,
-	args: unknown
+	// Include command specific args as well as the wrangler global flags
+	args: CommandArgs & OnlyCamelCase<CommonYargsOptions>
 ): Config {
 	let rawConfig: RawConfig = {};
 	if (!configPath) {
-		configPath = findWranglerToml();
+		configPath = findWranglerToml(process.cwd(), args.experimentalJsonConfig);
 	}
-
 	// Load the configuration from disk if available
-	if (configPath) {
+	if (configPath?.endsWith("toml")) {
 		rawConfig = parseTOML(readFileSync(configPath), configPath);
+	} else if (configPath?.endsWith("json")) {
+		rawConfig = parseJSONC(readFileSync(configPath), configPath);
 	}
 
 	// Process the top-level configuration.
@@ -61,10 +64,16 @@ export function readConfig(
  * from the current working directory.
  */
 export function findWranglerToml(
-	referencePath: string = process.cwd()
+	referencePath: string = process.cwd(),
+	preferJson = false
 ): string | undefined {
-	const configPath = findUpSync("wrangler.toml", { cwd: referencePath });
-	return configPath;
+	if (preferJson) {
+		return (
+			findUpSync(`wrangler.json`, { cwd: referencePath }) ??
+			findUpSync(`wrangler.toml`, { cwd: referencePath })
+		);
+	}
+	return findUpSync(`wrangler.toml`, { cwd: referencePath });
 }
 
 /**
@@ -88,17 +97,21 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		data_blobs,
 		durable_objects,
 		kv_namespaces,
+		send_email,
 		queues,
 		d1_databases,
+		constellation,
 		r2_buckets,
 		logfwdr,
 		services,
+		analytics_engine_datasets,
 		text_blobs,
+		browser,
 		unsafe,
 		vars,
-		metadata_binding,
 		wasm_modules,
 		dispatch_namespaces,
+		mtls_certificates,
 	} = bindings;
 
 	if (data_blobs !== undefined && Object.keys(data_blobs).length > 0) {
@@ -145,6 +158,23 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (send_email !== undefined && send_email.length > 0) {
+		output.push({
+			type: "Send Email",
+			entries: send_email.map(
+				({ name, destination_address, allowed_destination_addresses }) => {
+					return {
+						key: name,
+						value:
+							destination_address ||
+							allowed_destination_addresses?.join(", ") ||
+							"unrestricted",
+					};
+				}
+			),
+		});
+	}
+
 	if (queues !== undefined && queues.length > 0) {
 		output.push({
 			type: "Queues",
@@ -160,12 +190,32 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 	if (d1_databases !== undefined && d1_databases.length > 0) {
 		output.push({
 			type: "D1 Databases",
-			entries: d1_databases.map(({ binding, database_name, database_id }) => {
+			entries: d1_databases.map(
+				({ binding, database_name, database_id, preview_database_id }) => {
+					let databaseValue = `${database_id}`;
+					if (database_name) {
+						databaseValue = `${database_name} (${database_id})`;
+					}
+					//database_id is local when running `wrangler dev --local`
+					if (preview_database_id && database_id !== "local") {
+						databaseValue += `, Preview: (${preview_database_id})`;
+					}
+					return {
+						key: removeD1BetaPrefix(binding),
+						value: databaseValue,
+					};
+				}
+			),
+		});
+	}
+
+	if (constellation !== undefined && constellation.length > 0) {
+		output.push({
+			type: "Constellation Projects",
+			entries: constellation.map(({ binding, project_id }) => {
 				return {
-					key: removeD1BetaPrefix(binding),
-					value: database_name
-						? `${database_name} (${database_id})`
-						: database_id,
+					key: binding,
+					value: project_id,
 				};
 			}),
 		});
@@ -212,6 +262,21 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (
+		analytics_engine_datasets !== undefined &&
+		analytics_engine_datasets.length > 0
+	) {
+		output.push({
+			type: "Analytics Engine Datasets",
+			entries: analytics_engine_datasets.map(({ binding, dataset }) => {
+				return {
+					key: binding,
+					value: dataset ?? binding,
+				};
+			}),
+		});
+	}
+
 	if (text_blobs !== undefined && Object.keys(text_blobs).length > 0) {
 		output.push({
 			type: "Text Blobs",
@@ -222,10 +287,17 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
-	if (unsafe !== undefined && unsafe.length > 0) {
+	if (browser !== undefined) {
+		output.push({
+			type: "Browser",
+			entries: [{ key: "Name", value: browser.binding }],
+		});
+	}
+
+	if (unsafe?.bindings !== undefined && unsafe.bindings.length > 0) {
 		output.push({
 			type: "Unsafe",
-			entries: unsafe.map(({ name, type }) => ({
+			entries: unsafe.bindings.map(({ name, type }) => ({
 				key: type,
 				value: name,
 			})),
@@ -252,13 +324,6 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
-	if (metadata_binding !== undefined && metadata_binding.length > 0) {
-		output.push({
-			type: "Metadata Binding",
-			entries: [{ key: "metadata", value: metadata_binding }],
-		});
-	}
-
 	if (wasm_modules !== undefined && Object.keys(wasm_modules).length > 0) {
 		output.push({
 			type: "Wasm Modules",
@@ -281,6 +346,28 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (mtls_certificates !== undefined && mtls_certificates.length > 0) {
+		output.push({
+			type: "mTLS Certificates",
+			entries: mtls_certificates.map(({ binding, certificate_id }) => {
+				return {
+					key: binding,
+					value: certificate_id,
+				};
+			}),
+		});
+	}
+
+	if (unsafe?.metadata !== undefined) {
+		output.push({
+			type: "Unsafe Metadata",
+			entries: Object.entries(unsafe.metadata).map(([key, value]) => ({
+				key,
+				value: `${value}`,
+			})),
+		});
+	}
+
 	if (output.length === 0) {
 		return;
 	}
@@ -300,18 +387,13 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 	logger.log(message);
 }
 
-type CamelCase<T> = {
-	[key in keyof T as key | CamelCaseKey<key>]: T[key];
-};
-
-export function withConfig<T extends { config?: string }>(
+export function withConfig<T>(
 	handler: (
-		t: Omit<CamelCase<T>, "config"> & { config: Config }
+		t: OnlyCamelCase<T & CommonYargsOptions> & { config: Config }
 	) => Promise<void>
 ) {
-	return (t: CamelCase<T>) => {
-		const { config: configPath, ...rest } = t;
-		return handler({ ...rest, config: readConfig(configPath, rest) });
+	return (t: OnlyCamelCase<T & CommonYargsOptions>) => {
+		return handler({ ...t, config: readConfig(t.config, t) });
 	};
 }
 

package/src/config/validation-helpers.ts

@@ -550,7 +550,7 @@ export const getBindingNames = (value: unknown): string[] => {
 	} else if (isNamespaceList(value)) {
 		return value.map(({ binding }) => binding);
 	} else if (isRecord(value)) {
-		return Object.keys(value);
+		return Object.keys(value).filter((k) => value[k] !== undefined);
 	} else {
 		return [];
 	}