wrangler 0.0.0-e7cf0caa → 0.0.0-e87ad068

package/src/constellation/uploadModel.tsx

@@ -0,0 +1,84 @@
+import { readFileSync } from "node:fs";
+import { FormData, File } from "undici";
+import { fetchResult } from "../cfetch";
+import { withConfig } from "../config";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { constellationBetaWarning, getProjectByName } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { Model } from "./types";
+
+export function options(yargs: CommonYargsArgv) {
+	return yargs
+		.positional("projectName", {
+			describe: "The name of the project",
+			type: "string",
+			demandOption: true,
+		})
+		.positional("modelName", {
+			describe: "The name of the uploaded model",
+			type: "string",
+			demandOption: true,
+		})
+		.positional("modelFile", {
+			describe: "The name of the local file with the model contents",
+			type: "string",
+			demandOption: true,
+		})
+		.option("description", {
+			describe: "include a description of the model",
+			type: "string",
+			demandOption: false,
+			alias: "d",
+		})
+		.epilogue(constellationBetaWarning);
+}
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({
+		projectName,
+		modelName,
+		modelFile,
+		description,
+		config,
+	}): Promise<void> => {
+		const accountId = await requireAuth(config);
+		logger.log(constellationBetaWarning);
+
+		const proj = await getProjectByName(config, accountId, projectName);
+
+		const formData = new FormData();
+		formData.set(
+			"file",
+			new File([readFileSync(modelFile)], modelFile, {
+				type: "application/octet-stream",
+			})
+		);
+		formData.set("name", modelName);
+
+		if (description !== undefined) {
+			formData.set("description", description);
+		}
+
+		let model: Model;
+		try {
+			model = await fetchResult(
+				`/accounts/${accountId}/constellation/project/${proj.id}/model`,
+				{
+					method: "POST",
+					body: formData,
+				}
+			);
+		} catch (e) {
+			if ((e as { code: number }).code === 7408) {
+				throw new Error("A model with that name already exists");
+			}
+			throw e;
+		}
+
+		logger.log(`✅ Successfully uploaded Model "${model.name}"!`);
+	}
+);

package/src/constellation/utils.ts

@@ -0,0 +1,90 @@
+import { fetchResult } from "../cfetch";
+import { getEnvironmentVariableFactory } from "../environment-variables/factory";
+import type { Config } from "../config";
+import type { Project, Model, CatalogEntry } from "./types";
+
+export const getConstellationWarningFromEnv = getEnvironmentVariableFactory({
+	variableName: "NO_CONSTELLATION_WARNING",
+});
+
+export const constellationBetaWarning =
+	getConstellationWarningFromEnv() !== undefined
+		? ""
+		: "--------------------\n🚧 Constellation 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 give feedback, visit https://discord.gg/cloudflaredev\n--------------------\n";
+
+export const getProjectByName = async (
+	config: Config,
+	accountId: string,
+	name: string
+): Promise<Project> => {
+	const allProjects = await listProjects(accountId);
+	const matchingProj = allProjects.find((proj) => proj.name === name);
+	if (!matchingProj) {
+		throw new Error(`Couldn't find Project with name '${name}'`);
+	}
+	return matchingProj;
+};
+
+export const getProjectModelByName = async (
+	config: Config,
+	accountId: string,
+	proj: Project,
+	modelName: string
+): Promise<Model> => {
+	const allModels = await listModels(accountId, proj);
+	const matchingModel = allModels.find((model) => model.name === modelName);
+	if (!matchingModel) {
+		throw new Error(`Couldn't find Model with name '${modelName}'`);
+	}
+	return matchingModel;
+};
+
+export async function constellationList<ResponseType>(
+	accountId: string,
+	partialUrl: string
+): Promise<Array<ResponseType>> {
+	const pageSize = 50;
+	let page = 1;
+	const results = [];
+	while (results.length % pageSize === 0) {
+		const json: Array<ResponseType> = await fetchResult(
+			`/accounts/${accountId}/constellation/${partialUrl}`,
+			{},
+			new URLSearchParams({
+				per_page: pageSize.toString(),
+				page: page.toString(),
+			})
+		);
+		page++;
+		results.push(...json);
+		if (json.length < pageSize) {
+			break;
+		}
+	}
+	return results;
+}
+
+export const listCatalogEntries = async (
+	accountId: string
+): Promise<Array<CatalogEntry>> => {
+	return await constellationList(accountId, "catalog");
+};
+
+export const listModels = async (
+	accountId: string,
+	proj: Project
+): Promise<Array<Model>> => {
+	return constellationList(accountId, `project/${proj.id}/model`);
+};
+
+export const listProjects = async (
+	accountId: string
+): Promise<Array<Project>> => {
+	return await constellationList(accountId, "project");
+};
+
+export const listRuntimes = async (
+	accountId: string
+): Promise<Array<string>> => {
+	return await constellationList(accountId, "runtime");
+};

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

