wrangler 0.0.0-e452a35 → 0.0.0-e4ca780f

package/src/traverse-module-graph.ts

@@ -0,0 +1,53 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import { logger } from "./logger";
+import { matchFiles, parseRules } from "./module-collection";
+import type { BundleResult } from "./bundle";
+import type { Config } from "./config";
+import type { Entry } from "./entry";
+
+async function getFiles(root: string, relativeTo: string): Promise<string[]> {
+	const files = [];
+	for (const file of await readdir(root, { withFileTypes: true })) {
+		if (file.isDirectory()) {
+			files.push(...(await getFiles(path.join(root, file.name), relativeTo)));
+		} else {
+			files.push(path.relative(relativeTo, path.join(root, file.name)));
+		}
+	}
+	return files;
+}
+
+export default async function traverseModuleGraph(
+	entry: Entry,
+	rules: Config["rules"]
+): Promise<BundleResult> {
+	const files = await getFiles(entry.moduleRoot, entry.moduleRoot);
+	const relativeEntryPoint = path.relative(entry.moduleRoot, entry.file);
+
+	const modules = (await matchFiles(files, entry.moduleRoot, parseRules(rules)))
+		.filter((m) => m.name !== relativeEntryPoint)
+		.map((m) => ({
+			...m,
+			name: m.name,
+		}));
+
+	const bundleType = entry.format === "modules" ? "esm" : "commonjs";
+
+	if (modules.length > 0) {
+		logger.info(`Uploading additional modules:`);
+		modules.forEach(({ name, type }) => {
+			logger.info(`- ${chalk.blue(name)} (${chalk.green(type ?? "")})`);
+		});
+	}
+
+	return {
+		modules,
+		dependencies: {},
+		resolvedEntryPointPath: entry.file,
+		bundleType,
+		stop: undefined,
+		sourceMapPath: undefined,
+	};
+}

package/src/tsconfig-sanity.ts

@@ -0,0 +1,16 @@
+// `@types/node` should be included
+Buffer.from("test");
+
+// @ts-expect-error `@types/jest` should NOT be included
+test("test");
+
+// @ts-expect-error `@cloudflare/workers-types` should NOT be included
+const _handler: ExportedHandler = {};
+// @ts-expect-error `@cloudflare/workers-types` should NOT be included
+new HTMLRewriter();
+
+// @ts-expect-error `fetch` should NOT be included as our minimum supported
+//  Node version is 16.13.0 which does not include `fetch` on the global scope
+void fetch("http://localhost/");
+
+export {};

package/src/type-generation.ts

