wrangler 0.0.0-ece06ea → 0.0.0-ecfbb0c

package/src/intl-polyfill.d.ts

@@ -0,0 +1,139 @@
+/**
+ * TODO Remove once https://github.com/microsoft/TypeScript/pull/47254 lands
+ */
+declare namespace Intl {
+	interface DateTimeFormatOptions {
+		formatMatcher?: "basic" | "best fit" | "best fit" | undefined;
+		dateStyle?: "full" | "long" | "medium" | "short" | undefined;
+		timeStyle?: "full" | "long" | "medium" | "short" | undefined;
+		dayPeriod?: "narrow" | "short" | "long" | undefined;
+		fractionalSecondDigits?: 0 | 1 | 2 | 3 | undefined;
+	}
+
+	interface ResolvedDateTimeFormatOptions {
+		formatMatcher?: "basic" | "best fit" | "best fit";
+		dateStyle?: "full" | "long" | "medium" | "short";
+		timeStyle?: "full" | "long" | "medium" | "short";
+		hourCycle?: "h11" | "h12" | "h23" | "h24";
+		dayPeriod?: "narrow" | "short" | "long";
+		fractionalSecondDigits?: 0 | 1 | 2 | 3;
+	}
+
+	interface NumberFormat {
+		formatRange(startDate: number | bigint, endDate: number | bigint): string;
+		formatRangeToParts(
+			startDate: number | bigint,
+			endDate: number | bigint
+		): NumberFormatPart[];
+	}
+
+	/**
+	 * The locale matching algorithm to use.
+	 *
+	 * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation).
+	 */
+	type ListFormatLocaleMatcher = "lookup" | "best fit";
+
+	/**
+	 * The format of output message.
+	 *
+	 * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters).
+	 */
+	type ListFormatType = "conjunction" | "disjunction" | "unit";
+
+	/**
+	 * The length of the formatted message.
+	 *
+	 * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters).
+	 */
+	type ListFormatStyle = "long" | "short" | "narrow";
+
+	/**
+	 * An object with some or all properties of the `Intl.ListFormat` constructor `options` parameter.
+	 *
+	 * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters).
+	 */
+	interface ListFormatOptions {
+		/** The locale matching algorithm to use. For information about this option, see [Intl page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation). */
+		localeMatcher?: ListFormatLocaleMatcher;
+		/** The format of output message. */
+		type?: ListFormatType;
+		/** The length of the internationalized message. */
+		style?: ListFormatStyle;
+	}
+
+	interface ListFormat {
+		/**
+		 * Returns a string with a language-specific representation of the list.
+		 *
+		 * @param list - An iterable object, such as an [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array).
+		 *
+		 * @throws `TypeError` if `list` includes something other than the possible values.
+		 *
+		 * @returns {string} A language-specific formatted string representing the elements of the list.
+		 *
+		 * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/format).
+		 */
+		format(list: Iterable<string>): string;
+
+		/**
+		 * Returns an Array of objects representing the different components that can be used to format a list of values in a locale-aware fashion.
+		 *
+		 * @param list - An iterable object, such as an [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array), to be formatted according to a locale.
+		 *
+		 * @throws `TypeError` if `list` includes something other than the possible values.
+		 *
+		 * @returns {{ type: "element" | "literal", value: string; }[]} An Array of components which contains the formatted parts from the list.
+		 *
+		 * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/formatToParts).
+		 */
+		formatToParts(
+			list: Iterable<string>
+		): { type: "element" | "literal"; value: string }[];
+	}
+
+	const ListFormat: {
+		prototype: ListFormat;
+
+		/**
+		 * Creates [Intl.ListFormat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) objects that
+		 * enable language-sensitive list formatting.
+		 *
+		 * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings.
+		 *  For the general form and interpretation of the `locales` argument,
+		 *  see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation).
+		 *
+		 * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters)
+		 *  with some or all options of `ListFormatOptions`.
+		 *
+		 * @returns [Intl.ListFormatOptions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) object.
+		 *
+		 * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat).
+		 */
+		new (
+			locales?: BCP47LanguageTag | BCP47LanguageTag[],
+			options?: ListFormatOptions
+		): ListFormat;
+
+		/**
+		 * Returns an array containing those of the provided locales that are
+		 * supported in list formatting without having to fall back to the runtime's default locale.
+		 *
+		 * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings.
+		 *  For the general form and interpretation of the `locales` argument,
+		 *  see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation).
+		 *
+		 * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/supportedLocalesOf#parameters).
+		 *  with some or all possible options.
+		 *
+		 * @returns An array of strings representing a subset of the given locale tags that are supported in list
+		 *  formatting without having to fall back to the runtime's default locale.
+		 *
+		 * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/supportedLocalesOf).
+		 */
+		supportedLocalesOf(
+			locales: BCP47LanguageTag | BCP47LanguageTag[],
+			options?: Pick<ListFormatOptions, "localeMatcher">
+		): BCP47LanguageTag[];
+	};
+}

