wrangler 2.1.14 → 2.2.0

package/src/queues/cli/commands/index.ts

@@ -0,0 +1,33 @@
+import { type BuilderCallback } from "yargs";
+import { type CommonYargsOptions } from "../../../yargs-types";
+import { consumers } from "./consumer";
+
+import { options as createOptions, handler as createHandler } from "./create";
+import { options as deleteOptions, handler as deleteHandler } from "./delete";
+import { options as listOptions, handler as listHandler } from "./list";
+
+export const queues: BuilderCallback<CommonYargsOptions, unknown> = (yargs) => {
+	yargs.command("list", "List Queues", listOptions, listHandler);
+
+	yargs.command(
+		"create <name>",
+		"Create a Queue",
+		createOptions,
+		createHandler
+	);
+
+	yargs.command(
+		"delete <name>",
+		"Delete a Queue",
+		deleteOptions,
+		deleteHandler
+	);
+
+	yargs.command(
+		"consumer",
+		"Configure Queue Consumers",
+		async (consumersYargs) => {
+			await consumers(consumersYargs);
+		}
+	);
+};

package/src/queues/cli/commands/list.ts

@@ -0,0 +1,25 @@
+import { type Argv } from "yargs";
+import { readConfig } from "../../../config";
+import { logger } from "../../../logger";
+import { listQueues } from "../../client";
+
+interface Args {
+	config?: string;
+	page?: number;
+}
+
+export function options(yargs: Argv): Argv<Args> {
+	return yargs.options({
+		page: {
+			type: "number",
+			describe: "Page number for pagination",
+		},
+	});
+}
+
+export async function handler(args: Args) {
+	const config = readConfig(args.config, args);
+
+	const queues = await listQueues(config, args.page);
+	logger.log(JSON.stringify(queues));
+}

package/src/queues/client.ts

@@ -0,0 +1,135 @@
+import { fetchResult } from "../cfetch";
+import { type Config } from "../config";
+import { requireAuth } from "../user";
+
+export async function createQueue(
+	config: Config,
+	body: CreateQueueBody
+): Promise<QueueResponse> {
+	const accountId = await requireAuth(config);
+	return await fetchResult(`/accounts/${accountId}/workers/queues`, {
+		method: "POST",
+		body: JSON.stringify(body),
+	});
+}
+
+export interface CreateQueueBody {
+	queue_name: string;
+}
+
+export interface QueueResponse {
+	queue_name: string;
+	created_on: string;
+	modified_on: string;
+}
+
+export async function deleteQueue(
+	config: Config,
+	queueName: string
+): Promise<void> {
+	const accountId = await requireAuth(config);
+	return await fetchResult(
+		`/accounts/${accountId}/workers/queues/${queueName}`,
+		{
+			method: "DELETE",
+		}
+	);
+}
+
+// TODO(soon) show detailed queue response
+export async function listQueues(
+	config: Config,
+	page?: number
+): Promise<QueueResponse[]> {
+	page = page ?? 1;
+	const accountId = await requireAuth(config);
+	return await fetchResult(
+		`/accounts/${accountId}/workers/queues`,
+		{},
+		new URLSearchParams({ page: page.toString() })
+	);
+}
+
+export async function getQueue(
+	config: Config,
+	queueName: string
+): Promise<QueueResponse> {
+	const accountId = await requireAuth(config);
+	return await fetchResult(
+		`/accounts/${accountId}/workers/queues/${queueName}`,
+		{}
+	);
+}
+
+export async function postConsumer(
+	config: Config,
+	queueName: string,
+	body: PostConsumerBody
+): Promise<ConsumerResponse> {
+	const accountId = await requireAuth(config);
+	return fetchResult(
+		`/accounts/${accountId}/workers/queues/${queueName}/consumers`,
+		{
+			method: "POST",
+			body: JSON.stringify(body),
+		}
+	);
+}
+
+export interface PutConsumerBody {
+	settings: ConsumerSettings;
+	dead_letter_queue?: string;
+}
+
+export interface PostConsumerBody extends PutConsumerBody {
+	script_name: string;
+	environment_name: string;
+}
+
+export interface ConsumerSettings {
+	batch_size?: number;
+	max_retries?: number;
+	max_wait_time_ms?: number;
+}
+
+export interface ConsumerResponse extends PostConsumerBody {
+	queue_name: string;
+	script_name: string;
+	environment_name: string;
+	settings: ConsumerSettings;
+	dead_letter_queue?: string;
+}
+
+export async function deleteConsumer(
+	config: Config,
+	queueName: string,
+	scriptName: string,
+	envName?: string
+): Promise<void> {
+	const accountId = await requireAuth(config);
+	let resource = `/accounts/${accountId}/workers/queues/${queueName}/consumers/${scriptName}`;
+	if (envName !== undefined) {
+		resource += `/environments/${envName}`;
+	}
+	return fetchResult(resource, {
+		method: "DELETE",
+	});
+}
+
+export async function putConsumer(
+	config: Config,
+	queueName: string,
+	scriptName: string,
+	envName: string | undefined,
+	body: PutConsumerBody
+): Promise<ConsumerResponse> {
+	const accountId = await requireAuth(config);
+	let resource = `/accounts/${accountId}/workers/queues/${queueName}/consumers/${scriptName}`;
+	if (envName !== undefined) {
+		resource += `/environments/${envName}`;
+	}
+	return fetchResult(resource, {
+		method: "PUT",
+		body: JSON.stringify(body),
+	});
+}

