wrangler 0.0.0-e452a35 → 0.0.0-e4ca780f

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);
+}

package/src/d1/splitter.ts

@@ -0,0 +1,161 @@
+/**
+ * @module
+ * This code is inspired by that of https://www.atdatabases.org/docs/split-sql-query, which is published under MIT license,
+ * and is Copyright (c) 2019 Forbes Lindesay.
+ *
+ * See https://github.com/ForbesLindesay/atdatabases/blob/103c1e7/packages/split-sql-query/src/index.ts
+ * for the original code.
+ */
+
+/**
+ * Is the given `sql` string likely to contain multiple statements.
+ *
+ * If `mayContainMultipleStatements()` returns `false` you can be confident that the sql
+ * does not contain multiple statements. Otherwise you have to check further.
+ */
+export function mayContainMultipleStatements(sql: string): boolean {
+	const trimmed = sql.trimEnd();
+	const semiColonIndex = trimmed.indexOf(";");
+	return semiColonIndex !== -1 && semiColonIndex !== trimmed.length - 1;
+}
+
+/**
+ * Split an SQLQuery into an array of statements
+ */
+export default function splitSqlQuery(sql: string): string[] {
+	if (!mayContainMultipleStatements(sql)) return [sql];
+	const split = splitSqlIntoStatements(sql);
+	if (split.length === 0) {
+		return [sql];
+	} else {
+		return split;
+	}
+}
+
+function splitSqlIntoStatements(sql: string): string[] {
+	const statements: string[] = [];
+	let str = "";
+	const compoundStatementStack: ((s: string) => boolean)[] = [];
+
+	const iterator = sql[Symbol.iterator]();
+	let next = iterator.next();
+	while (!next.done) {
+		const char = next.value;
+
+		if (compoundStatementStack[0]?.(str + char)) {
+			compoundStatementStack.shift();
+		}
+
+		switch (char) {
+			case `'`:
+			case `"`:
+			case "`":
+				str += char + consumeUntilMarker(iterator, char);
+				break;
+			case `$`: {
+				const dollarQuote =
+					"$" + consumeWhile(iterator, isDollarQuoteIdentifier);
+				str += dollarQuote;
+				if (dollarQuote.endsWith("$")) {
+					str += consumeUntilMarker(iterator, dollarQuote);
+				}
+				break;
+			}
+			case `-`:
+				str += char;
+				next = iterator.next();
+				if (!next.done && next.value === "-") {
+					str += next.value + consumeUntilMarker(iterator, "\n");
+					break;
+				} else {
+					continue;
+				}
+			case `/`:
+				str += char;
+				next = iterator.next();
+				if (!next.done && next.value === "*") {
+					str += next.value + consumeUntilMarker(iterator, "*/");
+					break;
+				} else {
+					continue;
+				}
+			case `;`:
+				if (compoundStatementStack.length === 0) {
+					statements.push(str);
+					str = "";
+				} else {
+					str += char;
+				}
+				break;
+			default:
+				str += char;
+				break;
+		}
+
+		if (isCompoundStatementStart(str)) {
+			compoundStatementStack.unshift(isCompoundStatementEnd);
+		}
+
+		next = iterator.next();
+	}
+	statements.push(str);
+
+	return statements
+		.map((statement) => statement.trim())
+		.filter((statement) => statement.length > 0);
+}
+
+/**
+ * Pulls characters from the string iterator while the predicate remains true.
+ */
+function consumeWhile(
+	iterator: Iterator<string>,
+	predicate: (str: string) => boolean
+) {
+	let next = iterator.next();
+	let str = "";
+	while (!next.done) {
+		str += next.value;
+		if (!predicate(str)) {
+			break;
+		}
+		next = iterator.next();
+	}
+	return str;
+}
+
+/**
+ * Pulls characters from the string iterator until the `endMarker` is found.
+ */
+function consumeUntilMarker(iterator: Iterator<string>, endMarker: string) {
+	return consumeWhile(iterator, (str) => !str.endsWith(endMarker));
+}
+
+/**
+ * Returns true if the `str` ends with a dollar-quoted string marker.
+ * See https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-DOLLAR-QUOTING.
+ */
+function isDollarQuoteIdentifier(str: string) {
+	const lastChar = str.slice(-1);
+	return (
+		// The $ marks the end of the identifier
+		lastChar !== "$" &&
+		// we allow numbers, underscore and letters with diacritical marks
+		(/[0-9_]/i.test(lastChar) ||
+			lastChar.toLowerCase() !== lastChar.toUpperCase())
+	);
+}
+
+/**
+ * Returns true if the `str` ends with a compound statement `BEGIN` marker.
+ */
+function isCompoundStatementStart(str: string) {
+	return /\sBEGIN\s$/.test(str);
+}
+
+/**
+ * Returns true if the `str` ends with a compound statement `END` marker.
+ */
+function isCompoundStatementEnd(str: string) {
+	return /\sEND[;\s]$/.test(str);
+}

package/src/d1/types.ts

@@ -0,0 +1,25 @@
+export type Database = {
+	uuid: string;
+	previewDatabaseUuid?: 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;
+};

package/src/d1/utils.ts