package/src/kv.ts

@@ -0,0 +1,408 @@
+import { URLSearchParams } from "node:url";
+import { fetchListResult, fetchResult, fetchKVGetValue } from "./cfetch";
+import { logger } from "./logger";
+import type { Config } from "./config";
+
+/** The largest number of kv items we can pass to the API in a single request. */
+const API_MAX = 10000;
+// The const below are halved from the API's true capacity to help avoid
+// hammering it with large requests.
+const BATCH_KEY_MAX = API_MAX / 2;
+
+type KvArgs = {
+	binding?: string;
+	"namespace-id"?: string;
+	preview?: boolean;
+};
+
+/**
+ * Create a new namespace under the given `accountId` with the given `title`.
+ *
+ * @returns the generated id of the created namespace.
+ */
+export async function createKVNamespace(
+	accountId: string,
+	title: string
+): Promise<string> {
+	const response = await fetchResult<{ id: string }>(
+		`/accounts/${accountId}/storage/kv/namespaces`,
+		{
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({
+				title,
+			}),
+		}
+	);
+
+	return response.id;
+}
+
+/**
+ * The information about a namespace that is returned from `listNamespaces()`.
+ */
+export interface KVNamespaceInfo {
+	id: string;
+	title: string;
+	supports_url_encoding?: boolean;
+}
+
+/**
+ * Fetch a list of all the namespaces under the given `accountId`.
+ */
+export async function listKVNamespaces(
+	accountId: string
+): Promise<KVNamespaceInfo[]> {
+	const pageSize = 100;
+	let page = 1;
+	const results: KVNamespaceInfo[] = [];
+	while (results.length % pageSize === 0) {
+		const json = await fetchResult<KVNamespaceInfo[]>(
+			`/accounts/${accountId}/storage/kv/namespaces`,
+			{},
+			new URLSearchParams({
+				per_page: pageSize.toString(),
+				order: "title",
+				direction: "asc",
+				page: page.toString(),
+			})
+		);
+		page++;
+		results.push(...json);
+		if (json.length < pageSize) {
+			break;
+		}
+	}
+	return results;
+}
+
+export interface NamespaceKeyInfo {
+	name: string;
+	expiration?: number;
+	metadata?: { [key: string]: unknown };
+}
+
+export async function listKVNamespaceKeys(
+	accountId: string,
+	namespaceId: string,
+	prefix = ""
+) {
+	return await fetchListResult<NamespaceKeyInfo>(
+		`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/keys`,
+		{},
+		new URLSearchParams({ prefix })
+	);
+}
+
+export async function deleteKVNamespace(
+	accountId: string,
+	namespaceId: string
+) {
+	return await fetchResult<{ id: string }>(
+		`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}`,
+		{ method: "DELETE" }
+	);
+}
+
+/**
+ * Information about a key-value pair, including its "metadata" fields.
+ */
+export interface KeyValue {
+	key: string;
+	value: string | Buffer;
+	expiration?: number;
+	expiration_ttl?: number;
+	metadata?: object;
+	base64?: boolean;
+}
+
+const KeyValueKeys = new Set([
+	"key",
+	"value",
+	"expiration",
+	"expiration_ttl",
+	"metadata",
+	"base64",
+]);
+
+/**
+ * The object has the specified property.
+ */
+function hasProperty<T extends object>(
+	obj: object,
+	property: keyof T
+): obj is T {
+	return property in obj;
+}
+
+/**
+ * The object has a required property of the specified type.
+ */
+function hasTypedProperty<T extends object>(
+	obj: object,
+	property: keyof T,
+	type: string
+): obj is T {
+	return hasProperty(obj, property) && typeof obj[property] === type;
+}
+
+/**
+ * The object an optional property, of the specified type.
+ */
+function hasOptionalTypedProperty<T extends object>(
+	obj: object,
+	property: keyof T,
+	type: string
+): obj is Omit<T, typeof property> | T {
+	return !hasProperty(obj, property) || typeof obj[property] === type;
+}
+
+/**
+ * Is the given object a valid `KeyValue` type?
+ */
+export function isKVKeyValue(keyValue: unknown): keyValue is KeyValue {
+	if (
+		keyValue === null ||
+		typeof keyValue !== "object" ||
+		!hasTypedProperty(keyValue, "key", "string") ||
+		!hasTypedProperty(keyValue, "value", "string") ||
+		!hasOptionalTypedProperty(keyValue, "expiration", "number") ||
+		!hasOptionalTypedProperty(keyValue, "expiration_ttl", "number") ||
+		!hasOptionalTypedProperty(keyValue, "base64", "boolean") ||
+		!hasOptionalTypedProperty(keyValue, "metadata", "object")
+	) {
+		return false;
+	}
+	return true;
+}
+
+/**
+ * Get all the properties on the `keyValue` that are not expected.
+ */
+export function unexpectedKVKeyValueProps(keyValue: KeyValue): string[] {
+	const props = Object.keys(keyValue);
+	return props.filter((prop) => !KeyValueKeys.has(prop));
+}
+
+export async function putKVKeyValue(
+	accountId: string,
+	namespaceId: string,
+	keyValue: KeyValue
+) {
+	let searchParams: URLSearchParams | undefined;
+	if (keyValue.expiration || keyValue.expiration_ttl) {
+		searchParams = new URLSearchParams();
+		if (keyValue.expiration) {
+			searchParams.set("expiration", `${keyValue.expiration}`);
+		}
+		if (keyValue.expiration_ttl) {
+			searchParams.set("expiration_ttl", `${keyValue.expiration_ttl}`);
+		}
+	}
+	return await fetchResult(
+		`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${encodeURIComponent(
+			keyValue.key
+		)}`,
+		{ method: "PUT", body: keyValue.value },
+		searchParams
+	);
+}
+
+export async function getKVKeyValue(
+	accountId: string,
+	namespaceId: string,
+	key: string
+): Promise<ArrayBuffer> {
+	return await fetchKVGetValue(accountId, namespaceId, encodeURIComponent(key));
+}
+
+export async function deleteKVKeyValue(
+	accountId: string,
+	namespaceId: string,
+	key: string
+) {
+	return await fetchResult(
+		`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${encodeURIComponent(
+			key
+		)}`,
+		{ method: "DELETE" }
+	);
+}
+
+/**
+ * Formatter for converting e.g. 5328 --> 5,328
+ */
+const formatNumber = new Intl.NumberFormat("en-US", {
+	notation: "standard",
+}).format;
+
+/**
+ * Helper function for bulk requests, logs ongoing output to console.
+ */
+function logBulkProgress(
+	operation: "put" | "delete",
+	index: number,
+	total: number
+) {
+	logger.log(
+		`${operation === "put" ? "Uploaded" : "Deleted"} ${Math.floor(
+			(100 * index) / total
+		)}% (${formatNumber(index)} out of ${formatNumber(total)})`
+	);
+}
+
+export async function putKVBulkKeyValue(
+	accountId: string,
+	namespaceId: string,
+	keyValues: KeyValue[],
+	quiet = false
+) {
+	for (let index = 0; index < keyValues.length; index += BATCH_KEY_MAX) {
+		if (!quiet && keyValues.length > BATCH_KEY_MAX) {
+			logBulkProgress("put", index, keyValues.length);
+		}
+
+		await fetchResult(
+			`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
+			{
+				method: "PUT",
+				body: JSON.stringify(keyValues.slice(index, index + BATCH_KEY_MAX)),
+				headers: { "Content-Type": "application/json" },
+			}
+		);
+	}
+
+	if (!quiet && keyValues.length > BATCH_KEY_MAX) {
+		logBulkProgress("put", keyValues.length, keyValues.length);
+	}
+}
+
+export async function deleteKVBulkKeyValue(
+	accountId: string,
+	namespaceId: string,
+	keys: string[],
+	quiet = false
+) {
+	for (let index = 0; index < keys.length; index += BATCH_KEY_MAX) {
+		if (!quiet && keys.length > BATCH_KEY_MAX) {
+			logBulkProgress("delete", index, keys.length);
+		}
+
+		await fetchResult(
+			`/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
+			{
+				method: "DELETE",
+				body: JSON.stringify(keys.slice(index, index + BATCH_KEY_MAX)),
+				headers: { "Content-Type": "application/json" },
+			}
+		);
+	}
+	if (!quiet && keys.length > BATCH_KEY_MAX) {
+		logBulkProgress("delete", keys.length, keys.length);
+	}
+}
+
+export function getKVNamespaceId(
+	{ preview, binding, "namespace-id": namespaceId }: KvArgs,
+	config: Config
+): string {
+	// nice
+	if (namespaceId) {
+		return namespaceId;
+	}
+
+	// begin pre-flight checks
+
+	// `--binding` is only valid if there's a wrangler configuration.
+	if (binding && !config) {
+		throw new Error("--binding specified, but no config file was found.");
+	}
+
+	// there's no config. abort here
+	if (!config) {
+		throw new Error(
+			"Failed to find a config file.\n" +
+				"Either use --namespace-id to upload directly or create a configuration file with a binding."
+		);
+	}
+
+	// there's no KV namespaces
+	if (!config.kv_namespaces || config.kv_namespaces.length === 0) {
+		throw new Error(
+			"No KV Namespaces configured! Either use --namespace-id to upload directly or add a KV namespace to your wrangler config file."
+		);
+	}
+
+	const namespace = config.kv_namespaces.find((ns) => ns.binding === binding);
+
+	// we couldn't find a namespace with that binding
+	if (!namespace) {
+		throw new Error(
+			`A namespace with binding name "${binding}" was not found in the configured "kv_namespaces".`
+		);
+	}
+
+	// end pre-flight checks
+
+	// we're in preview mode, `--preview true` or `--preview` was passed
+	if (preview && namespace.preview_id) {
+		namespaceId = namespace.preview_id;
+		// We don't want to execute code below if preview is set to true, so we just return. Otherwise we will get errors!
+		return namespaceId;
+	} else if (preview) {
+		throw new Error(
+			`No preview ID found for ${binding}. Add one to your wrangler config file to use a separate namespace for previewing your worker.`
+		);
+	}
+
+	// either `--preview false`, or preview wasn't passed
+	// TODO: should we care? or should we just treat false and undefined the same
+	const previewIsDefined = typeof preview !== "undefined";
+
+	// --preview false was passed
+	if (previewIsDefined && namespace.id) {
+		namespaceId = namespace.id;
+		// We don't want to execute code below if preview is set to true, so we just return. Otherwise we can get error!
+		return namespaceId;
+	} else if (previewIsDefined) {
+		throw new Error(
+			`No namespace ID found for ${binding}. Add one to your wrangler config file to use a separate namespace for previewing your worker.`
+		);
+	}
+
+	// `--preview` wasn't passed
+	const bindingHasOnlyOneId =
+		(namespace.id && !namespace.preview_id) ||
+		(!namespace.id && namespace.preview_id);
+	if (bindingHasOnlyOneId) {
+		namespaceId = namespace.id || namespace.preview_id;
+	} else {
+		throw new Error(
+			`${binding} has both a namespace ID and a preview ID. Specify "--preview" or "--preview false" to avoid writing data to the wrong namespace.`
+		);
+	}
+
+	// shouldn't happen. we should be able to prove this with strong typing.
+	// TODO: when we add strongly typed commands, rewrite these checks so they're exhaustive
+	if (!namespaceId) {
+		throw Error(
+			"Something went wrong trying to determine which namespace to upload to.\n" +
+				"Please create a github issue with the command you just ran along with your wrangler configuration."
+		);
+	}
+
+	return namespaceId;
+}
+
+/**
+ * KV namespace binding names must be valid JS identifiers.
+ */
+export function isValidKVNamespaceBinding(
+	binding: string | undefined
+): binding is string {
+	return (
+		typeof binding === "string" && /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(binding)
+	);
+}

