wrangler 0.0.0-e6733a3 → 0.0.0-e6c71262

package/src/config-cache.ts

@@ -0,0 +1,85 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import * as path from "path";
+import { findUpSync } from "find-up";
+import { CI } from "./is-ci";
+import isInteractive from "./is-interactive";
+import { logger } from "./logger";
+
+let cacheMessageShown = false;
+
+let __cacheFolder: string | null | undefined;
+function getCacheFolder() {
+	if (__cacheFolder || __cacheFolder === null) return __cacheFolder;
+
+	const closestNodeModulesDirectory = findUpSync("node_modules", {
+		type: "directory",
+	});
+	__cacheFolder = closestNodeModulesDirectory
+		? path.join(closestNodeModulesDirectory, ".cache/wrangler")
+		: null;
+
+	if (!__cacheFolder) {
+		logger.debug("No folder available to cache configuration");
+	}
+	return __cacheFolder;
+}
+
+const arrayFormatter = new Intl.ListFormat("en", {
+	style: "long",
+	type: "conjunction",
+});
+
+function showCacheMessage(fields: string[], folder: string) {
+	if (!cacheMessageShown && isInteractive() && !CI.isCI()) {
+		if (fields.length > 0) {
+			logger.debug(
+				`Retrieving cached values for ${arrayFormatter.format(
+					fields
+				)} from ${path.relative(process.cwd(), folder)}`
+			);
+			cacheMessageShown = true;
+		}
+	}
+}
+
+export function getConfigCache<T>(fileName: string): Partial<T> {
+	try {
+		const cacheFolder = getCacheFolder();
+		if (cacheFolder) {
+			const configCacheLocation = path.join(cacheFolder, fileName);
+			const configCache = JSON.parse(
+				readFileSync(configCacheLocation, "utf-8")
+			);
+			showCacheMessage(Object.keys(configCache), cacheFolder);
+			return configCache;
+		} else return {};
+	} catch (err) {
+		return {};
+	}
+}
+
+export function saveToConfigCache<T>(
+	fileName: string,
+	newValues: Partial<T>
+): void {
+	const cacheFolder = getCacheFolder();
+	if (cacheFolder) {
+		logger.debug(`Saving to cache: ${JSON.stringify(newValues)}`);
+		const configCacheLocation = path.join(cacheFolder, fileName);
+		const existingValues = getConfigCache(fileName);
+
+		mkdirSync(path.dirname(configCacheLocation), { recursive: true });
+		writeFileSync(
+			configCacheLocation,
+			JSON.stringify({ ...existingValues, ...newValues }, null, 2)
+		);
+	}
+}
+
+export function purgeConfigCaches() {
+	const cacheFolder = getCacheFolder();
+	if (cacheFolder) {
+		rmSync(cacheFolder, { recursive: true, force: true });
+	}
+	__cacheFolder = undefined;
+}

package/src/constellation/createProject.tsx

@@ -0,0 +1,51 @@
+import { fetchResult } from "../cfetch";
+import { withConfig } from "../config";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { takeName } from "./options";
+import { constellationBetaWarning } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { Project } from "./types";
+
+export function options(yargs: CommonYargsArgv) {
+	return takeName(yargs)
+		.positional("runtime", {
+			describe: "The name of the runtime to use",
+			type: "string",
+			demandOption: true,
+		})
+		.epilogue(constellationBetaWarning);
+}
+
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({ name, runtime, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+
+		logger.log(constellationBetaWarning);
+
+		let proj: Project;
+		try {
+			proj = await fetchResult(`/accounts/${accountId}/constellation/project`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({
+					name,
+					runtime,
+				}),
+			});
+		} catch (e) {
+			if ((e as { code: number }).code === 7409) {
+				throw new Error("A project with that name already exists");
+			}
+			throw e;
+		}
+
+		logger.log(`✅ Successfully created Project "${proj.name}"!`);
+	}
+);

package/src/constellation/deleteProject.ts

