wrangler 2.1.2 → 2.1.4

package/src/init.ts

@@ -21,6 +21,7 @@ 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";
+import type { PackageManager } from "./package-manager";
 import type { Argv, ArgumentsCamelCase } from "yargs";
 
 export async function initOptions(yargs: Argv) {
@@ -234,6 +235,8 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 		"package.json"
 	);
 	let shouldCreatePackageJson = false;
+	let shouldCreateTests = false;
+	let newWorkerTestType: "jest" | "vitest" = "jest";
 
 	if (!pathToPackageJson) {
 		// If no package.json exists, ask to create one
@@ -355,48 +358,26 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 		!packageJsonContent.scripts?.publish &&
 		shouldCreatePackageJson;
 
-	/*
-	 * Passes the array of accumulated devDeps to install through to
-	 * the package manager. Also generates a human-readable list
-	 * of packages it installed.
-	 * If there are no devDeps to install, optionally runs
-	 * the package manager's install command.
-	 */
-	async function installPackages(
-		shouldRunInstall: boolean,
-		depsToInstall: string[]
-	) {
-		//lets install the devDeps they asked for
-		//and run their package manager's install command if needed
-		if (depsToInstall.length > 0) {
-			const formatter = new Intl.ListFormat("en", {
-				style: "long",
-				type: "conjunction",
-			});
-			await packageManager.addDevDeps(...depsToInstall);
-			const versionlessPackages = depsToInstall.map((dep) =>
-				dep === `wrangler@${wranglerVersion}` ? "wrangler" : dep
-			);
-
-			logger.log(
-				`✨ Installed ${formatter.format(
-					versionlessPackages
-				)} into devDependencies`
-			);
-		} else {
-			if (shouldRunInstall) {
-				await packageManager.install();
-			}
+	async function writePackageJsonScriptsAndUpdateWranglerToml({
+		isWritingScripts,
+		isAddingTests,
+		testRunner,
+		isCreatingWranglerToml,
+		packagePath,
+		scriptPath,
+		extraToml,
+	}: {
+		isWritingScripts: boolean;
+		isAddingTests?: boolean;
+		testRunner?: "jest" | "vitest";
+		isCreatingWranglerToml: boolean;
+		packagePath: string;
+		scriptPath: string;
+		extraToml: TOML.JsonMap;
+	}) {
+		if (isAddingTests && !testRunner) {
+			logger.error("testRunner is required if isAddingTests");
 		}
-	}
-
-	async function writePackageJsonScriptsAndUpdateWranglerToml(
-		isWritingScripts: boolean,
-		isCreatingWranglerToml: boolean,
-		packagePath: string,
-		scriptPath: string,
-		extraToml: TOML.JsonMap
-	) {
 		if (isCreatingWranglerToml) {
 			// rewrite wrangler.toml with main = "path/to/script" and any additional config specified in `extraToml`
 			const parsedWranglerToml = parseTOML(
@@ -412,7 +393,8 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 		}
 		const isNamedWorker =
 			isCreatingWranglerToml && path.dirname(packagePath) !== process.cwd();
-
+		const isAddingTestScripts =
+			isAddingTests && !packageJsonContent.scripts?.test;
 		if (isWritingScripts) {
 			await writeFile(
 				packagePath,
@@ -427,6 +409,7 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 							deploy: isCreatingWranglerToml
 								? `wrangler publish`
 								: `wrangler publish ${scriptPath}`,
+							...(isAddingTestScripts && { test: testRunner }),
 						},
 					},
 					null,
@@ -438,6 +421,9 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 					isNamedWorker ? `cd ${args.name} && ` : ""
 				}npm start\``
 			);
+			if (isAddingTestScripts) {
+				instructions.push(`To start testing your Worker, run \`npm test\``);
+			}
 			instructions.push(
 				`To publish your Worker to the Internet, run \`npm run deploy\``
 			);
@@ -455,53 +441,6 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 		}
 	}
 
-	async function getNewWorkerType(newWorkerFilename: string) {
-		return select(
-			`Would you like to create a Worker at ${newWorkerFilename}?`,
-			[
-				{
-					value: "none",
-					label: "None",
-				},
-				{
-					value: "fetch",
-					label: "Fetch handler",
-				},
-				{
-					value: "scheduled",
-					label: "Scheduled handler",
-				},
-			],
-			1
-		) as Promise<"none" | "fetch" | "scheduled">;
-	}
-
-	function getNewWorkerTemplate(
-		lang: "js" | "ts",
-		workerType: "fetch" | "scheduled"
-	) {
-		const templates = {
-			"js-fetch": "new-worker.js",
-			"js-scheduled": "new-worker-scheduled.js",
-			"ts-fetch": "new-worker.ts",
-			"ts-scheduled": "new-worker-scheduled.ts",
-		};
-
-		return templates[`${lang}-${workerType}`];
-	}
-
-	function getNewWorkerToml(workerType: "fetch" | "scheduled"): TOML.JsonMap {
-		if (workerType === "scheduled") {
-			return {
-				triggers: {
-					crons: ["1 * * * *"],
-				},
-			};
-		}
-
-		return {};
-	}
-
 	if (isTypescriptProject) {
 		if (!fs.existsSync(path.join(creationDirectory, "./src/index.ts"))) {
 			const newWorkerFilename = path.relative(
@@ -533,17 +472,16 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 					dashScript
 				);
 
-				await writePackageJsonScriptsAndUpdateWranglerToml(
-					shouldWritePackageJsonScripts,
-					justCreatedWranglerToml,
-					pathToPackageJson,
-					"src/index.ts",
-
-					(await getWorkerConfig(accountId, fromDashScriptName, {
+				await writePackageJsonScriptsAndUpdateWranglerToml({
+					isWritingScripts: shouldWritePackageJsonScripts,
+					isCreatingWranglerToml: justCreatedWranglerToml,
+					packagePath: pathToPackageJson,
+					scriptPath: "src/index.ts",
+					extraToml: (await getWorkerConfig(accountId, fromDashScriptName, {
 						defaultEnvironment,
 						environments: serviceMetaData.environments,
-					})) as TOML.JsonMap
-				);
+					})) as TOML.JsonMap,
+				});
 			} else {
 				const newWorkerType = yesFlag
 					? "fetch"
@@ -567,13 +505,13 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 						)}`
 					);
 
-					await writePackageJsonScriptsAndUpdateWranglerToml(
-						shouldWritePackageJsonScripts,
-						justCreatedWranglerToml,
-						pathToPackageJson,
-						"src/index.ts",
-						getNewWorkerToml(newWorkerType)
-					);
+					await writePackageJsonScriptsAndUpdateWranglerToml({
+						isWritingScripts: shouldWritePackageJsonScripts,
+						isCreatingWranglerToml: justCreatedWranglerToml,
+						packagePath: pathToPackageJson,
+						scriptPath: "src/index.ts",
+						extraToml: getNewWorkerToml(newWorkerType),
+					});
 				}
 			}
 		}
@@ -611,17 +549,17 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 					dashScript
 				);
 
-				await writePackageJsonScriptsAndUpdateWranglerToml(
-					shouldWritePackageJsonScripts,
-					justCreatedWranglerToml,
-					pathToPackageJson,
-					"src/index.ts",
+				await writePackageJsonScriptsAndUpdateWranglerToml({
+					isWritingScripts: shouldWritePackageJsonScripts,
+					isCreatingWranglerToml: justCreatedWranglerToml,
+					packagePath: pathToPackageJson,
+					scriptPath: "src/index.ts",
 					//? Should we have Environment argument for `wrangler init --from-dash` - Jacob
-					(await getWorkerConfig(accountId, fromDashScriptName, {
+					extraToml: (await getWorkerConfig(accountId, fromDashScriptName, {
 						defaultEnvironment,
 						environments: serviceMetaData.environments,
-					})) as TOML.JsonMap
-				);
+					})) as TOML.JsonMap,
+				});
 			} else {
 				const newWorkerType = yesFlag
 					? "fetch"
@@ -645,20 +583,50 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 						)}`
 					);
 
