wrangler 0.0.0-e978986 → 0.0.0-e98613f8

package/src/d1/index.ts

@@ -0,0 +1,101 @@
+import * as Backups from "./backups";
+import * as Create from "./create";
+import * as Delete from "./delete";
+import * as Execute from "./execute";
+import * as List from "./list";
+import * as Migrations from "./migrations";
+import { d1BetaWarning } from "./utils";
+import type { CommonYargsOptions } from "../yargs-types";
+import type { Argv } from "yargs";
+
+export const d1 = (yargs: Argv<CommonYargsOptions>) => {
+	return (
+		yargs
+			.command("list", "List D1 databases", List.Options, List.Handler)
+			.command(
+				"create <name>",
+				"Create D1 database",
+				Create.Options,
+				Create.Handler
+			)
+			.command(
+				"delete <name>",
+				"Delete D1 database",
+				Delete.Options,
+				Delete.Handler
+			)
+			.command("backup", "Interact with D1 Backups", (yargs2) =>
+				yargs2
+					.demandCommand()
+					.command(
+						"list <name>",
+						"List your D1 backups",
+						Backups.ListOptions,
+						Backups.ListHandler
+					)
+					.command(
+						"create <name>",
+						"Create a new D1 backup",
+						Backups.CreateOptions,
+						Backups.CreateHandler
+					)
+					.command(
+						"restore <name> <backup-id>",
+						"Restore a DB backup",
+						Backups.RestoreOptions,
+						Backups.RestoreHandler
+					)
+					.command(
+						"download <name> <backup-id>",
+						"Download a DB backup",
+						Backups.DownloadOptions,
+						Backups.DownloadHandler
+					)
+					.epilogue(d1BetaWarning)
+			)
+			// .command(
+			//   "console <name>",
+			//   "Open a Console on a D1 database",
+			//   (d1CreateYargs) => {
+			//     return d1CreateYargs.positional("name", {
+			//       describe: "The name of the DB",
+			//       type: "string",
+			//       demandOption: true,
+			//     });
+			//   },
+			//   async (_) => {
+			//     // TODO
+			//   }
+			// )
+			.command(
+				"execute <database>",
+				"Executed command or SQL file",
+				Execute.Options,
+				Execute.Handler
+			)
+			.command("migrations", "Interact with D1 Migrations", (yargs2) =>
+				yargs2
+					.demandCommand()
+					.command(
+						"list <database>",
+						"List your D1 migrations",
+						Migrations.ListOptions,
+						Migrations.ListHandler
+					)
+					.command(
+						"create <database> <message>",
+						"Create a new Migration",
+						Migrations.CreateOptions,
+						Migrations.CreateHandler
+					)
+					.command(
+						"apply <database>",
+						"Apply D1 Migrations",
+						Migrations.ApplyOptions,
+						Migrations.ApplyHandler
+					)
+					.epilogue(d1BetaWarning)
+			)
+			.epilogue(d1BetaWarning)
+	);
+};

package/src/d1/list.tsx

@@ -0,0 +1,48 @@
+import { render } from "ink";
+import Table from "ink-table";
+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 ListArgs = Record<string, never>;
+
+export function Options(d1ListYargs: Argv): Argv<ListArgs> {
+	return d1ListYargs.epilogue(d1BetaWarning);
+}
+
+export async function Handler(_: ArgumentsCamelCase<ListArgs>): Promise<void> {
+	const accountId = await requireAuth({});
+	logger.log(d1BetaWarning);
+
+	const dbs: Array<Database> = await listDatabases(accountId);
+
+	render(<Table data={dbs}></Table>);
+}
+
+export const listDatabases = async (
+	accountId: string
+): Promise<Array<Database>> => {
+	const pageSize = 10;
+	let page = 1;
+	const results = [];
+	while (results.length % pageSize === 0) {
+		const json: Array<Database> = await fetchResult(
+			`/accounts/${accountId}/d1/database`,
+			{},
+			new URLSearchParams({
+				per_page: pageSize.toString(),
+				page: page.toString(),
+			})
+		);
+		page++;
+		results.push(...json);
+		if (json.length < pageSize) {
+			break;
+		}
+	}
+	return results;
+};

