wrangler 2.20.0 → 3.0.0

package/src/d1/backups.tsx

@@ -1,219 +0,0 @@
-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

@@ -1,2 +0,0 @@
-export const DEFAULT_MIGRATION_PATH = "./migrations";
-export const DEFAULT_MIGRATION_TABLE = "d1_migrations";

package/src/d1/create.tsx

@@ -1,70 +0,0 @@
-import { Text, Box } 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 { 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);
-}
-
-type HandlerOptions = StrictYargsOptionsToInterface<typeof Options>;
-export const Handler = withConfig<HandlerOptions>(
-	async ({ name, config }): Promise<void> => {
-		const accountId = await requireAuth(config);
-
-		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

@@ -1,53 +0,0 @@
-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.`);
-	}
-);

package/src/d1/execute.tsx

@@ -1,357 +0,0 @@
-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(config);
-	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;
-}