package/src/logger.ts

@@ -0,0 +1,73 @@
+import { format } from "node:util";
+import { formatMessagesSync } from "esbuild";
+import { getEnvironmentVariableFactory } from "./environment-variables";
+
+const LOGGER_LEVELS = {
+	error: 0,
+	warn: 1,
+	log: 2,
+	debug: 3,
+} as const;
+
+type LoggerLevel = keyof typeof LOGGER_LEVELS;
+
+/** A map from LOGGER_LEVEL to the error `kind` needed by `formatMessagesSync()`. */
+const LOGGER_LEVEL_FORMAT_TYPE_MAP = {
+	error: "error",
+	warn: "warning",
+	log: undefined,
+	debug: undefined,
+} as const;
+
+const getLogLevelFromEnv = getEnvironmentVariableFactory({
+	variableName: "WRANGLER_LOG",
+	defaultValue: "log",
+});
+
+class Logger {
+	constructor() {}
+
+	loggerLevel: LoggerLevel = (getLogLevelFromEnv() as LoggerLevel) ?? "log";
+	columns = process.stdout.columns;
+
+	debug = (...args: unknown[]) => this.doLog("debug", args);
+	log = (...args: unknown[]) => this.doLog("log", args);
+	warn = (...args: unknown[]) => this.doLog("warn", args);
+	error = (...args: unknown[]) => this.doLog("error", args);
+
+	private doLog(messageLevel: LoggerLevel, args: unknown[]) {
+		if (LOGGER_LEVELS[this.loggerLevel] >= LOGGER_LEVELS[messageLevel]) {
+			console[messageLevel](this.formatMessage(messageLevel, format(...args)));
+		}
+	}
+
+	private formatMessage(level: LoggerLevel, message: string): string {
+		const kind = LOGGER_LEVEL_FORMAT_TYPE_MAP[level];
+		if (kind) {
+			// Format the message using the esbuild formatter.
+			// The first line of the message is the main `text`,
+			// subsequent lines are put into the `notes`.
+			const [firstLine, ...otherLines] = message.split("\n");
+			const notes =
+				otherLines.length > 0
+					? otherLines.map((text) => ({ text }))
+					: undefined;
+			return formatMessagesSync([{ text: firstLine, notes }], {
+				color: true,
+				kind,
+				terminalWidth: this.columns,
+			})[0];
+		} else {
+			return message;
+		}
+	}
+}
+
+/**
+ * A drop-in replacement for `console` for outputting logging messages.
+ *
+ * Errors and Warnings will get additional formatting to highlight them to the user.
+ * You can also set a `logger.loggerLevel` value to one of "debug", "log", "warn" or "error",
+ * to filter out logging messages.
+ */
+export const logger = new Logger();

