wrangler 0.0.0-e7cf0caa → 0.0.0-e8053554

package/src/create-worker-upload-form.ts

@@ -1,359 +0,0 @@
-import { readFileSync } from "node:fs";
-import { FormData, File } from "undici";
-import type {
-	CfWorkerInit,
-	CfModuleType,
-	CfDurableObjectMigrations,
-} from "./worker.js";
-
-export function toMimeType(type: CfModuleType): string {
-	switch (type) {
-		case "esm":
-			return "application/javascript+module";
-		case "commonjs":
-			return "application/javascript";
-		case "compiled-wasm":
-			return "application/wasm";
-		case "buffer":
-			return "application/octet-stream";
-		case "text":
-			return "text/plain";
-		default:
-			throw new TypeError("Unsupported module: " + type);
-	}
-}
-
-export type WorkerMetadataBinding =
-	// If you add any new binding types here, also add it to safeBindings
-	// under validateUnsafeBinding in config/validation.ts
-	| { type: "plain_text"; name: string; text: string }
-	| { type: "json"; name: string; json: unknown }
-	| { type: "wasm_module"; name: string; part: string }
-	| { type: "text_blob"; name: string; part: string }
-	| { type: "data_blob"; name: string; part: string }
-	| { type: "kv_namespace"; name: string; namespace_id: string }
-	| {
-			type: "send_email";
-			name: string;
-			destination_address?: string;
-			allowed_destination_addresses?: string[];
-	  }
-	| {
-			type: "durable_object_namespace";
-			name: string;
-			class_name: string;
-			script_name?: string;
-			environment?: string;
-	  }
-	| { type: "queue"; name: string; queue_name: string }
-	| { type: "r2_bucket"; name: string; bucket_name: string }
-	| { type: "d1"; name: string; id: string; internalEnv?: string }
-	| { type: "service"; name: string; service: string; environment?: string }
-	| { type: "analytics_engine"; name: string; dataset?: string }
-	| { type: "dispatch_namespace"; name: string; namespace: string }
-	| { type: "mtls_certificate"; name: string; certificate_id: string }
-	| {
-			type: "logfwdr";
-			name: string;
-			destination: string;
-	  };
-
-export interface WorkerMetadata {
-	/** The name of the entry point module. Only exists when the worker is in the ES module format */
-	main_module?: string;
-	/** The name of the entry point module. Only exists when the worker is in the service-worker format */
-	body_part?: string;
-	compatibility_date?: string;
-	compatibility_flags?: string[];
-	usage_model?: "bundled" | "unbound";
-	migrations?: CfDurableObjectMigrations;
-	capnp_schema?: string;
-	bindings: WorkerMetadataBinding[];
-	keep_bindings?: WorkerMetadataBinding["type"][];
-	logpush?: boolean;
-	// Allow unsafe.metadata to add arbitary properties at runtime
-	[key: string]: unknown;
-}
-
-/**
- * Creates a `FormData` upload from a `CfWorkerInit`.
- */
-export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
-	const formData = new FormData();
-	const {
-		main,
-		bindings,
-		migrations,
-		usage_model,
-		compatibility_date,
-		compatibility_flags,
-		keepVars,
-		logpush,
-	} = worker;
-
-	let { modules } = worker;
-
-	const metadataBindings: WorkerMetadata["bindings"] = [];
-
-	Object.entries(bindings.vars || {})?.forEach(([key, value]) => {
-		if (typeof value === "string") {
-			metadataBindings.push({ name: key, type: "plain_text", text: value });
-		} else {
-			metadataBindings.push({ name: key, type: "json", json: value });
-		}
-	});
-
-	bindings.kv_namespaces?.forEach(({ id, binding }) => {
-		metadataBindings.push({
-			name: binding,
-			type: "kv_namespace",
-			namespace_id: id,
-		});
-	});
-
-	bindings.send_email?.forEach(
-		({ name, destination_address, allowed_destination_addresses }) => {
-			metadataBindings.push({
-				name: name,
-				type: "send_email",
-				destination_address,
-				allowed_destination_addresses,
-			});
-		}
-	);
-
-	bindings.durable_objects?.bindings.forEach(
-		({ name, class_name, script_name, environment }) => {
-			metadataBindings.push({
-				name,
-				type: "durable_object_namespace",
-				class_name: class_name,
-				...(script_name && { script_name }),
-				...(environment && { environment }),
-			});
-		}
-	);
-
-	bindings.queues?.forEach(({ binding, queue_name }) => {
-		metadataBindings.push({
-			type: "queue",
-			name: binding,
-			queue_name,
-		});
-	});
-
-	bindings.r2_buckets?.forEach(({ binding, bucket_name }) => {
-		metadataBindings.push({
-			name: binding,
-			type: "r2_bucket",
-			bucket_name,
-		});
-	});
-
-	bindings.d1_databases?.forEach(
-		({ binding, database_id, database_internal_env }) => {
-			metadataBindings.push({
-				name: binding,
-				type: "d1",
-				id: database_id,
-				internalEnv: database_internal_env,
-			});
-		}
-	);
-
-	bindings.services?.forEach(({ binding, service, environment }) => {
-		metadataBindings.push({
-			name: binding,
-			type: "service",
-			service,
-			...(environment && { environment }),
-		});
-	});
-
-	bindings.analytics_engine_datasets?.forEach(({ binding, dataset }) => {
-		metadataBindings.push({
-			name: binding,
-			type: "analytics_engine",
-			dataset,
-		});
-	});
-
-	bindings.dispatch_namespaces?.forEach(({ binding, namespace }) => {
-		metadataBindings.push({
-			name: binding,
-			type: "dispatch_namespace",
-			namespace,
-		});
-	});
-
-	bindings.mtls_certificates?.forEach(({ binding, certificate_id }) => {
-		metadataBindings.push({
-			name: binding,
-			type: "mtls_certificate",
-			certificate_id,
-		});
-	});
-
-	bindings.logfwdr?.bindings.forEach(({ name, destination }) => {
-		metadataBindings.push({
-			name: name,
-			type: "logfwdr",
-			destination,
-		});
-	});
-
-	for (const [name, filePath] of Object.entries(bindings.wasm_modules || {})) {
-		metadataBindings.push({
-			name,
-			type: "wasm_module",
-			part: name,
-		});
-
-		formData.set(
-			name,
-			new File([readFileSync(filePath)], filePath, {
-				type: "application/wasm",
-			})
-		);
-	}
-
-	for (const [name, filePath] of Object.entries(bindings.text_blobs || {})) {
-		metadataBindings.push({
-			name,
-			type: "text_blob",
-			part: name,
-		});
-
-		if (name !== "__STATIC_CONTENT_MANIFEST") {
-			formData.set(
-				name,
-				new File([readFileSync(filePath)], filePath, {
-					type: "text/plain",
-				})
-			);
-		}
-	}
-
-	for (const [name, filePath] of Object.entries(bindings.data_blobs || {})) {
-		metadataBindings.push({
-			name,
-			type: "data_blob",
-			part: name,
-		});
-
-		formData.set(
-			name,
-			new File([readFileSync(filePath)], filePath, {
-				type: "application/octet-stream",
-			})
-		);
-	}
-
-	if (main.type === "commonjs") {
-		// This is a service-worker format worker.
-		for (const module of Object.values([...(modules || [])])) {
-			if (module.name === "__STATIC_CONTENT_MANIFEST") {
-				// Add the manifest to the form data.
-				formData.set(
-					module.name,
-					new File([module.content], module.name, {
-						type: "text/plain",
-					})
-				);
-				// And then remove it from the modules collection
-				modules = modules?.filter((m) => m !== module);
-			} else if (
-				module.type === "compiled-wasm" ||
-				module.type === "text" ||
-				module.type === "buffer"
-			) {
-				// Convert all wasm/text/data modules into `wasm_module`/`text_blob`/`data_blob` bindings.
-				// The "name" of the module is a file path. We use it
-				// to instead be a "part" of the body, and a reference
-				// that we can use inside our source. This identifier has to be a valid
-				// JS identifier, so we replace all non alphanumeric characters
-				// with an underscore.
-				const name = module.name.replace(/[^a-zA-Z0-9_$]/g, "_");
-				metadataBindings.push({
-					name,
-					type:
-						module.type === "compiled-wasm"
-							? "wasm_module"
-							: module.type === "text"
-							? "text_blob"
-							: "data_blob",
-					part: name,
-				});
-
-				// Add the module to the form data.
-				formData.set(
-					name,
-					new File([module.content], module.name, {
-						type:
-							module.type === "compiled-wasm"
-								? "application/wasm"
-								: module.type === "text"
-								? "text/plain"
-								: "application/octet-stream",
-					})
-				);
-				// And then remove it from the modules collection
-				modules = modules?.filter((m) => m !== module);
-			}
-		}
-	}
-
-	if (bindings.unsafe?.bindings) {
-		// @ts-expect-error unsafe bindings don't need to match a specific type here
-		metadataBindings.push(...bindings.unsafe.bindings);
-	}
-
-	const metadata: WorkerMetadata = {
-		...(main.type !== "commonjs"
-			? { main_module: main.name }
-			: { body_part: main.name }),
-		bindings: metadataBindings,
-		...(compatibility_date && { compatibility_date }),
-		...(compatibility_flags && { compatibility_flags }),
-		...(usage_model && { usage_model }),
-		...(migrations && { migrations }),
-		capnp_schema: bindings.logfwdr?.schema,
-		...(keepVars && { keep_bindings: ["plain_text", "json"] }),
-		...(logpush !== undefined && { logpush }),
-	};
-
-	if (bindings.unsafe?.metadata !== undefined) {
-		for (const key of Object.keys(bindings.unsafe.metadata)) {
-			metadata[key] = bindings.unsafe.metadata[key];
-		}
-	}
-
-	formData.set("metadata", JSON.stringify(metadata));
-
-	if (main.type === "commonjs" && modules && modules.length > 0) {
-		throw new TypeError(
-			"More than one module can only be specified when type = 'esm'"
-		);
-	}
-
-	for (const module of [main].concat(modules || [])) {
-		formData.set(
-			module.name,
-			new File([module.content], module.name, {
-				type: toMimeType(module.type ?? main.type ?? "esm"),
-			})
-		);
-	}
-
-	if (bindings.logfwdr && bindings.logfwdr.schema) {
-		const filePath = bindings.logfwdr.schema;
-		formData.set(
-			filePath,
-			new File([readFileSync(filePath)], filePath, {
-				type: "application/octet-stream",
-			})
-		);
-	}
-
-	return formData;
-}