package/src/d1/migrations/apply.tsx

@@ -0,0 +1,184 @@
+import fs from "node:fs";
+import path from "path";
+import { Box, render, Text } from "ink";
+import Table from "ink-table";
+import React from "react";
+import { withConfig } from "../../config";
+import { confirm } from "../../dialogs";
+import { CI } from "../../is-ci";
+import isInteractive from "../../is-interactive";
+import { logger } from "../../logger";
+import { requireAuth } from "../../user";
+import { createBackup } from "../backups";
+import { executeSql } from "../execute";
+import { d1BetaWarning, getDatabaseInfoFromConfig } from "../utils";
+import {
+	getMigrationsPath,
+	getUnappliedMigrations,
+	initMigrationsTable,
+} from "./helpers";
+import { DatabaseWithLocal } from "./options";
+import type { ParseError } from "../../parse";
+import type { BaseSqlExecuteArgs } from "../execute";
+import type { Argv } from "yargs";
+
+export function ApplyOptions(yargs: Argv): Argv<BaseSqlExecuteArgs> {
+	return DatabaseWithLocal(yargs);
+}
+
+export const ApplyHandler = withConfig<BaseSqlExecuteArgs>(
+	async ({ config, database, local, persistTo }): Promise<void> => {
+		const accountId = await requireAuth({});
+		logger.log(d1BetaWarning);
+
+		const databaseInfo = await getDatabaseInfoFromConfig(config, database);
+		if (!databaseInfo) {
+			throw new Error(
+				`Can't find a DB with name/binding '${database}' in local config. Check info in wrangler.toml...`
+			);
+		}
+
+		if (!config.configPath) {
+			return;
+		}
+
+		const migrationsPath = await getMigrationsPath(
+			path.dirname(config.configPath),
+			databaseInfo.migrationsFolderPath,
+			false
+		);
+		await initMigrationsTable(
+			databaseInfo.migrationsTableName,
+			local,
+			config,
+			database,
+			persistTo
+		);
+
+		const unappliedMigrations = (
+			await getUnappliedMigrations(
+				databaseInfo.migrationsTableName,
+				migrationsPath,
+				local,
+				config,
+				database,
+				persistTo
+			)
+		)
+			.map((migration) => {
+				return {
+					Name: migration,
+					Status: "🕒️",
+				};
+			})
+			.sort((a, b) => {
+				const migrationNumberA = parseInt(a.Name.split("_")[0]);
+				const migrationNumberB = parseInt(b.Name.split("_")[0]);
+				if (migrationNumberA < migrationNumberB) {
+					return -1;
+				}
+				if (migrationNumberA > migrationNumberB) {
+					return 1;
+				}
+
+				// numbers must be equal
+				return 0;
+			});
+
+		if (unappliedMigrations.length === 0) {
+			render(<Text>✅ No migrations to apply!</Text>);
+			return;
+		}
+
+		if (isInteractive() && !CI.isCI()) {
+			const ok = await confirm(
+				`About to apply ${unappliedMigrations.length} migration(s)\n` +
+					"Your database may not be available to serve requests during the migration, continue?",
+				<Box flexDirection="column">
+					<Text>Migrations to be applied:</Text>
+					<Table data={unappliedMigrations} columns={["Name"]}></Table>
+				</Box>
+			);
+			if (!ok) return;
+		}
+
+		render(<Text>🕒 Creating backup...</Text>);
+		await createBackup(accountId, databaseInfo.uuid);
+
+		for (const migration of unappliedMigrations) {
+			let query = fs.readFileSync(
+				`${migrationsPath}/${migration.Name}`,
+				"utf8"
+			);
+			query += `
+								INSERT INTO ${databaseInfo.migrationsTableName} (name)
+								values ('${migration.Name}');
+						`;
+
+			let success = true;
+			let errorNotes: Array<string> = [];
+			try {
+				const response = await executeSql(
+					local,
+					config,
+					database,
+					isInteractive() && !CI.isCI(),
+					persistTo,
+					undefined,
+					query
+				);
+
+				if (response === null) {
+					// TODO:  return error
+					return;
+				}
+
+				for (const result of response) {
+					// When executing more than 1 statement, response turns into an array of QueryResult
+					if (Array.isArray(result)) {
+						for (const subResult of result) {
+							if (!subResult.success) {
+								success = false;
+							}
+						}
+					} else {
+						if (!result.success) {
+							success = false;
+						}
+					}
+				}
+			} catch (e) {
+				const err = e as ParseError;
+
+				success = false;
+				errorNotes = err.notes.map((msg) => msg.text);
+			}
+
+			migration.Status = success ? "✅" : "❌";
+
+			render(
+				<Box flexDirection="column">
+					<Table
+						data={unappliedMigrations}
+						columns={["Name", "Status"]}
+					></Table>
+					{errorNotes.length > 0 && (
+						<Box flexDirection="column">
+							<Text>&nbsp;</Text>
+							<Text>
+								❌ Migration {migration.Name} failed with following Errors
+							</Text>
+							<Table
+								data={errorNotes.map((err) => {
+									return { Error: err };
+								})}
+							></Table>
+						</Box>
+					)}
+				</Box>
+			);
+
+			if (errorNotes.length > 0) return;
+		}
+	}
+);

