wrangler 2.1.6 → 2.1.7

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,7 @@ 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,
 					}
 			  );
 
@@ -476,6 +481,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 };