@@ -0,0 +1,49 @@
+import { DEFAULT_MIGRATION_PATH, DEFAULT_MIGRATION_TABLE } from "./constants";
+import { listDatabases } from "./list";
+import type { Config } from "../config";
+import type { Database } from "./types";
+
+export function getDatabaseInfoFromConfig(
+	config: Config,
+	name: string
+): Database | null {
+	for (const d1Database of config.d1_databases) {
+		if (
+			d1Database.database_id &&
+			(name === d1Database.database_name || name === d1Database.binding)
+		) {
+			return {
+				uuid: d1Database.database_id,
+				previewDatabaseUuid: d1Database.preview_database_id,
+				binding: d1Database.binding,
+				name: d1Database.database_name,
+				migrationsTableName:
+					d1Database.migrations_table || DEFAULT_MIGRATION_TABLE,
+				migrationsFolderPath:
+					d1Database.migrations_dir || DEFAULT_MIGRATION_PATH,
+				internal_env: d1Database.database_internal_env,
+			};
+		}
+	}
+	return null;
+}
+
+export const getDatabaseByNameOrBinding = async (
+	config: Config,
+	accountId: string,
+	name: string
+): Promise<Database> => {
+	const dbFromConfig = getDatabaseInfoFromConfig(config, name);
+	if (dbFromConfig) return dbFromConfig;
+
+	const allDBs = await listDatabases(accountId);
+	const matchingDB = allDBs.find((db) => db.name === name);
+	if (!matchingDB) {
+		throw new Error(`Couldn't find DB with name '${name}'`);
+	}
+	return matchingDB;
+};
+
+export const d1BetaWarning = process.env.NO_D1_WARNING
+	? ""
+	: "--------------------\n🚧 D1 is currently in open alpha and is not recommended for production data and traffic\n🚧 Please report any bugs to https://github.com/cloudflare/workers-sdk/issues/new/choose\n🚧 To request features, visit https://community.cloudflare.com/c/developers/d1\n🚧 To give feedback, visit https://discord.gg/cloudflaredev\n--------------------\n";

package/src/delete.ts

@@ -0,0 +1,100 @@
+import assert from "assert";
+import path from "path";
+import { fetchResult } from "./cfetch";
+import { findWranglerToml, readConfig } from "./config";
+import { confirm } from "./dialogs";
+import { deleteKVNamespace, listKVNamespaces } from "./kv/helpers";
+import { logger } from "./logger";
+import * as metrics from "./metrics";
+import { requireAuth } from "./user";
+import { getScriptName, printWranglerBanner } from "./index";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "./yargs-types";
+
+export function deleteOptions(yargs: CommonYargsArgv) {
+	return yargs
+		.positional("script", {
+			describe: "The path to an entry point for your worker",
+			type: "string",
+			requiresArg: true,
+		})
+		.option("name", {
+			describe: "Name of the worker",
+			type: "string",
+			requiresArg: true,
+		})
+		.option("dry-run", {
+			describe: "Don't actually delete",
+			type: "boolean",
+		})
+		.option("legacy-env", {
+			type: "boolean",
+			describe: "Use legacy environments",
+			hidden: true,
+		});
+}
+
+type DeleteArgs = StrictYargsOptionsToInterface<typeof deleteOptions>;
+
+export async function deleteHandler(args: DeleteArgs) {
+	await printWranglerBanner();
+
+	const configPath =
+		args.config || (args.script && findWranglerToml(path.dirname(args.script)));
+	const config = readConfig(configPath, args);
+	await metrics.sendMetricsEvent(
+		"delete worker script",
+		{},
+		{ sendMetrics: config.send_metrics }
+	);
+
+	const accountId = args.dryRun ? undefined : await requireAuth(config);
+
+	const scriptName = getScriptName(args, config);
+
+	assert(
+		scriptName,
+		"A worker name must be defined, either via --name, or in wrangler.toml"
+	);
+
+	if (args.dryRun) {
+		logger.log(`--dry-run: exiting now.`);
+		return;
+	}
+
+	assert(accountId, "Missing accountId");
+
+	const confirmed = await confirm(
+		`Are you sure you want to delete ${scriptName}? This action cannot be undone.`
+	);
+
+	if (confirmed) {
+		await fetchResult(
+			`/accounts/${accountId}/workers/services/${scriptName}`,
+			{ method: "DELETE" },
+			new URLSearchParams({ force: "true" })
+		);
+
+		await deleteSiteNamespaceIfExisting(scriptName, accountId);
+
+		logger.log("Successfully deleted", scriptName);
+	}
+}
+
+async function deleteSiteNamespaceIfExisting(
+	scriptName: string,
+	accountId: string
+): Promise<void> {
+	const title = `__${scriptName}-workers_sites_assets`;
+	const previewTitle = `__${scriptName}-workers_sites_assets_preview`;
+	const allNamespaces = await listKVNamespaces(accountId);
+	const namespacesToDelete = allNamespaces.filter(
+		(ns) => ns.title === title || ns.title === previewTitle
+	);
+	for (const ns of namespacesToDelete) {
+		await deleteKVNamespace(accountId, ns.id);
+		logger.log(`🌀 Deleted asset namespace for Workers Site "${ns.title}"`);
+	}
+}