@@ -0,0 +1,51 @@
+import { fetchResult } from "../cfetch";
+import { withConfig } from "../config";
+import { confirm } from "../dialogs";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { takeName } from "./options";
+import { constellationBetaWarning, getProjectByName } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+
+export function options(yargs: CommonYargsArgv) {
+	return takeName(yargs)
+		.option("force", {
+			describe: "Skip confirmation",
+			type: "boolean",
+			alias: "f",
+			default: false,
+		})
+		.epilogue(constellationBetaWarning);
+}
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({ name, force, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		logger.log(constellationBetaWarning);
+
+		const proj = await getProjectByName(config, accountId, name);
+
+		logger.log(`About to delete Project '${name}' (${proj.id}).`);
+		if (!force) {
+			const response = await confirm(`Ok to proceed?`);
+			if (!response) {
+				logger.log(`Not deleting.`);
+				return;
+			}
+
+			logger.log("Deleting...");
+		}
+
+		await fetchResult(
+			`/accounts/${accountId}/constellation/project/${proj.id}`,
+			{
+				method: "DELETE",
+			}
+		);
+
+		logger.log(`Deleted '${name}' successfully.`);
+	}
+);

package/src/constellation/deleteProjectModel.ts

@@ -0,0 +1,76 @@
+import { fetchResult } from "../cfetch";
+import { withConfig } from "../config";
+import { confirm } from "../dialogs";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import {
+	constellationBetaWarning,
+	getProjectByName,
+	getProjectModelByName,
+} from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { Project, 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,
+		})
+		.option("force", {
+			describe: "Skip confirmation",
+			type: "boolean",
+			alias: "f",
+			default: false,
+		})
+		.epilogue(constellationBetaWarning);
+}
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({ projectName, modelName, force, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		logger.log(constellationBetaWarning);
+
+		const proj: Project = await getProjectByName(
+			config,
+			accountId,
+			projectName
+		);
+
+		const model: Model = await getProjectModelByName(
+			config,
+			accountId,
+			proj,
+			modelName
+		);
+
+		logger.log(`About to delete Model '${modelName}' (${model.id}).`);
+		if (!force) {
+			const response = await confirm(`Ok to proceed?`);
+			if (!response) {
+				logger.log(`Not deleting.`);
+				return;
+			}
+
+			logger.log("Deleting...");
+		}
+
+		await fetchResult(
+			`/accounts/${accountId}/constellation/project/${proj.id}/model/${model.id}`,
+			{
+				method: "DELETE",
+			}
+		);
+
+		logger.log(`Deleted '${modelName}' successfully.`);
+	}
+);

package/src/constellation/index.ts

@@ -0,0 +1,75 @@
+import * as CreateProject from "./createProject";
+import * as DeleteProject from "./deleteProject";
+import * as DeleteProjectModel from "./deleteProjectModel";
+import * as ListCatalog from "./listCatalog";
+import * as ListModel from "./listModel";
+import * as ListProject from "./listProject";
+import * as ListRuntime from "./listRuntime";
+import * as UploadModel from "./uploadModel";
+import type { CommonYargsArgv } from "../yargs-types";
+
+export function constellation(yargs: CommonYargsArgv) {
+	return yargs
+		.command("project", "Manage your projects", (constProjYargs) => {
+			return constProjYargs
+				.command(
+					"list",
+					"List your projects",
+					ListProject.options,
+					ListProject.handler
+				)
+				.command(
+					"create <name> <runtime>",
+					"Create project",
+					CreateProject.options,
+					CreateProject.handler
+				)
+				.command(
+					"delete <name>",
+					"Delete project",
+					DeleteProject.options,
+					DeleteProject.handler
+				);
+		})
+		.command("model", "Manage your models", (constModelYargs) => {
+			return constModelYargs
+				.command(
+					"upload <projectName> <modelName> <modelFile>",
+					"Upload a model for an existing project",
+					UploadModel.options,
+					UploadModel.handler
+				)
+				.command(
+					"list <projectName>",
+					"List models of a project",
+					ListModel.options,
+					ListModel.handler
+				)
+				.command(
+					"delete <projectName> <modelName>",
+					"Delete a model of a project",
+					DeleteProjectModel.options,
+					DeleteProjectModel.handler
+				);
+		})
+		.command(
+			"catalog",
+			"Check the curated model catalog",
+			(constCatalogYargs) => {
+				return constCatalogYargs.command(
+					"list",
+					"List catalog models",
+					ListCatalog.options,
+					ListCatalog.handler
+				);
+			}
+		)
+		.command("runtime", "Check the suported runtimes", (constRuntimeYargs) => {
+			return constRuntimeYargs.command(
+				"list",
+				"List suported runtimes",
+				ListRuntime.options,
+				ListRuntime.handler
+			);
+		});
+}