@@ -0,0 +1,181 @@
+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.analytics_engine_datasets) {
+		for (const analyticsEngine of configToDTS.analytics_engine_datasets) {
+			envTypeStructure.push(
+				`${analyticsEngine.binding}: AnalyticsEngineDataset;`
+			);
+		}
+	}
+
+	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?.bindings) {
+		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,68 @@
+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(() => {
+			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/auth-variables.ts

@@ -0,0 +1,113 @@
+import { getEnvironmentVariableFactory } from "../environment-variables/factory";
+import { getCloudflareApiEnvironmentFromEnv } from "../environment-variables/misc-variables";
+import { getAccessToken } from "./access";
+
+/**
+ * `CLOUDFLARE_ACCOUNT_ID` overrides the account inferred from the current user.
+ */
+export const getCloudflareAccountIdFromEnv = getEnvironmentVariableFactory({
+	variableName: "CLOUDFLARE_ACCOUNT_ID",
+	deprecatedName: "CF_ACCOUNT_ID",
+});
+
+export const getCloudflareAPITokenFromEnv = getEnvironmentVariableFactory({
+	variableName: "CLOUDFLARE_API_TOKEN",
+	deprecatedName: "CF_API_TOKEN",
+});
+export const getCloudflareGlobalAuthKeyFromEnv = getEnvironmentVariableFactory({
+	variableName: "CLOUDFLARE_API_KEY",
+	deprecatedName: "CF_API_KEY",
+});
+export const getCloudflareGlobalAuthEmailFromEnv =
+	getEnvironmentVariableFactory({
+		variableName: "CLOUDFLARE_EMAIL",
+		deprecatedName: "CF_EMAIL",
+	});
+
+/**
+ * `WRANGLER_CLIENT_ID` is a UUID that is used to identify Wrangler
+ * to the Cloudflare APIs.
+ *
+ * Normally you should not need to set this explicitly.
+ * If you want to switch to the staging environment set the
+ * `WRANGLER_USE_STAGING` environment variable instead.
+ */
+export const getClientIdFromEnv = getEnvironmentVariableFactory({
+	variableName: "WRANGLER_CLIENT_ID",
+	defaultValue: () =>
+		getCloudflareApiEnvironmentFromEnv() === "staging"
+			? "4b2ea6cc-9421-4761-874b-ce550e0e3def"
+			: "54d11594-84e4-41aa-b438-e81b8fa78ee7",
+});
+
+/**
+ * `WRANGLER_AUTH_DOMAIN` is the URL base domain that is used
+ * to access OAuth URLs for the Cloudflare APIs.
+ *
+ * Normally you should not need to set this explicitly.
+ * If you want to switch to the staging environment set the
+ * `WRANGLER_USE_STAGING` environment variable instead.
+ */
+export const getAuthDomainFromEnv = getEnvironmentVariableFactory({
+	variableName: "WRANGLER_AUTH_DOMAIN",
+	defaultValue: () =>
+		getCloudflareApiEnvironmentFromEnv() === "staging"
+			? "dash.staging.cloudflare.com"
+			: "dash.cloudflare.com",
+});
+
+/**
+ * `WRANGLER_AUTH_URL` is the path that is used to access OAuth
+ * for the Cloudflare APIs.
+ *
+ * Normally you should not need to set this explicitly.
+ * If you want to switch to the staging environment set the
+ * `WRANGLER_USE_STAGING` environment variable instead.
+ */
+export const getAuthUrlFromEnv = getEnvironmentVariableFactory({
+	variableName: "WRANGLER_AUTH_URL",
+	defaultValue: () => `https://${getAuthDomainFromEnv()}/oauth2/auth`,
+});
+
+/**
+ * `WRANGLER_TOKEN_URL` is the path that is used to exchange an OAuth
+ * token for an API token.
+ *
+ * Normally you should not need to set this explicitly.
+ * If you want to switch to the staging environment set the
+ * `WRANGLER_USE_STAGING` environment variable instead.
+ */
+export const getTokenUrlFromEnv = getEnvironmentVariableFactory({
+	variableName: "WRANGLER_TOKEN_URL",
+	defaultValue: () => `https://${getAuthDomainFromEnv()}/oauth2/token`,
+});
+
+/**
+ * `WRANGLER_REVOKE_URL` is the path that is used to exchange an OAuth
+ * refresh token for a new OAuth token.
+ *
+ * Normally you should not need to set this explicitly.
+ * If you want to switch to the staging environment set the
+ * `WRANGLER_USE_STAGING` environment variable instead.
+ */
+export const getRevokeUrlFromEnv = getEnvironmentVariableFactory({
+	variableName: "WRANGLER_REVOKE_URL",
+	defaultValue: () => `https://${getAuthDomainFromEnv()}/oauth2/revoke`,
+});
+
+/**
+ * Set the `WRANGLER_CF_AUTHORIZATION_TOKEN` to the CF_Authorization token found at https://dash.staging.cloudflare.com/bypass-limits
+ * if you want to access the staging environment, triggered by `WRANGLER_API_ENVIRONMENT=staging`.
+ */
+export const getCloudflareAccessToken = async () => {
+	const env = getEnvironmentVariableFactory({
+		variableName: "WRANGLER_CF_AUTHORIZATION_TOKEN",
+	})();
+
+	// If the environment variable is defined, go ahead and use it.
+	if (env !== undefined) {
+		return env;
+	}
+
+	return getAccessToken(getAuthDomainFromEnv());
+};

package/src/user/choose-account.tsx

@@ -0,0 +1,39 @@
+import { fetchListResult } from "../cfetch";
+import { getCloudflareAccountIdFromEnv } from "./auth-variables";
+
+export type ChooseAccountItem = {
+	id: string;
+	name: string;
+};
+
+/**
+ * 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/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,2 @@
+export * from "./user";
+export * from "./choose-account";