@@ -4,6 +4,8 @@ import type {
 	CfWorkerInit,
 	CfModuleType,
 	CfDurableObjectMigrations,
+	CfPlacement,
+	CfTailConsumer,
 } from "./worker.js";
 
 export function toMimeType(type: CfModuleType): string {
@@ -30,6 +32,7 @@ export type WorkerMetadataBinding =
 	| { type: "json"; name: string; json: unknown }
 	| { type: "wasm_module"; name: string; part: string }
 	| { type: "text_blob"; name: string; part: string }
+	| { type: "browser"; name: string }
 	| { type: "data_blob"; name: string; part: string }
 	| { type: "kv_namespace"; name: string; namespace_id: string }
 	| {
@@ -48,6 +51,7 @@ export type WorkerMetadataBinding =
 	| { type: "queue"; name: string; queue_name: string }
 	| { type: "r2_bucket"; name: string; bucket_name: string }
 	| { type: "d1"; name: string; id: string; internalEnv?: string }
+	| { type: "constellation"; name: string; project: string }
 	| { type: "service"; name: string; service: string; environment?: string }
 	| { type: "analytics_engine"; name: string; dataset?: string }
 	| { type: "dispatch_namespace"; name: string; namespace: string }
@@ -71,6 +75,8 @@ export interface WorkerMetadata {
 	bindings: WorkerMetadataBinding[];
 	keep_bindings?: WorkerMetadataBinding["type"][];
 	logpush?: boolean;
+	placement?: CfPlacement;
+	tail_consumers?: CfTailConsumer[];
 	// Allow unsafe.metadata to add arbitary properties at runtime
 	[key: string]: unknown;
 }
@@ -89,6 +95,8 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		compatibility_flags,
 		keepVars,
 		logpush,
+		placement,
+		tail_consumers,
 	} = worker;
 
 	let { modules } = worker;
@@ -161,6 +169,14 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		}
 	);
 