-					await writePackageJsonScriptsAndUpdateWranglerToml(
-						shouldWritePackageJsonScripts,
-						justCreatedWranglerToml,
-						pathToPackageJson,
-						"src/index.js",
-						getNewWorkerToml(newWorkerType)
-					);
+					shouldCreateTests =
+						yesFlag ||
+						(await confirm("Would you like us to write your first test?"));
+
+					if (shouldCreateTests) {
+						newWorkerTestType = await getNewWorkerTestType();
+						devDepsToInstall.push(newWorkerTestType);
+						await writeFile(
+							path.join(creationDirectory, "./src/index.test.js"),
+							readFileSync(
+								path.join(
+									getBasePath(),
+									`templates/init-tests/test-${newWorkerTestType}-new-worker.js`
+								)
+							)
+						);
+						logger.log(
+							`✨ Created ${path.relative(
+								process.cwd(),
+								path.join(creationDirectory, "./src/index.test.js")
+							)}`
+						);
+					}
+
+					await writePackageJsonScriptsAndUpdateWranglerToml({
+						isWritingScripts: shouldWritePackageJsonScripts,
+						isAddingTests: shouldCreateTests,
+						testRunner: newWorkerTestType,
+						isCreatingWranglerToml: justCreatedWranglerToml,
+						packagePath: pathToPackageJson,
+						scriptPath: "src/index.js",
+						extraToml: getNewWorkerToml(newWorkerType),
+					});
 				}
 			}
 		}
 	}
 	// install packages as the final step of init
 	try {
-		await installPackages(shouldRunPackageManagerInstall, devDepsToInstall);
+		await installPackages(
+			shouldRunPackageManagerInstall,
+			devDepsToInstall,
+			packageManager
+		);
 	} catch (e) {
 		// fetching packages could fail due to loss of internet, etc
 		// we should let folks know we failed to fetch, but their
@@ -673,6 +641,106 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 	instructions.forEach((instruction) => logger.log(instruction));
 }
 
