wrangler 2.9.0 → 2.10.0

package/src/d1/execute.tsx

@@ -27,17 +27,6 @@ import type {
 	StrictYargsOptionsToInterface,
 } from "../yargs-types";
 import type { Database } from "./types";
-import type { Statement as StatementType } from "@miniflare/d1";
-import type { createSQLiteDB as createSQLiteDBType } from "@miniflare/shared";
-
-type MiniflareNpxImportTypes = [
-	{
-		Statement: typeof StatementType;
-	},
-	{
-		createSQLiteDB: typeof createSQLiteDBType;
-	}
-];
 
 export type QueryResult = {
 	results: Record<string, string | number | boolean>[];
@@ -64,7 +53,7 @@ export function Options(yargs: CommonYargsArgv) {
 			type: "boolean",
 		})
 		.option("file", {
-			describe: "A .sql file to injest",
+			describe: "A .sql file to ingest",
 			type: "string",
 		})
 		.option("command", {
@@ -80,55 +69,19 @@ export function Options(yargs: CommonYargsArgv) {
 			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,
 		});
 }
 
-function shorten(query: string | undefined, length: number) {
-	return query && query.length > length
-		? query.slice(0, length) + "..."
-		: query;
-}
-
-export async function executeSql(
-	local: undefined | boolean,
-	config: ConfigFields<DevConfig> & Environment,
-	name: string,
-	shouldPrompt: boolean | undefined,
-	persistTo: undefined | string,
-	file?: string,
-	command?: string,
-	json?: boolean
-) {
-	const sql = file ? readFileSync(file) : command;
-	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`);
-	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,
-				batchSplit(queries),
-				json
-		  );
-}
 type HandlerOptions = StrictYargsOptionsToInterface<typeof Options>;
 
 export const Handler = async (args: HandlerOptions): Promise<void> => {
-	const { local, database, yes, persistTo, file, command, json } = args;
+	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
@@ -140,16 +93,17 @@ export const Handler = async (args: HandlerOptions): Promise<void> => {
 		return logger.error(`Error: can't provide both --command and --file.`);
 
 	const isInteractive = process.stdout.isTTY;
-	const response: QueryResult[] | null = await executeSql(
+	const response: QueryResult[] | null = await executeSql({
 		local,
 		config,
-		database,
-		isInteractive && !yes,
+		name: database,
+		shouldPrompt: isInteractive && !yes,
 		persistTo,
 		file,
 		command,
-		json
-	);
+		json,
+		preview,
+	});
 
 	// Early exit if prompt rejected
 	if (!response) return;
@@ -183,14 +137,79 @@ export const Handler = async (args: HandlerOptions): Promise<void> => {
 	}
 };
 
