wrangler 0.0.0-e95e5a0 → 0.0.0-e98613f8

package/src/type-generation.ts

@@ -0,0 +1,173 @@
+import * as fs from "fs";
+import { findUpSync } from "find-up";
+import { getEntry } from "./entry";
+import { logger } from "./logger";
+import type { Config } from "./config";
+
+// Currently includes bindings & rules for declaring modules
+
+export async function generateTypes(
+	configToDTS: Partial<Config>,
+	config: Config
+) {
+	const entry = await getEntry({}, config, "types");
+	const envTypeStructure: string[] = [];
+
+	if (configToDTS.kv_namespaces) {
+		for (const kvNamespace of configToDTS.kv_namespaces) {
+			envTypeStructure.push(`${kvNamespace.binding}: KVNamespace;`);
+		}
+	}
+
+	if (configToDTS.vars) {
+		for (const varName in configToDTS.vars) {
+			const varValue = configToDTS.vars[varName];
+			if (
+				typeof varValue === "string" ||
+				typeof varValue === "number" ||
+				typeof varValue === "boolean"
+			) {
+				envTypeStructure.push(`${varName}: "${varValue}";`);
+			}
+			if (typeof varValue === "object" && varValue !== null) {
+				envTypeStructure.push(`${varName}: ${JSON.stringify(varValue)};`);
+			}
+		}
+	}
+
+	if (configToDTS.durable_objects?.bindings) {
+		for (const durableObject of configToDTS.durable_objects.bindings) {
+			envTypeStructure.push(`${durableObject.name}: DurableObjectNamespace;`);
+		}
+	}
+
+	if (configToDTS.r2_buckets) {
+		for (const R2Bucket of configToDTS.r2_buckets) {
+			envTypeStructure.push(`${R2Bucket.binding}: R2Bucket;`);
+		}
+	}
+
+	if (configToDTS.d1_databases) {
+		for (const d1 of configToDTS.d1_databases) {
+			envTypeStructure.push(`${d1.binding}: D1Database;`);
+		}
+	}
+
+	if (configToDTS.services) {
+		for (const service of configToDTS.services) {
+			envTypeStructure.push(`${service.binding}: Fetcher;`);
+		}
+	}
+
+	if (configToDTS.dispatch_namespaces) {
+		for (const namespace of configToDTS.dispatch_namespaces) {
+			envTypeStructure.push(`${namespace.binding}: any;`);
+		}
+	}
+
+	if (configToDTS.logfwdr?.schema) {
+		envTypeStructure.push(`LOGFWDR_SCHEMA: any;`);
+	}
+
+	if (configToDTS.data_blobs) {
+		for (const dataBlobs in configToDTS.data_blobs) {
+			envTypeStructure.push(`${dataBlobs}: ArrayBuffer;`);
+		}
+	}
+
+	if (configToDTS.text_blobs) {
+		for (const textBlobs in configToDTS.text_blobs) {
+			envTypeStructure.push(`${textBlobs}: string;`);
+		}
+	}
+
+	if (configToDTS.unsafe) {
+		for (const unsafe of configToDTS.unsafe.bindings) {
+			envTypeStructure.push(`${unsafe.name}: any;`);
+		}
+	}
+
+	if (configToDTS.queues) {
+		if (configToDTS.queues.producers) {
+			for (const queue of configToDTS.queues.producers) {
+				envTypeStructure.push(`${queue.binding}: Queue;`);
+			}
+		}
+	}
+
+	const modulesTypeStructure: string[] = [];
+	if (configToDTS.rules) {
+		const moduleTypeMap = {
+			Text: "string",
+			Data: "ArrayBuffer",
+			CompiledWasm: "WebAssembly.Module",
+		};
+		for (const ruleObject of configToDTS.rules) {
+			const typeScriptType =
+				moduleTypeMap[ruleObject.type as keyof typeof moduleTypeMap];
+			if (typeScriptType !== undefined) {
+				ruleObject.globs.forEach((glob) => {
+					modulesTypeStructure.push(`declare module "*.${glob
+						.split(".")
+						.at(-1)}" {
+	const value: ${typeScriptType};
+	export default value;
+}`);
+				});
+			}
+		}
+	}
+
+	writeDTSFile({
+		envTypeStructure,
+		modulesTypeStructure,
+		formatType: entry.format,
+	});
+}
+
+function writeDTSFile({
+	envTypeStructure,
+	modulesTypeStructure,
+	formatType,
+}: {
+	envTypeStructure: string[];
+	modulesTypeStructure: string[];
+	formatType: "modules" | "service-worker";
+}) {
+	const wranglerOverrideDTSPath = findUpSync("worker-configuration.d.ts");
+	try {
+		if (
+			wranglerOverrideDTSPath !== undefined &&
+			!fs
+				.readFileSync(wranglerOverrideDTSPath, "utf8")
+				.includes("Generated by Wrangler")
+		) {
+			throw new Error(
+				"A non-wrangler worker-configuration.d.ts already exists, please rename and try again."
+			);
+		}
+	} catch (error) {
+		if (error instanceof Error && !error.message.includes("not found")) {
+			throw error;
+		}
+	}
+
+	let combinedTypeStrings = "";
+	if (formatType === "modules") {
+		combinedTypeStrings += `interface Env {\n${envTypeStructure
+			.map((value) => `\t${value}`)
+			.join("\n")} \n}\n${modulesTypeStructure.join("\n")}`;
+	} else {
+		combinedTypeStrings += `export {};\ndeclare global {\n${envTypeStructure
+			.map((value) => `\tconst ${value}`)
+			.join("\n")} \n}\n${modulesTypeStructure.join("\n")}`;
+	}
+
+	if (envTypeStructure.length || modulesTypeStructure.length) {
+		fs.writeFileSync(
+			"worker-configuration.d.ts",
+			`// Generated by Wrangler on ${new Date()}` + "\n" + combinedTypeStrings
+		);
+		logger.log(combinedTypeStrings);
+	}
+}

