wrangler 0.0.0-e2b7352 → 0.0.0-e305903a

package/src/__tests__/worker-namespace.test.ts

@@ -0,0 +1,319 @@
+import { rest } from "msw";
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { msw } from "./helpers/msw";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+
+describe("dispatch-namespace", () => {
+	runInTempDir();
+	const std = mockConsoleMethods();
+	mockAccountId();
+	mockApiToken();
+
+	it("should should display a list of available subcommands, for dispatch-namespace with no subcommand", async () => {
+		await runWrangler("dispatch-namespace");
+
+		// wait a tick for the help menu to be printed
+		await new Promise((resolve) => setImmediate(resolve));
+
+		expect(std).toMatchInlineSnapshot(`
+		Object {
+		  "debug": "",
+		  "err": "",
+		  "out": "wrangler dispatch-namespace
+
+		📦 Interact with a dispatch namespace
+
+		Commands:
+		  wrangler dispatch-namespace list                          List all dispatch namespaces
+		  wrangler dispatch-namespace get <name>                    Get information about a dispatch namespace
+		  wrangler dispatch-namespace create <name>                 Create a dispatch namespace
+		  wrangler dispatch-namespace delete <name>                 Delete a dispatch namespace
+		  wrangler dispatch-namespace rename <old-name> <new-name>  Rename a dispatch namespace
+
+		Flags:
+		  -c, --config   Path to .toml configuration file  [string]
+		  -h, --help     Show help  [boolean]
+		  -v, --version  Show version number  [boolean]",
+		  "warn": "",
+		}
+	`);
+	});
+
+	describe("create namespace", () => {
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.post(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, cxt) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(
+						cxt.status(200),
+						cxt.json({
+							namespace_id: "some-namespace-id",
+							namespace_name: "namespace-name",
+							created_on: "2022-06-29T14:30:08.16152Z",
+							created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							modified_on: "2022-06-29T14:30:08.16152Z",
+							modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+						})
+					);
+				}
+			)
+		);
+
+		it("should display help for create", async () => {
+			await expect(
+				runWrangler("dispatch-namespace create")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 1"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler dispatch-namespace create <name>
+
+			Create a dispatch namespace
+
+			Positionals:
+			  name  Name of the dispatch namespace  [string] [required]
+
+			Flags:
+			  -c, --config   Path to .toml configuration file  [string]
+			  -h, --help     Show help  [boolean]
+			  -v, --version  Show version number  [boolean]"
+		`);
+		});
+
+		it("should attempt to create the given namespace", async () => {
+			await runWrangler(`dispatch-namespace create ${namespaceName}`);
+
+			expect(std.out).toMatchInlineSnapshot(
+				`"Created dispatch namespace \\"my-namespace\\" with ID \\"some-namespace-id\\""`
+			);
+		});
+	});
+
+	describe("delete namespace", () => {
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.delete(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, cxt) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(cxt.status(200), cxt.json(null));
+				}
+			)
+		);
+
+		it("should display help for delete", async () => {
+			await expect(
+				runWrangler("dispatch-namespace create")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 1"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler dispatch-namespace create <name>
+
+			Create a dispatch namespace
+
+			Positionals:
+			  name  Name of the dispatch namespace  [string] [required]
+
+			Flags:
+			  -c, --config   Path to .toml configuration file  [string]
+			  -h, --help     Show help  [boolean]
+			  -v, --version  Show version number  [boolean]"
+		`);
+		});
+
+		it("should try to delete the given namespace", async () => {
+			await runWrangler(`dispatch-namespace delete ${namespaceName}`);
+
+			expect(std.out).toMatchInlineSnapshot(
+				`"Deleted dispatch namespace \\"my-namespace\\""`
+			);
+		});
+	});
+
+	describe("get namespace", () => {
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.get(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, cxt) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(
+						cxt.status(200),
+						cxt.json({
+							namespace_id: "some-namespace-id",
+							namespace_name: "namespace-name",
+							created_on: "2022-06-29T14:30:08.16152Z",
+							created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							modified_on: "2022-06-29T14:30:08.16152Z",
+							modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+						})
+					);
+				}
+			)
+		);
+
+		it("should display help for get", async () => {
+			await expect(
+				runWrangler("dispatch-namespace get")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 1"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			        "
+			        wrangler dispatch-namespace get <name>
+
+			        Get information about a dispatch namespace
+
+			        Positionals:
+			          name  Name of the dispatch namespace  [string] [required]
+
+			        Flags:
+			          -c, --config   Path to .toml configuration file  [string]
+			          -h, --help     Show help  [boolean]
+			          -v, --version  Show version number  [boolean]"
+		      `);
+		});
+
+		it("should attempt to get info for the given namespace", async () => {
+			await runWrangler(`dispatch-namespace get ${namespaceName}`);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"{
+			  namespace_id: 'some-namespace-id',
+			  namespace_name: 'namespace-name',
+			  created_on: '2022-06-29T14:30:08.16152Z',
+			  created_by: '1fc1df98cc4420fe00367c3ab68c1639',
+			  modified_on: '2022-06-29T14:30:08.16152Z',
+			  modified_by: '1fc1df98cc4420fe00367c3ab68c1639'
+			}"
+		`);
+		});
+	});
+
+	describe("list namespaces", () => {
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.get(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, cxt) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(
+						cxt.status(200),
+						cxt.json({
+							namespace_id: "some-namespace-id",
+							namespace_name: "namespace-name",
+							created_on: "2022-06-29T14:30:08.16152Z",
+							created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							modified_on: "2022-06-29T14:30:08.16152Z",
+							modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+						})
+					);
+				}
+			)
+		);
+
+		it("should list all namespaces", async () => {
+			await runWrangler("dispatch-namespace list");
+			expect(std.out).toMatchInlineSnapshot(`
+			"[
+			  {
+			    namespace_id: 'some-namespace-id',
+			    namespace_name: 'namespace-name',
+			    created_on: '2022-06-29T14:30:08.16152Z',
+			    created_by: '1fc1df98cc4420fe00367c3ab68c1639',
+			    modified_on: '2022-06-29T14:30:08.16152Z',
+			    modified_by: '1fc1df98cc4420fe00367c3ab68c1639'
+			  }
+			]"
+		`);
+		});
+	});
+
+	describe("rename namespace", () => {
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.put(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, cxt) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(
+						cxt.status(200),
+						cxt.json({
+							namespace_id: "some-namespace-id",
+							namespace_name: "namespace-name",
+							created_on: "2022-06-29T14:30:08.16152Z",
+							created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							modified_on: "2022-06-29T14:30:08.16152Z",
+							modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+						})
+					);
+				}
+			)
+		);
+
+		it("should display help for rename", async () => {
+			await expect(
+				runWrangler("dispatch-namespace rename")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 2"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler dispatch-namespace rename <old-name> <new-name>
+
+			Rename a dispatch namespace
+
+			Positionals:
+			  old-name  Name of the dispatch namespace  [string] [required]
+			  new-name  New name of the dispatch namespace  [string] [required]
+
+			Flags:
+			  -c, --config   Path to .toml configuration file  [string]
+			  -h, --help     Show help  [boolean]
+			  -v, --version  Show version number  [boolean]"
+		`);
+		});
+
+		it("should attempt to rename the given namespace", async () => {
+			const newName = "new-namespace";
+			await runWrangler(
+				`dispatch-namespace rename ${namespaceName} ${newName}`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(
+				`"Renamed dispatch namespace \\"my-namespace\\" to \\"new-namespace\\""`
+			);
+		});
+	});
+});

package/src/abort.d.ts

@@ -0,0 +1,3 @@
+declare interface AbortSignal {
+	addEventListener(event: "abort", handler: () => void);
+}

package/src/api/dev.ts

@@ -0,0 +1,206 @@
+import { fetch, Request } from "undici";
+import { startApiDev, startDev } from "../dev";
+import { logger } from "../logger";
+
+import type { Environment } from "../config";
+import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli";
+import type { RequestInit, Response, RequestInfo } from "undici";
+
+interface DevOptions {
+	config?: string;
+	env?: string;
+	ip?: string;
+	port?: number;
+	bundle?: boolean;
+	inspectorPort?: number;
+	localProtocol?: "http" | "https";
+	assets?: string;
+	site?: string;
+	siteInclude?: string[];
+	siteExclude?: string[];
+	nodeCompat?: boolean;
+	compatibilityDate?: string;
+	compatibilityFlags?: string[];
+	persist?: boolean;
+	persistTo?: string;
+	liveReload?: boolean;
+	watch?: boolean;
+	vars?: {
+		[key: string]: unknown;
+	};
+	kv?: {
+		binding: string;
+		id: string;
+		preview_id?: string;
+	}[];
+	durableObjects?: {
+		name: string;
+		class_name: string;
+		script_name?: string | undefined;
+		environment?: string | undefined;
+	}[];
+	r2?: {
+		binding: string;
+		bucket_name: string;
+		preview_bucket_name?: string;
+	}[];
+	d1Databases?: Environment["d1_databases"];
+	showInteractiveDevSession?: boolean;
+	logLevel?: "none" | "info" | "error" | "log" | "warn" | "debug";
+	logPrefix?: string;
+	inspect?: boolean;
+	forceLocal?: boolean;
+	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
+	_?: (string | number)[]; //yargs wants this
+	$0?: string; //yargs wants this
+	testScheduled?: boolean;
+}
+
+interface DevApiOptions {
+	testMode?: boolean;
+	disableExperimentalWarning?: boolean;
+}
+
+export interface UnstableDevWorker {
+	port: number;
+	address: string;
+	stop: () => Promise<void>;
+	fetch: (input?: RequestInfo, init?: RequestInit) => Promise<Response>;
+	waitUntilExit: () => Promise<void>;
+}
+/**
+ *  unstable_dev starts a wrangler dev server, and returns a promise that resolves with utility functions to interact with it.
+ */
+export async function unstable_dev(
+	script: string,
+	options?: DevOptions,
+	apiOptions?: DevApiOptions
+): Promise<UnstableDevWorker> {
+	const { testMode = true, disableExperimentalWarning = false } =
+		apiOptions || {};
+	if (!disableExperimentalWarning) {
+		logger.warn(
+			`unstable_dev() is experimental\nunstable_dev()'s behaviour will likely change in future releases`
+		);
+	}
+	let readyPort: number;
+	let readyAddress: string;
+	//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<UnstableDevWorker>((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: "",
+					port: options?.port ?? 0,
+					...options,
+					local: true,
+					onReady: (address, port) => {
+						readyPort = port;
+						readyAddress = address;
+						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({
+					port: readyPort,
+					address: readyAddress,
+					stop: devServer.stop,
+					fetch: async (input?: RequestInfo, init?: RequestInit) => {
+						return await fetch(
+							...parseRequestInput(
+								readyAddress,
+								readyPort,
+								input,
+								init,
+								options?.localProtocol
+							)
+						);
+					},
+					//no-op, does nothing in tests
+					waitUntilExit: async () => {
+						return;
+					},
+				});
+			});
+		});
+	} else {
+		//outside of test mode, rebuilds work fine, but only one instance of wrangler will work at a time
+
+		return new Promise<UnstableDevWorker>((resolve) => {
+			//lmao
+			return new Promise<Awaited<ReturnType<typeof startDev>>>((ready) => {
+				const devServer = startDev({
+					script: script,
+					inspect: false,
+					showInteractiveDevSession: false,
+					_: [],
+					$0: "",
+					...options,
+					local: true,
+					onReady: (address, port) => {
+						readyPort = port;
+						readyAddress = address;
+						ready(devServer);
+					},
+				});
+			}).then((devServer) => {
+				resolve({
+					port: readyPort,
+					address: readyAddress,
+					stop: devServer.stop,
+					fetch: async (input?: RequestInfo, init?: RequestInit) => {
+						return await fetch(
+							...parseRequestInput(
+								readyAddress,
+								readyPort,
+								input,
+								init,
+								options?.localProtocol
+							)
+						);
+					},
+					waitUntilExit: devServer.devReactElement.waitUntilExit,
+				});
+			});
+		});
+	}
+}
+
+export function parseRequestInput(
+	readyAddress: string,
+	readyPort: number,
+	input?: RequestInfo,
+	init?: RequestInit,
+	protocol: "http" | "https" = "http"
+): [RequestInfo, RequestInit | undefined] {
+	if (input instanceof Request) {
+		return [input, undefined];
+	} else if (input instanceof URL) {
+		input = `${protocol}://${readyAddress}:${readyPort}${input.pathname}`;
+	} else if (typeof input === "string") {
+		try {
+			// Want to strip the URL to only get the pathname, but the user could pass in only the pathname
+			// Will error if we try and pass "/something" into new URL("/something")
+			input = `${protocol}://${readyAddress}:${readyPort}${
+				new URL(input).pathname
+			}`;
+		} catch {
+			input = `${protocol}://${readyAddress}:${readyPort}${input}`;
+		}
+	} else {
+		input = `${protocol}://${readyAddress}:${readyPort}`;
+	}
+
+	return [input, init];
+}

package/src/api/index.ts

@@ -0,0 +1,2 @@
+export { unstable_dev } from "./dev";
+export type { UnstableDevWorker } from "./dev";

package/src/bundle-reporter.tsx

@@ -0,0 +1,29 @@
+import { Blob } from "node:buffer";
+import { gzipSync } from "node:zlib";
+import { logger } from "./logger";
+import type { CfModule } from "./worker";
+
+async function getSize(modules: CfModule[]) {
+	const gzipSize = gzipSync(
+		await new Blob(modules.map((file) => file.content)).arrayBuffer()
+	).byteLength;
+	const aggregateSize = new Blob(modules.map((file) => file.content)).size;
+
+	return { size: aggregateSize, gzipSize };
+}
+
+export async function printBundleSize(
+	main: {
+		name: string;
+		content: string;
+	},
+	modules: CfModule[]
+) {
+	const { size, gzipSize } = await getSize([...modules, main]);
+
+	const bundleReport = `${(size / 1024).toFixed(2)} KiB / gzip: ${(
+		gzipSize / 1024
+	).toFixed(2)} KiB`;
+
+	logger.log(`Total Upload: ${bundleReport}`);
+}