wrangler 0.0.0-e7a0cd5b → 0.0.0-e7cf0caa

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

@@ -3,14 +3,11 @@ import { findUpSync } from "find-up";
 import { getEntry } from "./entry";
 import { logger } from "./logger";
 import type { Config } from "./config";
-import type { CfWorkerInit } from "./worker";
 
 // Currently includes bindings & rules for declaring modules
-export type PartialConfigToDTS = CfWorkerInit["bindings"] & {
-	rules: Config["rules"];
-};
+
 export async function generateTypes(
-	configToDTS: PartialConfigToDTS,
+	configToDTS: Partial<Config>,
 	config: Config
 ) {
 	const entry = await getEntry({}, config, "types");
@@ -18,7 +15,7 @@ export async function generateTypes(
 
 	if (configToDTS.kv_namespaces) {
 		for (const kvNamespace of configToDTS.kv_namespaces) {
-			envTypeStructure.push(`	${kvNamespace.binding}: KVNamespace;`);
+			envTypeStructure.push(`${kvNamespace.binding}: KVNamespace;`);
 		}
 	}
 
@@ -30,63 +27,79 @@ export async function generateTypes(
 				typeof varValue === "number" ||
 				typeof varValue === "boolean"
 			) {
-				envTypeStructure.push(`	${varName}: ${varValue};`);
+				envTypeStructure.push(`${varName}: "${varValue}";`);
 			}
 			if (typeof varValue === "object" && varValue !== null) {
-				envTypeStructure.push(`	${varName}: ${JSON.stringify(varValue)};`);
+				envTypeStructure.push(`${varName}: ${JSON.stringify(varValue)};`);
 			}
 		}
 	}
 
 	if (configToDTS.durable_objects?.bindings) {
 		for (const durableObject of configToDTS.durable_objects.bindings) {
-			envTypeStructure.push(`	${durableObject.name}: DurableObjectNamespace;`);
+			envTypeStructure.push(`${durableObject.name}: DurableObjectNamespace;`);
 		}
 	}
 
 	if (configToDTS.r2_buckets) {
 		for (const R2Bucket of configToDTS.r2_buckets) {
-			envTypeStructure.push(`	${R2Bucket.binding}: R2Bucket;`);
+			envTypeStructure.push(`${R2Bucket.binding}: R2Bucket;`);
 		}
 	}
 
 	if (configToDTS.d1_databases) {
 		for (const d1 of configToDTS.d1_databases) {
-			envTypeStructure.push(`	${d1.binding}: D1Database;`);
+			envTypeStructure.push(`${d1.binding}: D1Database;`);
 		}
 	}
 
 	if (configToDTS.services) {
 		for (const service of configToDTS.services) {
-			envTypeStructure.push(`	${service.binding}: Fetcher;`);
+			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;`);
+			envTypeStructure.push(`${namespace.binding}: any;`);
 		}
 	}
 
 	if (configToDTS.logfwdr?.schema) {
-		envTypeStructure.push(`	LOGFWDR_SCHEMA: any;`);
+		envTypeStructure.push(`LOGFWDR_SCHEMA: any;`);
 	}
 
 	if (configToDTS.data_blobs) {
 		for (const dataBlobs in configToDTS.data_blobs) {
-			envTypeStructure.push(`	${dataBlobs}: ArrayBuffer;`);
+			envTypeStructure.push(`${dataBlobs}: ArrayBuffer;`);
 		}
 	}
 
 	if (configToDTS.text_blobs) {
 		for (const textBlobs in configToDTS.text_blobs) {
-			envTypeStructure.push(`	${textBlobs}: string;`);
+			envTypeStructure.push(`${textBlobs}: string;`);
 		}
 	}
 
-	if (configToDTS.unsafe) {
-		for (const unsafe of configToDTS.unsafe) {
-			envTypeStructure.push(`	${unsafe.name}: any;`);
+	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;`);
+			}
 		}
 	}
 
@@ -113,47 +126,56 @@ export async function generateTypes(
 		}
 	}
 
-	function writeDTSFile(
-		typesString: string[],
-		formatType: "modules" | "service-worker"
-	) {
-		const wranglerOverrideDTSPath = findUpSync("worker-configuration.d.ts");
-		try {
-			if (
-				wranglerOverrideDTSPath !== undefined &&
-				!fs
-					.readFileSync(wranglerOverrideDTSPath, "utf8")
-					.includes("***AUTO GENERATED BY WORKERS CLI 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${typesString.join(
-				"\n"
-			)} \n}\n${modulesTypeStructure.join("\n")}`;
-		} else {
-			combinedTypeStrings = `declare global {\n${typesString.join(
-				"\n"
-			)} \n}\n${modulesTypeStructure.join("\n")}`;
-		}
+	writeDTSFile({
+		envTypeStructure,
+		modulesTypeStructure,
+		formatType: entry.format,
+	});
+}
 
-		if (envTypeStructure.length || modulesTypeStructure.length) {
-			fs.writeFileSync(
-				"worker-configuration.d.ts",
-				`// Generated by Wrangler on ${new Date()}` + "\n" + combinedTypeStrings
+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."
 			);
-			logger.log(combinedTypeStrings);
+		}
+	} catch (error) {
+		if (error instanceof Error && !error.message.includes("not found")) {
+			throw error;
 		}
 	}
 
-	writeDTSFile(envTypeStructure, entry.format);
+	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/user/access.ts

@@ -21,7 +21,6 @@ export async function domainUsesAccess(domain: string): Promise<boolean> {
 	try {
 		const controller = new AbortController();
 		const cancel = setTimeout(() => {
-			logger.debug("Timed out");
 			controller.abort();
 		}, 1000);
 

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

@@ -1,41 +1,11 @@
-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";
+import { getCloudflareAccountIdFromEnv } from "./auth-variables";
 
 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.
  */

package/src/user/index.ts

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