wrangler 2.0.28 → 2.0.29

package/src/__tests__/paths.test.ts

@@ -0,0 +1,17 @@
+import * as path from "node:path";
+import { getBasePath } from "../paths";
+
+describe("paths", () => {
+	describe("getBasePath()", () => {
+		it("should return the path to the wrangler package", () => {
+			expect(getBasePath()).toMatch(/packages[/\\]wrangler$/);
+		});
+
+		it("should use the __RELATIVE_PACKAGE_PATH__ as defined on the global context to compute the base path", () => {
+			(
+				global as unknown as { __RELATIVE_PACKAGE_PATH__: string }
+			).__RELATIVE_PACKAGE_PATH__ = "/foo/bar";
+			expect(getBasePath()).toEqual(path.resolve("/foo/bar"));
+		});
+	});
+});

package/src/api/dev.ts

@@ -1,10 +1,11 @@
-import { startDev } from "../dev";
+import { startApiDev, startDev } from "../dev";
 import { logger } from "../logger";
 
 import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli";
 import type { RequestInit, Response } from "undici";
 
 interface DevOptions {
+	config?: string;
 	env?: string;
 	ip?: string;
 	port?: number;
@@ -20,7 +21,7 @@ interface DevOptions {
 	experimentalEnableLocalPersistence?: boolean;
 	liveReload?: boolean;
 	watch?: boolean;
-	vars: {
+	vars?: {
 		[key: string]: unknown;
 	};
 	kv?: {
@@ -48,46 +49,91 @@ interface DevOptions {
 	_?: (string | number)[]; //yargs wants this
 	$0?: string; //yargs wants this
 }
+
+interface DevApiOptions {
+	testMode?: boolean;
+	disableExperimentalWarning?: boolean;
+}
+
+interface UnstableDev {
+	stop: () => Promise<void>;
+	fetch: (init?: RequestInit) => Promise<Response | undefined>;
+	waitUntilExit: () => Promise<void>;
+}
 /**
  *  unstable_dev starts a wrangler dev server, and returns a promise that resolves with utility functions to interact with it.
  *  @param {string} script
  *  @param {DevOptions} options
+ *  @param {DevApiOptions} apiOptions
+ * @returns {Promise<UnstableDev>}
  */
 export async function unstable_dev(
 	script: string,
-	options: DevOptions,
-	disableExperimentalWarning?: boolean
+	options?: DevOptions,
+	apiOptions?: DevApiOptions
 ) {
+	const { testMode = true, disableExperimentalWarning = false } =
+		apiOptions || {};
 	if (!disableExperimentalWarning) {
 		logger.warn(
 			`unstable_dev() is experimental\nunstable_dev()'s behaviour will likely change in future releases`
 		);
 	}
-
-	return new Promise<{
-		stop: () => void;
-		fetch: (init?: RequestInit) => Promise<Response | undefined>;
-		waitUntilExit: () => Promise<void>;
-	}>((resolve) => {
-		//lmao
-		return new Promise<Awaited<ReturnType<typeof startDev>>>((ready) => {
-			const devServer = startDev({
-				script: script,
-				inspect: false,
-				logLevel: "none",
-				showInteractiveDevSession: false,
-				_: [],
-				$0: "",
-				...options,
-				local: true,
-				onReady: () => ready(devServer),
+	//due to Pages adoption of unstable_dev, we can't *just* disable rebuilds and watching. instead, we'll have two versions of startDev, which will converge.
+	if (testMode) {
+		//in testMode, we can run multiple wranglers in parallel, but rebuilds might not work out of the box
+		return new Promise<UnstableDev>((resolve) => {
+			//lmao
+			return new Promise<Awaited<ReturnType<typeof startApiDev>>>((ready) => {
+				// once the devServer is ready for requests, we resolve the inner promise
+				// (where we've named the resolve function "ready")
+				const devServer = startApiDev({
+					script: script,
+					inspect: false,
+					logLevel: "none",
+					showInteractiveDevSession: false,
+					_: [],
+					$0: "",
+					...options,
+					local: true,
+					onReady: () => ready(devServer),
+				});
+			}).then((devServer) => {
+				// now that the inner promise has resolved, we can resolve the outer promise
+				// with an object that lets you fetch and stop the dev server
+				resolve({
+					stop: devServer.stop,
+					fetch: devServer.fetch,
+					//no-op, does nothing in tests
+					waitUntilExit: async () => {
+						return;
+					},
+				});
 			});
-		}).then((devServer) => {
-			resolve({
-				stop: devServer.stop,
-				fetch: devServer.fetch,
-				waitUntilExit: devServer.devReactElement.waitUntilExit,
+		});
+	} else {
+		//outside of test mode, rebuilds work fine, but only one instance of wrangler will work at a time
+		return new Promise<UnstableDev>((resolve) => {
+			//lmao
+			return new Promise<Awaited<ReturnType<typeof startDev>>>((ready) => {
+				const devServer = startDev({
+					script: script,
+					inspect: false,
+					logLevel: "none",
+					showInteractiveDevSession: false,
+					_: [],
+					$0: "",
+					...options,
+					local: true,
+					onReady: () => ready(devServer),
+				});
+			}).then((devServer) => {
+				resolve({
+					stop: devServer.stop,
+					fetch: devServer.fetch,
+					waitUntilExit: devServer.devReactElement.waitUntilExit,
+				});
 			});
 		});
-	});
+	}
 }

package/src/bundle.ts

@@ -7,6 +7,7 @@ import NodeModulesPolyfills from "@esbuild-plugins/node-modules-polyfill";
 import * as esbuild from "esbuild";
 import tmp from "tmp-promise";
 import createModuleCollector from "./module-collection";
+import { getBasePath } from "./paths";
 import type { Config } from "./config";
 import type { WorkerRegistry } from "./dev-registry";
 import type { Entry } from "./entry";
@@ -71,7 +72,7 @@ export async function bundleWorker(
 		nodeCompat: boolean | undefined;
 		define: Config["define"];
 		checkFetch: boolean;
-		services: Config["services"];
+		services: Config["services"] | undefined;
 		workerDefinitions: WorkerRegistry | undefined;
 		firstPartyWorkerDevFacade: boolean | undefined;
 	}
@@ -129,7 +130,7 @@ export async function bundleWorker(
 		});
 		fs.writeFileSync(
 			checkedFetchFileToInject,
-			fs.readFileSync(path.resolve(__dirname, "../templates/checked-fetch.js"))
+			fs.readFileSync(path.resolve(getBasePath(), "templates/checked-fetch.js"))
 		);
 	}
 
@@ -302,7 +303,9 @@ async function applyFormatDevErrorsFacade(
 ): Promise<Entry> {
 	const targetPath = path.join(tmpDirPath, "format-dev-errors.entry.js");
 	await esbuild.build({
-		entryPoints: [path.resolve(__dirname, "../templates/format-dev-errors.ts")],
+		entryPoints: [
+			path.resolve(getBasePath(), "templates/format-dev-errors.ts"),
+		],
 		bundle: true,
 		sourcemap: true,
 		format: "esm",
@@ -334,7 +337,7 @@ async function applyStaticAssetFacade(
 
 	await esbuild.build({
 		entryPoints: [
-			path.resolve(__dirname, "../templates/serve-static-assets.ts"),
+			path.resolve(getBasePath(), "templates/serve-static-assets.ts"),
 		],
 		bundle: true,
 		format: "esm",
@@ -342,7 +345,7 @@ async function applyStaticAssetFacade(
 		plugins: [
 			esbuildAliasExternalPlugin({
 				__ENTRY_POINT__: entry.file,
-				__KV_ASSET_HANDLER__: path.join(__dirname, "../kv-asset-handler.js"),
+				__KV_ASSET_HANDLER__: path.join(getBasePath(), "kv-asset-handler.js"),
 				__STATIC_CONTENT_MANIFEST: "__STATIC_CONTENT_MANIFEST",
 			}),
 		],
@@ -391,10 +394,10 @@ async function applyMultiWorkerDevFacade(
 	await esbuild.build({
 		entryPoints: [
 			path.join(
-				__dirname,
+				getBasePath(),
 				entry.format === "modules"
-					? "../templates/service-bindings-module-facade.js"
-					: "../templates/service-bindings-sw-facade.js"
+					? "templates/service-bindings-module-facade.js"
+					: "templates/service-bindings-sw-facade.js"
 			),
 		],
 		bundle: true,
@@ -440,8 +443,8 @@ async function applyFirstPartyWorkerDevFacade(
 	await esbuild.build({
 		entryPoints: [
 			path.resolve(
-				__dirname,
-				"../templates/first-party-worker-module-facade.ts"
+				getBasePath(),
+				"templates/first-party-worker-module-facade.ts"
 			),
 		],
 		bundle: true,

package/src/cli.ts

@@ -24,4 +24,4 @@ if (typeof jest === "undefined" && require.main) {
  * It makes it possible to import wrangler from 'wrangler',
  * and call wrangler.unstable_dev().
  */
-export default { unstable_dev };
+export { unstable_dev };