+/*
+ * Passes the array of accumulated devDeps to install through to
+ * the package manager. Also generates a human-readable list
+ * of packages it installed.
+ * If there are no devDeps to install, optionally runs
+ * the package manager's install command.
+ */
+async function installPackages(
+	shouldRunInstall: boolean,
+	depsToInstall: string[],
+	packageManager: PackageManager
+) {
+	//lets install the devDeps they asked for
+	//and run their package manager's install command if needed
+	if (depsToInstall.length > 0) {
+		const formatter = new Intl.ListFormat("en", {
+			style: "long",
+			type: "conjunction",
+		});
+		await packageManager.addDevDeps(...depsToInstall);
+		const versionlessPackages = depsToInstall.map((dep) =>
+			dep === `wrangler@${wranglerVersion}` ? "wrangler" : dep
+		);
+
+		logger.log(
+			`✨ Installed ${formatter.format(
+				versionlessPackages
+			)} into devDependencies`
+		);
+	} else {
+		if (shouldRunInstall) {
+			await packageManager.install();
+		}
+	}
+}
+
+async function getNewWorkerType(newWorkerFilename: string) {
+	return select(
+		`Would you like to create a Worker at ${newWorkerFilename}?`,
+		[
+			{
+				value: "none",
+				label: "None",
+			},
+			{
+				value: "fetch",
+				label: "Fetch handler",
+			},
+			{
+				value: "scheduled",
+				label: "Scheduled handler",
+			},
+		],
+		1
+	) as Promise<"none" | "fetch" | "scheduled">;
+}
+
+async function getNewWorkerTestType() {
+	return select(
+		`Which test runner would you like to use?`,
+		[
+			{
+				value: "vitest",
+				label: "Vitest",
+			},
+			{
+				value: "jest",
+				label: "Jest",
+			},
+		],
+		1
+	) as Promise<"jest" | "vitest">;
+}
+
+function getNewWorkerTemplate(
+	lang: "js" | "ts",
+	workerType: "fetch" | "scheduled"
+) {
+	const templates = {
+		"js-fetch": "new-worker.js",
+		"js-scheduled": "new-worker-scheduled.js",
+		"ts-fetch": "new-worker.ts",
+		"ts-scheduled": "new-worker-scheduled.ts",
+	};
+
+	return templates[`${lang}-${workerType}`];
+}
+
+function getNewWorkerToml(workerType: "fetch" | "scheduled"): TOML.JsonMap {
+	if (workerType === "scheduled") {
+		return {
+			triggers: {
+				crons: ["1 * * * *"],
+			},
+		};
+	}
+
+	return {};
+}
+
 /**
  * Find the path to the given `basename` file from the `cwd`.
  *

package/src/pages/dev.tsx

@@ -116,9 +116,22 @@ export function Options(yargs: Argv) {
 				choices: ["http", "https"] as const,
 			},
 			"experimental-enable-local-persistence": {
+				describe:
+					"Enable persistence for local mode (deprecated, use --persist)",
 				type: "boolean",
-				default: false,
-				describe: "Enable persistence for this session (only for local mode)",
+				deprecated: true,
+				hidden: true,
+			},
+			persist: {
+				describe:
+					"Enable persistence for local mode, using default path: .wrangler/state",
+				type: "boolean",
+			},
+			"persist-to": {
+				describe:
+					"Specify directory to use for local persistence (implies --persist)",
+				type: "string",
+				requiresArg: true,
 			},
 			"node-compat": {
 				describe: "Enable node.js compatibility",
@@ -151,7 +164,9 @@ export const Handler = async ({
 	r2: r2s = [],
 	"live-reload": liveReload,
 	"local-protocol": localProtocol,
-	"experimental-enable-local-persistence": experimentalEnableLocalPersistence,
+	experimentalEnableLocalPersistence,
+	persist,
+	persistTo,
 	"node-compat": nodeCompat,
 	config: config,
 	_: [_pages, _dev, ...remaining],
@@ -189,6 +204,14 @@ export const Handler = async ({
 		directory = resolve(directory);
 	}
 
+	if (experimentalEnableLocalPersistence) {
+		logger.warn(
+			`--experimental-enable-local-persistence is deprecated.\n` +
+				`Move any existing data to .wrangler/state and use --persist, or\n` +
+				`use --persist-to=./wrangler-local-state to keep using the old path.`
+		);
+	}
+
 	let scriptReadyResolve: () => void;
 	const scriptReadyPromise = new Promise<void>(
 		(promiseResolve) => (scriptReadyResolve = promiseResolve)
@@ -358,7 +381,8 @@ export const Handler = async ({
 				directory,
 			},
 			forceLocal: true,
-			experimentalEnableLocalPersistence,
+			persist,
+			persistTo,
 			showInteractiveDevSession: undefined,
 			inspect: true,
 			logLevel: "error",

package/templates/init-tests/test-jest-new-worker.js

@@ -0,0 +1,25 @@
+const { unstable_dev } = require("wrangler");
+
+describe("Worker", () => {
+	let worker;
+
+	beforeAll(async () => {
+		worker = await unstable_dev(
+			"src/index.js",
+			{},
+			{ disableExperimentalWarning: true }
+		);
+	});
+
+	afterAll(async () => {
+		await worker.stop();
+	});
+
+	it("should return Hello World", async () => {
+		const resp = await worker.fetch();
+		if (resp) {
+			const text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Hello World!"`);
+		}
+	});
+});

package/templates/init-tests/test-vitest-new-worker.js

@@ -0,0 +1,26 @@
+import { unstable_dev } from "wrangler";
+import { describe, expect, it, beforeAll, afterAll } from "vitest";
+
+describe("Worker", () => {
+	let worker;
+
+	beforeAll(async () => {
+		worker = await unstable_dev(
+			"src/index.js",
+			{},
+			{ disableExperimentalWarning: true }
+		);
+	});
+
+	afterAll(async () => {
+		await worker.stop();
+	});
+
+	it("should return Hello World", async () => {
+		const resp = await worker.fetch();
+		if (resp) {
+			const text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Hello World!"`);
+		}
+	});
+});

package/wrangler-dist/cli.d.ts

@@ -52,7 +52,8 @@ declare interface DevOptions {
     nodeCompat?: boolean;
     compatibilityDate?: string;
     compatibilityFlags?: string[];
-    experimentalEnableLocalPersistence?: boolean;
+    persist?: boolean;
+    persistTo?: string;
     liveReload?: boolean;
     watch?: boolean;
     vars?: {
@@ -253,8 +254,67 @@ declare type ReferrerPolicy =
 | 'strict-origin-when-cross-origin'
 | 'unsafe-url';
 
+declare class Request implements BodyMixin {
+    constructor (input: RequestInfo, init?: RequestInit)
+
+    readonly cache: RequestCache
+    readonly credentials: RequestCredentials
+    readonly destination: RequestDestination
+    readonly headers: Headers
+    readonly integrity: string
+    readonly method: string
+    readonly mode: RequestMode
+    readonly redirect: RequestRedirect
+    readonly referrerPolicy: string
+    readonly url: string
+
+    readonly keepalive: boolean
+    readonly signal: AbortSignal
+
+    readonly body: ReadableStream | null
+    readonly bodyUsed: boolean
+
+    readonly arrayBuffer: () => Promise<ArrayBuffer>
+    readonly blob: () => Promise<Blob_2>
+    readonly formData: () => Promise<FormData>
+    readonly json: () => Promise<unknown>
+    readonly text: () => Promise<string>
+
+    readonly clone: () => Request
+}
+
+declare type RequestCache =
+| 'default'
+| 'force-cache'
+| 'no-cache'
+| 'no-store'
+| 'only-if-cached'
+| 'reload'
+
 declare type RequestCredentials = 'omit' | 'include' | 'same-origin'
 
+declare type RequestDestination =
+| ''
+| 'audio'
+| 'audioworklet'
+| 'document'
+| 'embed'
+| 'font'
+| 'image'
+| 'manifest'
+| 'object'
+| 'paintworklet'
+| 'report'
+| 'script'
+| 'sharedworker'
+| 'style'
+| 'track'
+| 'video'
+| 'worker'
+| 'xslt'
+
+declare type RequestInfo = string | URL_2 | Request
+
 declare interface RequestInit {
     method?: string
     keepalive?: boolean
@@ -337,11 +397,11 @@ declare interface SpecIterator<T, TReturn = any, TNext = undefined> {
  *  @param {DevApiOptions} apiOptions
  * @returns {Promise<UnstableDev>}
  */
-export declare function unstable_dev(script: string, options?: DevOptions, apiOptions?: DevApiOptions): Promise<UnstableDev>;
+export declare function unstable_dev(script: string, options?: DevOptions, apiOptions?: DevApiOptions): Promise<UnstableDevWorker>;
 
-declare interface UnstableDev {
+export declare interface UnstableDevWorker {
     stop: () => Promise<void>;
-    fetch: (init?: RequestInit) => Promise<Response | undefined>;
+    fetch: (input?: RequestInfo, init?: RequestInit) => Promise<Response | undefined>;
     waitUntilExit: () => Promise<void>;
 }