package/src/update-check.ts

@@ -3,17 +3,17 @@ import checkForUpdate from "update-check";
 import pkg from "../package.json";
 
 export async function updateCheck(): Promise<string> {
-  let update = null;
-  try {
-    // default cache for update check is 1 day
-    update = await checkForUpdate(pkg, {
-      distTag: pkg.version.startsWith("0.0.0") ? "beta" : "latest",
-    });
-  } catch (err) {
-    // ignore error
-  }
+	let update = null;
+	try {
+		// default cache for update check is 1 day
+		update = await checkForUpdate(pkg, {
+			distTag: pkg.version.startsWith("0.0.0") ? "beta" : "latest",
+		});
+	} catch (err) {
+		// ignore error
+	}
 
-  if (update) return `(update available ${chalk.green(update.latest)})`;
+	if (update) return `(update available ${chalk.green(update.latest)})`;
 
-  return "";
+	return "";
 }

package/src/user/access.ts

@@ -0,0 +1,69 @@
+import { spawnSync } from "child_process";
+import { fetch } from "undici";
+import { logger } from "../logger";
+
+const cache: Record<string, string> = {};
+
+const usesAccessCache = new Map();
+
+export async function domainUsesAccess(domain: string): Promise<boolean> {
+	logger.debug("Checking if domain has Access enabled:", domain);
+
+	if (usesAccessCache.has(domain)) {
+		logger.debug(
+			"Using cached Access switch for:",
+			domain,
+			usesAccessCache.get(domain)
+		);
+		return usesAccessCache.get(domain);
+	}
+	logger.debug("Access switch not cached for:", domain);
+	try {
+		const controller = new AbortController();
+		const cancel = setTimeout(() => {
+			logger.debug("Timed out");
+			controller.abort();
+		}, 1000);
+
+		const output = await fetch(`https://${domain}`, {
+			redirect: "manual",
+			signal: controller.signal,
+		});
+		clearTimeout(cancel);
+		const usesAccess = !!(
+			output.status === 302 &&
+			output.headers.get("location")?.includes("cloudflareaccess.com")
+		);
+		logger.debug("Caching access switch for:", domain);
+
+		usesAccessCache.set(domain, usesAccess);
+		return usesAccess;
+	} catch (e) {
+		usesAccessCache.set(domain, false);
+		return false;
+	}
+}
+export async function getAccessToken(
+	domain: string
+): Promise<string | undefined> {
+	if (!(await domainUsesAccess(domain))) {
+		return undefined;
+	}
+	if (cache[domain]) {
+		return cache[domain];
+	}
+	const output = await spawnSync("cloudflared", ["access", "login", domain]);
+	if (output.error) {
+		// The cloudflared binary is not installed
+		throw new Error(
+			"To use Wrangler with Cloudflare Access, please install `cloudflared` from https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation"
+		);
+	}
+	const stringOutput = output.stdout.toString();
+	const matches = stringOutput.match(/fetched your token:\n\n(.*)/m);
+	if (matches && matches.length >= 2) {
+		cache[domain] = matches[1];
+		return matches[1];
+	}
+	throw new Error("Failed to authenticate with Cloudflare Access");
+}