package/src/constellation/listCatalog.tsx

@@ -0,0 +1,35 @@
+import { withConfig } from "../config";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { asJson } from "./options";
+import { constellationBetaWarning, listCatalogEntries } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+
+export function options(yargs: CommonYargsArgv) {
+	return asJson(yargs).epilogue(constellationBetaWarning);
+}
+
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({ json, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		const entries = await listCatalogEntries(accountId);
+
+		if (json) {
+			logger.log(JSON.stringify(entries, null, 2));
+		} else {
+			logger.log(constellationBetaWarning);
+			logger.table(
+				entries.map((entry) => ({
+					project_id: entry.project.id,
+					project_name: entry.project.name,
+					project_runtime: entry.project.runtime,
+					models: entry.models.map((model) => model.name).join(","),
+				}))
+			);
+		}
+	}
+);

package/src/constellation/listModel.tsx

@@ -0,0 +1,49 @@
+import { withConfig } from "../config";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import {
+	constellationBetaWarning,
+	getProjectByName,
+	listModels,
+} from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { Project } from "./types";
+
+export function options(yargs: CommonYargsArgv) {
+	return yargs
+		.positional("projectName", {
+			describe: "The name of the project",
+			type: "string",
+			demandOption: true,
+		})
+		.option("json", {
+			describe: "return output as clean JSON",
+			type: "boolean",
+			default: false,
+		})
+		.epilogue(constellationBetaWarning);
+}
+
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({ projectName, json, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		const proj: Project = await getProjectByName(
+			config,
+			accountId,
+			projectName
+		);
+
+		const models = await listModels(accountId, proj);
+
+		if (json) {
+			logger.log(JSON.stringify(models, null, 2));
+		} else {
+			logger.log(constellationBetaWarning);
+			logger.table(models);
+		}
+	}
+);

package/src/constellation/listProject.tsx

@@ -0,0 +1,28 @@
+import { withConfig } from "../config";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { asJson } from "./options";
+import { constellationBetaWarning, listProjects } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+
+export function options(yargs: CommonYargsArgv) {
+	return asJson(yargs).epilogue(constellationBetaWarning);
+}
+
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({ json, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		const projs = await listProjects(accountId);
+
+		if (json) {
+			logger.log(JSON.stringify(projs, null, 2));
+		} else {
+			logger.log(constellationBetaWarning);
+			logger.table(projs);
+		}
+	}
+);

package/src/constellation/listRuntime.tsx

@@ -0,0 +1,28 @@
+import { withConfig } from "../config";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { asJson } from "./options";
+import { constellationBetaWarning, listRuntimes } from "./utils";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+
+export function options(yargs: CommonYargsArgv) {
+	return asJson(yargs).epilogue(constellationBetaWarning);
+}
+
+type HandlerOptions = StrictYargsOptionsToInterface<typeof options>;
+export const handler = withConfig<HandlerOptions>(
+	async ({ json, config }): Promise<void> => {
+		const accountId = await requireAuth(config);
+		const runtimes = await listRuntimes(accountId);
+
+		if (json) {
+			logger.log(JSON.stringify(runtimes, null, 2));
+		} else {
+			logger.log(constellationBetaWarning);
+			logger.table(runtimes.map((runtime) => ({ name: runtime })));
+		}
+	}
+);

package/src/constellation/options.ts

@@ -0,0 +1,17 @@
+import type { CommonYargsArgv } from "../yargs-types";
+
+export function takeName(yargs: CommonYargsArgv) {
+	return yargs.positional("name", {
+		describe: "The name of the project",
+		type: "string",
+		demandOption: true,
+	});
+}
+
+export function asJson(yargs: CommonYargsArgv) {
+	return yargs.option("json", {
+		describe: "return output as clean JSON",
+		type: "boolean",
+		default: false,
+	});
+}

package/src/constellation/types.ts

@@ -0,0 +1,17 @@
+export type Project = {
+	id: string;
+	name: string;
+	runtime: string;
+};
+
+export type Model = {
+	id: string;
+	project_id: string;
+	name: string;
+	description: string;
+};
+
+export type CatalogEntry = {
+	project: Project;
+	models: Model[];
+};

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