package/src/d1/backups.tsx

@@ -1,219 +0,0 @@
-import fs from "node:fs/promises";
-import * as path from "path";
-import Table from "ink-table";
-import React from "react";
-import { fetchResult } from "../cfetch";
-import { performApiFetch } from "../cfetch/internal";
-import { withConfig } from "../config";
-import { logger } from "../logger";
-import { requireAuth } from "../user";
-import { renderToString } from "../utils/render";
-import { formatBytes, formatTimeAgo } from "./formatTimeAgo";
-import { Name } from "./options";
-import { d1BetaWarning, getDatabaseByNameOrBinding } from "./utils";
-import type {
-	CommonYargsArgv,
-	StrictYargsOptionsToInterface,
-} from "../yargs-types";
-import type { Backup, Database } from "./types";
-import type { Response } from "undici";
-
-export function ListOptions(yargs: CommonYargsArgv) {
-	return Name(yargs);
-}
-type ListHandlerOptions = StrictYargsOptionsToInterface<typeof ListOptions>;
-export const ListHandler = withConfig<ListHandlerOptions>(
-	async ({ config, name }): Promise<void> => {
-		const accountId = await requireAuth({});
-		logger.log(d1BetaWarning);
-		const db: Database = await getDatabaseByNameOrBinding(
-			config,
-			accountId,
-			name
-		);
-
-		const backups: Backup[] = await listBackups(accountId, db.uuid);
-		logger.log(
-			renderToString(
-				<Table
-					data={backups}
-					columns={["created_at", "id", "num_tables", "size"]}
-				></Table>
-			)
-		);
-	}
-);
-
-export const listBackups = async (
-	accountId: string,
-	uuid: string
-): Promise<Array<Backup>> => {
-	const json: Backup[] = await fetchResult(
-		`/accounts/${accountId}/d1/database/${uuid}/backup`,
-		{}
-	);
-	const results: Record<string, Backup> = {};
-
-	json
-		// First, convert created_at to a Date
-		.map((backup) => ({
-			...backup,
-			created_at: new Date(backup.created_at),
-		}))
-		// Then, sort descending based on created_at
-		.sort((a, b) => +b.created_at - +a.created_at)
-		// then group_by their human-readable timestamp i.e. "2 days ago"
-		// (storing only the first of each group)
-		// and replace the Date version with this new human-readable one
-		.forEach((backup) => {
-			const timeAgo = formatTimeAgo(backup.created_at);
-			if (!results[timeAgo]) {
-				results[timeAgo] = {
-					...backup,
-					created_at: timeAgo,
-					size: formatBytes(backup.file_size),
-				};
-			}
-		});
-
-	// Take advantage of JS objects' sorting to return the newest backup of a certain age
-	return Object.values(results);
-};
-
-export function CreateOptions(yargs: CommonYargsArgv) {
-	return ListOptions(yargs);
-}
-type CreateHandlerOptions = StrictYargsOptionsToInterface<typeof CreateOptions>;
-
-export const CreateHandler = withConfig<CreateHandlerOptions>(
-	async ({ config, name }): Promise<void> => {
-		const accountId = await requireAuth({});
-		logger.log(d1BetaWarning);
-		const db: Database = await getDatabaseByNameOrBinding(
-			config,
-			accountId,
-			name
-		);
-
-		const backup: Backup = await createBackup(accountId, db.uuid);
-		logger.log(
-			renderToString(
-				<Table
-					data={[backup]}
-					columns={["created_at", "id", "num_tables", "size", "state"]}
-				></Table>
-			)
-		);
-	}
-);
-
-export const createBackup = async (
-	accountId: string,
-	uuid: string
-): Promise<Backup> => {
-	const backup: Backup = await fetchResult(
-		`/accounts/${accountId}/d1/database/${uuid}/backup`,
-		{
-			method: "POST",
-		}
-	);
-	return {
-		...backup,
-		size: formatBytes(backup.file_size),
-	};
-};
-
-export function RestoreOptions(yargs: CommonYargsArgv) {
-	return ListOptions(yargs).positional("backup-id", {
-		describe: "The Backup ID to restore",
-		type: "string",
-		demandOption: true,
-	});
-}
-type RestoreHandlerOptions = StrictYargsOptionsToInterface<
-	typeof RestoreOptions
->;
-export const RestoreHandler = withConfig<RestoreHandlerOptions>(
-	async ({ config, name, backupId }): Promise<void> => {
-		const accountId = await requireAuth({});
-		logger.log(d1BetaWarning);
-		const db: Database = await getDatabaseByNameOrBinding(
-			config,
-			accountId,
-			name
-		);
-
-		logger.log(`Restoring ${name} from backup ${backupId}....`);
-		await restoreBackup(accountId, db.uuid, backupId);
-		logger.log(`Done!`);
-	}
-);
-
-export const restoreBackup = async (
-	accountId: string,
-	uuid: string,
-	backupId: string
-): Promise<void> => {
-	await fetchResult(
-		`/accounts/${accountId}/d1/database/${uuid}/backup/${backupId}/restore`,
-		{
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-			},
-		}
-	);
-};
-
-export function DownloadOptions(yargs: CommonYargsArgv) {
-	return ListOptions(yargs)
-		.positional("backup-id", {
-			describe: "The Backup ID to download",
-			type: "string",
-			demandOption: true,
-		})
-		.option("output", {
-			describe:
-				"The .sqlite3 file to write to (defaults to '<db-name>.<short-backup-id>.sqlite3'",
-			type: "string",
-		});
-}
-type DownloadHandlerOptions = StrictYargsOptionsToInterface<
-	typeof DownloadOptions
->;
-export const DownloadHandler = withConfig<DownloadHandlerOptions>(
-	async ({ name, backupId, output, config }): Promise<void> => {
-		const accountId = await requireAuth({});
-		logger.log(d1BetaWarning);
-		const db: Database = await getDatabaseByNameOrBinding(
-			config,
-			accountId,
-			name
-		);
-		const filename =
-			output || path.resolve(`${name}.${backupId.slice(0, 8)}.sqlite3`);
-
-		logger.log(`🌀 Downloading backup ${backupId} from '${name}'`);
-		const response = await getBackupResponse(accountId, db.uuid, backupId);
-		if (!response.ok) {
-			throw new Error(
-				`Failed to download backup ${backupId} from '${name}' - got ${response.status} from the API`
-			);
-		}
-		logger.log(`🌀 Saving to ${filename}`);
-		// TODO: stream this once we upgrade to Node18 and can use Writable.fromWeb
-		const buffer = await response.arrayBuffer();
-		await fs.writeFile(filename, new Buffer(buffer));
-		logger.log(`🌀 Done!`);
-	}
-);
-
-export const getBackupResponse = async (
-	accountId: string,
-	uuid: string,
-	backupId: string
-): Promise<Response> => {
-	return await performApiFetch(
-		`/accounts/${accountId}/d1/database/${uuid}/backup/${backupId}/download`
-	);
-};

