wrangler 2.1.6 → 2.1.8

package/src/index.tsx

@@ -7,33 +7,34 @@ import TOML from "@iarna/toml";
 import chalk from "chalk";
 import onExit from "signal-exit";
 import supportsColor from "supports-color";
-import { setGlobalDispatcher, ProxyAgent } from "undici";
+import { ProxyAgent, setGlobalDispatcher } from "undici";
 import makeCLI from "yargs";
 import { version as wranglerVersion } from "../package.json";
 import { fetchResult } from "./cfetch";
 import { findWranglerToml, readConfig } from "./config";
 import { createWorkerUploadForm } from "./create-worker-upload-form";
+import { d1api } from "./d1";
 import { devHandler, devOptions } from "./dev";
 import { confirm, prompt } from "./dialogs";
 import { workerNamespaceCommands } from "./dispatch-namespace";
 import { getEntry } from "./entry";
 import { DeprecationError } from "./errors";
 import { generateHandler, generateOptions } from "./generate";
-import { initOptions, initHandler } from "./init";
+import { initHandler, initOptions } from "./init";
 import {
-	getKVNamespaceId,
-	listKVNamespaces,
-	listKVNamespaceKeys,
-	putKVKeyValue,
-	putKVBulkKeyValue,
-	deleteKVBulkKeyValue,
 	createKVNamespace,
-	isValidKVNamespaceBinding,
+	deleteKVBulkKeyValue,
+	deleteKVKeyValue,
+	deleteKVNamespace,
 	getKVKeyValue,
+	getKVNamespaceId,
 	isKVKeyValue,
+	isValidKVNamespaceBinding,
+	listKVNamespaceKeys,
+	listKVNamespaces,
+	putKVBulkKeyValue,
+	putKVKeyValue,
 	unexpectedKVKeyValueProps,
-	deleteKVNamespace,
-	deleteKVKeyValue,
 } from "./kv";
 import { logger } from "./logger";
 import * as metrics from "./metrics";
@@ -66,11 +67,11 @@ import {
 } from "./tail";
 import { updateCheck } from "./update-check";
 import {
+	listScopes,
 	login,
 	logout,
-	listScopes,
-	validateScopeKeys,
 	requireAuth,
+	validateScopeKeys,
 } from "./user";
 import { whoami } from "./whoami";
 
@@ -80,7 +81,6 @@ import type { KeyValue } from "./kv";
 import type { TailCLIFilters } from "./tail";
 import type { Readable } from "node:stream";
 import type { RawData } from "ws";
-import type { CommandModule } from "yargs";
 import type Yargs from "yargs";
 
 export type ConfigPath = string | undefined;