package/src/d1/migrations/create.tsx

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import path from "path";
+import { Box, render, Text } from "ink";
+import React from "react";
+import { withConfig } from "../../config";
+import { logger } from "../../logger";
+import { requireAuth } from "../../user";
+import { Database } from "../options";
+import { d1BetaWarning, getDatabaseInfoFromConfig } from "../utils";
+import { getMigrationsPath, getNextMigrationNumber } from "./helpers";
+import type { Argv } from "yargs";
+
+type MigrationsCreateArgs = {
+	config?: string;
+	database: string;
+	message: string;
+};
+
+export function CreateOptions(yargs: Argv): Argv<MigrationsCreateArgs> {
+	return Database(yargs).positional("message", {
+		describe: "The Migration message",
+		type: "string",
+		demandOption: true,
+	});
+}
+
+export const CreateHandler = withConfig<MigrationsCreateArgs>(
+	async ({ config, database, message }): Promise<void> => {
+		await requireAuth({});
+		logger.log(d1BetaWarning);
+
+		const databaseInfo = await getDatabaseInfoFromConfig(config, database);
+		if (!databaseInfo) {
+			throw new Error(
+				`Can't find a DB with name/binding '${database}' in local config. Check info in wrangler.toml...`
+			);
+		}
+
+		if (!config.configPath) {
+			return;
+		}
+
+		const migrationsPath = await getMigrationsPath(
+			path.dirname(config.configPath),
+			databaseInfo.migrationsFolderPath,
+			true
+		);
+		const nextMigrationNumber = pad(getNextMigrationNumber(migrationsPath), 4);
+		const migrationName = message.replaceAll(" ", "_");
+
+		const newMigrationName = `${nextMigrationNumber}_${migrationName}.sql`;
+
+		fs.writeFileSync(
+			`${migrationsPath}/${newMigrationName}`,
+			`-- Migration number: ${nextMigrationNumber} \t ${new Date().toISOString()}\n`
+		);
+
+		render(
+			<Box flexDirection="column">
+				<Text>
+					✅ Successfully created Migration &apos;{newMigrationName}&apos;!
+				</Text>
+				<Text>&nbsp;</Text>
+				<Text>The migration is available for editing here</Text>
+				<Text>
+					{migrationsPath}/{newMigrationName}
+				</Text>
+			</Box>
+		);
+	}
+);
+
+function pad(num: number, size: number): string {
+	let newNum = num.toString();
+	while (newNum.length < size) newNum = "0" + newNum;
+	return newNum;
+}

package/src/d1/migrations/helpers.ts

