wrangler 0.0.0-e452a35 → 0.0.0-e4ca780f

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({});
+		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({});
+		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({});
+		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({});
+		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,2 @@
+export const DEFAULT_MIGRATION_PATH = "./migrations";
+export const DEFAULT_MIGRATION_TABLE = "d1_migrations";

package/src/d1/create.tsx

@@ -0,0 +1,68 @@
+import { Text, Box } from "ink";
+import React from "react";
+import { fetchResult } from "../cfetch";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { renderToString } from "../utils/render";
+import { d1BetaWarning } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { Database } from "./types";
+
+export function Options(yargs: CommonYargsArgv) {
+	return yargs
+		.positional("name", {
+			describe: "The name of the new DB",
+			type: "string",
+			demandOption: true,
+		})
+		.epilogue(d1BetaWarning);
+}
+
+export async function Handler({
+	name,
+}: StrictYargsOptionsToInterface<typeof Options>): Promise<void> {
+	const accountId = await requireAuth({});
+
+	logger.log(d1BetaWarning);
+
+	let db: Database;
+	try {
+		db = await fetchResult(`/accounts/${accountId}/d1/database`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({
+				name,
+			}),
+		});
+	} 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;!</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({});
+		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.`);
+	}
+);

package/src/d1/execute.tsx

@@ -0,0 +1,357 @@
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import { Static, Text } from "ink";
+import Table from "ink-table";
+import { npxImport } from "npx-import";
+import React from "react";
+import { fetchResult } from "../cfetch";
+import { readConfig } from "../config";
+import { getLocalPersistencePath } from "../dev/get-local-persistence-path";
+import { confirm } from "../dialogs";
+import { logger } from "../logger";
+import { readFileSync } from "../parse";
+import { readableRelative } from "../paths";
+import { requireAuth } from "../user";
+import { renderToString } from "../utils/render";
+import * as options from "./options";
+import splitSqlQuery from "./splitter";
+import {
+	d1BetaWarning,
+	getDatabaseByNameOrBinding,
+	getDatabaseInfoFromConfig,
+} from "./utils";
+import type { Config, ConfigFields, DevConfig, Environment } from "../config";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { Database } from "./types";
+
+export type QueryResult = {
+	results: Record<string, string | number | boolean>[];
+	success: boolean;
+	meta?: {
+		duration?: number;
+	};
+	query?: string;
+};
+// Max number of statements to send in a single /execute call
+const QUERY_LIMIT = 10_000;
+
+export function Options(yargs: CommonYargsArgv) {
+	return options
+		.Database(yargs)
+		.option("yes", {
+			describe: 'Answer "yes" to any prompts',
+			type: "boolean",
+			alias: "y",
+		})
+		.option("local", {
+			describe:
+				"Execute commands/files against a local DB for use with wrangler dev",
+			type: "boolean",
+		})
+		.option("file", {
+			describe: "A .sql file to ingest",
+			type: "string",
+		})
+		.option("command", {
+			describe: "A single SQL statement to execute",
+			type: "string",
+		})
+		.option("persist-to", {
+			describe: "Specify directory to use for local persistence (for --local)",
+			type: "string",
+			requiresArg: true,
+		})
+		.option("json", {
+			describe: "Return output as clean JSON",
+			type: "boolean",
+			default: false,
+		})
+		.option("preview", {
+			describe: "Execute commands/files against a preview D1 DB",
+			type: "boolean",
+			default: false,
+		});
+}
+
+type HandlerOptions = StrictYargsOptionsToInterface<typeof Options>;
+
+export const Handler = async (args: HandlerOptions): Promise<void> => {
+	const { local, database, yes, persistTo, file, command, json, preview } =
+		args;
+	const existingLogLevel = logger.loggerLevel;
+	if (json) {
+		// set loggerLevel to error to avoid readConfig warnings appearing in JSON output
+		logger.loggerLevel = "error";
+	}
+	const config = readConfig(args.config, args);
+	logger.log(d1BetaWarning);
+	if (file && command)
+		return logger.error(`Error: can't provide both --command and --file.`);
+
+	const isInteractive = process.stdout.isTTY;
+	const response: QueryResult[] | null = await executeSql({
+		local,
+		config,
+		name: database,
+		shouldPrompt: isInteractive && !yes,
+		persistTo,
+		file,
+		command,
+		json,
+		preview,
+	});
+
+	// Early exit if prompt rejected
+	if (!response) return;
+
+	if (isInteractive && !json) {
+		// Render table if single result
+		logger.log(
+			renderToString(
+				<Static items={response}>
+					{(result) => {
+						// batch results
+						if (!Array.isArray(result)) {
+							const { results, query } = result;
+
+							if (Array.isArray(results) && results.length > 0) {
+								const shortQuery = shorten(query, 48);
+								return (
+									<>
+										{shortQuery ? <Text dimColor>{shortQuery}</Text> : null}
+										<Table data={results}></Table>
+									</>
+								);
+							}
+						}
+					}}
+				</Static>
+			)
+		);
+	} else {
+		// set loggerLevel back to what it was before to actually output the JSON in stdout
+		logger.loggerLevel = existingLogLevel;
+		logger.log(JSON.stringify(response, null, 2));
+	}
+};
+
+export async function executeSql({
+	local,
+	config,
+	name,
+	shouldPrompt,
+	persistTo,
+	file,
+	command,
+	json,
+	preview,
+}: {
+	local: boolean | undefined;
+	config: ConfigFields<DevConfig> & Environment;
+	name: string;
+	shouldPrompt: boolean | undefined;
+	persistTo: string | undefined;
+	file: string | undefined;
+	command: string | undefined;
+	json: boolean | undefined;
+	preview: boolean | undefined;
+}) {
+	const sql = file ? readFileSync(file) : command;
+	if (!sql) throw new Error(`Error: must provide --command or --file.`);
+	if (preview && local)
+		throw new Error(`Error: can't use --preview with --local`);
+	if (persistTo && !local)
+		throw new Error(`Error: can't use --persist-to without --local`);
+	logger.log(`🌀 Mapping SQL input into an array of statements`);
+	const queries = splitSqlQuery(sql);
+
+	if (file && sql) {
+		if (queries[0].startsWith("SQLite format 3")) {
+			//TODO: update this error to recommend using `wrangler d1 restore` when it exists
+			throw new Error(
+				"Provided file is a binary SQLite database file instead of an SQL text file.\nThe execute command can only process SQL text files.\nPlease export an SQL file from your SQLite database and try again."
+			);
+		}
+	}
+
+	return local
+		? await executeLocally({
+				config,
+				name,
+				shouldPrompt,
+				queries,
+				persistTo,
+				json,
+		  })
+		: await executeRemotely({
+				config,
+				name,
+				shouldPrompt,
+				batches: batchSplit(queries),
+				json,
+				preview,
+		  });
+}
+
+async function executeLocally({
+	config,
+	name,
+	shouldPrompt,
+	queries,
+	persistTo,
+	json,
+}: {
+	config: Config;
+	name: string;
+	shouldPrompt: boolean | undefined;
+	queries: string[];
+	persistTo: string | undefined;
+	json: boolean | undefined;
+}) {
+	const localDB = getDatabaseInfoFromConfig(config, name);
+	if (!localDB) {
+		throw new Error(
+			`Can't find a DB with name/binding '${name}' in local config. Check info in wrangler.toml...`
+		);
+	}
+
+	const persistencePath = getLocalPersistencePath(
+		persistTo,
+		true,
+		config.configPath
+	);
+
+	const dbDir = path.join(persistencePath, "d1");
+	const dbPath = path.join(dbDir, `${localDB.binding}.sqlite3`);
+	const [{ D1Database, D1DatabaseAPI }, { createSQLiteDB }] = await npxImport<
+		// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+		[typeof import("@miniflare/d1"), typeof import("@miniflare/shared")]
+	>(["@miniflare/d1", "@miniflare/shared"], logger.log);
+
+	if (!existsSync(dbDir)) {
+		const ok =
+			json ||
+			!shouldPrompt ||
+			(await confirm(`About to create ${readableRelative(dbPath)}, ok?`));
+		if (!ok) return null;
+		await mkdir(dbDir, { recursive: true });
+	}
+
+	logger.log(`🌀 Loading DB at ${readableRelative(dbPath)}`);
+
+	const sqliteDb = await createSQLiteDB(dbPath);
+	const db = new D1Database(new D1DatabaseAPI(sqliteDb));
+	const stmts = queries.map((query) => db.prepare(query));
+	return (await db.batch(stmts)) as QueryResult[];
+}
+
+async function executeRemotely({
+	config,
+	name,
+	shouldPrompt,
+	batches,
+	json,
+	preview,
+}: {
+	config: Config;
+	name: string;
+	shouldPrompt: boolean | undefined;
+	batches: string[];
+	json: boolean | undefined;
+	preview: boolean | undefined;
+}) {
+	const multiple_batches = batches.length > 1;
+	// in JSON mode, we don't want a prompt here
+	if (multiple_batches && !json) {
+		const warning = `⚠️  Too much SQL to send at once, this execution will be sent as ${batches.length} batches.`;
+
+		if (shouldPrompt) {
+			const ok = await confirm(
+				`${warning}\nℹ️  Each batch is sent individually and may leave your DB in an unexpected state if a later batch fails.\n⚠️  Make sure you have a recent backup. Ok to proceed?`
+			);
+			if (!ok) return null;
+			logger.log(`🌀 Let's go`);
+		} else {
+			logger.error(warning);
+		}
+	}
+
+	const accountId = await requireAuth({});
+	const db: Database = await getDatabaseByNameOrBinding(
+		config,
+		accountId,
+		name
+	);
+	if (preview && !db.previewDatabaseUuid) {
+		throw logger.error(
+			"Please define a `preview_database_id` in your wrangler.toml to execute your queries against a preview database"
+		);
+	}
+	const dbUuid = preview ? db.previewDatabaseUuid : db.uuid;
+	logger.log(`🌀 Executing on ${name} (${dbUuid}):`);
+
+	const results: QueryResult[] = [];
+	for (const sql of batches) {
+		if (multiple_batches)
+			logger.log(
+				chalk.gray(`  ${sql.slice(0, 70)}${sql.length > 70 ? "..." : ""}`)
+			);
+
+		const result = await fetchResult<QueryResult[]>(
+			`/accounts/${accountId}/d1/database/${dbUuid}/query`,
+			{
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...(db.internal_env ? { "x-d1-internal-env": db.internal_env } : {}),
+				},
+				body: JSON.stringify({ sql }),
+			}
+		);
+		result.map(logResult);
+		results.push(...result);
+	}
+	return results;
+}
+
+function logResult(r: QueryResult | QueryResult[]) {
+	logger.log(
+		`🚣 Executed ${
+			Array.isArray(r) ? `${r.length} commands` : "1 command"
+		} in ${
+			Array.isArray(r)
+				? r
+						.map((d: QueryResult) => d.meta?.duration || 0)
+						.reduce((a: number, b: number) => a + b, 0)
+				: r.meta?.duration
+		}ms`
+	);
+}
+
+function batchSplit(queries: string[]) {
+	logger.log(`🌀 Parsing ${queries.length} statements`);
+	const num_batches = Math.ceil(queries.length / QUERY_LIMIT);
+	const batches: string[] = [];
+	for (let i = 0; i < num_batches; i++) {
+		batches.push(
+			queries.slice(i * QUERY_LIMIT, (i + 1) * QUERY_LIMIT).join("; ")
+		);
+	}
+	if (num_batches > 1) {
+		logger.log(
+			`🌀 We are sending ${num_batches} batch(es) to D1 (limited to ${QUERY_LIMIT} statements per batch)`
+		);
+	}
+	return batches;
+}
+
+function shorten(query: string | undefined, length: number) {
+	return query && query.length > length
+		? query.slice(0, length) + "..."
+		: query;
+}

package/src/d1/formatTimeAgo.ts

@@ -0,0 +1,14 @@
+import TimeAgo from "javascript-time-ago";
+import en from "javascript-time-ago/locale/en";
+import prettyBytes from "pretty-bytes";
+TimeAgo.addDefaultLocale(en);
+const timeAgo = new TimeAgo("en-US");
+
+export const formatTimeAgo = (date: Date): string => {
+	const result = timeAgo.format(date);
+	return Array.isArray(result) ? result[0] : result;
+};
+
+export const formatBytes = (bytes: number): string => {
+	return prettyBytes(bytes);
+};