package/src/d1/constants.ts

@@ -1,2 +0,0 @@
-export const DEFAULT_MIGRATION_PATH = "./migrations";
-export const DEFAULT_MIGRATION_TABLE = "d1_migrations";

package/src/d1/create.tsx

@@ -1,68 +0,0 @@
-import { Text, Box } from "ink";
-import React from "react";
-import { fetchResult } from "../cfetch";
-import { logger } from "../logger";
-import { requireAuth } from "../user";
-import { renderToString } from "../utils/render";
-import { d1BetaWarning } from "./utils";
-import type {
-	CommonYargsArgv,
-	StrictYargsOptionsToInterface,
-} from "../yargs-types";
-import type { Database } from "./types";
-
-export function Options(yargs: CommonYargsArgv) {
-	return yargs
-		.positional("name", {
-			describe: "The name of the new DB",
-			type: "string",
-			demandOption: true,
-		})
-		.epilogue(d1BetaWarning);
-}
-
-export async function Handler({
-	name,
-}: StrictYargsOptionsToInterface<typeof Options>): Promise<void> {
-	const accountId = await requireAuth({});
-
-	logger.log(d1BetaWarning);
-
-	let db: Database;
-	try {
-		db = await fetchResult(`/accounts/${accountId}/d1/database`, {
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-			},
-			body: JSON.stringify({
-				name,
-			}),
-		});
-	} catch (e) {
-		if ((e as { code: number }).code === 7502) {
-			throw new Error("A database with that name already exists");
-		}
-		throw e;
-	}
-
-	logger.log(
-		renderToString(
-			<Box flexDirection="column">
-				<Text>✅ Successfully created DB &apos;{db.name}&apos;!</Text>
-				<Text>&nbsp;</Text>
-				<Text>
-					Add the following to your wrangler.toml to connect to it from a
-					Worker:
-				</Text>
-				<Text>&nbsp;</Text>
-				<Text>[[ d1_databases ]]</Text>
-				<Text>
-					binding = &quot;DB&quot; # i.e. available in your Worker on env.DB
-				</Text>
-				<Text>database_name = &quot;{db.name}&quot;</Text>
-				<Text>database_id = &quot;{db.uuid}&quot;</Text>
-			</Box>
-		)
-	);
-}

