wrangler 2.1.13 → 2.1.15

package/src/__tests__/type-generation.test.ts

@@ -0,0 +1,217 @@
+import * as fs from "fs";
+import * as TOML from "@iarna/toml";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import type { Config } from "../config";
+import type { CfWorkerInit } from "../worker";
+
+const bindingsConfigMock: CfWorkerInit["bindings"] & {
+	rules: Config["rules"];
+} = {
+	kv_namespaces: [{ binding: "TEST_KV_NAMESPACE", id: "1234" }],
+	vars: {
+		SOMETHING: "asdasdfasdf",
+		ANOTHER: "thing",
+		OBJECT_VAR: {
+			enterprise: "1701-D",
+			activeDuty: true,
+			captian: "Picard",
+		}, // We can assume the objects will be stringified
+	},
+	durable_objects: {
+		bindings: [
+			{ name: "DURABLE_TEST1", class_name: "Durability1" },
+			{ name: "DURABLE_TEST2", class_name: "Durability2" },
+		],
+	},
+	r2_buckets: [
+		{
+			binding: "R2_BUCKET_BINDING",
+			bucket_name: "R2BUCKET_NAME_TEST",
+		},
+	],
+	d1_databases: [
+		{
+			// @ts-expect-error This type is resolved in the function that handles creating BETA string
+			binding: "D1_TESTING_SOMETHING",
+			database_name: "D1_BINDING",
+			database_id: "1234",
+		},
+	],
+	services: [{ binding: "SERVICE_BINDING", service: "SERVICE_NAME" }],
+	dispatch_namespaces: [
+		{ binding: "NAMESPACE_BINDING", namespace: "NAMESPACE_ID" },
+	],
+	logfwdr: {
+		schema: "LOGFWDER_SCHEMA",
+		bindings: [{ name: "LOGFWDR_BINDING", destination: "LOGFWDR_DESTINATION" }],
+	},
+	data_blobs: {
+		SOME_DATA_BLOB1: "SOME_DATA_BLOB1.bin",
+		SOME_DATA_BLOB2: "SOME_DATA_BLOB2.bin",
+	},
+	text_blobs: {
+		SOME_TEXT_BLOB1: "SOME_TEXT_BLOB1.txt",
+		SOME_TEXT_BLOB2: "SOME_TEXT_BLOB2.txt",
+	},
+	wasm_modules: { MODULE1: "module1.wasm", MODULE2: "module2.wasm" },
+	unsafe: [
+		{
+			// @ts-expect-error Unsafe bindings type is somewhat different in different places
+			bindings: [{ name: "testing_unsafe", type: "plain_text" }],
+		},
+	],
+	rules: [
+		{
+			type: "Text",
+			globs: ["**/*.txt"],
+			fallthrough: true,
+		},
+		{
+			type: "Data",
+			globs: ["**/*.webp"],
+			fallthrough: true,
+		},
+		{ type: "CompiledWasm", globs: ["**/*.wasm"], fallthrough: true },
+	],
+};
+
+describe("generateTypes()", () => {
+	const std = mockConsoleMethods();
+	runInTempDir();
+
+	it("should log the interface type generated and declare modules", async () => {
+		fs.writeFileSync("./index.ts", "export default { async fetch () {} };");
+		fs.writeFileSync(
+			"./wrangler.toml",
+			TOML.stringify({
+				compatibility_date: "2022-01-12",
+				name: "test-name",
+				main: "./index.ts",
+				// eslint-disable-next-line @typescript-eslint/no-explicit-any
+				...(bindingsConfigMock as any),
+				unsafe: bindingsConfigMock.unsafe?.at(0) ?? {},
+			}),
+			"utf-8"
+		);
+
+		await runWrangler("types");
+		expect(std.out).toMatchInlineSnapshot(`
+		"interface Env {
+			TEST_KV_NAMESPACE: KVNamespace;
+			SOMETHING: asdasdfasdf;
+			ANOTHER: thing;
+			OBJECT_VAR: {\\"enterprise\\":\\"1701-D\\",\\"activeDuty\\":true,\\"captian\\":\\"Picard\\"};
+			DURABLE_TEST1: DurableObjectNamespace;
+			DURABLE_TEST2: DurableObjectNamespace;
+			R2_BUCKET_BINDING: R2Bucket;
+			D1_TESTING_SOMETHING: D1Database;
+			SERVICE_BINDING: Fetcher;
+			NAMESPACE_BINDING: any;
+			LOGFWDR_SCHEMA: any;
+			SOME_DATA_BLOB1: ArrayBuffer;
+			SOME_DATA_BLOB2: ArrayBuffer;
+			SOME_TEXT_BLOB1: string;
+			SOME_TEXT_BLOB2: string;
+			testing_unsafe: any;
+		}
+		declare module \\"*.txt\\" {
+			const value: string;
+			export default value;
+		}
+		declare module \\"*.webp\\" {
+			const value: ArrayBuffer;
+			export default value;
+		}
+		declare module \\"*.wasm\\" {
+			const value: WebAssembly.Module;
+			export default value;
+		}"
+	`);
+	});
+
+	it("should create a DTS file at the location that the command is executed from", async () => {
+		fs.writeFileSync("./index.ts", "export default { async fetch () {} };");
+		fs.writeFileSync(
+			"./wrangler.toml",
+			TOML.stringify({
+				compatibility_date: "2022-01-12",
+				name: "test-name",
+				main: "./index.ts",
+				// @ts-expect-error This type is out of sync with the actual bindingsConfig type
+				vars: bindingsConfigMock.vars,
+			}),
+			"utf-8"
+		);
+		await runWrangler("types");
+		expect(fs.existsSync("./worker-configuration.d.ts")).toBe(true);
+	});
+
+	it("should not create DTS file if there is nothing in the config to generate types from", async () => {
+		fs.writeFileSync("./index.ts", "export default { async fetch () {} };");
+		fs.writeFileSync(
+			"./wrangler.toml",
+			TOML.stringify({
+				compatibility_date: "2022-01-12",
+				name: "test-name",
+				main: "./index.ts",
+			}),
+			"utf-8"
+		);
+		await runWrangler("types");
+		expect(fs.existsSync("./worker-configuration.d.ts")).toBe(false);
+		expect(std.out).toMatchInlineSnapshot(`""`);
+	});
+
+	it("should create a DTS file at the location that the command is executed from", async () => {
+		fs.writeFileSync(
+			"./worker-configuration.d.ts",
+			"NOT THE CONTENTS OF THE GENERATED FILE"
+		);
+		fs.writeFileSync("./index.ts", "export default { async fetch () {} };");
+		fs.writeFileSync(
+			"./wrangler.toml",
+			TOML.stringify({
+				compatibility_date: "2022-01-12",
+				name: "test-name",
+				main: "./index.ts",
+				// @ts-expect-error This type is out of sync with the actual bindingsConfig type
+				vars: bindingsConfigMock.vars,
+			}),
+			"utf-8"
+		);
+
+		await expect(runWrangler("types")).rejects.toMatchInlineSnapshot(
+			`[Error: A non-wrangler worker-configuration.d.ts already exists, please rename and try again.]`
+		);
+		expect(fs.existsSync("./worker-configuration.d.ts")).toBe(true);
+	});
+
+	it("should log the declare global type generated and declare modules", async () => {
+		fs.writeFileSync(
+			"./index.ts",
+			`addEventListener('fetch', event => {  event.respondWith(handleRequest(event.request));
+		}); async function handleRequest(request) {  return new Response('Hello worker!', {headers: { 'content-type': 'text/plain' },});}`
+		);
+		fs.writeFileSync(
+			"./wrangler.toml",
+			TOML.stringify({
+				compatibility_date: "2022-01-12",
+				name: "test-name",
+				main: "./index.ts",
+				// @ts-expect-error This type is out of sync with the actual bindingsConfig type
+				unsafe: bindingsConfigMock.unsafe?.at(0) ?? {},
+			}),
+			"utf-8"
+		);
+
+		await runWrangler("types");
+		expect(std.out).toMatchInlineSnapshot(`
+		"declare global {
+			testing_unsafe: any;
+		}
+		"
+	`);
+	});
+});

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/is-interactive.ts

