wrangler 2.1.5 → 2.1.7

package/src/config/index.ts

@@ -1,9 +1,11 @@
 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,
@@ -84,6 +86,7 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		data_blobs,
 		durable_objects,
 		kv_namespaces,
+		d1_databases,
 		r2_buckets,
 		logfwdr,
 		services,
@@ -138,6 +141,20 @@ 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 }) => {
+				return {
+					key: removeD1BetaPrefix(binding),
+					value: database_name
+						? `${database_name} (${database_id})`
+						: database_id,
+				};
+			}),
+		});
+	}
+
 	if (r2_buckets !== undefined && r2_buckets.length > 0) {
 		output.push({
 			type: "R2 Buckets",
@@ -249,3 +266,18 @@ 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 }>(
+	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) });
+	};
+}

package/src/config/validation.ts

@@ -102,6 +102,14 @@ export function normalizeAndValidateConfig(
 		"boolean"
 	);
 
+	validateOptionalProperty(
+		diagnostics,
+		"",
+		"keep_vars",
+		rawConfig.keep_vars,
+		"boolean"
+	);
+
 	// TODO: set the default to false to turn on service environments as the default
 	const isLegacyEnv =
 		(args as { "legacy-env": boolean | undefined })["legacy-env"] ??
@@ -182,6 +190,7 @@ export function normalizeAndValidateConfig(
 		configPath,
 		legacy_env: isLegacyEnv,
 		send_metrics: rawConfig.send_metrics,
+		keep_vars: rawConfig.keep_vars,
 		...activeEnv,
 		dev: normalizeAndValidateDev(diagnostics, rawConfig.dev ?? {}),
 		migrations: normalizeAndValidateMigrations(
@@ -889,6 +898,7 @@ function normalizeAndValidateEnvironment(
 	);
 
 	// The field "experimental_services" doesn't exist anymore in the config, but we still want to error about any older usage.
+
 	deprecated(
 		diagnostics,
 		rawEnv,
@@ -1075,6 +1085,16 @@ function normalizeAndValidateEnvironment(
 			validateBindingArray(envName, validateR2Binding),
 			[]
 		),
+		d1_databases: notInheritable(
+			diagnostics,
+			topLevelEnv,
+			rawConfig,
+			rawEnv,
+			envName,
+			"d1_databases",
+			validateBindingArray(envName, validateD1Binding),
+			[]
+		),
 		services: notInheritable(
 			diagnostics,
 			topLevelEnv,
@@ -1539,6 +1559,7 @@ const validateUnsafeBinding: ValidatorFn = (diagnostics, field, value) => {
 			"text_blob",
 			"kv_namespace",
 			"durable_object_namespace",
+			"d1_database",
 			"r2_bucket",
 			"service",
 			"logfwdr",
@@ -1693,6 +1714,53 @@ const validateR2Binding: ValidatorFn = (diagnostics, field, value) => {
 	return isValid;
 };
 
+const validateD1Binding: ValidatorFn = (diagnostics, field, value) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`"d1_databases" bindings should be objects, but got ${JSON.stringify(
+				value
+			)}`
+		);
+		return false;
+	}
+	let isValid = true;
+	// D1 databases must have a binding and either a database_name or database_id.
+	if (!isRequiredProperty(value, "binding", "string")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should have a string "binding" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (
+		// TODO: allow name only, where we look up the ID dynamically
+		// !isOptionalProperty(value, "database_name", "string") &&
+		!isRequiredProperty(value, "database_id", "string")
+	) {
+		diagnostics.errors.push(
+			`"${field}" bindings must have a "database_id" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (!isOptionalProperty(value, "preview_database_id", "string")) {
+		diagnostics.errors.push(
+			`"${field}" bindings should, optionally, have a string "preview_database_id" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (isValid && !process.env.NO_D1_WARNING) {
+		diagnostics.warnings.push(
+			`D1 Bindings are currently in beta to allow the API to evolve before general availability.\nPlease report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose\nNote: set NO_D1_WARNING=true to hide this message`
+		);
+	}
+	return isValid;
+};
+
 /**
  * Check that bindings whose names might conflict, don't.
  *

package/src/config-cache.ts

@@ -32,7 +32,7 @@ const arrayFormatter = new Intl.ListFormat("en", {
 function showCacheMessage(fields: string[], folder: string) {
 	if (!cacheMessageShown && isInteractive() && !CI.isCI()) {
 		if (fields.length > 0) {
-			logger.log(
+			logger.debug(
 				`Retrieving cached values for ${arrayFormatter.format(
 					fields
 				)} from ${path.relative(process.cwd(), folder)}`

package/src/create-worker-upload-form.ts

@@ -40,6 +40,7 @@ type WorkerMetadataBinding =
 			environment?: string;
 	  }
 	| { type: "r2_bucket"; name: string; bucket_name: string }
+	| { type: "d1"; name: string; id: string }
 	| { type: "service"; name: string; service: string; environment?: string }
 	| { type: "namespace"; name: string; namespace: string }
 	| {
@@ -59,7 +60,7 @@ export interface WorkerMetadata {
 	migrations?: CfDurableObjectMigrations;
 	capnp_schema?: string;
 	bindings: WorkerMetadataBinding[];
-	keep_bindings: WorkerMetadataBinding["type"][];
+	keep_bindings?: WorkerMetadataBinding["type"][];
 }
 
 /**
@@ -74,6 +75,7 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		usage_model,
 		compatibility_date,
 		compatibility_flags,
+		keepVars,
 	} = worker;
 
 	let { modules } = worker;
@@ -116,6 +118,14 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		});
 	});
 
+	bindings.d1_databases?.forEach(({ binding, database_id }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "d1",
+			id: database_id,
+		});
+	});
+
 	bindings.services?.forEach(({ binding, service, environment }) => {
 		metadataBindings.push({
 			name: binding,
@@ -257,7 +267,7 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		...(usage_model && { usage_model }),
 		...(migrations && { migrations }),
 		capnp_schema: bindings.logfwdr?.schema,
-		keep_bindings: ["plain_text", "json"],
+		...(keepVars && { keep_bindings: ["plain_text", "json"] }),
 	};
 
 	formData.set("metadata", JSON.stringify(metadata));

package/src/d1/backups.tsx

@@ -0,0 +1,212 @@
+import fs from "node:fs/promises";
+import { render } from "ink";
+import Table from "ink-table";
+import React from "react";
+import { fetchResult } from "../cfetch";
+import { performApiFetch } from "../cfetch/internal";
+import { withConfig } from "../config";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { formatBytes, formatTimeAgo } from "./formatTimeAgo";
+import { Name } from "./options";
+import { d1BetaWarning, getDatabaseByNameOrBinding } from "./utils";
+import type { Backup, Database } from "./types";
+import type { Response } from "undici";
+import type { Argv } from "yargs";
+
+type BackupListArgs = { config?: string; name: string };
+
+export function ListOptions(yargs: Argv): Argv<BackupListArgs> {
+	return Name(yargs);
+}
+
+export const ListHandler = withConfig<BackupListArgs>(
+	async ({ config, name }): Promise<void> => {
+		const accountId = await requireAuth({});
+		logger.log(d1BetaWarning);
+		const db: Database = await getDatabaseByNameOrBinding(
+			config,
+			accountId,
+			name
+		);
+
+		const backups: Backup[] = await listBackups(accountId, db.uuid);
+		render(
+			<Table
+				data={backups}
+				columns={["created_at", "id", "num_tables", "size"]}
+			></Table>
+		);
+	}
+);
+
+export const listBackups = async (
+	accountId: string,
+	uuid: string
+): Promise<Array<Backup>> => {
+	const json: Backup[] = await fetchResult(
+		`/accounts/${accountId}/d1/database/${uuid}/backup`,
+		{}
+	);
+	const results: Record<string, Backup> = {};
+
+	json
+		// First, convert created_at to a Date
+		.map((backup) => ({
+			...backup,
+			created_at: new Date(backup.created_at),
+		}))
+		// Then, sort descending based on created_at
+		.sort((a, b) => +b.created_at - +a.created_at)
+		// then group_by their human-readable timestamp i.e. "2 days ago"
+		// (storing only the first of each group)
+		// and replace the Date version with this new human-readable one
+		.forEach((backup) => {
+			const timeAgo = formatTimeAgo(backup.created_at);
+			if (!results[timeAgo]) {
+				results[timeAgo] = {
+					...backup,
+					created_at: timeAgo,
+					size: formatBytes(backup.file_size),
+				};
+			}
+		});
+
+	// Take advantage of JS objects' sorting to return the newest backup of a certain age
+	return Object.values(results);
+};
+
+type BackupCreateArgs = BackupListArgs;
+
+export function CreateOptions(yargs: Argv): Argv<BackupCreateArgs> {
+	return ListOptions(yargs);
+}
+
+export const CreateHandler = withConfig<BackupCreateArgs>(
+	async ({ config, name }): Promise<void> => {
+		const accountId = await requireAuth({});
+		logger.log(d1BetaWarning);
+		const db: Database = await getDatabaseByNameOrBinding(
+			config,
+			accountId,
+			name
+		);
+
+		const backup: Backup = await createBackup(accountId, db.uuid);
+		render(
+			<Table
+				data={[backup]}
+				columns={["created_at", "id", "num_tables", "size", "state"]}
+			></Table>
+		);
+	}
+);
+
+export const createBackup = async (
+	accountId: string,
+	uuid: string
+): Promise<Backup> => {
+	const backup: Backup = await fetchResult(
+		`/accounts/${accountId}/d1/database/${uuid}/backup`,
+		{
+			method: "POST",
+		}
+	);
+	return {
+		...backup,
+		size: formatBytes(backup.file_size),
+	};
+};
+
+type BackupRestoreArgs = BackupListArgs & {
+	"backup-id": string;
+};
+
+export function RestoreOptions(yargs: Argv): Argv<BackupRestoreArgs> {
+	return ListOptions(yargs).positional("backup-id", {
+		describe: "The Backup ID to restore",
+		type: "string",
+		demandOption: true,
+	});
+}
+
+export const RestoreHandler = withConfig<BackupRestoreArgs>(
+	async ({ config, name, backupId }): Promise<void> => {
+		const accountId = await requireAuth({});
+		logger.log(d1BetaWarning);
+		const db: Database = await getDatabaseByNameOrBinding(
+			config,
+			accountId,
+			name
+		);
+
+		console.log(`Restoring ${name} from backup ${backupId}....`);
+		await restoreBackup(accountId, db.uuid, backupId);
+		console.log(`Done!`);
+	}
+);
+
+export const restoreBackup = async (
+	accountId: string,
+	uuid: string,
+	backupId: string
+): Promise<void> => {
+	await fetchResult(
+		`/accounts/${accountId}/d1/database/${uuid}/backup/${backupId}/restore`,
+		{
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+		}
+	);
+};
+
+type BackupDownloadArgs = BackupRestoreArgs & {
+	output?: string;
+};
+
+export function DownloadOptions(yargs: Argv): Argv<BackupDownloadArgs> {
+	return ListOptions(yargs)
+		.positional("backup-id", {
+			describe: "The Backup ID to download",
+			type: "string",
+			demandOption: true,
+		})
+		.option("output", {
+			describe:
+				"The .sqlite3 file to write to (defaults to '<db-name>.<short-backup-id>.sqlite3'",
+			type: "string",
+		});
+}
+
+export const DownloadHandler = withConfig<BackupDownloadArgs>(
+	async ({ name, backupId, output, config }): Promise<void> => {
+		const accountId = await requireAuth({});
+		logger.log(d1BetaWarning);
+		const db: Database = await getDatabaseByNameOrBinding(
+			config,
+			accountId,
+			name
+		);
+		const filename = output || `./${name}.${backupId.slice(0, 8)}.sqlite3`;
+
+		console.log(`Downloading backup ${backupId} of ${name} to: ${filename}`);
+		const response = await getBackupResponse(accountId, db.uuid, backupId);
+		console.log(`Got file. Saving...`);
+		// TODO: stream this once we upgrade to Node18 and can use Writable.fromWeb
+		const buffer = await response.arrayBuffer();
+		await fs.writeFile(filename, new Buffer(buffer));
+		console.log(`Done! Wrote ${filename} (${formatBytes(buffer.byteLength)})`);
+	}
+);
+
+export const getBackupResponse = async (
+	accountId: string,
+	uuid: string,
+	backupId: string
+): Promise<Response> => {
+	return await performApiFetch(
+		`/accounts/${accountId}/d1/database/${uuid}/backup/${backupId}/download`
+	);
+};

package/src/d1/create.tsx

@@ -0,0 +1,54 @@
+import { render, Text, Box } from "ink";
+import React from "react";
+import { fetchResult } from "../cfetch";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { d1BetaWarning } from "./utils";
+import type { Database } from "./types";
+import type { ArgumentsCamelCase, Argv } from "yargs";
+
+type CreateArgs = { name: string };
+
+export function Options(yargs: Argv): Argv<CreateArgs> {
+	return yargs
+		.positional("name", {
+			describe: "The name of the new DB",
+			type: "string",
+			demandOption: true,
+		})
+		.epilogue(d1BetaWarning);
+}
+
+export async function Handler({
+	name,
+}: ArgumentsCamelCase<CreateArgs>): Promise<void> {
+	const accountId = await requireAuth({});
+	logger.log(d1BetaWarning);
+
+	const db: Database = await fetchResult(`/accounts/${accountId}/d1/database`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+		},
+		body: JSON.stringify({
+			name,
+		}),
+	});
+
+	render(
+		<Box flexDirection="column">
+			<Text>✅ Successfully created DB &apos;{db.name}&apos;!</Text>
+			<Text>&nbsp;</Text>
+			<Text>
+				Add the following to your wrangler.toml to connect to it from a Worker:
+			</Text>
+			<Text>&nbsp;</Text>
+			<Text>[[ d1_databases ]]</Text>
+			<Text>
+				binding = &quot;DB&quot; # i.e. available in your Worker on env.DB
+			</Text>
+			<Text>database_name = &quot;{db.name}&quot;</Text>
+			<Text>database_id = &quot;{db.uuid}&quot;</Text>
+		</Box>
+	);
+}

package/src/d1/delete.tsx

@@ -0,0 +1,56 @@
+import { fetchResult } from "../cfetch";
+import { withConfig } from "../config";
+import { confirm } from "../dialogs";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { Name } from "./options";
+import { d1BetaWarning, getDatabaseByNameOrBinding } from "./utils";
+import type { Database } from "./types";
+import type { Argv } from "yargs";
+
+type CreateArgs = {
+	config?: string;
+	name: string;
+	"skip-confirmation": boolean;
+};
+
+export function Options(d1ListYargs: Argv): Argv<CreateArgs> {
+	return Name(d1ListYargs)
+		.option("skip-confirmation", {
+			describe: "Skip confirmation",
+			type: "boolean",
+			alias: "y",
+			default: false,
+		})
+		.epilogue(d1BetaWarning);
+}
+
+export const Handler = withConfig<CreateArgs>(
+	async ({ name, skipConfirmation, config }): Promise<void> => {
+		const accountId = await requireAuth({});
+		logger.log(d1BetaWarning);
+
+		const db: Database = await getDatabaseByNameOrBinding(
+			config,
+			accountId,
+			name
+		);
+
+		console.log(`About to delete DB '${name}' (${db.uuid}).`);
+		if (!skipConfirmation) {
+			const response = await confirm(`Ok to proceed?`);
+			if (!response) {
+				console.log(`Not deleting.`);
+				return;
+			}
+		}
+
+		console.log("Deleting...");
+
+		await fetchResult(`/accounts/${accountId}/d1/database/${db.uuid}`, {
+			method: "DELETE",
+		});
+
+		console.log(`Deleted '${name}' successfully.`);
+	}
+);