wrangler 2.1.13 → 2.1.14

package/src/delete.ts

@@ -1,9 +1,11 @@
+import assert from "assert";
 import path from "path";
 import { fetchResult } from "./cfetch";
 import { findWranglerToml, readConfig } from "./config";
 import { confirm } from "./dialogs";
 import { CI } from "./is-ci";
 import isInteractive from "./is-interactive";
+import { deleteKVNamespace, listKVNamespaces } from "./kv/helpers";
 import { logger } from "./logger";
 import * as metrics from "./metrics";
 import { requireAuth } from "./user";
@@ -60,11 +62,18 @@ export async function deleteHandler(args: ArgumentsCamelCase<DeleteArgs>) {
 
 	const scriptName = getScriptName(args, config);
 
+	assert(
+		scriptName,
+		"A worker name must be defined, either via --name, or in wrangler.toml"
+	);
+
 	if (args.dryRun) {
 		logger.log(`--dry-run: exiting now.`);
 		return;
 	}
 
+	assert(accountId, "Missing accountId");
+
 	let confirmed = true;
 	if (isInteractive() || !CI.isCI()) {
 		confirmed = await confirm(
@@ -79,8 +88,24 @@ export async function deleteHandler(args: ArgumentsCamelCase<DeleteArgs>) {
 			new URLSearchParams({ force: "true" })
 		);
 
+		await deleteSiteNamespaceIfExisting(scriptName, accountId);
+
 		logger.log("Successfully deleted", scriptName);
 	}
+}
 
-	// TODO: maybe delete sites/assets kv namespace as well?
+async function deleteSiteNamespaceIfExisting(
+	scriptName: string,
+	accountId: string
+): Promise<void> {
+	const title = `__${scriptName}-workers_sites_assets`;
+	const previewTitle = `__${scriptName}-workers_sites_assets_preview`;
+	const allNamespaces = await listKVNamespaces(accountId);
+	const namespacesToDelete = allNamespaces.filter(
+		(ns) => ns.title === title || ns.title === previewTitle
+	);
+	for (const ns of namespacesToDelete) {
+		await deleteKVNamespace(accountId, ns.id);
+		logger.log(`🌀 Deleted asset namespace for Workers Site "${ns.title}"`);
+	}
 }

package/src/dev/local.tsx

@@ -3,6 +3,7 @@ import { fork } from "node:child_process";
 import { realpathSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import chalk from "chalk";
 import { npxImport } from "npx-import";
 import { useState, useEffect, useRef } from "react";
 import onExit from "signal-exit";
@@ -221,6 +222,10 @@ function useLocalWorker({
 				cwd: path.dirname(scriptPath),
 				execArgv: nodeOptions,
 				stdio: "pipe",
+				env: {
+					...process.env,
+					FORCE_COLOR: chalk.supportsColor.hasBasic ? "1" : undefined,
+				},
 			}));
 
 			child.on("message", async (messageString) => {

package/src/entry.ts

@@ -26,7 +26,7 @@ export async function getEntry(
 		assets?: string | undefined;
 	},
 	config: Config,
-	command: "dev" | "publish"
+	command: "dev" | "publish" | "types"
 ): Promise<Entry> {
 	let file: string;
 	let directory = process.cwd();

package/src/index.tsx

@@ -5,6 +5,7 @@ import supportsColor from "supports-color";
 import { ProxyAgent, setGlobalDispatcher } from "undici";
 import makeCLI from "yargs";
 import { version as wranglerVersion } from "../package.json";
+import { fetchResult } from "./cfetch";
 import { readConfig } from "./config";
 import { d1 } from "./d1";
 import { deleteHandler, deleteOptions } from "./delete";
@@ -35,11 +36,22 @@ import { pubSubCommands } from "./pubsub/pubsub-commands";
 import { r2 } from "./r2";
 import { secret, secretBulkHandler, secretBulkOptions } from "./secret";
 import { tailOptions, tailHandler } from "./tail";
+import { generateTypes } from "./type-generation";
 import { updateCheck } from "./update-check";
-import { listScopes, login, logout, validateScopeKeys } from "./user";
+import {
+	listScopes,
+	login,
+	logout,
+	requireAuth,
+	validateScopeKeys,
+} from "./user";
 import { whoami } from "./whoami";
 
+import type { DeploymentListRes } from "./__tests__/helpers/msw/handlers/deployments";
 import type { Config } from "./config";
+import type { ServiceMetadataRes } from "./init";
+import type { PartialConfigToDTS } from "./type-generation";
+import type { ArgumentsCamelCase } from "yargs";
 import type Yargs from "yargs";
 
 export type ConfigPath = string | undefined;
@@ -262,7 +274,7 @@ export function createCLIParser(argv: string[]) {
 	// delete
 	wrangler.command(
 		"delete [script]",
-		"🗑 Delete your Worker from Cloudflare.",
+		"🗑  Delete your Worker from Cloudflare.",
 		deleteOptions,
 		deleteHandler
 	);
@@ -467,6 +479,80 @@ export function createCLIParser(argv: string[]) {
 		}
 	);
 
+	// type generation
+	wrangler.command(
+		"types",
+		"📝 Generate types from bindings & module rules in config",
+		() => {},
+		async () => {
+			await printWranglerBanner();
+			const config = readConfig(undefined, {});
+
+			const configBindings: PartialConfigToDTS = {
+				kv_namespaces: config.kv_namespaces ?? [],
+				vars: { ...config.vars },
+				wasm_modules: config.wasm_modules,
+				text_blobs: {
+					...config.text_blobs,
+				},
+				data_blobs: config.data_blobs,
+				durable_objects: config.durable_objects,
+				r2_buckets: config.r2_buckets,
+				// @ts-expect-error - We don't want the type generated to inlcude the Beta prefix
+				d1_databases: config.d1_databases,
+				services: config.services,
+				dispatch_namespaces: config.dispatch_namespaces,
+				logfwdr: config.logfwdr,
+				unsafe: config.unsafe?.bindings,
+				rules: config.rules,
+			};
+
+			await generateTypes(configBindings, config);
+		}
+	);
+
+	wrangler.command(
+		"deployments",
+		false,
+		// "🚢 Logs the 10 most recent deployments with 'Version ID', 'Version number','Author email', 'Created on' and 'Latest deploy'",
+		(yargs) => {
+			yargs.option("name", {
+				describe: "The name of your worker",
+				type: "string",
+			});
+		},
+		async (deploymentsYargs: ArgumentsCamelCase<{ name: string }>) => {
+			await printWranglerBanner();
+			const config = readConfig(
+				deploymentsYargs.config as ConfigPath,
+				deploymentsYargs
+			);
+			const accountId = await requireAuth(config);
+			const scriptName = getScriptName(
+				{ name: deploymentsYargs.name, env: undefined },
+				config
+			);
+			const scriptMetadata = await fetchResult<ServiceMetadataRes>(
+				`/accounts/${accountId}/workers/services/${scriptName}`
+			);
+
+			const scriptTag = scriptMetadata.default_environment.script.tag;
+			const deployments = await fetchResult<DeploymentListRes>(
+				`/accounts/${accountId}/workers/versions/by-script/${scriptTag}`
+			);
+
+			const versionMessages = deployments.versions.map(
+				(versions, index) =>
+					`\nVersion ID: ${versions.version_id}\nVersion number: ${
+						versions.version_number
+					}\nCreated on: ${versions.metadata.created_on}\nAuthor email: ${
+						versions.metadata.author_email
+					}\nLatest deploy: ${index === 0}\n`
+			);
+			logger.log(...versionMessages);
+		}
+	);
+
 	// This set to false to allow overwrite of default behaviour
 	wrangler.version(false);
 

package/src/init.ts

@@ -16,8 +16,8 @@ import { parsePackageJSON, parseTOML, readFileSync } from "./parse";
 import { getBasePath } from "./paths";
 import { requireAuth } from "./user";
 import { CommandLineArgsError, printWranglerBanner } from "./index";
-import type { RawConfig } from "./config";
 
+import type { RawConfig } from "./config";
 import type { Route, SimpleRoute } from "./config/environment";
 import type { WorkerMetadata } from "./create-worker-upload-form";
 import type { ConfigPath } from "./index";

package/src/logger.ts

@@ -2,7 +2,7 @@ import { format } from "node:util";
 import { formatMessagesSync } from "esbuild";
 import { getEnvironmentVariableFactory } from "./environment-variables";
 
-const LOGGER_LEVELS = {
+export const LOGGER_LEVELS = {
 	none: -1,
 	error: 0,
 	warn: 1,
@@ -11,7 +11,7 @@ const LOGGER_LEVELS = {
 	debug: 4,
 } as const;
 
-type LoggerLevel = keyof typeof LOGGER_LEVELS;
+export type LoggerLevel = keyof typeof LOGGER_LEVELS;
 
 /** A map from LOGGER_LEVEL to the error `kind` needed by `formatMessagesSync()`. */
 const LOGGER_LEVEL_FORMAT_TYPE_MAP = {

package/src/miniflare-cli/index.ts

@@ -4,16 +4,18 @@ import {
 	DurableObjectStub,
 } from "@miniflare/durable-objects";
 import {
-	Log,
+	Log as MiniflareLog,
+	LogLevel as MiniflareLogLevel,
 	Miniflare,
-	Response as MiniflareResponse,
 	Request as MiniflareRequest,
+	Response as MiniflareResponse,
 } from "miniflare";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { FatalError } from "../errors";
 import generateASSETSBinding from "./assets";
 import { getRequestContextCheckOptions } from "./request-context";
+import type { LoggerLevel } from "../logger";
 import type { Options } from "./assets";
 import type { AddressInfo } from "net";
 
@@ -24,7 +26,7 @@ export interface EnablePagesAssetsServiceBindingOptions {
 
 // miniflare defines this but importing it throws:
 // Dynamic require of "path" is not supported
-class NoOpLog extends Log {
+class MiniflareNoOpLog extends MiniflareLog {
 	log(): void {}
 
 	error(message: Error): void {
@@ -41,14 +43,17 @@ async function main() {
 		...JSON.parse((args._[0] as string) ?? "{}"),
 		...requestContextCheckOptions,
 	};
-	const logLevel = config.logLevel.toUpperCase();
+
+	let logLevelString: Uppercase<LoggerLevel> = config.logLevel.toUpperCase();
+	if (logLevelString === "LOG") logLevelString = "INFO";
+	const logLevel = MiniflareLogLevel[logLevelString];
 
 	config.log =
-		config.logLevel === "none"
-			? new NoOpLog()
-			: new Log(logLevel, config.logOptions);
+		logLevel === MiniflareLogLevel.NONE
+			? new MiniflareNoOpLog()
+			: new MiniflareLog(logLevel, config.logOptions);
 
-	if (logLevel === "DEBUG" || logLevel === "VERBOSE") {
+	if (logLevel === MiniflareLogLevel.DEBUG) {
 		console.log("MINIFLARE OPTIONS:\n", JSON.stringify(config, null, 2));
 	}
 

package/src/pages/dev.tsx

@@ -379,6 +379,10 @@ export const Handler = async ({
 					plugins: [
 						esbuildAliasExternalPlugin({
 							__ENTRY_POINT__: entrypointFile,
+							"./pages-dev-util": resolve(
+								getBasePath(),
+								"templates/pages-dev-util.ts"
+							),
 						}),
 					],
 					outfile,

package/src/sites.tsx

@@ -77,7 +77,7 @@ async function createKVNamespaceIfNotAlreadyExisting(
 	// check if it already exists
 	// TODO: this is super inefficient, should be made better
 	const namespaces = await listKVNamespaces(accountId);
-	const found = namespaces.find((x) => x.title === title);
+	const found = namespaces.find((ns) => ns.title === title);
 	if (found) {
 		return { created: false, id: found.id };
 	}

package/src/type-generation.ts

@@ -0,0 +1,159 @@
+import * as fs from "fs";
+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,
+	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) {
+			envTypeStructure.push(`	${unsafe.name}: any;`);
+		}
+	}
+
+	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;
+}`);
+				});
+			}
+		}
+	}
+
+	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")}`;
+		}
+
+		if (envTypeStructure.length || modulesTypeStructure.length) {
+			fs.writeFileSync(
+				"worker-configuration.d.ts",
+				`// Generated by Wrangler on ${new Date()}` + "\n" + combinedTypeStrings
+			);
+			logger.log(combinedTypeStrings);
+		}
+	}
+
+	writeDTSFile(envTypeStructure, entry.format);
+}

package/templates/__tests__/pages-dev-util.test.ts

@@ -0,0 +1,128 @@
+import { isRoutingRuleMatch } from "../pages-dev-util";
+
+describe("isRoutingRuleMatch", () => {
+	it("should match rules referencing root level correctly", () => {
+		const routingRule = "/";
+
+		expect(isRoutingRuleMatch("/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeFalsy();
+	});
+
+	it("should match include-all rules correctly", () => {
+		const routingRule = "/*";
+
+		expect(isRoutingRuleMatch("/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/baz", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/baz/", routingRule)).toBeTruthy();
+	});
+
+	it("should match `/*` suffix-ed rules correctly", () => {
+		let routingRule = "/foo/*";
+
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foobar", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/baz", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/bar/foo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/bar/foo/baz", routingRule)).toBeFalsy();
+
+		routingRule = "/foo/bar/*";
+
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/baz", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/barfoo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("baz/foo/bar", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("baz/foo/bar/", routingRule)).toBeFalsy();
+	});
+
+	it("should match `/` suffix-ed rules correctly", () => {
+		let routingRule = "/foo/";
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeTruthy();
+
+		routingRule = "/foo/bar/";
+		expect(isRoutingRuleMatch("/foo/bar/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+	});
+
+	it("should match `*` suffix-ed rules correctly", () => {
+		let routingRule = "/foo*";
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foobar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/barfoo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/bar/foo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/bar/foobar", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/bar/baz", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/bar/foo/baz", routingRule)).toBeFalsy();
+
+		routingRule = "/foo/bar*";
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/barfoo", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/bar/foo/barfoo", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/foo/bar/baz", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/bar/foo/bar/baz", routingRule)).toBeFalsy();
+	});
+
+	it("should match rules without wildcards correctly", () => {
+		let routingRule = "/foo";
+
+		expect(isRoutingRuleMatch("/foo", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/bar/foo", routingRule)).toBeFalsy();
+
+		routingRule = "/foo/bar";
+		expect(isRoutingRuleMatch("/foo/bar", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/", routingRule)).toBeTruthy();
+		expect(isRoutingRuleMatch("/foo/bar/baz", routingRule)).toBeFalsy();
+		expect(isRoutingRuleMatch("/baz/foo/bar", routingRule)).toBeFalsy();
+	});
+
+	it("should throw an error if pathname or routing rule params are missing", () => {
+		// MISSING PATHNAME
+		expect(() =>
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore: sanity check
+			isRoutingRuleMatch(undefined, "/*")
+		).toThrow("Pathname is undefined.");
+
+		expect(() =>
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore: sanity check
+			isRoutingRuleMatch(null, "/*")
+		).toThrow("Pathname is undefined.");
+
+		expect(() => isRoutingRuleMatch("", "/*")).toThrow(
+			"Pathname is undefined."
+		);
+
+		// MISSING ROUTING RULE
+		expect(() =>
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore: sanity check
+			isRoutingRuleMatch("/foo", undefined)
+		).toThrow("Routing rule is undefined.");
+
+		expect(() =>
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore: sanity check
+			isRoutingRuleMatch("/foo", null)
+		).toThrow("Routing rule is undefined.");
+
+		expect(() => isRoutingRuleMatch("/foo", "")).toThrow(
+			"Routing rule is undefined."
+		);
+	});
+});

package/templates/pages-dev-pipeline.ts

@@ -2,30 +2,23 @@
 import worker from "__ENTRY_POINT__";
 // @ts-ignore entry point will get replaced
 export * from "__ENTRY_POINT__";
+import { isRoutingRuleMatch } from "./pages-dev-util";
 
-const transformToRegex = (filter: string) => {
-	return filter.replace("*", ".*");
-};
-
-const routes = {
-	// @ts-ignore routes are injected
-	include: __ROUTES__.include.map(transformToRegex),
-	// @ts-ignore routes are injected
-	exclude: __ROUTES__.exclude.map(transformToRegex) || [],
-};
+// @ts-ignore routes are injected
+const routes = __ROUTES__;
 
 export default {
 	fetch(request, env, context) {
 		const { pathname } = new URL(request.url);
 
 		for (const exclude of routes.exclude) {
-			if (pathname.match(exclude)) {
+			if (isRoutingRuleMatch(pathname, exclude)) {
 				return env.ASSETS.fetch(request);
 			}
 		}
 
 		for (const include of routes.include) {
-			if (pathname.match(include)) {
+			if (isRoutingRuleMatch(pathname, include)) {
 				return worker.fetch(request, env, context);
 			}
 		}

package/templates/pages-dev-util.ts

@@ -0,0 +1,52 @@
+/**
+ * @param pathname A pathname string, such as `/foo` or `/foo/bar`
+ * @param routingRule The routing rule, such as `/foo/*`
+ * @returns True if pathname matches the routing rule
+ *
+ * /       ->  /
+ * /*      ->  /*
+ * /foo    ->  /foo
+ * /foo*   ->  /foo, /foo-bar, /foo/*
+ * /foo/*  ->  /foo, /foo/bar
+ */
+export function isRoutingRuleMatch(
+	pathname: string,
+	routingRule: string
+): boolean {
+	// sanity checks
+	if (!pathname) {
+		throw new Error("Pathname is undefined.");
+	}
+	if (!routingRule) {
+		throw new Error("Routing rule is undefined.");
+	}
+
+	const ruleRegExp = transformRoutingRuleToRegExp(routingRule);
+	return pathname.match(ruleRegExp) !== null;
+}
+
+function transformRoutingRuleToRegExp(rule: string): RegExp {
+	let transformedRule;
+
+	if (rule === "/" || rule === "/*") {
+		transformedRule = rule;
+	} else if (rule.endsWith("/*")) {
+		// make `/*` an optional group so we can match both /foo/* and /foo
+		// /foo/* => /foo(/*)?
+		transformedRule = `${rule.substring(0, rule.length - 2)}(/*)?`;
+	} else if (rule.endsWith("/")) {
+		// make `/` an optional group so we can match both /foo/ and /foo
+		// /foo/ => /foo(/)?
+		transformedRule = `${rule.substring(0, rule.length - 1)}(/)?`;
+	} else if (rule.endsWith("*")) {
+		transformedRule = rule;
+	} else {
+		transformedRule = `${rule}(/)?`;
+	}
+
+	// /foo* => /foo.* => ^/foo.*$
+	transformedRule = `^${transformedRule.replace("*", ".*")}$`;
+
+	// ^/foo.*$ => /^\/foo.*$/
+	return new RegExp(transformedRule);
+}