@@ -0,0 +1,147 @@
+import fs from "node:fs";
+import path from "path";
+import { confirm } from "../../dialogs";
+import { CI } from "../../is-ci";
+import isInteractive from "../../is-interactive";
+import { logger } from "../../logger";
+import { DEFAULT_MIGRATION_PATH } from "../constants";
+import { executeSql } from "../execute";
+import type { ConfigFields, DevConfig, Environment } from "../../config";
+import type { QueryResult } from "../execute";
+import type { Migration } from "../types";
+
+export async function getMigrationsPath(
+	projectPath: string,
+	migrationsFolderPath: string,
+	createIfMissing: boolean
+): Promise<string> {
+	const dir = path.resolve(projectPath, migrationsFolderPath);
+	if (fs.existsSync(dir)) return dir;
+
+	const warning = `No migrations folder found.${
+		migrationsFolderPath === DEFAULT_MIGRATION_PATH
+			? " Set `migrations_dir` in wrangler.toml to choose a different path."
+			: ""
+	}`;
+
+	if (createIfMissing && (await confirm(`${warning}\nOk to create ${dir}?`))) {
+		fs.mkdirSync(dir, { recursive: true });
+		return dir;
+	} else {
+		logger.warn(warning);
+	}
+
+	throw new Error(`No migrations present at ${dir}.`);
+}
+
+export async function getUnappliedMigrations(
+	migrationsTableName: string,
+	migrationsPath: string,
+	local: undefined | boolean,
+	config: ConfigFields<DevConfig> & Environment,
+	name: string,
+	persistTo: undefined | string
+): Promise<Array<string>> {
+	const appliedMigrations = (
+		await listAppliedMigrations(
+			migrationsTableName,
+			local,
+			config,
+			name,
+			persistTo
+		)
+	).map((migration) => {
+		return migration.name;
+	});
+	const projectMigrations = getMigrationNames(migrationsPath);
+
+	const unappliedMigrations: Array<string> = [];
+
+	for (const migration of projectMigrations) {
+		if (!appliedMigrations.includes(migration)) {
+			unappliedMigrations.push(migration);
+		}
+	}
+
+	return unappliedMigrations;
+}
+
+const listAppliedMigrations = async (
+	migrationsTableName: string,
+	local: undefined | boolean,
+	config: ConfigFields<DevConfig> & Environment,
+	name: string,
+	persistTo: undefined | string
+): Promise<Migration[]> => {
+	const Query = `SELECT *
+									 FROM ${migrationsTableName}
+									 ORDER BY id`;
+
+	const response: QueryResult[] | null = await executeSql(
+		local,
+		config,
+		name,
+		isInteractive() && !CI.isCI(),
+		persistTo,
+		undefined,
+		Query
+	);
+
+	if (!response || response[0].results.length === 0) return [];
+
+	return response[0].results as Migration[];
+};
+
+function getMigrationNames(migrationsPath: string): Array<string> {
+	const migrations = [];
+
+	const dir = fs.opendirSync(migrationsPath);
+
+	let dirent;
+	while ((dirent = dir.readSync()) !== null) {
+		if (dirent.name.endsWith(".sql")) migrations.push(dirent.name);
+	}
+
+	dir.closeSync();
+
+	return migrations;
+}
+
+export function getNextMigrationNumber(migrationsPath: string): number {
+	let highestMigrationNumber = -1;
+
+	for (const migration in getMigrationNames(migrationsPath)) {
+		const migrationNumber = parseInt(migration.split("_")[0]);
+
+		if (migrationNumber > highestMigrationNumber) {
+			highestMigrationNumber = migrationNumber;
+		}
+	}
+
+	return highestMigrationNumber + 1;
+}
+
+export const initMigrationsTable = async (
+	migrationsTableName: string,
+	local: undefined | boolean,
+	config: ConfigFields<DevConfig> & Environment,
+	name: string,
+	persistTo: undefined | string
+) => {
+	return executeSql(
+		local,
+		config,
+		name,
+		isInteractive() && !CI.isCI(),
+		persistTo,
+		undefined,
+		`
+						CREATE TABLE IF NOT EXISTS ${migrationsTableName}
+						(
+								id         INTEGER PRIMARY KEY AUTOINCREMENT,
+								name       TEXT UNIQUE,
+								applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
+						);
+				`
+	);
+};

package/src/d1/migrations/index.tsx

@@ -0,0 +1,3 @@
+export { ApplyHandler, ApplyOptions } from "./apply";
+export { CreateHandler, CreateOptions } from "./create";
+export { ListHandler, ListOptions } from "./list";