package/src/d1/delete.ts

@@ -1,53 +0,0 @@
-import { fetchResult } from "../cfetch";
-import { withConfig } from "../config";
-import { confirm } from "../dialogs";
-import { logger } from "../logger";
-import { requireAuth } from "../user";
-import { Name } from "./options";
-import { d1BetaWarning, getDatabaseByNameOrBinding } from "./utils";
-import type {
-	CommonYargsArgv,
-	StrictYargsOptionsToInterface,
-} from "../yargs-types";
-import type { Database } from "./types";
-
-export function Options(d1ListYargs: CommonYargsArgv) {
-	return Name(d1ListYargs)
-		.option("skip-confirmation", {
-			describe: "Skip confirmation",
-			type: "boolean",
-			alias: "y",
-			default: false,
-		})
-		.epilogue(d1BetaWarning);
-}
-type HandlerOptions = StrictYargsOptionsToInterface<typeof Options>;
-export const Handler = withConfig<HandlerOptions>(
-	async ({ name, skipConfirmation, config }): Promise<void> => {
-		const accountId = await requireAuth({});
-		logger.log(d1BetaWarning);
-
-		const db: Database = await getDatabaseByNameOrBinding(
-			config,
-			accountId,
-			name
-		);
-
-		logger.log(`About to delete DB '${name}' (${db.uuid}).`);
-		if (!skipConfirmation) {
-			const response = await confirm(`Ok to proceed?`);
-			if (!response) {
-				logger.log(`Not deleting.`);
-				return;
-			}
-		}
-
-		logger.log("Deleting...");
-
-		await fetchResult(`/accounts/${accountId}/d1/database/${db.uuid}`, {
-			method: "DELETE",
-		});
-
-		logger.log(`Deleted '${name}' successfully.`);
-	}
-);