wrangler 0.0.0-e5a3814 → 0.0.0-e60dc909

package/src/config/index.ts

@@ -1,55 +1,59 @@
+import fs from "node:fs";
+import dotenv from "dotenv";
 import { findUpSync } from "find-up";
 import { logger } from "../logger";
 import { 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";
 
 export type {
-  Config,
-  RawConfig,
-  ConfigFields,
-  DevConfig,
-  RawDevConfig,
+	Config,
+	RawConfig,
+	ConfigFields,
+	DevConfig,
+	RawDevConfig,
 } from "./config";
 export type {
-  Environment,
-  RawEnvironment,
-  ConfigModuleRuleType,
+	Environment,
+	RawEnvironment,
+	ConfigModuleRuleType,
 } from "./environment";
 
 /**
  * Get the Wrangler configuration; read it from the give `configPath` if available.
  */
 export function readConfig(
-  configPath: string | undefined,
-  args: unknown
+	configPath: string | undefined,
+	args: unknown
 ): Config {
-  let rawConfig: RawConfig = {};
-  if (!configPath) {
-    configPath = findWranglerToml();
-  }
-
-  // Load the configuration from disk if available
-  if (configPath) {
-    rawConfig = parseTOML(readFileSync(configPath), configPath);
-  }
-
-  // Process the top-level configuration.
-  const { config, diagnostics } = normalizeAndValidateConfig(
-    rawConfig,
-    configPath,
-    args
-  );
-
-  if (diagnostics.hasWarnings()) {
-    logger.warn(diagnostics.renderWarnings());
-  }
-  if (diagnostics.hasErrors()) {
-    throw new Error(diagnostics.renderErrors());
-  }
-
-  return config;
+	let rawConfig: RawConfig = {};
+	if (!configPath) {
+		configPath = findWranglerToml();
+	}
+
+	// Load the configuration from disk if available
+	if (configPath) {
+		rawConfig = parseTOML(readFileSync(configPath), configPath);
+	}
+
+	// Process the top-level configuration.
+	const { config, diagnostics } = normalizeAndValidateConfig(
+		rawConfig,
+		configPath,
+		args
+	);
+
+	if (diagnostics.hasWarnings()) {
+		logger.warn(diagnostics.renderWarnings());
+	}
+	if (diagnostics.hasErrors()) {
+		throw new Error(diagnostics.renderErrors());
+	}
+
+	return config;
 }
 
 /**
@@ -57,169 +61,298 @@ export function readConfig(
  * from the current working directory.
  */
 export function findWranglerToml(
-  referencePath: string = process.cwd()
+	referencePath: string = process.cwd()
 ): string | undefined {
-  const configPath = findUpSync("wrangler.toml", { cwd: referencePath });
-  return configPath;
+	const configPath = findUpSync("wrangler.toml", { cwd: referencePath });
+	return configPath;
 }
 
 /**
  * Print all the bindings a worker using a given config would have access to
  */
 export function printBindings(bindings: CfWorkerInit["bindings"]) {
-  const truncate = (item: string | Record<string, unknown>) => {
-    const s = typeof item === "string" ? item : JSON.stringify(item);
-    const maxLength = 40;
-    if (s.length < maxLength) {
-      return s;
-    }
-
-    return `${s.substring(0, maxLength - 3)}...`;
-  };
-
-  const output: { type: string; entries: { key: string; value: string }[] }[] =
-    [];
-
-  const {
-    data_blobs,
-    durable_objects,
-    kv_namespaces,
-    r2_buckets,
-    services,
-    text_blobs,
-    unsafe,
-    vars,
-    wasm_modules,
-  } = bindings;
-
-  if (data_blobs !== undefined && Object.keys(data_blobs).length > 0) {
-    output.push({
-      type: "Data Blobs",
-      entries: Object.entries(data_blobs).map(([key, value]) => ({
-        key,
-        value: truncate(value),
-      })),
-    });
-  }
-
-  if (durable_objects !== undefined && durable_objects.bindings.length > 0) {
-    output.push({
-      type: "Durable Objects",
-      entries: durable_objects.bindings.map(
-        ({ name, class_name, script_name, environment }) => {
-          let value = class_name;
-          if (script_name) {
-            value += ` (defined in ${script_name})`;
-          }
-          if (environment) {
-            value += ` - ${environment}`;
-          }
-
-          return {
-            key: name,
-            value,
-          };
-        }
-      ),
-    });
-  }
-
-  if (kv_namespaces !== undefined && kv_namespaces.length > 0) {
-    output.push({
-      type: "KV Namespaces",
-      entries: kv_namespaces.map(({ binding, id }) => {
-        return {
-          key: binding,
-          value: id,
-        };
-      }),
-    });
-  }
-
-  if (r2_buckets !== undefined && r2_buckets.length > 0) {
-    output.push({
-      type: "R2 Buckets",
-      entries: r2_buckets.map(({ binding, bucket_name }) => {
-        return {
-          key: binding,
-          value: bucket_name,
-        };
-      }),
-    });
-  }
-
-  if (services !== undefined && services.length > 0) {
-    output.push({
-      type: "Services",
-      entries: services.map(({ binding, service, environment }) => {
-        let value = service;
-        if (environment) {
-          value += ` - ${environment}`;
-        }
-
-        return {
-          key: binding,
-          value,
-        };
-      }),
-    });
-  }
-
-  if (text_blobs !== undefined && Object.keys(text_blobs).length > 0) {
-    output.push({
-      type: "Text Blobs",
-      entries: Object.entries(text_blobs).map(([key, value]) => ({
-        key,
-        value: truncate(value),
-      })),
-    });
-  }
-
-  if (unsafe !== undefined && unsafe.length > 0) {
-    output.push({
-      type: "Unsafe",
-      entries: unsafe.map(({ name, type }) => ({
-        key: type,
-        value: name,
-      })),
-    });
-  }
-
-  if (vars !== undefined && Object.keys(vars).length > 0) {
-    output.push({
-      type: "Vars",
-      entries: Object.entries(vars).map(([key, value]) => ({
-        key,
-        value: `"${truncate(`${value}`)}"`,
-      })),
-    });
-  }
-
-  if (wasm_modules !== undefined && Object.keys(wasm_modules).length > 0) {
-    output.push({
-      type: "Wasm Modules",
-      entries: Object.entries(wasm_modules).map(([key, value]) => ({
-        key,
-        value: truncate(value),
-      })),
-    });
-  }
-
-  if (output.length === 0) {
-    return;
-  }
-
-  const message = [
-    `Your worker has access to the following bindings:`,
-    ...output
-      .map((bindingGroup) => {
-        return [
-          `- ${bindingGroup.type}:`,
-          bindingGroup.entries.map(({ key, value }) => `  - ${key}: ${value}`),
-        ];
-      })
-      .flat(2),
-  ].join("\n");
-
-  logger.log(message);
+	const truncate = (item: string | Record<string, unknown>) => {
+		const s = typeof item === "string" ? item : JSON.stringify(item);
+		const maxLength = 40;
+		if (s.length < maxLength) {
+			return s;
+		}
+
+		return `${s.substring(0, maxLength - 3)}...`;
+	};
+
+	const output: { type: string; entries: { key: string; value: string }[] }[] =
+		[];
+
+	const {
+		data_blobs,
+		durable_objects,
+		kv_namespaces,
+		queues,
+		d1_databases,
+		r2_buckets,
+		logfwdr,
+		services,
+		analytics_engine_datasets,
+		text_blobs,
+		unsafe,
+		vars,
+		wasm_modules,
+		dispatch_namespaces,
+	} = bindings;
+
+	if (data_blobs !== undefined && Object.keys(data_blobs).length > 0) {
+		output.push({
+			type: "Data Blobs",
+			entries: Object.entries(data_blobs).map(([key, value]) => ({
+				key,
+				value: truncate(value),
+			})),
+		});
+	}
+
+	if (durable_objects !== undefined && durable_objects.bindings.length > 0) {
+		output.push({
+			type: "Durable Objects",
+			entries: durable_objects.bindings.map(
+				({ name, class_name, script_name, environment }) => {
+					let value = class_name;
+					if (script_name) {
+						value += ` (defined in ${script_name})`;
+					}
+					if (environment) {
+						value += ` - ${environment}`;
+					}
+
+					return {
+						key: name,
+						value,
+					};
+				}
+			),
+		});
+	}
+
+	if (kv_namespaces !== undefined && kv_namespaces.length > 0) {
+		output.push({
+			type: "KV Namespaces",
+			entries: kv_namespaces.map(({ binding, id }) => {
+				return {
+					key: binding,
+					value: id,
+				};
+			}),
+		});
+	}
+
+	if (queues !== undefined && queues.length > 0) {
+		output.push({
+			type: "Queues",
+			entries: queues.map(({ binding, queue_name }) => {
+				return {
+					key: binding,
+					value: queue_name,
+				};
+			}),
+		});
+	}
+
+	if (d1_databases !== undefined && d1_databases.length > 0) {
+		output.push({
+			type: "D1 Databases",
+			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 (r2_buckets !== undefined && r2_buckets.length > 0) {
+		output.push({
+			type: "R2 Buckets",
+			entries: r2_buckets.map(({ binding, bucket_name }) => {
+				return {
+					key: binding,
+					value: bucket_name,
+				};
+			}),
+		});
+	}
+
+	if (logfwdr !== undefined && logfwdr.bindings.length > 0) {
+		output.push({
+			type: "logfwdr",
+			entries: logfwdr.bindings.map((binding) => {
+				return {
+					key: binding.name,
+					value: binding.destination,
+				};
+			}),
+		});
+	}
+
+	if (services !== undefined && services.length > 0) {
+		output.push({
+			type: "Services",
+			entries: services.map(({ binding, service, environment }) => {
+				let value = service;
+				if (environment) {
+					value += ` - ${environment}`;
+				}
+
+				return {
+					key: binding,
+					value,
+				};
+			}),
+		});
+	}
+
+	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",
+			entries: Object.entries(text_blobs).map(([key, value]) => ({
+				key,
+				value: truncate(value),
+			})),
+		});
+	}
+
+	if (unsafe !== undefined && unsafe.length > 0) {
+		output.push({
+			type: "Unsafe",
+			entries: unsafe.map(({ name, type }) => ({
+				key: type,
+				value: name,
+			})),
+		});
+	}
+
+	if (vars !== undefined && Object.keys(vars).length > 0) {
+		output.push({
+			type: "Vars",
+			entries: Object.entries(vars).map(([key, value]) => {
+				let parsedValue;
+				if (typeof value === "string") {
+					parsedValue = `"${truncate(value)}"`;
+				} else if (typeof value === "object") {
+					parsedValue = JSON.stringify(value, null, 1);
+				} else {
+					parsedValue = `${truncate(`${value}`)}`;
+				}
+				return {
+					key,
+					value: parsedValue,
+				};
+			}),
+		});
+	}
+
+	if (wasm_modules !== undefined && Object.keys(wasm_modules).length > 0) {
+		output.push({
+			type: "Wasm Modules",
+			entries: Object.entries(wasm_modules).map(([key, value]) => ({
+				key,
+				value: truncate(value),
+			})),
+		});
+	}
+
+	if (dispatch_namespaces !== undefined && dispatch_namespaces.length > 0) {
+		output.push({
+			type: "dispatch namespaces",
+			entries: dispatch_namespaces.map(({ binding, namespace }) => {
+				return {
+					key: binding,
+					value: namespace,
+				};
+			}),
+		});
+	}
+
+	if (output.length === 0) {
+		return;
+	}
+
+	const message = [
+		`Your worker has access to the following bindings:`,
+		...output
+			.map((bindingGroup) => {
+				return [
+					`- ${bindingGroup.type}:`,
+					bindingGroup.entries.map(({ key, value }) => `  - ${key}: ${value}`),
+				];
+			})
+			.flat(2),
+	].join("\n");
+
+	logger.log(message);
+}
+
+type CamelCase<T> = {
+	[key in keyof T as key | CamelCaseKey<key>]: T[key];
+};
+
+export function withConfig<T extends { config?: string }>(
+	handler: (
+		t: Omit<CamelCase<T>, "config"> & { config: Config }
+	) => Promise<void>
+) {
+	return (t: CamelCase<T>) => {
+		const { config: configPath, ...rest } = t;
+		return handler({ ...rest, config: readConfig(configPath, rest) });
+	};
+}
+
+export interface DotEnv {
+	path: string;
+	parsed: dotenv.DotenvParseOutput;
+}
+
+function tryLoadDotEnv(path: string): DotEnv | undefined {
+	try {
+		const parsed = dotenv.parse(fs.readFileSync(path));
+		return { path, parsed };
+	} catch (e) {
+		logger.debug(`Failed to load .env file "${path}":`, e);
+	}
+}
+
+/**
+ * Loads a dotenv file from <path>, preferring to read <path>.<environment> if
+ * <environment> is defined and that file exists.
+ */
+export function loadDotEnv(path: string, env?: string): DotEnv | undefined {
+	if (env === undefined) {
+		return tryLoadDotEnv(path);
+	} else {
+		return tryLoadDotEnv(`${path}.${env}`) ?? tryLoadDotEnv(path);
+	}
 }