-async function executeLocally(
-	config: Config,
-	name: string,
-	shouldPrompt: boolean | undefined,
-	queries: string[],
-	persistTo: string | undefined,
-	json?: boolean
-) {
+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(
@@ -206,11 +225,10 @@ async function executeLocally(
 
 	const dbDir = path.join(persistencePath, "d1");
 	const dbPath = path.join(dbDir, `${localDB.binding}.sqlite3`);
-	const [{ Statement }, { createSQLiteDB }] =
-		await npxImport<MiniflareNpxImportTypes>(
-			["@miniflare/d1", "@miniflare/shared"],
-			logger.log
-		);
+	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 =
@@ -222,24 +240,28 @@ async function executeLocally(
 	}
 
 	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;
+	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: Config,
-	name: string,
-	shouldPrompt: boolean | undefined,
-	batches: string[],
-	json?: boolean
-) {
+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) {
@@ -262,8 +284,13 @@ async function executeRemotely(
 		accountId,
 		name
 	);
-
-	logger.log(`🌀 Executing on ${name} (${db.uuid}):`);
+	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) {
@@ -273,7 +300,7 @@ async function executeRemotely(
 			);
 
 		const result = await fetchResult<QueryResult[]>(
-			`/accounts/${accountId}/d1/database/${db.uuid}/query`,
+			`/accounts/${accountId}/d1/database/${dbUuid}/query`,
 			{
 				method: "POST",
 				headers: {
@@ -319,3 +346,9 @@ function batchSplit(queries: string[]) {
 	}
 	return batches;
 }
+
+function shorten(query: string | undefined, length: number) {
+	return query && query.length > length
+		? query.slice(0, length) + "..."
+		: query;
+}

package/src/d1/migrations/apply.tsx

@@ -19,7 +19,7 @@ import {
 	getUnappliedMigrations,
 	initMigrationsTable,
 } from "./helpers";
-import { DatabaseWithLocal } from "./options";
+import { MigrationOptions } from "./options";
 import type { ParseError } from "../../parse";
 import type {
 	CommonYargsArgv,
@@ -27,14 +27,16 @@ import type {
 } from "../../yargs-types";
 
 export function ApplyOptions(yargs: CommonYargsArgv) {
-	return DatabaseWithLocal(yargs);
+	return MigrationOptions(yargs);
 }
+
 type ApplyHandlerOptions = StrictYargsOptionsToInterface<typeof ApplyOptions>;
+
 export const ApplyHandler = withConfig<ApplyHandlerOptions>(
-	async ({ config, database, local, persistTo }): Promise<void> => {
+	async ({ config, database, local, persistTo, preview }): Promise<void> => {
 		logger.log(d1BetaWarning);
 
-		const databaseInfo = await getDatabaseInfoFromConfig(config, database);
+		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...`
@@ -45,31 +47,34 @@ export const ApplyHandler = withConfig<ApplyHandlerOptions>(
 			return;
 		}
 
-		const migrationsPath = await getMigrationsPath(
-			path.dirname(config.configPath),
-			databaseInfo?.migrationsFolderPath ?? DEFAULT_MIGRATION_PATH,
-			false
-		);
+		const migrationsPath = await getMigrationsPath({
+			projectPath: path.dirname(config.configPath),
+			migrationsFolderPath:
+				databaseInfo?.migrationsFolderPath ?? DEFAULT_MIGRATION_PATH,
+			createIfMissing: false,
+		});
 
-		const migrationTableName =
+		const migrationsTableName =
 			databaseInfo?.migrationsTableName ?? DEFAULT_MIGRATION_TABLE;
-		await initMigrationsTable(
-			migrationTableName,
+		await initMigrationsTable({
+			migrationsTableName,
 			local,
 			config,
-			database,
-			persistTo
-		);
+			name: database,
+			persistTo,
+			preview,
+		});
 
 		const unappliedMigrations = (
-			await getUnappliedMigrations(
-				migrationTableName,
+			await getUnappliedMigrations({
+				migrationsTableName,
 				migrationsPath,
 				local,
 				config,
-				database,
-				persistTo
-			)
+				name: database,
+				persistTo,
+				preview,
+			})
 		)
 			.map((migration) => {
 				return {
@@ -107,8 +112,8 @@ Your database may not be available to serve requests during the migration, conti
 		);
 		if (!ok) return;
 
-		// don't backup prod db when applying migrations locally
-		if (!local) {
+		// 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."
@@ -124,22 +129,24 @@ Your database may not be available to serve requests during the migration, conti
 				"utf8"
 			);
 			query += `
-								INSERT INTO ${migrationTableName} (name)
+								INSERT INTO ${migrationsTableName} (name)
 								values ('${migration.Name}');
 						`;
 
 			let success = true;
 			let errorNotes: Array<string> = [];
 			try {
-				const response = await executeSql(
+				const response = await executeSql({
 					local,
 					config,
-					database,
-					isInteractive() && !CI.isCI(),
+					name: database,
+					shouldPrompt: isInteractive() && !CI.isCI(),
 					persistTo,
-					undefined,
-					query
-				);
+					command: query,
+					file: undefined,
+					json: undefined,
+					preview,
+				});
 
 				if (response === null) {
 					// TODO:  return error

package/src/d1/migrations/create.tsx

@@ -4,7 +4,7 @@ import { Box, render, Text } from "ink";
 import React from "react";
 import { withConfig } from "../../config";
 import { logger } from "../../logger";
-import { requireAuth } from "../../user";
+import { DEFAULT_MIGRATION_PATH } from "../constants";
 import { Database } from "../options";
 import { d1BetaWarning, getDatabaseInfoFromConfig } from "../utils";
 import { getMigrationsPath, getNextMigrationNumber } from "./helpers";
@@ -20,13 +20,14 @@ export function CreateOptions(yargs: CommonYargsArgv) {
 		demandOption: true,
 	});
 }
+
 type CreateHandlerOptions = StrictYargsOptionsToInterface<typeof CreateOptions>;
+
 export const CreateHandler = withConfig<CreateHandlerOptions>(
 	async ({ config, database, message }): Promise<void> => {
-		await requireAuth({});
 		logger.log(d1BetaWarning);
 
-		const databaseInfo = await getDatabaseInfoFromConfig(config, database);
+		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...`
@@ -37,11 +38,12 @@ export const CreateHandler = withConfig<CreateHandlerOptions>(
 			return;
 		}
 
-		const migrationsPath = await getMigrationsPath(
-			path.dirname(config.configPath),
-			databaseInfo.migrationsFolderPath,
-			true
-		);
+		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(" ", "_");
 

package/src/d1/migrations/helpers.ts

@@ -10,11 +10,15 @@ 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> {
+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;
 
@@ -34,21 +38,31 @@ export async function getMigrationsPath(
 	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>> {
+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
+			persistTo,
+			preview
 		)
 	).map((migration) => {
 		return migration.name;
@@ -68,24 +82,25 @@ export async function getUnappliedMigrations(
 
 const listAppliedMigrations = async (
 	migrationsTableName: string,
-	local: undefined | boolean,
+	local: boolean | undefined,
 	config: ConfigFields<DevConfig> & Environment,
 	name: string,
-	persistTo: undefined | string
+	persistTo: string | undefined,
+	preview: boolean | undefined
 ): Promise<Migration[]> => {
-	const Query = `SELECT *
-									 FROM ${migrationsTableName}
-									 ORDER BY id`;
-
-	const response: QueryResult[] | null = await executeSql(
+	const response: QueryResult[] | null = await executeSql({
 		local,
 		config,
 		name,
-		isInteractive() && !CI.isCI(),
+		shouldPrompt: isInteractive() && !CI.isCI(),
 		persistTo,
-		undefined,
-		Query
-	);
+		command: `SELECT *
+		FROM ${migrationsTableName}
+		ORDER BY id`,
+		file: undefined,
+		json: undefined,
+		preview,
+	});
 
 	if (!response || response[0].results.length === 0) return [];
 
@@ -121,27 +136,37 @@ export function getNextMigrationNumber(migrationsPath: string): number {
 	return highestMigrationNumber + 1;
 }
 
-export const initMigrationsTable = async (
-	migrationsTableName: string,
-	local: undefined | boolean,
-	config: ConfigFields<DevConfig> & Environment,
-	name: string,
-	persistTo: undefined | string
-) => {
-	return executeSql(
+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,
-		isInteractive() && !CI.isCI(),
+		shouldPrompt: isInteractive() && !CI.isCI(),
 		persistTo,
-		undefined,
-		`
+		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/list.tsx

@@ -5,29 +5,34 @@ 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 { DatabaseWithLocal } from "./options";
+import { MigrationOptions } from "./options";
 import type {
 	CommonYargsArgv,
 	StrictYargsOptionsToInterface,
 } from "../../yargs-types";
 
 export function ListOptions(yargs: CommonYargsArgv) {
-	return DatabaseWithLocal(yargs);
+	return MigrationOptions(yargs);
 }
+
 type ListHandlerOptions = StrictYargsOptionsToInterface<typeof ListOptions>;
+
 export const ListHandler = withConfig<ListHandlerOptions>(
-	async ({ config, database, local, persistTo }): Promise<void> => {
-		await requireAuth({});
+	async ({ config, database, local, persistTo, preview }): Promise<void> => {
+		if (!local) {
+			await requireAuth({});
+		}
 		logger.log(d1BetaWarning);
 
-		const databaseInfo = await getDatabaseInfoFromConfig(config, database);
-		if (!databaseInfo) {
+		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...`
 			);
@@ -36,30 +41,36 @@ export const ListHandler = withConfig<ListHandlerOptions>(
 		if (!config.configPath) {
 			return;
 		}
-		const { migrationsTableName, migrationsFolderPath } = databaseInfo;
 
-		const migrationsPath = await getMigrationsPath(
-			path.dirname(config.configPath),
-			migrationsFolderPath,
-			false
-		);
-		await initMigrationsTable(
+		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,
-			database,
-			persistTo
-		);
+			name: database,
+			persistTo,
+			preview,
+		});
 
 		const unappliedMigrations = (
-			await getUnappliedMigrations(
+			await getUnappliedMigrations({
 				migrationsTableName,
 				migrationsPath,
 				local,
 				config,
-				database,
-				persistTo
-			)
+				name: database,
+				persistTo,
+				preview,
+			})
 		).map((migration) => {
 			return {
 				Name: migration,