wrangler 0.0.0-e0d2f35 → 0.0.0-e178d6fb

package/src/whoami.tsx

@@ -2,68 +2,90 @@ import { Text, render } from "ink";
 import Table from "ink-table";
 import React from "react";
 import { fetchListResult, fetchResult } from "./cfetch";
-import { getAPIToken } from "./user";
+import { logger } from "./logger";
+import { getAPIToken, getAuthFromEnv } from "./user";
 
 export async function whoami() {
-  console.log("Getting User settings...");
-  const user = await getUserInfo();
-  render(<WhoAmI user={user}></WhoAmI>);
+	logger.log("Getting User settings...");
+	const user = await getUserInfo();
+	const { unmount } = render(<WhoAmI user={user}></WhoAmI>);
+	unmount();
 }
 
 export function WhoAmI({ user }: { user: UserInfo | undefined }) {
-  return user ? (
-    <>
-      <Email tokenType={user.authType} email={user.email}></Email>
-      <Accounts accounts={user.accounts}></Accounts>
-    </>
-  ) : (
-    <Text>You are not authenticated. Please run `wrangler login`.</Text>
-  );
+	return user ? (
+		<>
+			<Email tokenType={user.authType} email={user.email}></Email>
+			<Accounts accounts={user.accounts}></Accounts>
+		</>
+	) : (
+		<Text>You are not authenticated. Please run `wrangler login`.</Text>
+	);
 }
 
