wrangler 0.0.0-e7a0cd5b → 0.0.0-e7c7235fd

package/src/d1/backups.tsx

@@ -1,218 +0,0 @@
-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";
-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 ||
-			path.join(
-				process.env.INIT_CWD as string,
-				`${name}.${backupId.slice(0, 8)}.sqlite3`
-			);
-
-		logger.log(`🌀 Downloading backup ${backupId} from '${name}'`);
-		const response = await getBackupResponse(accountId, db.uuid, backupId);
-		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/create.tsx

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

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

package/src/d1/execute.tsx

@@ -1,299 +0,0 @@
-import { existsSync } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import path from "node:path";
-import { render, Static, Text } from "ink";
-import Table from "ink-table";
-import { npxImport } from "npx-import";
-import React from "react";
-import { fetchResult } from "../cfetch";
-import { withConfig } from "../config";
-import { getLocalPersistencePath } from "../dev/get-local-persistence-path";
-import { confirm, logDim } from "../dialogs";
-import { logger } from "../logger";
-import { readableRelative } from "../paths";
-import { requireAuth } from "../user";
-import { Name } from "./options";
-import {
-	d1BetaWarning,
-	getDatabaseByNameOrBinding,
-	getDatabaseInfoFromConfig,
-} from "./utils";
-import type { Config } from "../config";
-import type { Database } from "./types";
-import type splitSqlQuery from "@databases/split-sql-query";
-import type { SQL, SQLQuery } from "@databases/sql";
-import type { Statement as StatementType } from "@miniflare/d1";
-import type { createSQLiteDB as createSQLiteDBType } from "@miniflare/shared";
-import type { Argv } from "yargs";
-
-type MiniflareNpxImportTypes = [
-	{
-		Statement: typeof StatementType;
-	},
-	{
-		createSQLiteDB: typeof createSQLiteDBType;
-	}
-];
-
-type ExecuteArgs = {
-	config?: string;
-	name: string;
-	file?: string;
-	command?: string;
-	local?: boolean;
-	"persist-to"?: string;
-};
-
-type QueryResult = {
-	results: Record<string, string | number | boolean>[];
-	success: boolean;
-	duration: number;
-	query?: string;
-};
-// Max number of bytes to send in a single /execute call
-const QUERY_LIMIT = 10_000;
-
-export function Options(yargs: Argv): Argv<ExecuteArgs> {
-	return Name(yargs)
-		.option("local", {
-			describe:
-				"Execute commands/files against a local DB for use with wrangler dev",
-			type: "boolean",
-		})
-		.option("file", {
-			describe: "A .sql file to injest",
-			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,
-		});
-}
-
-function shorten(query: string | undefined, length: number) {
-	return query && query.length > length
-		? query.slice(0, length) + "..."
-		: query;
-}
-
-export const Handler = withConfig<ExecuteArgs>(
-	async ({ config, name, file, command, local, persistTo }): Promise<void> => {
-		logger.log(d1BetaWarning);
-		if (file && command)
-			return console.error(`Error: can't provide both --command and --file.`);
-		const { parser, splitter } = await loadSqlUtils();
-
-		const sql = file
-			? parser.file(file)
-			: command
-			? parser.__dangerous__rawValue(command)
-			: null;
-
-		if (!sql) throw new Error(`Error: must provide --command or --file.`);
-		if (persistTo && !local)
-			throw new Error(`Error: can't use --persist-to without --local`);
-
-		const isInteractive = process.stdout.isTTY;
-		const response: QueryResult[] | null = local
-			? await executeLocally(
-					config,
-					name,
-					isInteractive,
-					splitSql(splitter, sql),
-					persistTo
-			  )
-			: await executeRemotely(
-					config,
-					name,
-					isInteractive,
-					batchSplit(splitter, sql)
-			  );
-
-		// Early exit if prompt rejected
-		if (!response) return;
-
-		if (isInteractive) {
-			// Render table if single result
-			render(
-				<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 {
-			console.log(JSON.stringify(response, null, 2));
-		}
-	}
-);
-
-async function executeLocally(
-	config: Config,
-	name: string,
-	isInteractive: boolean,
-	queries: string[],
-	persistTo: string | 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 [{ Statement }, { createSQLiteDB }] =
-		await npxImport<MiniflareNpxImportTypes>(
-			["@miniflare/d1", "@miniflare/shared"],
-			logDim
-		);
-
-	if (!existsSync(dbDir) && isInteractive) {
-		const ok = 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 db = await createSQLiteDB(dbPath);
-
-	const results: QueryResult[] = [];
-	for (const sql of queries) {
-		const statement = new Statement(db, sql);
-		results.push((await statement.all()) as QueryResult);
-	}
-
-	return results;
-}
-
-async function executeRemotely(
-	config: Config,
-	name: string,
-	isInteractive: boolean,
-	batches: string[]
-) {
-	if (batches.length > 1) {
-		const warning = `⚠️  Too much SQL to send at once, this execution will be sent as ${batches.length} batches.`;
-
-		if (isInteractive) {
-			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 {
-			console.error(warning);
-		}
-	}
-
-	const accountId = await requireAuth({});
-	const db: Database = await getDatabaseByNameOrBinding(
-		config,
-		accountId,
-		name
-	);
-
-	if (isInteractive) {
-		logger.log(`🌀 Executing on ${name} (${db.uuid}):`);
-	} else {
-		// Pipe to error so we don't break jq
-		console.error(`Executing on ${name} (${db.uuid}):`);
-	}
-
-	const results: QueryResult[] = [];
-	for (const sql of batches) {
-		const result = await fetchResult<QueryResult[]>(
-			`/accounts/${accountId}/d1/database/${db.uuid}/query`,
-			{
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-				},
-				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 : "1"} command(s) in ${
-			Array.isArray(r)
-				? r
-						.map((d: QueryResult) => d.duration)
-						.reduce((a: number, b: number) => a + b, 0)
-				: r.duration
-		}ms`
-	);
-}
-
-function splitSql(splitter: (query: SQLQuery) => SQLQuery[], sql: SQLQuery) {
-	// We have no interpolations, so convert everything to text
-	logger.log(`🌀 Mapping SQL input into an array of statements`);
-	return splitter(sql).map(
-		(q) =>
-			q.format({
-				escapeIdentifier: (_) => "",
-				formatValue: (_, __) => ({ placeholder: "", value: "" }),
-			}).text
-	);
-}
-
-function batchSplit(splitter: typeof splitSqlQuery, sql: SQLQuery) {
-	const queries = splitSql(splitter, sql);
-	logger.log(`🌀 Parsing ${queries.length} statements`);
-	const batches: string[] = [];
-	const nbatches = Math.floor(queries.length / QUERY_LIMIT);
-	for (let i = 0; i <= nbatches; i++) {
-		batches.push(
-			queries.slice(i * QUERY_LIMIT, (i + 1) * QUERY_LIMIT).join("; ")
-		);
-	}
-	logger.log(
-		`🌀 We are sending ${batches.length} batch(es) to D1 (limited to ${QUERY_LIMIT} statements per batch)`
-	);
-	return batches;
-}
-
-async function loadSqlUtils() {
-	const [
-		{ default: parser },
-		{
-			// No idea why this is doubly-nested, see https://github.com/ForbesLindesay/atdatabases/issues/255
-			default: { default: splitter },
-		},
-	] = await npxImport<
-		[{ default: SQL }, { default: { default: typeof splitSqlQuery } }]
-	>(["@databases/sql@3.2.0", "@databases/split-sql-query@1.0.3"], logDim);
-	return { parser, splitter };
-}

package/src/d1/formatTimeAgo.ts

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