wrangler 0.0.0-e7a0cd5b → 0.0.0-e87ad068

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

@@ -4,6 +4,8 @@ import type {
 	CfWorkerInit,
 	CfModuleType,
 	CfDurableObjectMigrations,
+	CfPlacement,
+	CfTailConsumer,
 } from "./worker.js";
 
 export function toMimeType(type: CfModuleType): string {
@@ -23,15 +25,22 @@ export function toMimeType(type: CfModuleType): string {
 	}
 }
 
-type WorkerMetadataBinding =
+export type WorkerMetadataBinding =
 	// If you add any new binding types here, also add it to safeBindings
 	// under validateUnsafeBinding in config/validation.ts
 	| { type: "plain_text"; name: string; text: string }
 	| { type: "json"; name: string; json: unknown }
 	| { type: "wasm_module"; name: string; part: string }
 	| { type: "text_blob"; name: string; part: string }
+	| { type: "browser"; name: string }
 	| { type: "data_blob"; name: string; part: string }
 	| { type: "kv_namespace"; name: string; namespace_id: string }
+	| {
+			type: "send_email";
+			name: string;
+			destination_address?: string;
+			allowed_destination_addresses?: string[];
+	  }
 	| {
 			type: "durable_object_namespace";
 			name: string;
@@ -41,15 +50,17 @@ type WorkerMetadataBinding =
 	  }
 	| { type: "queue"; name: string; queue_name: string }
 	| { type: "r2_bucket"; name: string; bucket_name: string }
-	| { type: "d1"; name: string; id: string }
+	| { type: "d1"; name: string; id: string; internalEnv?: string }
+	| { type: "constellation"; name: string; project: string }
 	| { type: "service"; name: string; service: string; environment?: string }
