wrangler 0.0.0-ea7ee45 → 0.0.0-eab9542

package/bin/wrangler.js

@@ -6,6 +6,10 @@ const os = require("os");
 const semiver = require("semiver");
 
 const MIN_NODE_VERSION = "16.7.0";
+const debug =
+	process.env["WRANGLER_LOG"] === "debug"
+		? (...args) => console.log(...args)
+		: () => {};
 
 let wranglerProcess;
 
@@ -84,9 +88,8 @@ function runDelegatedWrangler() {
 	} = JSON.parse(fs.readFileSync(packageJsonPath));
 	const resolvedBinaryPath = path.resolve(packageJsonPath, "..", binaryPath);
 
-	console.log(
-		`Delegating to locally-installed version of wrangler @ v${version}`
-	);
+	debug(`Delegating to locally-installed version of wrangler @ v${version}`);
+
 	// this call to `spawn` is simpler because the delegated version will do all
 	// of the other work.
 	return spawn(

package/miniflare-dist/index.mjs

@@ -4871,6 +4871,7 @@ async function main() {
   try {
     await mf.startServer();
     await mf.startScheduler();
+    process.send && process.send("ready");
   } catch (e) {
     mf.log.error(e);
     process.exitCode = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "0.0.0-ea7ee45",
+	"version": "0.0.0-eab9542",
 	"author": "wrangler@cloudflare.com",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"bin": {

package/src/__tests__/config-cache-without-cache-dir.test.ts

@@ -0,0 +1,38 @@
+import { getConfigCache, saveToConfigCache } from "../config-cache";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+interface PagesConfigCache {
+	account_id: string;
+	pages_project_name: string;
+}
+
+describe("config cache", () => {
+	runInTempDir();
+	mockConsoleMethods();
+	// In this set of tests, we don't create a node_modules folder
+	const pagesConfigCacheFilename = "pages-config-cache.json";
+
+	it("should return an empty config if no file exists", () => {
+		expect(
+			getConfigCache<PagesConfigCache>(pagesConfigCacheFilename)
+		).toMatchInlineSnapshot(`Object {}`);
+	});
+
+	it("should ignore attempts to cache values ", () => {
+		saveToConfigCache<PagesConfigCache>(pagesConfigCacheFilename, {
+			account_id: "some-account-id",
+			pages_project_name: "foo",
+		});
+		expect(getConfigCache<PagesConfigCache>(pagesConfigCacheFilename)).toEqual(
+			{}
+		);
+
+		saveToConfigCache<PagesConfigCache>(pagesConfigCacheFilename, {
+			pages_project_name: "bar",
+		});
+		expect(getConfigCache<PagesConfigCache>(pagesConfigCacheFilename)).toEqual(
+			{}
+		);
+	});
+});

package/src/__tests__/config-cache.test.ts

@@ -1,4 +1,6 @@
+import { mkdirSync } from "node:fs";
 import { getConfigCache, saveToConfigCache } from "../config-cache";
+import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 
 interface PagesConfigCache {
@@ -8,6 +10,10 @@ interface PagesConfigCache {
 
 describe("config cache", () => {
 	runInTempDir();
+	mockConsoleMethods();
+	beforeEach(() => {
+		mkdirSync("node_modules");
+	});
 
 	const pagesConfigCacheFilename = "pages-config-cache.json";
 

package/src/__tests__/configuration.test.ts

@@ -16,6 +16,7 @@ describe("normalizeAndValidateConfig()", () => {
 
 		expect(config).toEqual({
 			account_id: undefined,
+			assets: undefined,
 			build: {
 				command: undefined,
 				cwd: undefined,
@@ -55,6 +56,7 @@ describe("normalizeAndValidateConfig()", () => {
 			unsafe: {
 				bindings: [],
 			},
+			worker_namespaces: [],
 			usage_model: undefined,
 			vars: {},
 			define: {},
@@ -62,6 +64,7 @@ describe("normalizeAndValidateConfig()", () => {
 			data_blobs: undefined,
 			workers_dev: undefined,
 			zone_id: undefined,
+			no_bundle: undefined,
 			minify: undefined,
 			node_compat: undefined,
 		});
@@ -848,6 +851,7 @@ describe("normalizeAndValidateConfig()", () => {
 						},
 					],
 				},
+				no_bundle: true,
 				minify: true,
 				node_compat: true,
 			};
@@ -920,6 +924,7 @@ describe("normalizeAndValidateConfig()", () => {
 				define: {
 					DEF1: 1777,
 				},
+				no_bundle: "INVALID",
 				minify: "INVALID",
 				node_compat: "INVALID",
 			} as unknown as RawEnvironment;
@@ -986,6 +991,7 @@ describe("normalizeAndValidateConfig()", () => {
 			  - Expected \\"main\\" to be of type string but got 1333.
 			  - Expected \\"usage_model\\" field to be one of [\\"bundled\\",\\"unbound\\"] but got \\"INVALID\\".
 			  - The field \\"define.DEF1\\" should be a string but got 1777.
+			  - Expected \\"no_bundle\\" to be of type boolean but got \\"INVALID\\".
 			  - Expected \\"minify\\" to be of type boolean but got \\"INVALID\\".
 			  - Expected \\"node_compat\\" to be of type boolean but got \\"INVALID\\"."
 		`);
@@ -1835,6 +1841,112 @@ describe("normalizeAndValidateConfig()", () => {
 			});
 		});
 
+		describe("[worker_namespaces]", () => {
+			it("should log an experimental warning when worker_namespaces is used", () => {
+				const { config, diagnostics } = normalizeAndValidateConfig(
+					{
+						worker_namespaces: [
+							{
+								binding: "BINDING_1",
+								namespace: "NAMESPACE_1",
+							},
+						],
+					} as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+				expect(config).toEqual(
+					expect.not.objectContaining({ worker_namespaces: expect.anything })
+				);
+				expect(diagnostics.hasWarnings()).toBe(true);
+				expect(diagnostics.hasErrors()).toBe(false);
+				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+			"Processing wrangler configuration:
+			  - \\"worker_namespaces\\" fields are experimental and may change or break at any time."
+		`);
+			});
+
+			it("should error if worker_namespaces is not an array", () => {
+				const { config, diagnostics } = normalizeAndValidateConfig(
+					{
+						worker_namespaces: "just a string",
+					} as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+
+				expect(config).toEqual(
+					expect.not.objectContaining({ worker_namespaces: expect.anything })
+				);
+				expect(diagnostics.hasWarnings()).toBe(true);
+				expect(diagnostics.hasErrors()).toBe(true);
+				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+			          "Processing wrangler configuration:
+			            - \\"worker_namespaces\\" fields are experimental and may change or break at any time."
+		        `);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			"Processing wrangler configuration:
+			  - The field \\"worker_namespaces\\" should be an array but got \\"just a string\\"."
+		`);
+			});
+
+			it("should error on non valid worker_namespaces", () => {
+				const { config, diagnostics } = normalizeAndValidateConfig(
+					{
+						worker_namespaces: [
+							"a string",
+							123,
+							{
+								binding: 123,
+								namespace: 456,
+							},
+							{
+								binding: "WORKER_NAMESPACE_BINDING_1",
+								namespace: 456,
+							},
+							// this one is valid
+							{
+								binding: "WORKER_NAMESPACE_BINDING_1",
+								namespace: "WORKER_NAMESPACE_BINDING_NAMESPACE_1",
+							},
+							{
+								binding: 123,
+								namespace: "WORKER_NAMESPACE_BINDING_SERVICE_1",
+							},
+							{
+								binding: 123,
+								service: 456,
+							},
+						],
+					} as unknown as RawConfig,
+					undefined,
+					{ env: undefined }
+				);
+				expect(config).toEqual(
+					expect.not.objectContaining({
+						worker_namespaces: expect.anything,
+					})
+				);
+				expect(diagnostics.hasWarnings()).toBe(true);
+				expect(diagnostics.hasErrors()).toBe(true);
+				expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+			"Processing wrangler configuration:
+			  - \\"worker_namespaces\\" fields are experimental and may change or break at any time."
+		`);
+				expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+			"Processing wrangler configuration:
+			  - \\"worker_namespaces[0]\\" binding should be objects, but got \\"a string\\"
+			  - \\"worker_namespaces[1]\\" binding should be objects, but got 123
+			  - \\"worker_namespaces[2]\\" should have a string \\"binding\\" field but got {\\"binding\\":123,\\"namespace\\":456}.
+			  - \\"worker_namespaces[2]\\" should have a string \\"namespace\\" field but got {\\"binding\\":123,\\"namespace\\":456}.
+			  - \\"worker_namespaces[3]\\" should have a string \\"namespace\\" field but got {\\"binding\\":\\"WORKER_NAMESPACE_BINDING_1\\",\\"namespace\\":456}.
+			  - \\"worker_namespaces[5]\\" should have a string \\"binding\\" field but got {\\"binding\\":123,\\"namespace\\":\\"WORKER_NAMESPACE_BINDING_SERVICE_1\\"}.
+			  - \\"worker_namespaces[6]\\" should have a string \\"binding\\" field but got {\\"binding\\":123,\\"service\\":456}.
+			  - \\"worker_namespaces[6]\\" should have a string \\"namespace\\" field but got {\\"binding\\":123,\\"service\\":456}."
+		`);
+			});
+		});
+
 		describe("[unsafe.bindings]", () => {
 			it("should error if unsafe is an array", () => {
 				const { config, diagnostics } = normalizeAndValidateConfig(
@@ -2192,6 +2304,7 @@ describe("normalizeAndValidateConfig()", () => {
 					cwd: "CWD",
 					watch_dir: "WATCH_DIR",
 				},
+				no_bundle: true,
 				minify: true,
 				node_compat: true,
 			};
@@ -2234,6 +2347,7 @@ describe("normalizeAndValidateConfig()", () => {
 					cwd: "ENV_CWD",
 					watch_dir: "ENV_WATCH_DIR",
 				},
+				no_bundle: false,
 				minify: false,
 				node_compat: false,
 			};
@@ -2255,6 +2369,7 @@ describe("normalizeAndValidateConfig()", () => {
 					cwd: "CWD",
 					watch_dir: "WATCH_DIR",
 				},
+				no_bundle: true,
 				minify: true,
 				node_compat: true,
 				env: {
@@ -2515,6 +2630,7 @@ describe("normalizeAndValidateConfig()", () => {
 					cwd: 1555,
 					watch_dir: 1666,
 				},
+				no_bundle: "INVALID",
 				minify: "INVALID",
 				node_compat: "INVALID",
 			} as unknown as RawEnvironment;
@@ -2550,6 +2666,7 @@ describe("normalizeAndValidateConfig()", () => {
 			    - Expected \\"name\\" to be of type string, alphanumeric and lowercase with dashes only but got 111.
 			    - Expected \\"main\\" to be of type string but got 1333.
 			    - Expected \\"usage_model\\" field to be one of [\\"bundled\\",\\"unbound\\"] but got \\"INVALID\\".
+			    - Expected \\"no_bundle\\" to be of type boolean but got \\"INVALID\\".
 			    - Expected \\"minify\\" to be of type boolean but got \\"INVALID\\".
 			    - Expected \\"node_compat\\" to be of type boolean but got \\"INVALID\\"."
 		`);

package/src/__tests__/dev.test.tsx

@@ -889,7 +889,7 @@ describe("wrangler dev", () => {
 
 			Options:
 			      --name                                       Name of the worker  [string]
-			      --no-build                                   Skip internal build steps and directly publish script  [boolean] [default: false]
+			      --no-bundle                                  Skip internal build steps and directly publish script  [boolean] [default: false]
 			      --format                                     Choose an entry type  [deprecated] [choices: \\"modules\\", \\"service-worker\\"]
 			  -e, --env                                        Perform on a specific environment  [string]
 			      --compatibility-date                         Date to use for compatibility checks  [string]

package/src/__tests__/publish.test.ts

@@ -5303,6 +5303,48 @@ addEventListener('fetch', event => {});`
 			});
 		});
 
+		describe("[worker_namespaces]", () => {
+			it("should support bindings to a worker namespace", async () => {
+				writeWranglerToml({
+					worker_namespaces: [
+						{
+							binding: "foo",
+							namespace: "Foo",
+						},
+					],
+				});
+				writeWorkerSource();
+				mockSubDomainRequest();
+				mockUploadWorkerRequest({
+					expectedBindings: [
+						{
+							type: "namespace",
+							name: "foo",
+							namespace: "Foo",
+						},
+					],
+				});
+				await runWrangler("publish index.js");
+				expect(std.out).toMatchInlineSnapshot(`
+			          "Your worker has access to the following bindings:
+			          - Worker Namespaces:
+			            - foo: Foo
+			          Total Upload: 0xx KiB / gzip: 0xx KiB
+			          Uploaded test-name (TIMINGS)
+			          Published test-name (TIMINGS)
+			            test-name.test-sub-domain.workers.dev"
+		        `);
+				expect(std.err).toMatchInlineSnapshot(`""`);
+				expect(std.warn).toMatchInlineSnapshot(`
+			"▲ [WARNING] Processing wrangler.toml configuration:
+
+			    - \\"worker_namespaces\\" fields are experimental and may change or break at any time.
+
+			"
+		`);
+			});
+		});
+
 		describe("[unsafe]", () => {
 			it("should warn if using unsafe bindings", async () => {
 				writeWranglerToml({
@@ -5962,6 +6004,7 @@ addEventListener('fetch', event => {});`
 			        }
 		      `);
 		});
+
 		it("should print the bundle size, with API errors", async () => {
 			setMockRawResponse(
 				"/accounts/:accountId/workers/scripts/:scriptName",
@@ -6025,15 +6068,28 @@ addEventListener('fetch', event => {});`
 		});
 	});
 
-	describe("--no-build", () => {
-		it("should not transform the source code before publishing it", async () => {
+	describe("--no-bundle", () => {
+		it("(cli) should not transform the source code before publishing it", async () => {
 			writeWranglerToml();
 			const scriptContent = `
       import X from '@cloudflare/no-such-package'; // let's add an import that doesn't exist
       const xyz = 123; // a statement that would otherwise be compiled out
     `;
 			fs.writeFileSync("index.js", scriptContent);
-			await runWrangler("publish index.js --no-build --dry-run --outdir dist");
+			await runWrangler("publish index.js --no-bundle --dry-run --outdir dist");
+			expect(fs.readFileSync("dist/index.js", "utf-8")).toMatch(scriptContent);
+		});
+
+		it("(config) should not transform the source code before publishing it", async () => {
+			writeWranglerToml({
+				no_bundle: true,
+			});
+			const scriptContent = `
+			import X from '@cloudflare/no-such-package'; // let's add an import that doesn't exist
+			const xyz = 123; // a statement that would otherwise be compiled out
+		`;
+			fs.writeFileSync("index.js", scriptContent);
+			await runWrangler("publish index.js --dry-run --outdir dist");
 			expect(fs.readFileSync("dist/index.js", "utf-8")).toMatch(scriptContent);
 		});
 	});

package/src/__tests__/pubsub.test.ts

@@ -21,7 +21,63 @@ describe("wrangler", () => {
 	});
 
 	describe("pubsub", () => {
+		describe("help menu", () => {
+			it("shows usage details", async () => {
+				await runWrangler("pubsub --help");
+				expect(std).toMatchInlineSnapshot(`
+			Object {
+			  "debug": "",
+			  "err": "",
+			  "out": "wrangler pubsub
+
+			📮 Interact and manage Pub/Sub Brokers
+
+			Commands:
+			  wrangler pubsub namespace  Manage your Pub/Sub Namespaces
+			  wrangler pubsub broker     Interact with your Pub/Sub Brokers
+
+			Flags:
+			  -c, --config   Path to .toml configuration file  [string]
+			  -h, --help     Show help  [boolean]
+			  -v, --version  Show version number  [boolean]
+
+			👷🏽 'wrangler pubsub ...' commands are currently in private beta. If your account isn't authorized, commands will fail. Visit the Pub/Sub docs for more info: https://developers.cloudflare.com/pub-sub/",
+			  "warn": "",
+			}
+		`);
+			});
+		});
+
 		describe("namespaces", () => {
+			describe("help menu", () => {
+				it("shows usage details", async () => {
+					await runWrangler("pubsub namespace --help");
+					expect(std).toMatchInlineSnapshot(`
+				Object {
+				  "debug": "",
+				  "err": "",
+				  "out": "wrangler pubsub namespace
+
+				Manage your Pub/Sub Namespaces
+
+				Commands:
+				  wrangler pubsub namespace create <name>    Create a new Pub/Sub Namespace
+				  wrangler pubsub namespace list             List your existing Pub/Sub Namespaces
+				  wrangler pubsub namespace delete <name>    Delete a Pub/Sub Namespace
+				  wrangler pubsub namespace describe <name>  Describe a Pub/Sub Namespace
+
+				Flags:
+				  -c, --config   Path to .toml configuration file  [string]
+				  -h, --help     Show help  [boolean]
+				  -v, --version  Show version number  [boolean]
+
+				👷🏽 'wrangler pubsub ...' commands are currently in private beta. If your account isn't authorized, commands will fail. Visit the Pub/Sub docs for more info: https://developers.cloudflare.com/pub-sub/",
+				  "warn": "",
+				}
+			`);
+				});
+			});
+
 			describe("create", () => {
 				function mockCreateRequest(expectedNamespaceName: string) {
 					const requests = { count: 0 };
@@ -77,6 +133,41 @@ describe("wrangler", () => {
 		});
 
 		describe("brokers", () => {
+			describe("help menu", () => {
+				it("shows usage details", async () => {
+					await runWrangler("pubsub broker --help");
+					expect(std).toMatchInlineSnapshot(`
+				Object {
+				  "debug": "",
+				  "err": "",
+				  "out": "wrangler pubsub broker
+
+				Interact with your Pub/Sub Brokers
+
+				Commands:
+				  wrangler pubsub broker create <name>            Create a new Pub/Sub Broker
+				  wrangler pubsub broker update <name>            Update an existing Pub/Sub Broker's configuration.
+				  wrangler pubsub broker list                     List the Pub/Sub Brokers within a Namespace
+				  wrangler pubsub broker delete <name>            Delete an existing Pub/Sub Broker
+				  wrangler pubsub broker describe <name>          Describe an existing Pub/Sub Broker.
+				  wrangler pubsub broker issue <name>             Issue new client credentials for a specific Pub/Sub Broker.
+				  wrangler pubsub broker revoke <name>            Revoke a set of active client credentials associated with the given Broker
+				  wrangler pubsub broker unrevoke <name>          Restore access to a set of previously revoked client credentials.
+				  wrangler pubsub broker show-revocations <name>  Show all previously revoked client credentials.
+				  wrangler pubsub broker public-keys <name>       Show the public keys used for verifying on-publish hooks and credentials for a Broker.
+
+				Flags:
+				  -c, --config   Path to .toml configuration file  [string]
+				  -h, --help     Show help  [boolean]
+				  -v, --version  Show version number  [boolean]
+
+				👷🏽 'wrangler pubsub ...' commands are currently in private beta. If your account isn't authorized, commands will fail. Visit the Pub/Sub docs for more info: https://developers.cloudflare.com/pub-sub/",
+				  "warn": "",
+				}
+			`);
+				});
+			});
+
 			describe("create", () => {
 				function mockCreateRequest(expectedBrokerName: string) {
 					const requests = { count: 0 };

package/src/api/dev.ts

@@ -1,5 +1,8 @@
 import { startDev } from "../dev";
 import { logger } from "../logger";
+
+import type { RequestInit, Response } from "undici";
+
 interface DevOptions {
 	env?: string;
 	ip?: string;
@@ -14,13 +17,20 @@ interface DevOptions {
 	_: (string | number)[]; //yargs wants this
 	$0: string; //yargs wants this
 }
-
+/**
+ *  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
+ */
 export async function unstable_dev(script: string, options: DevOptions) {
 	logger.warn(
 		`unstable_dev() is experimental\nunstable_dev()'s behaviour will likely change in future releases`
 	);
 
-	return new Promise<{ stop: () => void }>((resolve) => {
+	return new Promise<{
+		stop: () => void;
+		fetch: (init?: RequestInit) => Promise<Response | undefined>;
+	}>((resolve) => {
 		//lmao
 		return new Promise<Awaited<ReturnType<typeof startDev>>>((ready) => {
 			const devServer = startDev({
@@ -33,7 +43,10 @@ export async function unstable_dev(script: string, options: DevOptions) {
 				showInteractiveDevSession: false,
 			});
 		}).then((devServer) => {
-			resolve({ stop: devServer.stop });
+			resolve({
+				stop: devServer.stop,
+				fetch: devServer.fetch,
+			});
 		});
 	});
 }

package/src/cli.ts

@@ -9,7 +9,7 @@ import { main } from ".";
  * The main entrypoint for the CLI.
  * main only gets called when the script is run directly, not when it's imported as a module.
  */
-if (require.main) {
+if (typeof jest === "undefined" && require.main) {
 	main(hideBin(process.argv)).catch((e) => {
 		// The logging of any error that was thrown from `main()` is handled in the `yargs.fail()` handler.
 		// Here we just want to ensure that the process exits with a non-zero code.

package/src/config/environment.ts

@@ -183,6 +183,12 @@ interface EnvironmentInheritable {
 		upload?: DeprecatedUpload;
 	};
 
+	/**
+	 * Skip internal build steps and directly publish script
+	 * @inheritable
+	 */
+	no_bundle: boolean | undefined;
+
 	/**
 	 * Minify the script before uploading.
 	 * @inheritable
@@ -191,9 +197,26 @@ interface EnvironmentInheritable {
 
 	/**
 	 * Add polyfills for node builtin modules and globals
+	 * @inheritable
 	 */
 	node_compat: boolean | undefined;
 
+	/**
+	 * Specifies namespace bindings 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
+	 */
+	worker_namespaces: {
+		/** The binding name used to refer to the bound service. */
+		binding: string;
+		/** The namespace to bind to. */
+		namespace: string;
+	}[];
+
 	/**
 	 * TODO: remove this as it has been deprecated.
 	 *

package/src/config/index.ts

@@ -90,6 +90,7 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		unsafe,
 		vars,
 		wasm_modules,
+		worker_namespaces,
 	} = bindings;
 
 	if (data_blobs !== undefined && Object.keys(data_blobs).length > 0) {
@@ -205,6 +206,18 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (worker_namespaces !== undefined && worker_namespaces.length > 0) {
+		output.push({
+			type: "Worker Namespaces",
+			entries: worker_namespaces.map(({ binding, namespace }) => {
+				return {
+					key: binding,
+					value: namespace,
+				};
+			}),
+		});
+	}
+
 	if (output.length === 0) {
 		return;
 	}