package/src/miniflare-cli/README.md

@@ -0,0 +1,30 @@
+# Custom Miniflare CLI
+
+This directory contains a simple wrapper around the programmatic Miniflare API,
+which Wrangler spawns when running `wrangler dev` in local mode.
+
+## Building
+
+This CLI is built at the same time as Wrangler by running
+
+```
+npm run -w wrangler build
+```
+
+The output of the build is `miniflare-dist/index.mjs`.
+
+## Running
+
+The CLI expects a single command line argument which is the Miniflare options formatted as a string of JSON.
+
+```bash
+node --no-warnings ./packages/wrangler/miniflare-dist/index.mjs '{"watch": true, "script": ""}' --log VERBOSE
+```
+
+The `--log` argument is optional and takes one of Miniflare's LogLevels: "NONE", "ERROR", "WARN", "INFO", "DEBUG", "VERBOSE".
+It defaults to `INFO`.
+
+## Debugging
+
+Simply place a breakpoint in the code and run the above command in the VS Code "JavaScript Debug Terminal".
+The code will stop at the breakpoint as expected.

package/src/miniflare-cli/enum-keys.ts

@@ -0,0 +1,17 @@
+export type EnumKeys<Enum> = Exclude<keyof Enum, number>;
+
+export const enumObject = <Enum extends Record<string, number | string>>(
+	e: Enum
+) => {
+	const copy = { ...e } as { [K in EnumKeys<Enum>]: Enum[K] };
+	Object.values(e).forEach(
+		(value) => typeof value === "number" && delete copy[value]
+	);
+	return copy;
+};
+
+export const enumKeys = <Enum extends Record<string, number | string>>(
+	e: Enum
+) => {
+	return Object.keys(enumObject(e)) as EnumKeys<Enum>[];
+};