-	| { type: "namespace"; name: string; namespace: string }
+	| { type: "analytics_engine"; name: string; dataset?: string }
+	| { type: "dispatch_namespace"; name: string; namespace: string }
+	| { type: "mtls_certificate"; name: string; certificate_id: string }
 	| {
 			type: "logfwdr";
 			name: string;
 			destination: string;
-	  }
-	| { type: "metadata"; name: string };
+	  };
 
 export interface WorkerMetadata {
 	/** The name of the entry point module. Only exists when the worker is in the ES module format */
@@ -64,6 +75,10 @@ export interface WorkerMetadata {
 	bindings: WorkerMetadataBinding[];
 	keep_bindings?: WorkerMetadataBinding["type"][];
 	logpush?: boolean;
+	placement?: CfPlacement;
+	tail_consumers?: CfTailConsumer[];
+	// Allow unsafe.metadata to add arbitary properties at runtime
+	[key: string]: unknown;
 }
 
 /**
@@ -80,19 +95,14 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		compatibility_flags,
 		keepVars,
 		logpush,
+		placement,
+		tail_consumers,
 	} = worker;
 
 	let { modules } = worker;
 
 	const metadataBindings: WorkerMetadata["bindings"] = [];
 
-	if (bindings.metadata_binding) {
-		metadataBindings.push({
-			name: bindings.metadata_binding,
-			type: "metadata",
-		});
-	}
-
 	Object.entries(bindings.vars || {})?.forEach(([key, value]) => {
 		if (typeof value === "string") {
 			metadataBindings.push({ name: key, type: "plain_text", text: value });
@@ -109,6 +119,17 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		});
 	});
 
+	bindings.send_email?.forEach(
+		({ name, destination_address, allowed_destination_addresses }) => {
+			metadataBindings.push({
+				name: name,
+				type: "send_email",
+				destination_address,
+				allowed_destination_addresses,
+			});
+		}
+	);
+
 	bindings.durable_objects?.bindings.forEach(
 		({ name, class_name, script_name, environment }) => {
 			metadataBindings.push({
@@ -137,11 +158,22 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		});
 	});
 
-	bindings.d1_databases?.forEach(({ binding, database_id }) => {
+	bindings.d1_databases?.forEach(
+		({ binding, database_id, database_internal_env }) => {
+			metadataBindings.push({
+				name: binding,
+				type: "d1",
+				id: database_id,
+				internalEnv: database_internal_env,
+			});
+		}
+	);
+
+	bindings.constellation?.forEach(({ binding, project_id }) => {
 		metadataBindings.push({
 			name: binding,
-			type: "d1",
-			id: database_id,
+			type: "constellation",
+			project: project_id,
 		});
 	});
 
@@ -154,14 +186,30 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		});
 	});
 
+	bindings.analytics_engine_datasets?.forEach(({ binding, dataset }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "analytics_engine",
+			dataset,
+		});
+	});
+
 	bindings.dispatch_namespaces?.forEach(({ binding, namespace }) => {
 		metadataBindings.push({
 			name: binding,
-			type: "namespace",
+			type: "dispatch_namespace",
 			namespace,
 		});
 	});
 
+	bindings.mtls_certificates?.forEach(({ binding, certificate_id }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "mtls_certificate",
+			certificate_id,
+		});
+	});
+
 	bindings.logfwdr?.bindings.forEach(({ name, destination }) => {
 		metadataBindings.push({
 			name: name,
@@ -185,6 +233,13 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		);
 	}
 
+	if (bindings.browser !== undefined) {
+		metadataBindings.push({
+			name: bindings.browser.binding,
+			type: "browser",
+		});
+	}
+
 	for (const [name, filePath] of Object.entries(bindings.text_blobs || {})) {
 		metadataBindings.push({
 			name,
@@ -271,9 +326,9 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		}
 	}
 
-	if (bindings.unsafe) {
+	if (bindings.unsafe?.bindings) {
 		// @ts-expect-error unsafe bindings don't need to match a specific type here
-		metadataBindings.push(...bindings.unsafe);
+		metadataBindings.push(...bindings.unsafe.bindings);
 	}
 
 	const metadata: WorkerMetadata = {
@@ -288,8 +343,16 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		capnp_schema: bindings.logfwdr?.schema,
 		...(keepVars && { keep_bindings: ["plain_text", "json"] }),
 		...(logpush !== undefined && { logpush }),
+		...(placement && { placement }),
+		...(tail_consumers && { tail_consumers }),
 	};
 
+	if (bindings.unsafe?.metadata !== undefined) {
+		for (const key of Object.keys(bindings.unsafe.metadata)) {
+			metadata[key] = bindings.unsafe.metadata[key];
+		}
+	}
+
 	formData.set("metadata", JSON.stringify(metadata));
 
 	if (main.type === "commonjs" && modules && modules.length > 0) {

package/src/d1/backups.tsx

@@ -1,6 +1,5 @@
 import fs from "node:fs/promises";
 import * as path from "path";
-import { render } from "ink";
 import Table from "ink-table";
 import React from "react";
 import { fetchResult } from "../cfetch";
@@ -8,22 +7,24 @@ import { performApiFetch } from "../cfetch/internal";
 import { withConfig } from "../config";
 import { logger } from "../logger";
 import { requireAuth } from "../user";
+import { renderToString } from "../utils/render";
 import { formatBytes, formatTimeAgo } from "./formatTimeAgo";
 import { Name } from "./options";
 import { d1BetaWarning, getDatabaseByNameOrBinding } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
 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> {
+export function ListOptions(yargs: CommonYargsArgv) {
 	return Name(yargs);
 }
-
-export const ListHandler = withConfig<BackupListArgs>(
+type ListHandlerOptions = StrictYargsOptionsToInterface<typeof ListOptions>;
+export const ListHandler = withConfig<ListHandlerOptions>(
 	async ({ config, name }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 		const db: Database = await getDatabaseByNameOrBinding(
 			config,
@@ -32,11 +33,13 @@ export const ListHandler = withConfig<BackupListArgs>(
 		);
 
 		const backups: Backup[] = await listBackups(accountId, db.uuid);
-		render(
-			<Table
-				data={backups}
-				columns={["created_at", "id", "num_tables", "size"]}
-			></Table>
+		logger.log(
+			renderToString(
+				<Table
+					data={backups}
+					columns={["created_at", "id", "num_tables", "size"]}
+				></Table>
+			)
 		);
 	}
 );
@@ -77,15 +80,14 @@ export const listBackups = async (
 	return Object.values(results);
 };
 
-type BackupCreateArgs = BackupListArgs;
-
-export function CreateOptions(yargs: Argv): Argv<BackupCreateArgs> {
+export function CreateOptions(yargs: CommonYargsArgv) {
 	return ListOptions(yargs);
 }
+type CreateHandlerOptions = StrictYargsOptionsToInterface<typeof CreateOptions>;
 
-export const CreateHandler = withConfig<BackupCreateArgs>(
+export const CreateHandler = withConfig<CreateHandlerOptions>(
 	async ({ config, name }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 		const db: Database = await getDatabaseByNameOrBinding(
 			config,
@@ -94,11 +96,13 @@ export const CreateHandler = withConfig<BackupCreateArgs>(
 		);
 
 		const backup: Backup = await createBackup(accountId, db.uuid);
-		render(
-			<Table
-				data={[backup]}
-				columns={["created_at", "id", "num_tables", "size", "state"]}
-			></Table>
+		logger.log(
+			renderToString(
+				<Table
+					data={[backup]}
+					columns={["created_at", "id", "num_tables", "size", "state"]}
+				></Table>
+			)
 		);
 	}
 );
@@ -119,21 +123,19 @@ export const createBackup = async (
 	};
 };
 
-type BackupRestoreArgs = BackupListArgs & {
-	"backup-id": string;
-};
-
-export function RestoreOptions(yargs: Argv): Argv<BackupRestoreArgs> {
+export function RestoreOptions(yargs: CommonYargsArgv) {
 	return ListOptions(yargs).positional("backup-id", {
 		describe: "The Backup ID to restore",
 		type: "string",
 		demandOption: true,
 	});
 }
-
-export const RestoreHandler = withConfig<BackupRestoreArgs>(
+type RestoreHandlerOptions = StrictYargsOptionsToInterface<
+	typeof RestoreOptions
+>;
+export const RestoreHandler = withConfig<RestoreHandlerOptions>(
 	async ({ config, name, backupId }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 		const db: Database = await getDatabaseByNameOrBinding(
 			config,
@@ -141,9 +143,9 @@ export const RestoreHandler = withConfig<BackupRestoreArgs>(
 			name
 		);
 
-		console.log(`Restoring ${name} from backup ${backupId}....`);
+		logger.log(`Restoring ${name} from backup ${backupId}....`);
 		await restoreBackup(accountId, db.uuid, backupId);
-		console.log(`Done!`);
+		logger.log(`Done!`);
 	}
 );
 
@@ -163,11 +165,7 @@ export const restoreBackup = async (
 	);
 };
 
-type BackupDownloadArgs = BackupRestoreArgs & {
-	output?: string;
-};
-
-export function DownloadOptions(yargs: Argv): Argv<BackupDownloadArgs> {
+export function DownloadOptions(yargs: CommonYargsArgv) {
 	return ListOptions(yargs)
 		.positional("backup-id", {
 			describe: "The Backup ID to download",
@@ -180,10 +178,12 @@ export function DownloadOptions(yargs: Argv): Argv<BackupDownloadArgs> {
 			type: "string",
 		});
 }
-
-export const DownloadHandler = withConfig<BackupDownloadArgs>(
+type DownloadHandlerOptions = StrictYargsOptionsToInterface<
+	typeof DownloadOptions
+>;
+export const DownloadHandler = withConfig<DownloadHandlerOptions>(
 	async ({ name, backupId, output, config }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 		const db: Database = await getDatabaseByNameOrBinding(
 			config,
@@ -191,14 +191,15 @@ export const DownloadHandler = withConfig<BackupDownloadArgs>(
 			name
 		);
 		const filename =
-			output ||
-			path.join(
-				process.env.INIT_CWD as string,
-				`${name}.${backupId.slice(0, 8)}.sqlite3`
-			);
+			output || path.resolve(`${name}.${backupId.slice(0, 8)}.sqlite3`);
 
 		logger.log(`🌀 Downloading backup ${backupId} from '${name}'`);
 		const response = await getBackupResponse(accountId, db.uuid, backupId);
+		if (!response.ok) {
+			throw new Error(
+				`Failed to download backup ${backupId} from '${name}' - got ${response.status} from the API`
+			);
+		}
 		logger.log(`🌀 Saving to ${filename}`);
 		// TODO: stream this once we upgrade to Node18 and can use Writable.fromWeb
 		const buffer = await response.arrayBuffer();

package/src/d1/constants.ts

@@ -0,0 +1,5 @@
+export const DEFAULT_MIGRATION_PATH = "./migrations";
+export const DEFAULT_MIGRATION_TABLE = "d1_migrations";
+export const LOCATION_CHOICES = ["weur", "eeur", "apac", "wnam", "enam"];
+// Max number of statements to send in a single /execute call
+export const DEFAULT_BATCH_SIZE = 10_000;

package/src/d1/create.tsx

@@ -1,54 +1,102 @@
-import { render, Text, Box } from "ink";
+import { Box, Text } from "ink";
 import React from "react";
 import { fetchResult } from "../cfetch";
+import { withConfig } from "../config";
 import { logger } from "../logger";
 import { requireAuth } from "../user";
+import { renderToString } from "../utils/render";
+import { LOCATION_CHOICES } from "./constants";
 import { d1BetaWarning } from "./utils";
-import type { Database } from "./types";
-import type { ArgumentsCamelCase, Argv } from "yargs";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { DatabaseCreationResult } from "./types";
 
-type CreateArgs = { name: string };
-
-export function Options(yargs: Argv): Argv<CreateArgs> {
+export function Options(yargs: CommonYargsArgv) {
 	return yargs
 		.positional("name", {
 			describe: "The name of the new DB",
 			type: "string",
 			demandOption: true,
 		})
+		.option("location", {
+			describe:
+				"A hint for the primary location of the new DB. Options:\nweur: Western Europe\neeur: Eastern Europe\napac: Asia Pacific\nwnam: Western North America\nenam: Eastern North America \n",
+			type: "string",
+		})
+		.option("experimental-backend", {
+			default: false,
+			describe: "Use new experimental DB backend",
+			type: "boolean",
+		})
 		.epilogue(d1BetaWarning);
 }
 
-export async function Handler({
-	name,
-}: ArgumentsCamelCase<CreateArgs>): Promise<void> {
-	const accountId = await requireAuth({});
-	logger.log(d1BetaWarning);
+type HandlerOptions = StrictYargsOptionsToInterface<typeof Options>;
+export const Handler = withConfig<HandlerOptions>(
+	async ({ name, config, location, experimentalBackend }): Promise<void> => {
+		const accountId = await requireAuth(config);
 
-	const db: Database = await fetchResult(`/accounts/${accountId}/d1/database`, {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-		},
-		body: JSON.stringify({
-			name,
-		}),
-	});
+		logger.log(d1BetaWarning);
 
-	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>
-	);
-}
+		if (!experimentalBackend && location) {
+			if (LOCATION_CHOICES.indexOf(location.toLowerCase()) === -1) {
+				throw new Error(
+					`Location '${location}' invalid. Valid values are ${LOCATION_CHOICES.join(
+						","
+					)}`
+				);
+			}
+		}
+
+		let db: DatabaseCreationResult;
+		try {
+			db = await fetchResult(`/accounts/${accountId}/d1/database`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({
+					name,
+					...(location && { primary_location_hint: location }),
+					...(experimentalBackend && { experimental: true }),
+				}),
+			});
+		} catch (e) {
+			if ((e as { code: number }).code === 7502) {
+				throw new Error("A database with that name already exists");
+			}
+			throw e;
+		}
+
+		logger.log(
+			renderToString(
+				<Box flexDirection="column">
+					<Text>
+						✅ Successfully created DB &apos;{db.name}&apos;
+						{db.created_in_region
+							? ` in region ${db.created_in_region}`
+							: location
+							? ` using primary location hint ${location}`
+							: ``}
+					</Text>
+					{experimentalBackend && (
+						<Text>
+							Created your database using D1&apos;s new storage backend. The new
+							storage backend is not yet recommended for production workloads
+							and does not yet support backups.
+						</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 → delete.ts}

@@ -5,16 +5,13 @@ import { logger } from "../logger";
 import { requireAuth } from "../user";
 import { Name } from "./options";
 import { d1BetaWarning, getDatabaseByNameOrBinding } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
 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> {
+export function Options(d1ListYargs: CommonYargsArgv) {
 	return Name(d1ListYargs)
 		.option("skip-confirmation", {
 			describe: "Skip confirmation",
@@ -24,10 +21,10 @@ export function Options(d1ListYargs: Argv): Argv<CreateArgs> {
 		})
 		.epilogue(d1BetaWarning);
 }
-
-export const Handler = withConfig<CreateArgs>(
+type HandlerOptions = StrictYargsOptionsToInterface<typeof Options>;
+export const Handler = withConfig<HandlerOptions>(
 	async ({ name, skipConfirmation, config }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 
 		const db: Database = await getDatabaseByNameOrBinding(
@@ -36,21 +33,21 @@ export const Handler = withConfig<CreateArgs>(
 			name
 		);
 
-		console.log(`About to delete DB '${name}' (${db.uuid}).`);
+		logger.log(`About to delete DB '${name}' (${db.uuid}).`);
 		if (!skipConfirmation) {
 			const response = await confirm(`Ok to proceed?`);
 			if (!response) {
-				console.log(`Not deleting.`);
+				logger.log(`Not deleting.`);
 				return;
 			}
 		}
 
-		console.log("Deleting...");
+		logger.log("Deleting...");
 
 		await fetchResult(`/accounts/${accountId}/d1/database/${db.uuid}`, {
 			method: "DELETE",
 		});
 
-		console.log(`Deleted '${name}' successfully.`);
+		logger.log(`Deleted '${name}' successfully.`);
 	}
 );