package/src/secret/index.ts

@@ -14,12 +14,13 @@ import { parseJSON, readFileSync } from "../parse";
 import { requireAuth } from "../user";
 
 import type { ConfigPath } from "../index";
-import type { YargsOptionsToInterface } from "../yargs-types";
-import type { Argv, BuilderCallback } from "yargs";
+import type {
+	CommonYargsOptions,
+	YargsOptionsToInterface,
+} from "../yargs-types";
+import type { Argv } from "yargs";
 
-export const secret: BuilderCallback<unknown, unknown> = (
-	secretYargs: Argv
-) => {
+export const secret = (secretYargs: Argv<CommonYargsOptions>) => {
 	return secretYargs
 		.option("legacy-env", {
 			type: "boolean",
@@ -39,13 +40,6 @@ export const secret: BuilderCallback<unknown, unknown> = (
 						describe: "Name of the Worker",
 						type: "string",
 						requiresArg: true,
-					})
-					.option("env", {
-						type: "string",
-						requiresArg: true,
-						describe:
-							"Binds the secret to the Worker of the specific environment",
-						alias: "e",
 					});
 			},
 			async (args) => {
@@ -110,6 +104,7 @@ export const secret: BuilderCallback<unknown, unknown> = (
 									kv_namespaces: [],
 									vars: {},
 									durable_objects: { bindings: [] },
+									queues: [],
 									r2_buckets: [],
 									d1_databases: [],
 									services: [],
@@ -126,6 +121,7 @@ export const secret: BuilderCallback<unknown, unknown> = (
 								compatibility_flags: undefined,
 								usage_model: undefined,
 								keepVars: false, // this doesn't matter since it's a new script anyway
+								logpush: false,
 							}),
 						}
 					);
@@ -172,13 +168,6 @@ export const secret: BuilderCallback<unknown, unknown> = (
 						describe: "Name of the Worker",
 						type: "string",
 						requiresArg: true,
-					})
-					.option("env", {
-						type: "string",
-						requiresArg: true,
-						describe:
-							"Binds the secret to the Worker of the specific environment",
-						alias: "e",
 					});
 			},
 			async (args) => {
@@ -225,19 +214,11 @@ export const secret: BuilderCallback<unknown, unknown> = (
 			"list",
 			"List all secrets for a Worker",
 			(yargs) => {
-				return yargs
-					.option("name", {
-						describe: "Name of the Worker",
-						type: "string",
-						requiresArg: true,
-					})
-					.option("env", {
-						type: "string",
-						requiresArg: true,
-						describe:
-							"Binds the secret to the Worker of the specific environment.",
-						alias: "e",
-					});
+				return yargs.option("name", {
+					describe: "Name of the Worker",
+					type: "string",
+					requiresArg: true,
+				});
 			},
 			async (args) => {
 				const config = readConfig(args.config as ConfigPath, args);
@@ -264,7 +245,7 @@ export const secret: BuilderCallback<unknown, unknown> = (
 		);
 };
 
-export const secretBulkOptions = (yargs: Argv) => {
+export const secretBulkOptions = (yargs: Argv<CommonYargsOptions>) => {
 	return yargs
 		.positional("json", {
 			describe: `The JSON file of key-value pairs to upload, in form {"key": value, ...}`,
@@ -275,12 +256,6 @@ export const secretBulkOptions = (yargs: Argv) => {
 			describe: "Name of the Worker",
 			type: "string",
 			requiresArg: true,
-		})
-		.option("env", {
-			type: "string",
-			requiresArg: true,
-			describe: "Binds the secret to the Worker of the specific environment.",
-			alias: "e",
 		});
 };
 

package/src/tail/index.ts

@@ -21,12 +21,15 @@ import {
 } from "./createTail";
 import type { WorkerMetadata } from "../create-worker-upload-form";
 import type { ConfigPath } from "../index";
-import type { YargsOptionsToInterface } from "../yargs-types";
+import type {
+	CommonYargsOptions,
+	YargsOptionsToInterface,
+} from "../yargs-types";
 import type { TailCLIFilters } from "./createTail";
 import type { RawData } from "ws";
 import type { Argv } from "yargs";
 
-export function tailOptions(yargs: Argv) {
+export function tailOptions(yargs: Argv<CommonYargsOptions>) {
 	return yargs
 		.positional("worker", {
 			describe: "Name or route of the worker to tail",
@@ -69,12 +72,6 @@ export function tailOptions(yargs: Argv) {
 				'Filter by the IP address the request originates from. Use "self" to filter for your own IP',
 			array: true,
 		})
-		.option("env", {
-			type: "string",
-			requiresArg: true,
-			describe: "Perform on a specific environment",
-			alias: "e",
-		})
 		.option("debug", {
 			type: "boolean",
 			hidden: true,

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/worker.ts

@@ -113,6 +113,11 @@ export interface CfDurableObject {
 	environment?: string;
 }
 
+export interface CfQueue {
+	binding: string;
+	queue_name: string;
+}
+
 export interface CfR2Bucket {
 	binding: string;
 	bucket_name: string;
@@ -194,6 +199,7 @@ export interface CfWorkerInit {
 		text_blobs: CfTextBlobBindings | undefined;
 		data_blobs: CfDataBlobBindings | undefined;
 		durable_objects: { bindings: CfDurableObject[] } | undefined;
+		queues: CfQueue[] | undefined;
 		r2_buckets: CfR2Bucket[] | undefined;
 		d1_databases: CfD1Database[] | undefined;
 		services: CfService[] | undefined;
@@ -206,6 +212,7 @@ export interface CfWorkerInit {
 	compatibility_flags: string[] | undefined;
 	usage_model: "bundled" | "unbound" | undefined;
 	keepVars: boolean | undefined;
+	logpush: boolean | undefined;
 }
 
 export interface CfWorkerContext {

package/src/yargs-types.ts

@@ -1,7 +1,20 @@
 import type { ArgumentsCamelCase, Argv } from "yargs";
+
+/**
+ * Yargs options included in every wrangler command.
+ */
+export interface CommonYargsOptions {
+	v: boolean | undefined;
+	config: string | undefined;
+	env: string | undefined;
+}
+
 /**
  * Given some Yargs Options function factory, extract the interface
  * that corresponds to the yargs arguments
  */
-export type YargsOptionsToInterface<T extends (yargs: Argv) => Argv> =
-	T extends (yargs: Argv) => Argv<infer P> ? ArgumentsCamelCase<P> : never;
+export type YargsOptionsToInterface<
+	T extends (yargs: Argv<CommonYargsOptions>) => Argv
+> = T extends (yargs: Argv<CommonYargsOptions>) => Argv<infer P>
+	? ArgumentsCamelCase<P>
+	: never;

package/src/zones.ts

@@ -9,12 +9,38 @@ export interface Zone {
 	host: string;
 }
 
+/**
+ * Get the hostname on which to run a Worker.
+ *
+ * The most accurate place is usually
+ * `route.pattern`, as that includes any subdomains. For example:
+ * ```js
+ * {
+ * 	pattern: foo.example.com
+ * 	zone_name: example.com
+ * }
+ * ```
+ * However, in the case of patterns that _can't_ be parsed as a hostname
+ * (primarily the pattern `*/ /*`), we fall back to the `zone_name`
+ * (and in the absence of that throw an error).
+ * @param route
+ */
 export function getHostFromRoute(route: Route): string | undefined {
-	return typeof route === "string"
-		? getHostFromUrl(route)
-		: typeof route === "object"
-		? getHostFromUrl(route.pattern)
-		: undefined;
+	if (typeof route === "string") {
+		return getHostFromUrl(route);
+	} else if (typeof route === "object") {
+		try {
+			return getHostFromUrl(route.pattern);
+		} catch (e) {
+			if (
+				(e as { code: string }).code === "ERR_INVALID_URL" &&
+				"zone_name" in route
+			) {
+				return getHostFromUrl(route.zone_name);
+			}
+			throw e;
+		}
+	}
 }
 
 /**

package/templates/pages-template-plugin.ts

@@ -19,6 +19,7 @@ type EventContext<Env, P extends string, Data> = {
 	request: Request;
 	functionPath: string;
 	waitUntil: (promise: Promise<unknown>) => void;
+	passThroughOnException: () => void;
 	next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
 	env: Env & { ASSETS: { fetch: typeof fetch } };
 	params: Params<P>;
@@ -29,6 +30,7 @@ type EventPluginContext<Env, P extends string, Data, PluginArgs> = {
 	request: Request;
 	functionPath: string;
 	waitUntil: (promise: Promise<unknown>) => void;
+	passThroughOnException: () => void;
 	next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
 	env: Env & { ASSETS: { fetch: typeof fetch } };
 	params: Params<P>;
@@ -146,6 +148,8 @@ export default function (pluginArgs) {
 					pluginArgs,
 					env,
 					waitUntil: workerContext.waitUntil.bind(workerContext),
+					passThroughOnException:
+						workerContext.passThroughOnException.bind(workerContext),
 				};
 
 				const response = await handler(context);

package/templates/pages-template-worker.ts

@@ -19,6 +19,7 @@ type EventContext<Env, P extends string, Data> = {
 	request: Request;
 	functionPath: string;
 	waitUntil: (promise: Promise<unknown>) => void;
+	passThroughOnException: () => void;
 	next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
 	env: Env & { ASSETS: { fetch: typeof fetch } };
 	params: Params<P>;
@@ -53,6 +54,7 @@ type FetchEnv = {
 
 type WorkerContext = {
 	waitUntil: (promise: Promise<unknown>) => void;
+	passThroughOnException: () => void;
 };
 
 function* executeRequest(request: Request) {
@@ -111,9 +113,16 @@ function* executeRequest(request: Request) {
 }
 
 export default {
-	async fetch(request: Request, env: FetchEnv, workerContext: WorkerContext) {
+	async fetch(
+		originalRequest: Request,
+		env: FetchEnv,
+		workerContext: WorkerContext
+	) {
+		let request = originalRequest;
 		const handlerIterator = executeRequest(request);
 		const data = {}; // arbitrary data the user can set between functions
+		let isFailOpen = false;
+
 		const next = async (input?: RequestInfo, init?: RequestInit) => {
 			if (input !== undefined) {
 				let url = input;
@@ -135,6 +144,9 @@ export default {
 					data,
 					env,
 					waitUntil: workerContext.waitUntil.bind(workerContext),
+					passThroughOnException: () => {
+						isFailOpen = true;
+					},
 				};
 
 				const response = await handler(context);
@@ -156,9 +168,14 @@ export default {
 		};
 
 		try {
-			return next();
-		} catch (err) {
-			return new Response("Internal Error", { status: 500 });
+			return await next();
+		} catch (error) {
+			if (isFailOpen) {
+				const response = await env[__FALLBACK_SERVICE__].fetch(request);
+				return cloneResponse(response);
+			}
+
+			throw error;
 		}
 	},
 };

package/wrangler-dist/cli.d.ts

@@ -347,6 +347,17 @@ declare interface EnvironmentInheritable {
             destination: string;
         }[];
     };
+    /**
+     * Send Trace Events from this worker to Workers Logpush.
+     *
+     * This will not configure a corresponding Logpush job automatically.
+     *
+     * For more information about Workers Logpush, see:
+     * https://blog.cloudflare.com/logpush-for-workers/
+     *
+     * @inheritable
+     */
+    logpush: boolean | undefined;
 }
 
 /**
@@ -424,6 +435,37 @@ declare interface EnvironmentNonInheritable {
         /** The ID of the KV namespace used during `wrangler dev` */
         preview_id?: string;
     }[];
+    /**
+     * Specifies Queues that are bound to this Worker environment.
+     *
+     * NOTE: This field is not automatically inherited from the top level environment,
+     * and so must be specified in every named environment.
+     *
+     * @default `{}`
+     * @nonInheritable
+     */
+    queues: {
+        /** Producer bindings */
+        producers?: {
+            /** The binding name used to refer to the Queue in the worker. */
+            binding: string;
+            /** The name of this Queue. */
+            queue: string;
+        }[];
+        /** Consumer configuration */
+        consumers?: {
+            /** The name of the queue from which this script should consume. */
+            queue: string;
+            /** The maximum number of messages per batch */
+            max_batch_size?: number;
+            /** The maximum number of seconds to wait to fill a batch with messages. */
+            max_batch_timeout?: number;
+            /** The maximum number of retries for each message. */
+            max_retries?: number;
+            /** The queue to send messages that failed to be consumed. */
+            dead_letter_queue?: string;
+        }[];
+    };
     /**
      * Specifies R2 buckets that are bound to this Worker environment.
      *