-function Email(props: { tokenType: string; email: string }) {
-  return (
-    <Text>
-      👋 You are logged in with an {props.tokenType} Token, associated with the
-      email &apos;{props.email}&apos;!
-    </Text>
-  );
+function Email(props: { tokenType: string; email: string | undefined }) {
+	return props.email === undefined ? (
+		<Text>
+			👋 You are logged in with an {props.tokenType}. Unable to retrieve email
+			for this user. Are you missing the `User-&gt;User Details-&gt;Read`
+			permission?
+		</Text>
+	) : (
+		<Text>
+			👋 You are logged in with an {props.tokenType}, associated with the email
+			&apos;{props.email}&apos;!
+		</Text>
+	);
 }
 
 function Accounts(props: { accounts: AccountInfo[] }) {
-  const accounts = props.accounts.map((account) => ({
-    "Account Name": account.name,
-    "Account ID": account.id,
-  }));
-  return <Table data={accounts}></Table>;
+	const accounts = props.accounts.map((account) => ({
+		"Account Name": account.name,
+		"Account ID": account.id,
+	}));
+	return <Table data={accounts}></Table>;
 }
 
 export interface UserInfo {
-  apiToken: string;
-  authType: string;
-  email: string;
-  accounts: AccountInfo[];
+	apiToken: string;
+	authType: string;
+	email: string | undefined;
+	accounts: AccountInfo[];
 }
 
 export async function getUserInfo(): Promise<UserInfo | undefined> {
-  const apiToken = getAPIToken();
-  return apiToken
-    ? {
-        apiToken,
-        authType: "OAuth",
-        email: await getEmail(),
-        accounts: await getAccounts(),
-      }
-    : undefined;
+	const apiToken = getAPIToken();
+	if (!apiToken) return;
+
+	const usingEnvAuth = !!getAuthFromEnv();
+	const usingGlobalAuthKey = "authKey" in apiToken;
+	return {
+		apiToken: usingGlobalAuthKey ? apiToken.authKey : apiToken.apiToken,
+		authType: usingGlobalAuthKey
+			? "Global API Key"
+			: usingEnvAuth
+			? "API Token"
+			: "OAuth Token",
+		email: "authEmail" in apiToken ? apiToken.authEmail : await getEmail(),
+		accounts: await getAccounts(),
+	};
 }
 
-async function getEmail(): Promise<string> {
-  const { email } = await fetchResult<{ email: string }>("/user");
-  return email;
+async function getEmail(): Promise<string | undefined> {
+	try {
+		const { email } = await fetchResult<{ email: string }>("/user");
+		return email;
+	} catch (e) {
+		if ((e as { code?: number }).code === 9109) {
+			return undefined;
+		} else {
+			throw e;
+		}
+	}
 }
 
 type AccountInfo = { name: string; id: string };
 
 async function getAccounts(): Promise<AccountInfo[]> {
-  return await fetchListResult<AccountInfo>("/accounts");
+	return await fetchListResult<AccountInfo>("/accounts");
 }

package/src/worker-namespace.ts

@@ -0,0 +1,206 @@
+import { fetchResult } from "./cfetch";
+import { readConfig } from "./config";
+import { logger } from "./logger";
+import * as metrics from "./metrics";
+import { requireAuth } from "./user";
+import { printWranglerBanner } from ".";
+import type { ConfigPath } from ".";
+import type { Argv, CommandModule } from "yargs";
+
+type Namespace = {
+	namespace_id: string;
+	namespace_name: string;
+	created_on: string;
+	created_by: string;
+	modified_on: string;
+	modified_by: string;
+};
+
+// Supporting Workers For Platforms
+// More details at https://blog.cloudflare.com/workers-for-platforms/
+
+/**
+ * Create a dynamic dispatch namespace.
+ */
+async function createWorkerNamespace(accountId: string, name: string) {
+	const namespace = await fetchResult<Namespace>(
+		`/accounts/${accountId}/workers/dispatch/namespaces`,
+		{
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({ name }),
+		}
+	);
+	logger.log(
+		`Created Worker namespace "${name}" with ID "${namespace.namespace_id}"`
+	);
+}
+
+/**
+ * Delete a dynamic dispatch namespace.
+ */
+async function deleteWorkerNamespace(accountId: string, name: string) {
+	await fetchResult(
+		`/accounts/${accountId}/workers/dispatch/namespaces/${name}`,
+		{ method: "DELETE" }
+	);
+	logger.log(`Deleted Worker namespace "${name}"`);
+}
+
+/**
+ * List all created dynamic dispatch namespaces for an account
+ */
+async function listWorkerNamespaces(accountId: string) {
+	logger.log(
+		await fetchResult<Namespace>(
+			`/accounts/${accountId}/workers/dispatch/namespaces`,
+			{
+				headers: {
+					"Content-Type": "application/json",
+				},
+			}
+		)
+	);
+}
+
+/**
+ * Get info for a specific dynamic dispatch namespace
+ */
+async function getWorkerNamespaceInfo(accountId: string, name: string) {
+	logger.log(
+		await fetchResult<Namespace>(
+			`/accounts/${accountId}/workers/dispatch/namespaces/${name}`,
+			{
+				headers: {
+					"Content-Type": "application/json",
+				},
+			}
+		)
+	);
+}
+
+/**
+ * Rename a dynamic dispatch namespace
+ */
+async function renameWorkerNamespace(
+	accountId: string,
+	oldName: string,
+	newName: string
+) {
+	printWranglerBanner();
+
+	await fetchResult(
+		`/accounts/${accountId}/workers/dispatch/namespaces/${oldName}`,
+		{
+			method: "PUT",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({ name: newName }),
+		}
+	);
+	logger.log(`Renamed Worker namespace "${oldName}" to "${newName}"`);
+}
+
+export function workerNamespaceCommands(
+	workerNamespaceYargs: Argv,
+	subHelp: CommandModule
+): Argv {
+	return workerNamespaceYargs
+		.command(subHelp)
+		.command("list", "List all Worker namespaces", {}, async (args) => {
+			const config = readConfig(args.config as ConfigPath, args);
+			const accountId = await requireAuth(config);
+			await listWorkerNamespaces(accountId);
+			await metrics.sendMetricsEvent("list worker namespaces", {
+				sendMetrics: config.send_metrics,
+			});
+		})
+		.command(
+			"get <name>",
+			"Get information about a Worker namespace",
+			(yargs) => {
+				return yargs.positional("name", {
+					describe: "Name of the Worker namespace",
+					type: "string",
+					demandOption: true,
+				});
+			},
+			async (args) => {
+				const config = readConfig(args.config as ConfigPath, args);
+				const accountId = await requireAuth(config);
+				await getWorkerNamespaceInfo(accountId, args.name);
+				await metrics.sendMetricsEvent("view worker namespace", {
+					sendMetrics: config.send_metrics,
+				});
+			}
+		)
+		.command(
+			"create <name>",
+			"Create a Worker namespace",
+			(yargs) => {
+				return yargs.positional("name", {
+					describe: "Name of the Worker namespace",
+					type: "string",
+					demandOption: true,
+				});
+			},
+			async (args) => {
+				await printWranglerBanner();
+				const config = readConfig(args.config as ConfigPath, args);
+				const accountId = await requireAuth(config);
+				await createWorkerNamespace(accountId, args.name);
+				await metrics.sendMetricsEvent("create worker namespace", {
+					sendMetrics: config.send_metrics,
+				});
+			}
+		)
+		.command(
+			"delete <name>",
+			"Delete a Worker namespace",
+			(yargs) => {
+				return yargs.positional("name", {
+					describe: "Name of the Worker namespace",
+					type: "string",
+					demandOption: true,
+				});
+			},
+			async (args) => {
+				await printWranglerBanner();
+				const config = readConfig(args.config as ConfigPath, args);
+				const accountId = await requireAuth(config);
+				await deleteWorkerNamespace(accountId, args.name);
+				await metrics.sendMetricsEvent("delete worker namespace", {
+					sendMetrics: config.send_metrics,
+				});
+			}
+		)
+		.command(
+			"rename <old-name> <new-name>",
+			"Rename a Worker namespace",
+			(yargs) => {
+				return yargs
+					.positional("old-name", {
+						describe: "Name of the Worker namespace",
+						type: "string",
+						demandOption: true,
+					})
+					.positional("new-name", {
+						describe: "New name of the Worker namespace",
+						type: "string",
+						demandOption: true,
+					});
+			},
+			async (args) => {
+				await printWranglerBanner();
+				const config = readConfig(args.config as ConfigPath, args);
+				const accountId = await requireAuth(config);
+				await renameWorkerNamespace(accountId, args.oldName, args.newName);
+				await metrics.sendMetricsEvent("rename worker namespace", {
+					sendMetrics: config.send_metrics,
+				});
+			}
+		);
+}

package/src/worker.ts

@@ -0,0 +1,191 @@
+import type { Route } from "./config/environment";
+import type { ApiCredentials } from "./user";
+
+/**
+ * A Cloudflare account.
+ */
+export interface CfAccount {
+	/**
+	 * An API token.
+	 *
+	 * @link https://api.cloudflare.com/#user-api-tokens-properties
+	 */
+	apiToken: ApiCredentials;
+	/**
+	 * An account ID.
+	 */
+	accountId: string;
+}
+
+/**
+ * The type of Worker
+ */
+export type CfScriptFormat = "modules" | "service-worker";
+
+/**
+ * A module type.
+ */
+export type CfModuleType =
+	| "esm"
+	| "commonjs"
+	| "compiled-wasm"
+	| "text"
+	| "buffer";
+
+/**
+ * An imported module.
+ */
+export interface CfModule {
+	/**
+	 * The module name.
+	 *
+	 * @example
+	 * './src/index.js'
+	 */
+	name: string;
+	/**
+	 * The module content, usually JavaScript or WASM code.
+	 *
+	 * @example
+	 * export default {
+	 *   async fetch(request) {
+	 *     return new Response('Ok')
+	 *   }
+	 * }
+	 */
+	content: string | Buffer;
+	/**
+	 * The module type.
+	 *
+	 * If absent, will default to the main module's type.
+	 */
+	type?: CfModuleType;
+}
+
+/**
+ * A map of variable names to values.
+ */
+interface CfVars {
+	[key: string]: unknown;
+}
+
+/**
+ * A KV namespace.
+ */
+interface CfKvNamespace {
+	binding: string;
+	id: string;
+}
+
+/**
+ * A binding to a wasm module (in service-worker format)
+ */
+
+interface CfWasmModuleBindings {
+	[key: string]: string;
+}
+
+/**
+ * A binding to a text blob (in service-worker format)
+ */
+
+interface CfTextBlobBindings {
+	[key: string]: string;
+}
+
+/**
+ * A binding to a data blob (in service-worker format)
+ */
+
+interface CfDataBlobBindings {
+	[key: string]: string;
+}
+
+/**
+ * A Durable Object.
+ */
+interface CfDurableObject {
+	name: string;
+	class_name: string;
+	script_name?: string;
+	environment?: string;
+}
+
+interface CfR2Bucket {
+	binding: string;
+	bucket_name: string;
+}
+
+interface CfService {
+	binding: string;
+	service: string;
+	environment?: string;
+}
+
+interface CfWorkerNamespace {
+	binding: string;
+	namespace: string;
+}
+
+interface CfUnsafeBinding {
+	name: string;
+	type: string;
+}
+
+export interface CfDurableObjectMigrations {
+	old_tag?: string;
+	new_tag: string;
+	steps: {
+		new_classes?: string[];
+		renamed_classes?: {
+			from: string;
+			to: string;
+		}[];
+		deleted_classes?: string[];
+	}[];
+}
+
+/**
+ * Options for creating a `CfWorker`.
+ */
+export interface CfWorkerInit {
+	/**
+	 * The name of the worker.
+	 */
+	name: string | undefined;
+	/**
+	 * The entrypoint module.
+	 */
+	main: CfModule;
+	/**
+	 * The list of additional modules.
+	 */
+	modules: CfModule[] | undefined;
+	/**
+	 * All the bindings
+	 */
+	bindings: {
+		vars: CfVars | undefined;
+		kv_namespaces: CfKvNamespace[] | undefined;
+		wasm_modules: CfWasmModuleBindings | undefined;
+		text_blobs: CfTextBlobBindings | undefined;
+		data_blobs: CfDataBlobBindings | undefined;
+		durable_objects: { bindings: CfDurableObject[] } | undefined;
+		r2_buckets: CfR2Bucket[] | undefined;
+		services: CfService[] | undefined;
+		worker_namespaces: CfWorkerNamespace[] | undefined;
+		unsafe: CfUnsafeBinding[] | undefined;
+	};
+	migrations: CfDurableObjectMigrations | undefined;
+	compatibility_date: string | undefined;
+	compatibility_flags: string[] | undefined;
+	usage_model: "bundled" | "unbound" | undefined;
+}
+
+export interface CfWorkerContext {
+	env: string | undefined;
+	legacyEnv: boolean | undefined;
+	zone: string | undefined;
+	host: string | undefined;
+	routes: Route[] | undefined;
+}

package/src/zones.ts

@@ -0,0 +1,76 @@
+import { fetchListResult } from "./cfetch";
+import type { Route } from "./config/environment";
+
+/**
+ * An object holding information about a zone for publishing.
+ */
+export interface Zone {
+	id: string;
+	host: string;
+}
+
+export function getHostFromRoute(route: Route): string | undefined {
+	return typeof route === "string"
+		? getHostFromUrl(route)
+		: typeof route === "object"
+		? "zone_name" in route
+			? getHostFromUrl(route.zone_name)
+			: getHostFromUrl(route.pattern)
+		: undefined;
+}
+
+/**
+ * Try to compute the a zone ID and host name for one or more routes.
+ *
+ * When we're given a route, we do 2 things:
+ * - We try to extract a host from it
+ * - We try to get a zone id from the host
+ */
+export async function getZoneForRoute(route: Route): Promise<Zone | undefined> {
+	const host = getHostFromRoute(route);
+	const id =
+		typeof route === "object" && "zone_id" in route
+			? route.zone_id
+			: host
+			? await getZoneIdFromHost(host)
+			: undefined;
+	return id && host ? { id, host } : undefined;
+}
+
+/**
+ * Given something that resembles a URL, try to extract a host from it.
+ */
+function getHostFromUrl(urlLike: string): string | undefined {
+	// strip leading * / *.
+	urlLike = urlLike.replace(/^\*(\.)?/g, "");
+
+	if (!(urlLike.startsWith("http://") || urlLike.startsWith("https://"))) {
+		urlLike = "http://" + urlLike;
+	}
+	return new URL(urlLike).host;
+}
+
+/**
+ * Given something that resembles a host, try to infer a zone id from it.
+ *
+ * It's hard to get a 'valid' domain from a string, so we don't even try to validate TLDs, etc.
+ * For each domain-like part of the host (e.g. w.x.y.z) try to get a zone id for it by
+ * lopping off subdomains until we get a hit from the API.
+ */
+export async function getZoneIdFromHost(host: string): Promise<string> {
+	const hostPieces = host.split(".");
+
+	while (hostPieces.length > 1) {
+		const zones = await fetchListResult<{ id: string }>(
+			`/zones`,
+			{},
+			new URLSearchParams({ name: hostPieces.join(".") })
+		);
+		if (zones.length > 0) {
+			return zones[0].id;
+		}
+		hostPieces.shift();
+	}
+
+	throw new Error(`Could not find zone for ${host}`);
+}

package/templates/checked-fetch.js

@@ -0,0 +1,17 @@
+const urls = new Set();
+
+export function checkedFetch(request, init) {
+	const url = new URL(
+		(typeof request === "string" ? new Request(request, init) : request).url
+	);
+	if (url.port && url.port !== "443" && url.protocol === "https:") {
+		if (!urls.has(url.toString())) {
+			urls.add(url.toString());
+			console.warn(
+				`WARNING: known issue with \`fetch()\` requests to custom HTTPS ports in published Workers:\n` +
+					` - ${url.toString()} - the custom port will be ignored when the Worker is published using the \`wrangler publish\` command.\n`
+			);
+		}
+	}
+	return globalThis.fetch(request, init);
+}