package/src/user/choose-account.tsx

@@ -0,0 +1,69 @@
+import { Text } from "ink";
+import SelectInput from "ink-select-input";
+import React from "react";
+import { fetchListResult } from "../cfetch";
+import { logger } from "../logger";
+import { getCloudflareAccountIdFromEnv } from "./env-vars";
+
+export type ChooseAccountItem = {
+	id: string;
+	name: string;
+};
+
+/**
+ * A component that allows the user to select from a list of available accounts.
+ */
+export function ChooseAccount(props: {
+	accounts: ChooseAccountItem[];
+	onSelect: (account: { name: string; id: string }) => void;
+	onError: (error: Error) => void;
+}) {
+	return (
+		<>
+			<Text bold>Select an account from below:</Text>
+			<SelectInput
+				items={props.accounts.map((item) => ({
+					key: item.id,
+					label: item.name,
+					value: item,
+				}))}
+				onSelect={(item) => {
+					logger.log(`Using account: "${item.value.name} - ${item.value.id}"`);
+					props.onSelect({ id: item.value.id, name: item.value.name });
+				}}
+			/>
+		</>
+	);
+}
+
+/**
+ * Infer a list of available accounts for the current user.
+ */
+export async function getAccountChoices(): Promise<ChooseAccountItem[]> {
+	const accountIdFromEnv = getCloudflareAccountIdFromEnv();
+	if (accountIdFromEnv) {
+		return [{ id: accountIdFromEnv, name: "" }];
+	} else {
+		try {
+			const response = await fetchListResult<{
+				account: ChooseAccountItem;
+			}>(`/memberships`);
+			const accounts = response.map((r) => r.account);
+			if (accounts.length === 0) {
+				throw new Error(
+					"Failed to automatically retrieve account IDs for the logged in user.\n" +
+						"In a non-interactive environment, it is mandatory to specify an account ID, either by assigning its value to CLOUDFLARE_ACCOUNT_ID, or as `account_id` in your `wrangler.toml` file."
+				);
+			} else {
+				return accounts;
+			}
+		} catch (err) {
+			if ((err as { code: number }).code === 9109) {
+				throw new Error(
+					`Failed to automatically retrieve account IDs for the logged in user.
+You may have incorrect permissions on your API token. You can skip this account check by adding an \`account_id\` in your \`wrangler.toml\`, or by setting the value of CLOUDFLARE_ACCOUNT_ID"`
+				);
+			} else throw err;
+		}
+	}
+}