+	bindings.constellation?.forEach(({ binding, project_id }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "constellation",
+			project: project_id,
+		});
+	});
+
 	bindings.services?.forEach(({ binding, service, environment }) => {
 		metadataBindings.push({
 			name: binding,
@@ -217,6 +233,13 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		);
 	}
 
+	if (bindings.browser !== undefined) {
+		metadataBindings.push({
+			name: bindings.browser.binding,
+			type: "browser",
+		});
+	}
+
 	for (const [name, filePath] of Object.entries(bindings.text_blobs || {})) {
 		metadataBindings.push({
 			name,
@@ -320,6 +343,8 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		capnp_schema: bindings.logfwdr?.schema,
 		...(keepVars && { keep_bindings: ["plain_text", "json"] }),
 		...(logpush !== undefined && { logpush }),
+		...(placement && { placement }),
+		...(tail_consumers && { tail_consumers }),
 	};
 
 	if (bindings.unsafe?.metadata !== undefined) {

package/src/d1/backups.tsx

@@ -24,7 +24,7 @@ export function ListOptions(yargs: CommonYargsArgv) {
 type ListHandlerOptions = StrictYargsOptionsToInterface<typeof ListOptions>;
 export const ListHandler = withConfig<ListHandlerOptions>(
 	async ({ config, name }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 		const db: Database = await getDatabaseByNameOrBinding(
 			config,
@@ -87,7 +87,7 @@ type CreateHandlerOptions = StrictYargsOptionsToInterface<typeof CreateOptions>;
 
 export const CreateHandler = withConfig<CreateHandlerOptions>(
 	async ({ config, name }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 		const db: Database = await getDatabaseByNameOrBinding(
 			config,
@@ -135,7 +135,7 @@ type RestoreHandlerOptions = StrictYargsOptionsToInterface<
 >;
 export const RestoreHandler = withConfig<RestoreHandlerOptions>(
 	async ({ config, name, backupId }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 		const db: Database = await getDatabaseByNameOrBinding(
 			config,
@@ -183,7 +183,7 @@ type DownloadHandlerOptions = StrictYargsOptionsToInterface<
 >;
 export const DownloadHandler = withConfig<DownloadHandlerOptions>(
 	async ({ name, backupId, output, config }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 		const db: Database = await getDatabaseByNameOrBinding(
 			config,

package/src/d1/constants.ts

@@ -1,2 +1,5 @@
 export const DEFAULT_MIGRATION_PATH = "./migrations";
 export const DEFAULT_MIGRATION_TABLE = "d1_migrations";
+export const LOCATION_CHOICES = ["weur", "eeur", "apac", "wnam", "enam"];
+// Max number of statements to send in a single /execute call
+export const DEFAULT_BATCH_SIZE = 10_000;

package/src/d1/create.tsx

@@ -1,15 +1,17 @@
-import { Text, Box } from "ink";
+import { Box, Text } from "ink";
 import React from "react";
 import { fetchResult } from "../cfetch";
+import { withConfig } from "../config";
 import { logger } from "../logger";
 import { requireAuth } from "../user";
 import { renderToString } from "../utils/render";
+import { LOCATION_CHOICES } from "./constants";
 import { d1BetaWarning } from "./utils";
 import type {
 	CommonYargsArgv,
 	StrictYargsOptionsToInterface,
 } from "../yargs-types";
-import type { Database } from "./types";
+import type { DatabaseCreationResult } from "./types";
 
 export function Options(yargs: CommonYargsArgv) {
 	return yargs
@@ -18,51 +20,83 @@ export function Options(yargs: CommonYargsArgv) {
 			type: "string",
 			demandOption: true,
 		})
+		.option("location", {
+			describe:
+				"A hint for the primary location of the new DB. Options:\nweur: Western Europe\neeur: Eastern Europe\napac: Asia Pacific\nwnam: Western North America\nenam: Eastern North America \n",
+			type: "string",
+		})
+		.option("experimental-backend", {
+			default: false,
+			describe: "Use new experimental DB backend",
+			type: "boolean",
+		})
 		.epilogue(d1BetaWarning);
 }
 
-export async function Handler({
-	name,
-}: StrictYargsOptionsToInterface<typeof Options>): Promise<void> {
-	const accountId = await requireAuth({});
+type HandlerOptions = StrictYargsOptionsToInterface<typeof Options>;
+export const Handler = withConfig<HandlerOptions>(
+	async ({ name, config, location, experimentalBackend }): Promise<void> => {
+		const accountId = await requireAuth(config);
 
-	logger.log(d1BetaWarning);
+		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");
+		if (!experimentalBackend && location) {
+			if (LOCATION_CHOICES.indexOf(location.toLowerCase()) === -1) {
+				throw new Error(
+					`Location '${location}' invalid. Valid values are ${LOCATION_CHOICES.join(
+						","
+					)}`
+				);
+			}
 		}
-		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>
-		)
-	);
-}
+		let db: DatabaseCreationResult;
+		try {
+			db = await fetchResult(`/accounts/${accountId}/d1/database`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({
+					name,
+					...(location && { primary_location_hint: location }),
+					...(experimentalBackend && { experimental: true }),
+				}),
+			});
+		} 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;
+						{db.created_in_region
+							? ` in region ${db.created_in_region}`
+							: location
+							? ` using primary location hint ${location}`
+							: ``}
+					</Text>
+					{experimentalBackend && (
+						<Text>
+							Created your database using D1&apos;s new storage backend. The new
+							storage backend is not yet recommended for production workloads
+							and does not yet support backups.
+						</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

@@ -24,7 +24,7 @@ export function Options(d1ListYargs: CommonYargsArgv) {
 type HandlerOptions = StrictYargsOptionsToInterface<typeof Options>;
 export const Handler = withConfig<HandlerOptions>(
 	async ({ name, skipConfirmation, config }): Promise<void> => {
-		const accountId = await requireAuth({});
+		const accountId = await requireAuth(config);
 		logger.log(d1BetaWarning);
 
 		const db: Database = await getDatabaseByNameOrBinding(

package/src/d1/execute.tsx

@@ -15,6 +15,7 @@ import { readFileSync } from "../parse";
 import { readableRelative } from "../paths";
 import { requireAuth } from "../user";
 import { renderToString } from "../utils/render";
+import { DEFAULT_BATCH_SIZE } from "./constants";
 import * as options from "./options";
 import splitSqlQuery from "./splitter";
 import {
@@ -37,8 +38,6 @@ export type QueryResult = {
 	};
 	query?: string;
 };
-// Max number of statements to send in a single /execute call
-const QUERY_LIMIT = 10_000;
 
 export function Options(yargs: CommonYargsArgv) {
 	return options
@@ -75,14 +74,28 @@ export function Options(yargs: CommonYargsArgv) {
 			describe: "Execute commands/files against a preview D1 DB",
 			type: "boolean",
 			default: false,
+		})
+		.option("batch-size", {
+			describe: "Number of queries to send in a single batch",
+			type: "number",
+			default: DEFAULT_BATCH_SIZE,
 		});
 }
 
 type HandlerOptions = StrictYargsOptionsToInterface<typeof Options>;
 
 export const Handler = async (args: HandlerOptions): Promise<void> => {
-	const { local, database, yes, persistTo, file, command, json, preview } =
-		args;
+	const {
+		local,
+		database,
+		yes,
+		persistTo,
+		file,
+		command,
+		json,
+		preview,
+		batchSize,
+	} = args;
 	const existingLogLevel = logger.loggerLevel;
 	if (json) {
 		// set loggerLevel to error to avoid readConfig warnings appearing in JSON output
@@ -104,6 +117,7 @@ export const Handler = async (args: HandlerOptions): Promise<void> => {
 		command,
 		json,
 		preview,
+		batchSize,
 	});
 
 	// Early exit if prompt rejected
@@ -150,6 +164,7 @@ export async function executeSql({
 	command,
 	json,
 	preview,
+	batchSize,
 }: {
 	local: boolean | undefined;
 	config: ConfigFields<DevConfig> & Environment;
@@ -160,6 +175,7 @@ export async function executeSql({
 	command: string | undefined;
 	json: boolean | undefined;
 	preview: boolean | undefined;
+	batchSize: number;
 }) {
 	const sql = file ? readFileSync(file) : command;
 	if (!sql) throw new Error(`Error: must provide --command or --file.`);
@@ -192,7 +208,7 @@ export async function executeSql({
 				config,
 				name,
 				shouldPrompt,
-				batches: batchSplit(queries),
+				batches: batchSplit(queries, batchSize),
 				json,
 				preview,
 		  });
@@ -281,7 +297,7 @@ async function executeRemotely({
 		}
 	}
 
-	const accountId = await requireAuth({});
+	const accountId = await requireAuth(config);
 	const db: Database = await getDatabaseByNameOrBinding(
 		config,
 		accountId,
@@ -313,7 +329,7 @@ async function executeRemotely({
 				body: JSON.stringify({ sql }),
 			}
 		);
-		result.map(logResult);
+		logResult(result);
 		results.push(...result);
 	}
 	return results;
@@ -333,18 +349,16 @@ function logResult(r: QueryResult | QueryResult[]) {
 	);
 }
 
-function batchSplit(queries: string[]) {
+function batchSplit(queries: string[], batchSize: number) {
 	logger.log(`🌀 Parsing ${queries.length} statements`);
-	const num_batches = Math.ceil(queries.length / QUERY_LIMIT);
+	const num_batches = Math.ceil(queries.length / batchSize);
 	const batches: string[] = [];
 	for (let i = 0; i < num_batches; i++) {
-		batches.push(
-			queries.slice(i * QUERY_LIMIT, (i + 1) * QUERY_LIMIT).join("; ")
-		);
+		batches.push(queries.slice(i * batchSize, (i + 1) * batchSize).join("; "));
 	}
 	if (num_batches > 1) {
 		logger.log(
-			`🌀 We are sending ${num_batches} batch(es) to D1 (limited to ${QUERY_LIMIT} statements per batch)`
+			`🌀 We are sending ${num_batches} batch(es) to D1 (limited to ${batchSize} statements per batch. Use --batch-size to override.)`
 		);
 	}
 	return batches;

package/src/d1/list.tsx

@@ -1,6 +1,7 @@
 import Table from "ink-table";
 import React from "react";
 import { fetchResult } from "../cfetch";
+import { withConfig } from "../config";
 import { logger } from "../logger";
 import { requireAuth } from "../user";
 import { renderToString } from "../utils/render";
@@ -21,19 +22,20 @@ export function Options(d1ListYargs: CommonYargsArgv) {
 		.epilogue(d1BetaWarning);
 }
 
-export async function Handler({
-	json,
-}: StrictYargsOptionsToInterface<typeof Options>): Promise<void> {
-	const accountId = await requireAuth({});
-	const dbs: Array<Database> = await listDatabases(accountId);
+type HandlerOptions = StrictYargsOptionsToInterface<typeof Options>;
+export const Handler = withConfig<HandlerOptions>(
+	async ({ json, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		const dbs: Array<Database> = await listDatabases(accountId);
 
-	if (json) {
-		logger.log(JSON.stringify(dbs, null, 2));
-	} else {
-		logger.log(d1BetaWarning);
-		logger.log(renderToString(<Table data={dbs}></Table>));
+		if (json) {
+			logger.log(JSON.stringify(dbs, null, 2));
+		} else {
+			logger.log(d1BetaWarning);
+			logger.log(renderToString(<Table data={dbs}></Table>));
+		}
 	}
-}
+);
 
 export const listDatabases = async (
 	accountId: string

package/src/d1/migrations/apply.tsx

@@ -12,7 +12,11 @@ import { logger } from "../../logger";
 import { requireAuth } from "../../user";
 import { renderToString } from "../../utils/render";
 import { createBackup } from "../backups";
-import { DEFAULT_MIGRATION_PATH, DEFAULT_MIGRATION_TABLE } from "../constants";
+import {
+	DEFAULT_MIGRATION_PATH,
+	DEFAULT_MIGRATION_TABLE,
+	DEFAULT_BATCH_SIZE,
+} from "../constants";
 import { executeSql } from "../execute";
 import { d1BetaWarning, getDatabaseInfoFromConfig } from "../utils";
 import {
@@ -28,13 +32,31 @@ import type {
 } from "../../yargs-types";
 
 export function ApplyOptions(yargs: CommonYargsArgv) {
-	return MigrationOptions(yargs);
+	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 }): Promise<void> => {
+	async ({
+		config,
+		database,
+		local,
+		persistTo,
+		preview,
+		experimentalBackend,
+		batchSize,
+	}): Promise<void> => {
 		logger.log(d1BetaWarning);
 
 		const databaseInfo = getDatabaseInfoFromConfig(config, database);
@@ -115,14 +137,14 @@ 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 or in preview
-		if (!local && !preview) {
+		// 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({});
+			const accountId = await requireAuth(config);
 			await createBackup(accountId, databaseInfo.uuid);
 		}
 
@@ -149,6 +171,7 @@ Your database may not be available to serve requests during the migration, conti
 					file: undefined,
 					json: undefined,
 					preview,
+					batchSize,
 				});
 
 				if (response === null) {