wrangler 0.0.0-e178d6fb → 0.0.0-e1c2f5b9

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

package/src/d1/utils.ts

@@ -0,0 +1,48 @@
+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,
+				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
+	? ""
+	: "🚧 D1 is currently in open alpha and is not recommended for production data and traffic.\nPlease report any bugs to https://github.com/cloudflare/wrangler2/issues/new/choose.\nTo request features, visit https://community.cloudflare.com/c/developers/d1.\nTo give feedback, visit https://discord.gg/cloudflaredev";

package/src/delete.ts

@@ -0,0 +1,108 @@
+import assert from "assert";
+import path from "path";
+import { fetchResult } from "./cfetch";
+import { findWranglerToml, readConfig } from "./config";
+import { confirm } from "./dialogs";
+import { CI } from "./is-ci";
+import isInteractive from "./is-interactive";
+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 { ConfigPath } from "./index";
+import type {
+	CommonYargsOptions,
+	YargsOptionsToInterface,
+} from "./yargs-types";
+import type { Argv } from "yargs";
+
+export function deleteOptions(yargs: Argv<CommonYargsOptions>) {
+	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 = YargsOptionsToInterface<typeof deleteOptions>;
+
+export async function deleteHandler(args: DeleteArgs) {
+	await printWranglerBanner();
+
+	const configPath =
+		(args.config as ConfigPath) ||
+		(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");
+
+	let confirmed = true;
+	if (isInteractive() || !CI.isCI()) {
+		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}"`);
+	}
+}

package/src/deployments.ts

@@ -0,0 +1,83 @@
+import { URLSearchParams } from "url";
+import { fetchResult } from "./cfetch";
+import { logger } from "./logger";
+import type { ServiceMetadataRes } from "./init";
+
+export type DeploymentListRes = {
+	latest: {
+		id: string;
+		number: string;
+		metadata: {
+			author_id: string;
+			author_email: string;
+			source: "api" | "dash" | "wrangler" | "terraform" | "other";
+			created_on: string;
+			modified_on: string;
+		};
+		resources: {
+			script: string;
+			bindings: unknown[];
+		};
+	};
+	items: {
+		id: string;
+		number: string;
+		metadata: {
+			author_id: string;
+			author_email: string;
+			source: "api" | "dash" | "wrangler" | "terraform" | "other";
+			created_on: string;
+			modified_on: string;
+		};
+	}[];
+};
+
+export async function deployments(
+	accountId: string,
+	scriptName: string | undefined
+) {
+	if (!scriptName) {
+		throw new Error(
+			"Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with `--name`"
+		);
+	}
+
+	const scriptMetadata = await fetchResult<ServiceMetadataRes>(
+		`/accounts/${accountId}/workers/services/${scriptName}`
+	);
+
+	const scriptTag = scriptMetadata.default_environment.script.tag;
+	const params = new URLSearchParams({ order: "asc" });
+	const { items: deploys } = await fetchResult<DeploymentListRes>(
+		`/accounts/${accountId}/workers/deployments/by-script/${scriptTag}`,
+		undefined,
+		params
+	);
+
+	const versionMessages = deploys.map(
+		(versions) =>
+			`\nDeployment ID: ${versions.id}
+Created on: ${versions.metadata.created_on}
+Author: ${versions.metadata.author_email}
+Source: ${sourceStr(versions.metadata.source)}\n`
+	);
+
+	versionMessages[versionMessages.length - 1] += "🟩 Active";
+	logger.log(...versionMessages);
+}
+
+// TODO Include emoji/icon for each source
+function sourceStr(source: string): string {
+	switch (source) {
+		case "api":
+			return "API";
+		case "dash":
+			return "Dashboard";
+		case "wrangler":
+			return "Wrangler";
+		case "terraform":
+			return "Terraform";
+		default:
+			return "Other";
+	}
+}