@@ -262,7 +262,7 @@ function createCLIParser(argv: string[]) {
 		.wrap(null);
 
 	// Default help command that supports the subcommands
-	const subHelp: CommandModule = {
+	const subHelp: Yargs.CommandModule = {
 		command: ["*"],
 		handler: async (args) => {
 			setImmediate(() =>
@@ -578,7 +578,6 @@ function createCLIParser(argv: string[]) {
 					"The --assets argument is experimental and may change or break at any time"
 				);
 			}
-
 			if (args.latest) {
 				logger.warn(
 					"Using the latest version of the Workers runtime. To silence this warning, please choose a specific version of the runtime with --compatibility-date, or add a compatibility_date to your wrangler.toml.\n"
@@ -1015,6 +1014,7 @@ function createCLIParser(argv: string[]) {
 											vars: {},
 											durable_objects: { bindings: [] },
 											r2_buckets: [],
+											d1_databases: [],
 											services: [],
 											wasm_modules: {},
 											text_blobs: {},
@@ -2182,6 +2182,8 @@ function createCLIParser(argv: string[]) {
 		}
 	);
 
+	wrangler.command("d1", "🗄  Interact with a D1 database", d1api);
+
 	wrangler.command(
 		"pubsub",
 		"📮 Interact and manage Pub/Sub Brokers",

package/src/logger.ts

@@ -3,10 +3,12 @@ import { formatMessagesSync } from "esbuild";
 import { getEnvironmentVariableFactory } from "./environment-variables";
 
 const LOGGER_LEVELS = {
+	none: -1,
 	error: 0,
 	warn: 1,
-	log: 2,
-	debug: 3,
+	info: 2,
+	log: 3,
+	debug: 4,
 } as const;
 
 type LoggerLevel = keyof typeof LOGGER_LEVELS;
@@ -15,6 +17,7 @@ type LoggerLevel = keyof typeof LOGGER_LEVELS;
 const LOGGER_LEVEL_FORMAT_TYPE_MAP = {
 	error: "error",
 	warn: "warning",
+	info: undefined,
 	log: undefined,
 	debug: undefined,
 } as const;
@@ -31,17 +34,21 @@ class Logger {
 	columns = process.stdout.columns;
 
 	debug = (...args: unknown[]) => this.doLog("debug", args);
+	info = (...args: unknown[]) => this.doLog("info", 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[]) {
+	private doLog(messageLevel: Exclude<LoggerLevel, "none">, args: unknown[]) {
 		if (LOGGER_LEVELS[this.loggerLevel] >= LOGGER_LEVELS[messageLevel]) {
 			console[messageLevel](this.formatMessage(messageLevel, format(...args)));
 		}
 	}
 
-	private formatMessage(level: LoggerLevel, message: string): string {
+	private formatMessage(
+		level: Exclude<LoggerLevel, "none">,
+		message: string
+	): string {
 		const kind = LOGGER_LEVEL_FORMAT_TYPE_MAP[level];
 		if (kind) {
 			// Format the message using the esbuild formatter.

package/src/miniflare-cli/index.ts

@@ -5,7 +5,6 @@ import {
 } from "@miniflare/durable-objects";
 import {
 	Log,
-	LogLevel,
 	Miniflare,
 	Response as MiniflareResponse,
 	Request as MiniflareRequest,
@@ -14,7 +13,6 @@ import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { FatalError } from "../errors";
 import generateASSETSBinding from "./assets";
-import { enumKeys } from "./enum-keys";
 import { getRequestContextCheckOptions } from "./request-context";
 import type { Options } from "./assets";
 import type { AddressInfo } from "net";
@@ -35,26 +33,23 @@ class NoOpLog extends Log {
 }
 
 async function main() {
-	const args = await yargs(hideBin(process.argv))
-		.help(false)
-		.version(false)
-		.option("log", {
-			choices: enumKeys(LogLevel),
-		}).argv;
-
-	const logLevel = LogLevel[args.log ?? "INFO"];
+	const args = await yargs(hideBin(process.argv)).help(false).version(false)
+		.argv;
+
 	const requestContextCheckOptions = await getRequestContextCheckOptions();
 	const config = {
 		...JSON.parse((args._[0] as string) ?? "{}"),
 		...requestContextCheckOptions,
 	};
-	//miniflare's logLevel 0 still logs routes, so lets override the logger
-	config.log = config.disableLogs
-		? new NoOpLog()
-		: new Log(logLevel, config.logOptions);
+	const logLevel = config.logLevel.toUpperCase();
+
+	config.log =
+		config.logLevel === "none"
+			? new NoOpLog()
+			: new Log(logLevel, config.logOptions);
 
-	if (logLevel > LogLevel.INFO) {
-		console.log("OPTIONS:\n", JSON.stringify(config, null, 2));
+	if (logLevel === "DEBUG" || logLevel === "VERBOSE") {
+		console.log("MINIFLARE OPTIONS:\n", JSON.stringify(config, null, 2));
 	}
 
 	config.bindings = {

package/src/pages/dev.tsx

@@ -99,6 +99,10 @@ export function Options(yargs: Argv) {
 				description: "KV namespace to bind (--kv KV_BINDING)",
 				alias: "k",
 			},
+			d1: {
+				type: "array",
+				description: "D1 database to bind",
+			},
 			do: {
 				type: "array",
 				description: "Durable Object to bind (--do NAME=CLASS)",
@@ -146,12 +150,9 @@ export function Options(yargs: Argv) {
 				type: "string",
 				hidden: true,
 			},
-
 			"log-level": {
-				// "none" will currently default to "error" for Wrangler Logger
 				choices: ["debug", "info", "log", "warn", "error", "none"] as const,
 				describe: "Specify logging level",
-				default: "log",
 			},
 		})
 		.epilogue(pagesBetaWarning);
@@ -170,6 +171,7 @@ export const Handler = async ({
 	binding: bindings = [],
 	kv: kvs = [],
 	do: durableObjects = [],
+	d1: d1s = [],
 	r2: r2s = [],
 	"live-reload": liveReload,
 	"local-protocol": localProtocol,
@@ -186,12 +188,8 @@ export const Handler = async ({
 
 	type LogLevelArg = "debug" | "info" | "log" | "warn" | "error" | "none";
 	if (logLevel) {
-		// we don't define a "none" logLevel, so "error" will do for now.
 		// The YargsOptionsToInterface doesn't handle the passing in of Unions from choices in Yargs
-		logger.loggerLevel =
-			(logLevel as LogLevelArg) === "none"
-				? "error"
-				: (logLevel as Exclude<"none", LogLevelArg>);
+		logger.loggerLevel = logLevel as LogLevelArg;
 	}
 
 	if (!local) {
@@ -499,6 +497,12 @@ export const Handler = async ({
 				return { binding: binding.toString(), bucket_name: "" };
 			}),
 
+			d1Databases: d1s.map((binding) => ({
+				binding: binding.toString(),
+				database_id: "", // Required for types, but unused by dev
+				database_name: `local-${binding}`,
+			})),
+
 			enablePagesAssetsServiceBinding: {
 				proxyPort,
 				directory,
@@ -508,8 +512,8 @@ export const Handler = async ({
 			persistTo,
 			showInteractiveDevSession: undefined,
 			inspect: true,
-			logLevel: "warn",
 			logPrefix: "pages",
+			logLevel: logLevel ?? "warn",
 		},
 		{ testMode: false, disableExperimentalWarning: true }
 	);

package/src/paths.ts

@@ -1,5 +1,5 @@
 import { assert } from "node:console";
-import { resolve } from "node:path";
+import { relative, basename, resolve } from "node:path";
 
 type DiscriminatedPath<Discriminator extends string> = string & {
 	_discriminator: Discriminator;
@@ -18,12 +18,38 @@ export type UrlPath = DiscriminatedPath<"UrlPath">;
  * Use this helper to convert a `string` to a `UrlPath` when it is not clear whether the string needs normalizing.
  * Replaces all back-slashes with forward-slashes, and throws an error if the path contains a drive letter (e.g. `C:`).
  */
-export function toUrlPath(path: string): UrlPath {
+export function toUrlPath(filePath: string): UrlPath {
 	assert(
-		!/^[a-z]:/i.test(path),
+		!/^[a-z]:/i.test(filePath),
 		"Tried to convert a Windows file path with a drive to a URL path."
 	);
-	return path.replace(/\\/g, "/") as UrlPath;
+	return filePath.replace(/\\/g, "/") as UrlPath;
+}
+
+/**
+ * Get a human-readable path, relative to process.cwd(), prefixed with ./ if
+ * in a nested subdirectory, to aid with readability.
+ * Only used for logging e.g. `Loading DB at ${readableRelative(dbPath)}`:
+ *
+ * E.g. (assuming process.cwd() is /pwd)
+ *
+ *	readableRelative('/pwd/wrangler.toml') => 'wrangler.toml'
+ *	readableRelative('/wrangler.toml') => '../wrangler.toml'
+ *	readableRelative('/pwd/subdir/wrangler.toml') => './subdir/wrangler.toml'
+ *
+ * */
+export function readableRelative(to: string) {
+	const relativePath = relative(process.cwd(), to);
+	if (
+		// No directory nesting, return as-is
+		basename(relativePath) === relativePath ||
+		// Outside current directory
+		relativePath.startsWith(".")
+	) {
+		return relativePath;
+	} else {
+		return "./" + relativePath;
+	}
 }
 
 /**

package/src/proxy.ts

@@ -1,6 +1,7 @@
 import { createServer as createHttpServer } from "node:http";
 import { connect } from "node:http2";
 import { createServer as createHttpsServer } from "node:https";
+import { networkInterfaces } from "node:os";
 import WebSocket from "faye-websocket";
 import { createHttpTerminator } from "http-terminator";
 import { useEffect, useRef, useState } from "react";
@@ -327,7 +328,15 @@ export function usePreviewServer({
 		})
 			.then(() => {
 				proxy.server.on("listening", () => {
-					logger.log(`⬣ Listening at ${localProtocol}://${ip}:${port}`);
+					const address = proxy.server.address();
+					const usedPort =
+						address && typeof address === "object" ? address.port : port;
+					logger.log(`⬣ Listening at ${localProtocol}://${ip}:${usedPort}`);
+					const accessibleHosts =
+						ip !== "0.0.0.0" ? [ip] : getAccessibleHosts();
+					for (const accessibleHost of accessibleHosts) {
+						logger.log(`- ${localProtocol}://${accessibleHost}:${usedPort}`);
+					}
 				});
 				proxy.server.listen(port, ip);
 			})
@@ -484,3 +493,14 @@ export async function waitForPortToBeAvailable(
 		}
 	});
 }
+
+function getAccessibleHosts(): string[] {
+	const hosts: string[] = [];
+	Object.values(networkInterfaces()).forEach((net) => {
+		net?.forEach(({ family, address }) => {
+			// @ts-expect-error the `family` property is numeric as of Node.js 18.0.0
+			if (family === "IPv4" || family === 4) hosts.push(address);
+		});
+	});
+	return hosts;
+}

package/src/publish.ts

@@ -14,6 +14,7 @@ import { logger } from "./logger";
 import { getMetricsUsageHeaders } from "./metrics";
 import { ParseError } from "./parse";
 import { syncAssets } from "./sites";
+import { identifyD1BindingsAsBeta } from "./worker";
 import { getZoneForRoute } from "./zones";
 import type { Config } from "./config";
 import type {
@@ -407,6 +408,9 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 					{
 						serveAssetsFromWorker:
 							!props.isWorkersSite && Boolean(props.assetPaths),
+						betaD1Shims: identifyD1BindingsAsBeta(config.d1_databases)?.map(
+							(db) => db.binding
+						),
 						jsxFactory,
 						jsxFragment,
 						rules: props.rules,
@@ -429,6 +433,8 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 						// We want to know if the build is for development or publishing
 						// This could potentially cause issues as we no longer have identical behaviour between dev and publish?
 						targetConsumer: "publish",
+						local: false,
+						experimentalLocalStubCache: false,
 					}
 			  );
 
@@ -476,6 +482,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 			data_blobs: config.data_blobs,
 			durable_objects: config.durable_objects,
 			r2_buckets: config.r2_buckets,
+			d1_databases: identifyD1BindingsAsBeta(config.d1_databases),
 			services: config.services,
 			dispatch_namespaces: config.dispatch_namespaces,
 			logfwdr: config.logfwdr,

package/src/user/user.tsx

@@ -309,6 +309,7 @@ const Scopes = {
 	"workers_scripts:write":
 		"See and change Cloudflare Workers scripts, durable objects, subdomains, triggers, and tail data.",
 	"workers_tail:read": "See Cloudflare Workers tail and script data.",
+	"d1:write": "See and change D1 Databases.",
 	"pages:write":
 		"See and change Cloudflare Pages projects, settings and deployments.",
 	"zone:read": "Grants read level access to account zone.",

package/src/worker.ts

@@ -1,9 +1,11 @@
+import type { Environment } from "./config";
 import type { Route } from "./config/environment";
 import type { ApiCredentials } from "./user";
 
 /**
  * A Cloudflare account.
  */
+
 export interface CfAccount {
 	/**
 	 * An API token.
@@ -116,6 +118,17 @@ export interface CfR2Bucket {
 	bucket_name: string;
 }
 
+export const D1_BETA_PREFIX = `__D1_BETA__` as const;
+export type D1PrefixedBinding = `${typeof D1_BETA_PREFIX}${string}`;
+
+export interface CfD1Database {
+	// For now, all D1 bindings are beta
+	binding: D1PrefixedBinding;
+	database_id: string;
+	database_name?: string;
+	preview_database_id?: string;
+}
+
 interface CfService {
 	binding: string;
 	service: string;
@@ -182,6 +195,7 @@ export interface CfWorkerInit {
 		data_blobs: CfDataBlobBindings | undefined;
 		durable_objects: { bindings: CfDurableObject[] } | undefined;
 		r2_buckets: CfR2Bucket[] | undefined;
+		d1_databases: CfD1Database[] | undefined;
 		services: CfService[] | undefined;
 		dispatch_namespaces: CfDispatchNamespace[] | undefined;
 		logfwdr: CfLogfwdr | undefined;
@@ -202,3 +216,19 @@ export interface CfWorkerContext {
 	routes: Route[] | undefined;
 	sendMetrics: boolean | undefined;
 }
+
+// Prefix binding with identifier which will then get picked up by the D1 shim.
+// Once the D1 Api is out of beta, this function can be removed.
+export function identifyD1BindingsAsBeta(
+	dbs: Environment["d1_databases"]
+): CfD1Database[] | undefined {
+	return dbs?.map((db) => ({
+		...db,
+		binding: `${D1_BETA_PREFIX}${db.binding}`,
+	}));
+}
+
+// Remove beta prefix
+export function removeD1BetaPrefix(binding: D1PrefixedBinding): string {
+	return binding.slice(D1_BETA_PREFIX.length);
+}

package/templates/d1-beta-facade.js

@@ -0,0 +1,174 @@
+// src/shim.ts
+import worker from "__ENTRY_POINT__";
+export * from "__ENTRY_POINT__";
+
+// src/index.ts
+var D1Database = class {
+	constructor(binding) {
+		this.binding = binding;
+	}
+	prepare(query) {
+		return new D1PreparedStatement(this, query);
+	}
+	async dump() {
+		const response = await this.binding.fetch("/dump", {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+			},
+		});
+		if (response.status !== 200) {
+			const err = await response.json();
+			throw new Error("D1_DUMP_ERROR", {
+				cause: new Error(err.error),
+			});
+		}
+		return await response.arrayBuffer();
+	}
+	async batch(statements) {
+		const exec = await this._send(
+			"/query",
+			statements.map((s) => s.statement),
+			statements.map((s) => s.params)
+		);
+		return exec;
+	}
+	async exec(query) {
+		const lines = query.trim().split("\n");
+		const _exec = await this._send("/query", lines, []);
+		const exec = Array.isArray(_exec) ? _exec : [_exec];
+		const error = exec
+			.map((r) => {
+				return r.error ? 1 : 0;
+			})
+			.indexOf(1);
+		if (error !== -1) {
+			throw new Error("D1_EXEC_ERROR", {
+				cause: new Error(
+					`Error in line ${error + 1}: ${lines[error]}: ${exec[error].error}`
+				),
+			});
+		} else {
+			return {
+				count: exec.length,
+				duration: exec.reduce((p, c) => {
+					return p + c.duration;
+				}, 0),
+			};
+		}
+	}
+	async _send(endpoint, query, params) {
+		const body = JSON.stringify(
+			typeof query == "object"
+				? query.map((s, index) => {
+						return { sql: s, params: params[index] };
+				  })
+				: {
+						sql: query,
+						params,
+				  }
+		);
+		const response = await this.binding.fetch(endpoint, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+			},
+			body,
+		});
+		if (response.status !== 200) {
+			const err = await response.json();
+			throw new Error("D1_ERROR", { cause: new Error(err.error) });
+		}
+		const answer = await response.json();
+		return Array.isArray(answer) ? answer : answer;
+	}
+};
+var D1PreparedStatement = class {
+	constructor(database, statement, values) {
+		this.database = database;
+		this.statement = statement;
+		this.params = values || [];
+	}
+	bind(...values) {
+		return new D1PreparedStatement(this.database, this.statement, values);
+	}
+	async first(colName) {
+		const info = firstIfArray(
+			await this.database._send("/query", this.statement, this.params)
+		);
+		const results = info.results;
+		if (results.length < 1) {
+			throw new Error("D1_NORESULTS", { cause: new Error("No results") });
+		}
+		const result = results[0];
+		if (colName !== void 0) {
+			if (result[colName] === void 0) {
+				throw new Error("D1_COLUMN_NOTFOUND", {
+					cause: new Error(`Column not found`),
+				});
+			}
+			return result[colName];
+		} else {
+			return result;
+		}
+	}
+	async run() {
+		return firstIfArray(
+			await this.database._send("/execute", this.statement, this.params)
+		);
+	}
+	async all() {
+		return firstIfArray(
+			await this.database._send("/query", this.statement, this.params)
+		);
+	}
+	async raw() {
+		const s = firstIfArray(
+			await this.database._send("/query", this.statement, this.params)
+		);
+		const raw = [];
+		for (var r in s.results) {
+			const entry = Object.keys(s.results[r]).map((k) => {
+				return s.results[r][k];
+			});
+			raw.push(entry);
+		}
+		return raw;
+	}
+};
+function firstIfArray(results) {
+	return Array.isArray(results) ? results[0] : results;
+}
+
+// src/shim.ts
+var D1_IMPORTS = __D1_IMPORTS__;
+var LOCAL_MODE = __LOCAL_MODE__;
+var D1_BETA_PREFIX = `__D1_BETA__`;
+var envMap = /* @__PURE__ */ new Map();
+function getMaskedEnv(env) {
+	if (envMap.has(env)) return envMap.get(env);
+	const newEnv = new Map(Object.entries(env));
+	D1_IMPORTS.filter((bindingName) =>
+		bindingName.startsWith(D1_BETA_PREFIX)
+	).forEach((bindingName) => {
+		newEnv.delete(bindingName);
+		const newName = bindingName.slice(D1_BETA_PREFIX.length);
+		const newBinding = !LOCAL_MODE
+			? new D1Database(env[bindingName])
+			: env[bindingName];
+		newEnv.set(newName, newBinding);
+	});
+	const newEnvObj = Object.fromEntries(newEnv.entries());
+	envMap.set(env, newEnvObj);
+	return newEnvObj;
+}
+var shim_default = {
+	async fetch(request, env, ctx) {
+		return worker.fetch(request, getMaskedEnv(env), ctx);
+	},
+
+	async scheduled(controller, env, ctx) {
+		return worker.scheduled(controller, getMaskedEnv(env), ctx);
+	},
+};
+export { shim_default as default };

package/templates/experimental-local-cache-stubs.js

@@ -0,0 +1,27 @@
+// `workerd` currently throws on any use of the Cache API. Workers Sites
+// requires the Cache API to function though, so stub it out to no-ops, like in
+// regular `wrangler dev`.
+
+class Cache {
+	async put(req, res) {}
+
+	async match(req, options) {}
+
+	async delete(req, options) {
+		return false;
+	}
+}
+
+class CacheStorage {
+	#cache = new Cache();
+
+	get default() {
+		return this.#cache;
+	}
+
+	async open(cacheName) {
+		return this.#cache;
+	}
+}
+
+globalThis.caches = new CacheStorage();