package/src/user/env-vars.ts

@@ -0,0 +1,46 @@
+import { getEnvironmentVariableFactory } from "../environment-variables";
+
+export type ApiCredentials =
+	| {
+			apiToken: string;
+	  }
+	| {
+			authKey: string;
+			authEmail: string;
+	  };
+
+const getCloudflareAPITokenFromEnv = getEnvironmentVariableFactory({
+	variableName: "CLOUDFLARE_API_TOKEN",
+	deprecatedName: "CF_API_TOKEN",
+});
+const getCloudflareGlobalAuthKeyFromEnv = getEnvironmentVariableFactory({
+	variableName: "CLOUDFLARE_API_KEY",
+	deprecatedName: "CF_API_KEY",
+});
+const getCloudflareGlobalAuthEmailFromEnv = getEnvironmentVariableFactory({
+	variableName: "CLOUDFLARE_EMAIL",
+	deprecatedName: "CF_EMAIL",
+});
+
+/**
+ * Try to read an API token or Global Auth from the environment.
+ */
+export function getAuthFromEnv(): ApiCredentials | undefined {
+	const globalApiKey = getCloudflareGlobalAuthKeyFromEnv();
+	const globalApiEmail = getCloudflareGlobalAuthEmailFromEnv();
+	const apiToken = getCloudflareAPITokenFromEnv();
+
+	if (globalApiKey && globalApiEmail) {
+		return { authKey: globalApiKey, authEmail: globalApiEmail };
+	} else if (apiToken) {
+		return { apiToken };
+	}
+}
+
+/**
+ * Try to read the account ID from the environment.
+ */
+export const getCloudflareAccountIdFromEnv = getEnvironmentVariableFactory({
+	variableName: "CLOUDFLARE_ACCOUNT_ID",
+	deprecatedName: "CF_ACCOUNT_ID",
+});

package/src/user/generate-auth-url.ts

@@ -0,0 +1,33 @@
+interface GenerateAuthUrlProps {
+	authUrl: string;
+	clientId: string;
+	callbackUrl: string;
+	scopes: string[];
+	stateQueryParam: string;
+	codeChallenge: string;
+}
+
+/**
+ * generateAuthUrl was extracted from getAuthURL in user.tsx
+ * to make it possible to mock the generated URL
+ */
+export const generateAuthUrl = ({
+	authUrl,
+	clientId,
+	callbackUrl,
+	scopes,
+	stateQueryParam,
+	codeChallenge,
+}: GenerateAuthUrlProps) => {
+	return (
+		authUrl +
+		`?response_type=code&` +
+		`client_id=${encodeURIComponent(clientId)}&` +
+		`redirect_uri=${encodeURIComponent(callbackUrl)}&` +
+		// we add offline_access manually for every request
+		`scope=${encodeURIComponent([...scopes, "offline_access"].join(" "))}&` +
+		`state=${stateQueryParam}&` +
+		`code_challenge=${encodeURIComponent(codeChallenge)}&` +
+		`code_challenge_method=S256`
+	);
+};

package/src/user/generate-random-state.ts

@@ -0,0 +1,16 @@
+import { webcrypto as crypto } from "node:crypto";
+import { PKCE_CHARSET } from "../user";
+
+/**
+ * Generates random state to be passed for anti-csrf.
+ * extracted from  user.tsx to make it possible to
+ * mock the generated URL
+ */
+export function generateRandomState(lengthOfState: number): string {
+	const output = new Uint32Array(lengthOfState);
+	// @ts-expect-error crypto's types aren't there yet
+	crypto.getRandomValues(output);
+	return Array.from(output)
+		.map((num: number) => PKCE_CHARSET[num % PKCE_CHARSET.length])
+		.join("");
+}

package/src/user/index.ts

@@ -0,0 +1,3 @@
+export * from "./user";
+export * from "./env-vars";
+export * from "./choose-account";