package/src/d1/migrations/list.tsx

@@ -0,0 +1,79 @@
+import path from "path";
+import { Box, render, Text } from "ink";
+import Table from "ink-table";
+import React from "react";
+import { withConfig } from "../../config";
+import { logger } from "../../logger";
+import { requireAuth } from "../../user";
+import { d1BetaWarning, getDatabaseInfoFromConfig } from "../utils";
+import {
+	getMigrationsPath,
+	getUnappliedMigrations,
+	initMigrationsTable,
+} from "./helpers";
+import { DatabaseWithLocal } from "./options";
+import type { BaseSqlExecuteArgs } from "../execute";
+import type { Argv } from "yargs";
+
+export function ListOptions(yargs: Argv): Argv<BaseSqlExecuteArgs> {
+	return DatabaseWithLocal(yargs);
+}
+
+export const ListHandler = withConfig<BaseSqlExecuteArgs>(
+	async ({ config, database, local, persistTo }): Promise<void> => {
+		await requireAuth({});
+		logger.log(d1BetaWarning);
+
+		const databaseInfo = await getDatabaseInfoFromConfig(config, database);
+		if (!databaseInfo) {
+			throw new Error(
+				`Can't find a DB with name/binding '${database}' in local config. Check info in wrangler.toml...`
+			);
+		}
+
+		if (!config.configPath) {
+			return;
+		}
+		const { migrationsTableName, migrationsFolderPath } = databaseInfo;
+
+		const migrationsPath = await getMigrationsPath(
+			path.dirname(config.configPath),
+			migrationsFolderPath,
+			false
+		);
+		await initMigrationsTable(
+			migrationsTableName,
+			local,
+			config,
+			database,
+			persistTo
+		);
+
+		const unappliedMigrations = (
+			await getUnappliedMigrations(
+				migrationsTableName,
+				migrationsPath,
+				local,
+				config,
+				database,
+				persistTo
+			)
+		).map((migration) => {
+			return {
+				Name: migration,
+			};
+		});
+
+		if (unappliedMigrations.length === 0) {
+			render(<Text>✅ No migrations to apply!</Text>);
+			return;
+		}
+
+		render(
+			<Box flexDirection="column">
+				<Text>Migrations to be applied:</Text>
+				<Table data={unappliedMigrations} columns={["Name"]}></Table>
+			</Box>
+		);
+	}
+);

package/src/d1/migrations/options.ts

@@ -0,0 +1,18 @@
+import { Database } from "../options";
+import type { Argv } from "yargs";
+
+export function DatabaseWithLocal(yargs: Argv) {
+	return Database(yargs)
+		.option("local", {
+			describe:
+				"Execute commands/files against a local DB for use with wrangler dev --local",
+			type: "boolean",
+		})
+		.option("persist-to", {
+			describe:
+				"Specify directory to use for local persistence (you must use --local with this flag)",
+			type: "string",
+			requiresArg: true,
+		})
+		.implies("persist-to", "local");
+}

package/src/d1/options.ts

@@ -0,0 +1,22 @@
+import { d1BetaWarning } from "./utils";
+import type { Argv } from "yargs";
+
+export function Name(yargs: Argv) {
+	return yargs
+		.positional("name", {
+			describe: "The name or binding of the DB",
+			type: "string",
+			demandOption: true,
+		})
+		.epilogue(d1BetaWarning);
+}
+
+export function Database(yargs: Argv) {
+	return yargs
+		.positional("database", {
+			describe: "The name or binding of the DB",
+			type: "string",
+			demandOption: true,
+		})
+		.epilogue(d1BetaWarning);
+}

package/src/d1/types.tsx

@@ -0,0 +1,24 @@
+export type Database = {
+	uuid: string;
+	name: string;
+	binding: string;
+	internal_env?: string;
+	migrationsTableName: string;
+	migrationsFolderPath: string;
+};
+
+export type Backup = {
+	id: string;
+	database_id: string;
+	created_at: string;
+	state: "progress" | "done";
+	num_tables: number;
+	file_size: number;
+	size?: string;
+};
+
+export type Migration = {
+	id: string;
+	name: string;
+	applied_at: string;
+};