wrangler 0.0.0-e64812e → 0.0.0-e6c71262

package/src/d1/migrations/apply.tsx

@@ -0,0 +1,235 @@
+import assert from "node:assert";
+import fs from "node:fs";
+import path from "path";
+import { Box, 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 { renderToString } from "../../utils/render";
+import { createBackup } from "../backups";
+import {
+	DEFAULT_MIGRATION_PATH,
+	DEFAULT_MIGRATION_TABLE,
+	DEFAULT_BATCH_SIZE,
+} 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)
+		.option("experimentalBackend", {
+			default: false,
+			describe: "Use new experimental DB backend",
+			type: "boolean",
+		})
+		.option("batch-size", {
+			describe: "Number of queries to send in a single batch",
+			type: "number",
+			default: DEFAULT_BATCH_SIZE,
+		});
+}
+
+type ApplyHandlerOptions = StrictYargsOptionsToInterface<typeof ApplyOptions>;
+
+export const ApplyHandler = withConfig<ApplyHandlerOptions>(
+	async ({
+		config,
+		database,
+		local,
+		persistTo,
+		preview,
+		experimentalBackend,
+		batchSize,
+	}): 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) {
+			logger.log(renderToString(<Text>✅ No migrations to apply!</Text>));
+			return;
+		}
+		logger.log(
+			renderToString(
+				<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, in preview, or when using the experimental backend
+		if (!(local || preview || experimentalBackend)) {
+			assert(
+				databaseInfo,
+				"In non-local mode `databaseInfo` should be defined."
+			);
+			logger.log(renderToString(<Text>🕒 Creating backup...</Text>));
+			const accountId = await requireAuth(config);
+			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,
+					batchSize,
+				});
+
+				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;
+				const maybeCause = (err.cause ?? err) as Error;
+
+				success = false;
+				errorNotes = err.notes?.map((msg) => msg.text) ?? [
+					maybeCause?.message ?? maybeCause.toString(),
+				];
+			}
+
+			migration.Status = success ? "✅" : "❌";
+
+			logger.log(
+				renderToString(
+					<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,79 @@
+import fs from "node:fs";
+import path from "path";
+import { Box, Text } from "ink";
+import React from "react";
+import { withConfig } from "../../config";
+import { logger } from "../../logger";
+import { renderToString } from "../../utils/render";
+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`
+		);
+
+		logger.log(
+			renderToString(
+				<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,171 @@
+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, DEFAULT_BATCH_SIZE } 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,
+		batchSize: DEFAULT_BATCH_SIZE,
+	});
+
+	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,
+		batchSize: DEFAULT_BATCH_SIZE,
+	});
+};

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,95 @@
+import path from "path";
+import { Box, 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 { renderToString } from "../../utils/render";
+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) {
+			logger.log(renderToString(<Text>✅ No migrations to apply!</Text>));
+			return;
+		}
+
+		logger.log(
+			renderToString(
+				<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,23 @@
+import { Database } from "../options";
+import type { CommonYargsArgv } from "../../yargs-types";
+
+export function MigrationOptions(yargs: CommonYargsArgv) {
+	return Database(yargs)
+		.option("local", {
+			describe:
+				"Execute commands/files against a local DB for use with wrangler dev --local",
+			type: "boolean",
+		})
+		.option("preview", {
+			describe: "Execute commands/files against a preview D1 DB",
+			type: "boolean",
+			default: false,
+		})
+		.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 { CommonYargsArgv } from "../yargs-types";
+
+export function Name(yargs: CommonYargsArgv) {
+	return yargs
+		.positional("name", {
+			describe: "The name or binding of the DB",
+			type: "string",
+			demandOption: true,
+		})
+		.epilogue(d1BetaWarning);
+}
+
+export function Database(yargs: CommonYargsArgv) {
+	return yargs
+		.positional("database", {
+			describe: "The name or binding of the DB",
+			type: "string",
+			demandOption: true,
+		})
+		.epilogue(d1BetaWarning);
+}