wrangler 0.0.0-e6733a3 → 0.0.0-e6e1daba

package/src/d1/index.ts

@@ -0,0 +1,100 @@
+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 { CommonYargsArgv } from "../yargs-types";
+
+export function d1(yargs: CommonYargsArgv) {
+	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", (backupArgs) =>
+				backupArgs
+					.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,60 @@
+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 {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { Database } from "./types";
+
+export function Options(d1ListYargs: CommonYargsArgv) {
+	return d1ListYargs
+		.option("json", {
+			describe: "return output as clean JSON",
+			type: "boolean",
+			default: false,
+		})
+		.epilogue(d1BetaWarning);
+}
+
+export async function Handler({
+	json,
+}: StrictYargsOptionsToInterface<typeof Options>): Promise<void> {
+	const accountId = await requireAuth({});
+	const dbs: Array<Database> = await listDatabases(accountId);
+
+	if (json) {
+		logger.log(JSON.stringify(dbs, null, 2));
+	} else {
+		logger.log(d1BetaWarning);
+		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,206 @@
+import assert from "node:assert";
+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 { DEFAULT_MIGRATION_PATH, DEFAULT_MIGRATION_TABLE } from "../constants";
+import { executeSql } from "../execute";
+import { d1BetaWarning, getDatabaseInfoFromConfig } from "../utils";
+import {
+	getMigrationsPath,
+	getUnappliedMigrations,
+	initMigrationsTable,
+} from "./helpers";
+import { MigrationOptions } from "./options";
+import type { ParseError } from "../../parse";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../../yargs-types";
+
+export function ApplyOptions(yargs: CommonYargsArgv) {
+	return MigrationOptions(yargs);
+}
+
+type ApplyHandlerOptions = StrictYargsOptionsToInterface<typeof ApplyOptions>;
+
+export const ApplyHandler = withConfig<ApplyHandlerOptions>(
+	async ({ config, database, local, persistTo, preview }): Promise<void> => {
+		logger.log(d1BetaWarning);
+
+		const databaseInfo = getDatabaseInfoFromConfig(config, database);
+		if (!databaseInfo && !local) {
+			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({
+			projectPath: path.dirname(config.configPath),
+			migrationsFolderPath:
+				databaseInfo?.migrationsFolderPath ?? DEFAULT_MIGRATION_PATH,
+			createIfMissing: false,
+		});
+
+		const migrationsTableName =
+			databaseInfo?.migrationsTableName ?? DEFAULT_MIGRATION_TABLE;
+		await initMigrationsTable({
+			migrationsTableName,
+			local,
+			config,
+			name: database,
+			persistTo,
+			preview,
+		});
+
+		const unappliedMigrations = (
+			await getUnappliedMigrations({
+				migrationsTableName,
+				migrationsPath,
+				local,
+				config,
+				name: database,
+				persistTo,
+				preview,
+			})
+		)
+			.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;
+		}
+		render(
+			<Box flexDirection="column">
+				<Text>Migrations to be applied:</Text>
+				<Table data={unappliedMigrations} columns={["Name"]}></Table>
+			</Box>
+		);
+		const ok = await confirm(
+			`About to apply ${unappliedMigrations.length} migration(s)
+Your database may not be available to serve requests during the migration, continue?`
+		);
+		if (!ok) return;
+
+		// don't backup prod db when applying migrations locally or in preview
+		if (!local && !preview) {
+			assert(
+				databaseInfo,
+				"In non-local mode `databaseInfo` should be defined."
+			);
+			render(<Text>🕒 Creating backup...</Text>);
+			const accountId = await requireAuth({});
+			await createBackup(accountId, databaseInfo.uuid);
+		}
+
+		for (const migration of unappliedMigrations) {
+			let query = fs.readFileSync(
+				`${migrationsPath}/${migration.Name}`,
+				"utf8"
+			);
+			query += `
+								INSERT INTO ${migrationsTableName} (name)
+								values ('${migration.Name}');
+						`;
+
+			let success = true;
+			let errorNotes: Array<string> = [];
+			try {
+				const response = await executeSql({
+					local,
+					config,
+					name: database,
+					shouldPrompt: isInteractive() && !CI.isCI(),
+					persistTo,
+					command: query,
+					file: undefined,
+					json: undefined,
+					preview,
+				});
+
+				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) ?? [
+					err.message ?? err.toString(),
+				];
+			}
+
+			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,76 @@
+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 { DEFAULT_MIGRATION_PATH } from "../constants";
+import { Database } from "../options";
+import { d1BetaWarning, getDatabaseInfoFromConfig } from "../utils";
+import { getMigrationsPath, getNextMigrationNumber } from "./helpers";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../../yargs-types";
+
+export function CreateOptions(yargs: CommonYargsArgv) {
+	return Database(yargs).positional("message", {
+		describe: "The Migration message",
+		type: "string",
+		demandOption: true,
+	});
+}
+
+type CreateHandlerOptions = StrictYargsOptionsToInterface<typeof CreateOptions>;
+
+export const CreateHandler = withConfig<CreateHandlerOptions>(
+	async ({ config, database, message }): Promise<void> => {
+		logger.log(d1BetaWarning);
+
+		const databaseInfo = 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({
+			projectPath: path.dirname(config.configPath),
+			migrationsFolderPath:
+				databaseInfo.migrationsFolderPath ?? DEFAULT_MIGRATION_PATH,
+			createIfMissing: 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,172 @@
+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,
+	migrationsFolderPath,
+	createIfMissing,
+}: {
+	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,
+	migrationsPath,
+	local,
+	config,
+	name,
+	persistTo,
+	preview,
+}: {
+	migrationsTableName: string;
+	migrationsPath: string;
+	local: boolean | undefined;
+	config: ConfigFields<DevConfig> & Environment;
+	name: string;
+	persistTo: string | undefined;
+	preview: boolean | undefined;
+}): Promise<Array<string>> {
+	const appliedMigrations = (
+		await listAppliedMigrations(
+			migrationsTableName,
+			local,
+			config,
+			name,
+			persistTo,
+			preview
+		)
+	).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: boolean | undefined,
+	config: ConfigFields<DevConfig> & Environment,
+	name: string,
+	persistTo: string | undefined,
+	preview: boolean | undefined
+): Promise<Migration[]> => {
+	const response: QueryResult[] | null = await executeSql({
+		local,
+		config,
+		name,
+		shouldPrompt: isInteractive() && !CI.isCI(),
+		persistTo,
+		command: `SELECT *
+		FROM ${migrationsTableName}
+		ORDER BY id`,
+		file: undefined,
+		json: undefined,
+		preview,
+	});
+
+	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,
+	local,
+	config,
+	name,
+	persistTo,
+	preview,
+}: {
+	migrationsTableName: string;
+	local: boolean | undefined;
+	config: ConfigFields<DevConfig> & Environment;
+	name: string;
+	persistTo: string | undefined;
+	preview: boolean | undefined;
+}) => {
+	return executeSql({
+		local,
+		config,
+		name,
+		shouldPrompt: isInteractive() && !CI.isCI(),
+		persistTo,
+		command: `
+						CREATE TABLE IF NOT EXISTS ${migrationsTableName}
+						(
+								id         INTEGER PRIMARY KEY AUTOINCREMENT,
+								name       TEXT UNIQUE,
+								applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
+						);
+				`,
+		file: undefined,
+		json: undefined,
+		preview,
+	});
+};

package/src/d1/migrations/index.ts

@@ -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,92 @@
+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 { DEFAULT_MIGRATION_PATH, DEFAULT_MIGRATION_TABLE } from "../constants";
+import { d1BetaWarning, getDatabaseInfoFromConfig } from "../utils";
+import {
+	getMigrationsPath,
+	getUnappliedMigrations,
+	initMigrationsTable,
+} from "./helpers";
+import { MigrationOptions } from "./options";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../../yargs-types";
+
+export function ListOptions(yargs: CommonYargsArgv) {
+	return MigrationOptions(yargs);
+}
+
+type ListHandlerOptions = StrictYargsOptionsToInterface<typeof ListOptions>;
+
+export const ListHandler = withConfig<ListHandlerOptions>(
+	async ({ config, database, local, persistTo, preview }): Promise<void> => {
+		if (!local) {
+			await requireAuth({});
+		}
+		logger.log(d1BetaWarning);
+
+		const databaseInfo = getDatabaseInfoFromConfig(config, database);
+		if (!databaseInfo && !local) {
+			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({
+			projectPath: path.dirname(config.configPath),
+			migrationsFolderPath:
+				databaseInfo?.migrationsFolderPath ?? DEFAULT_MIGRATION_PATH,
+			createIfMissing: false,
+		});
+
+		const migrationsTableName =
+			databaseInfo?.migrationsTableName ?? DEFAULT_MIGRATION_TABLE;
+
+		await initMigrationsTable({
+			migrationsTableName,
+			local,
+			config,
+			name: database,
+			persistTo,
+			preview,
+		});
+
+		const unappliedMigrations = (
+			await getUnappliedMigrations({
+				migrationsTableName,
+				migrationsPath,
+				local,
+				config,
+				name: database,
+				persistTo,
+				preview,
+			})
+		).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>
+		);
+	}
+);