wrangler 0.0.0-e452a04 → 0.0.0-e464fcdb

package/src/d1/backups.tsx

@@ -0,0 +1,219 @@
+import fs from "node:fs/promises";
+import * as path from "path";
+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 { 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";
+
+export function ListOptions(yargs: CommonYargsArgv) {
+	return Name(yargs);
+}
+type ListHandlerOptions = StrictYargsOptionsToInterface<typeof ListOptions>;
+export const ListHandler = withConfig<ListHandlerOptions>(
+	async ({ config, name }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		logger.log(d1BetaWarning);
+		const db: Database = await getDatabaseByNameOrBinding(
+			config,
+			accountId,
+			name
+		);
+
+		const backups: Backup[] = await listBackups(accountId, db.uuid);
+		logger.log(
+			renderToString(
+				<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);
+};
+
+export function CreateOptions(yargs: CommonYargsArgv) {
+	return ListOptions(yargs);
+}
+type CreateHandlerOptions = StrictYargsOptionsToInterface<typeof CreateOptions>;
+
+export const CreateHandler = withConfig<CreateHandlerOptions>(
+	async ({ config, name }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		logger.log(d1BetaWarning);
+		const db: Database = await getDatabaseByNameOrBinding(
+			config,
+			accountId,
+			name
+		);
+
+		const backup: Backup = await createBackup(accountId, db.uuid);
+		logger.log(
+			renderToString(
+				<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),
+	};
+};
+
+export function RestoreOptions(yargs: CommonYargsArgv) {
+	return ListOptions(yargs).positional("backup-id", {
+		describe: "The Backup ID to restore",
+		type: "string",
+		demandOption: true,
+	});
+}
+type RestoreHandlerOptions = StrictYargsOptionsToInterface<
+	typeof RestoreOptions
+>;
+export const RestoreHandler = withConfig<RestoreHandlerOptions>(
+	async ({ config, name, backupId }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		logger.log(d1BetaWarning);
+		const db: Database = await getDatabaseByNameOrBinding(
+			config,
+			accountId,
+			name
+		);
+
+		logger.log(`Restoring ${name} from backup ${backupId}....`);
+		await restoreBackup(accountId, db.uuid, backupId);
+		logger.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",
+			},
+		}
+	);
+};
+
+export function DownloadOptions(yargs: CommonYargsArgv) {
+	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",
+		});
+}
+type DownloadHandlerOptions = StrictYargsOptionsToInterface<
+	typeof DownloadOptions
+>;
+export const DownloadHandler = withConfig<DownloadHandlerOptions>(
+	async ({ name, backupId, output, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		logger.log(d1BetaWarning);
+		const db: Database = await getDatabaseByNameOrBinding(
+			config,
+			accountId,
+			name
+		);
+		const filename =
+			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();
+		await fs.writeFile(filename, new Buffer(buffer));
+		logger.log(`🌀 Done!`);
+	}
+);
+
+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/constants.ts

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

package/src/d1/create.tsx

@@ -0,0 +1,103 @@
+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 {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { DatabaseCreationResult } from "./types";
+
+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: Europe (west)\neeur: Europe (east)\napac: Asia Pacific\nwnam: North America (west)\nenam: North America (east) \n",
+			type: "string",
+		})
+		.option("experimental", {
+			default: false,
+			describe: "Use new experimental DB backend",
+			type: "boolean",
+		})
+		.epilogue(d1BetaWarning);
+}
+
+type HandlerOptions = StrictYargsOptionsToInterface<typeof Options>;
+
+export const Handler = withConfig<HandlerOptions>(
+	async ({ name, config, experimental, location }): Promise<void> => {
+		const accountId = await requireAuth(config);
+
+		logger.log(d1BetaWarning);
+
+		if (!experimental && 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,
+					}),
+					...(experimental && { 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>
+					<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.ts

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