wrangler 0.0.0-e928f94 → 0.0.0-e9307365

package/src/whoami.tsx

@@ -0,0 +1,169 @@
+import { Text, render } from "ink";
+import Table from "ink-table";
+import React from "react";
+import { fetchListResult, fetchResult } from "./cfetch";
+import { logger } from "./logger";
+import { getAPIToken, getAuthFromEnv, getScopes } from "./user";
+
+export async function 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>
+			<Permissions
+				tokenType={user.authType}
+				tokenPermissions={user.tokenPermissions}
+			/>
+		</>
+	) : (
+		<Text>You are not authenticated. Please run `wrangler login`.</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>;
+}
+
+function Permissions(props: {
+	tokenPermissions: string[] | undefined;
+	tokenType: string;
+}) {
+	const permissions =
+		props.tokenPermissions?.map((scope) => scope.split(":")) || [];
+	return props.tokenType === "OAuth Token" ? (
+		props.tokenPermissions ? (
+			<>
+				<Text>
+					🔓 Token Permissions: If scopes are missing, you may need to logout
+					and re-login.
+				</Text>
+				<Text>Scope (Access)</Text>
+				{permissions.map(([type, name]) => (
+					<>
+						<Text>
+							- {type} {name && `(${name})`}
+						</Text>
+					</>
+				))}
+			</>
+		) : null
+	) : (
+		<Text>
+			🔓 To see token permissions visit
+			https://dash.cloudflare.com/profile/api-tokens
+		</Text>
+	);
+}
+
+export interface UserInfo {
+	apiToken: string;
+	authType: string;
+	email: string | undefined;
+	accounts: AccountInfo[];
+	tokenPermissions: string[] | undefined;
+}
+
+export async function getUserInfo(): Promise<UserInfo | undefined> {
+	const apiToken = getAPIToken();
+	if (!apiToken) return;
+
+	const tokenPermissions = await getTokenPermissions();
+
+	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(),
+		tokenPermissions,
+	};
+}
+
+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");
+}
+
+async function getTokenPermissions(): Promise<string[] | undefined> {
+	// Tokens can either be API tokens or Oauth tokens.
+	// Here we only extract permissions from OAuth tokens.
+
+	return getScopes() as string[];
+
+	// In future we may be able to get the token permissions on an API token,
+	// but currently we cannot as that permission is not able to be added to
+	// an API token.
+
+	// try {
+	// 	// First we get the token identifier (only returned on API tokens)
+	// 	const { id } = await fetchResult<{ id: string }>("/user/tokens/verify");
+
+	// 	// Get the token permissions for the current token
+	// 	const { policies } = await fetchResult<{
+	// 		policies: { id: string; name: string }[];
+	// 	}>(`/user/tokens/${id}`);
+
+	// 	return policies.map((p) => p.name);
+	// } catch (e) {
+	// 	if ((e as { code?: number }).code === 1000) {
+	// 		// Invalid token - Oauth token
+
+	// 		// Get scopes
+	// 		const scopes = getScopes() as string[];
+	// 		// We may not get scopes back if they are not currently cached,
+	// 		// however next time an access token is requested,
+	// 		// the scopes will be added to the cache.
+	// 		return scopes;
+	// 	} else if ((e as { code?: number }).code === 9109) {
+	// 		// Token cannot view its permissions
+	// 		return undefined;
+	// 	} else {
+	// 		throw e;
+	// 	}
+	// }
+}

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,203 @@
+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 CfLogfwdr {
+	schema: string | undefined;
+	bindings: CfLogfwdrBinding[];
+}
+
+interface CfLogfwdrBinding {
+	name: string;
+	destination: 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;
+		logfwdr: CfLogfwdr | 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;
+	sendMetrics: boolean | 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);
+}

package/templates/first-party-worker-module-facade.ts

@@ -0,0 +1,18 @@
+// @ts-ignore entry point will get replaced
+import worker from "__ENTRY_POINT__";
+// @ts-ignore entry point will get replaced
+export * from "__ENTRY_POINT__";
+
+type Env = {
+	// TODO: type this
+};
+
+/**
+ * Setup globals/vars as required
+ */
+
+export default {
+	async fetch(request: Request, env: Env, ctx: ExecutionContext) {
+		return worker.fetch(request, env, ctx);
+	},
+};