@@ -4,6 +4,10 @@
  * or you're piping values from / to another process, etc
  */
 export default function isInteractive(): boolean {
+	if (process.env.CF_PAGES === "1") {
+		return false;
+	}
+
 	try {
 		return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 	} catch {

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

@@ -1,5 +1,7 @@
 import { version as wranglerVersion } from "../../package.json";
 
+export const MAX_ASSET_COUNT = 20_000;
+export const MAX_ASSET_SIZE = 25 * 1024 * 1024;
 export const PAGES_CONFIG_CACHE_FILENAME = "pages.json";
 export const MAX_BUCKET_SIZE = 50 * 1024 * 1024;
 export const MAX_BUCKET_FILE_COUNT = 5000;

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/pages/upload.tsx

@@ -3,13 +3,17 @@ import { dirname, join, relative, resolve, sep } from "node:path";
 import { render, Text } from "ink";
 import Spinner from "ink-spinner";
 import { getType } from "mime";
+import { Minimatch } from "minimatch";
 import PQueue from "p-queue";
 import prettyBytes from "pretty-bytes";
 import React from "react";
 import { fetchResult } from "../cfetch";
 import { FatalError } from "../errors";
+import isInteractive from "../is-interactive";
 import { logger } from "../logger";
 import {
+	MAX_ASSET_COUNT,
+	MAX_ASSET_SIZE,
 	BULK_UPLOAD_CONCURRENCY,
 	MAX_BUCKET_FILE_COUNT,
 	MAX_BUCKET_SIZE,
@@ -96,10 +100,11 @@ export const upload = async (
 		"_redirects",
 		"_headers",
 		"_routes.json",
-		".DS_Store",
-		"node_modules",
-		".git",
-	];
+		"functions",
+		"**/.DS_Store",
+		"**/node_modules",
+		"**/.git",
+	].map((pattern) => new Minimatch(pattern));
 
 	const directory = resolve(args.directory);
 
@@ -121,10 +126,13 @@ export const upload = async (
 		await Promise.all(
 			files.map(async (file) => {
 				const filepath = join(dir, file);
+				const relativeFilepath = relative(startingDir, filepath);
 				const filestat = await stat(filepath);
 
-				if (IGNORE_LIST.includes(file)) {
-					return;
+				for (const minimatch of IGNORE_LIST) {
+					if (minimatch.match(relativeFilepath)) {
+						return;
+					}
 				}
 
 				if (filestat.isSymbolicLink()) {
@@ -134,12 +142,12 @@ export const upload = async (
 				if (filestat.isDirectory()) {
 					fileMap = await walk(filepath, fileMap, startingDir);
 				} else {
-					const name = relative(startingDir, filepath).split(sep).join("/");
+					const name = relativeFilepath.split(sep).join("/");
 
-					if (filestat.size > 25 * 1024 * 1024) {
+					if (filestat.size > MAX_ASSET_SIZE) {
 						throw new FatalError(
 							`Error: Pages only supports files up to ${prettyBytes(
-								25 * 1024 * 1024
+								MAX_ASSET_SIZE
 							)} in size\n${name} is ${prettyBytes(filestat.size)} in size`,
 							1
 						);
@@ -161,9 +169,9 @@ export const upload = async (
 
 	const fileMap = await walk(directory);
 
-	if (fileMap.size > 20000) {
+	if (fileMap.size > MAX_ASSET_COUNT) {
 		throw new FatalError(
-			`Error: Pages only supports up to 20,000 files in a deployment. Ensure you have specified your build output directory correctly.`,
+			`Error: Pages only supports up to ${MAX_ASSET_COUNT.toLocaleString()} files in a deployment. Ensure you have specified your build output directory correctly.`,
 			1
 		);
 	}
@@ -309,7 +317,9 @@ export const upload = async (
 				(error) => {
 					return Promise.reject(
 						new FatalError(
-							"Failed to upload files. Please try again.",
+							`Failed to upload files. Please try again. Error: ${JSON.stringify(
+								error
+							)})`,
 							error.code || 1
 						)
 					);
@@ -390,7 +400,7 @@ function Progress({ done, total }: { done: number; total: number }) {
 	return (
 		<>
 			<Text>
-				<Spinner type="earth" />
+				{isInteractive() ? <Spinner type="earth" /> : null}
 				{` Uploading... (${done}/${total})\n`}
 			</Text>
 		</>

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 };
 	}