wrangler 0.0.0-e151223 → 0.0.0-e1e2ee5c

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

@@ -0,0 +1,327 @@
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
+import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+
+describe("worker-namespace", () => {
+	runInTempDir();
+	const std = mockConsoleMethods();
+	mockAccountId();
+	mockApiToken();
+
+	afterEach(() => {
+		unsetAllMocks();
+	});
+
+	it("should should display a list of available subcommands, for worker-namespace with no subcommand", async () => {
+		await runWrangler("worker-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 worker-namespace
+
+		📦 Interact with a worker namespace
+
+		Commands:
+		  wrangler worker-namespace list                          List all Worker namespaces
+		  wrangler worker-namespace get <name>                    Get information about a Worker namespace
+		  wrangler worker-namespace create <name>                 Create a Worker namespace
+		  wrangler worker-namespace delete <name>                 Delete a Worker namespace
+		  wrangler worker-namespace rename <old-name> <new-name>  Rename a Worker 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", () => {
+		function mockCreateRequest(expectedName: string) {
+			const requests = { count: 0 };
+			setMockResponse(
+				"/accounts/:accountId/workers/dispatch/namespaces",
+				([_url], init) => {
+					requests.count += 1;
+
+					const incomingText = init.body?.toString() || "";
+					const { name: namespace_name } = JSON.parse(incomingText);
+
+					expect(init.method).toBe("POST");
+					expect(namespace_name).toEqual(expectedName);
+
+					return {
+						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",
+					};
+				}
+			);
+			return requests;
+		}
+
+		it("should display help for create", async () => {
+			await expect(
+				runWrangler("worker-namespace create")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 1"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler worker-namespace create <name>
+
+			Create a Worker namespace
+
+			Positionals:
+			  name  Name of the Worker 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 () => {
+			const namespaceName = "my-namespace";
+			const requests = mockCreateRequest(namespaceName);
+			await runWrangler(`worker-namespace create ${namespaceName}`);
+			expect(requests.count).toEqual(1);
+
+			expect(std.out).toMatchInlineSnapshot(
+				`"Created Worker namespace \\"my-namespace\\" with ID \\"some-namespace-id\\""`
+			);
+		});
+	});
+
+	describe("delete namespace", () => {
+		function mockDeleteRequest(expectedName: string) {
+			const requests = { count: 0 };
+			setMockResponse(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceName",
+				([_url, _, namespaceName], init) => {
+					requests.count += 1;
+
+					expect(init.method).toBe("DELETE");
+					expect(namespaceName).toEqual(expectedName);
+
+					return null;
+				}
+			);
+			return requests;
+		}
+
+		it("should display help for delete", async () => {
+			await expect(
+				runWrangler("worker-namespace create")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 1"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler worker-namespace create <name>
+
+			Create a Worker namespace
+
+			Positionals:
+			  name  Name of the Worker 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 () => {
+			const namespaceName = "my-namespace";
+			const requests = mockDeleteRequest(namespaceName);
+			await runWrangler(`worker-namespace delete ${namespaceName}`);
+			expect(requests.count).toBe(1);
+
+			expect(std.out).toMatchInlineSnapshot(
+				`"Deleted Worker namespace \\"my-namespace\\""`
+			);
+		});
+	});
+
+	describe("get namespace", () => {
+		function mockInfoRequest(expectedName: string) {
+			const requests = { count: 0 };
+			setMockResponse(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceName",
+				([_url, _, namespaceName], _init) => {
+					requests.count += 1;
+
+					expect(namespaceName).toEqual(expectedName);
+
+					return {
+						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",
+					};
+				}
+			);
+			return requests;
+		}
+
+		it("should display help for get", async () => {
+			await expect(
+				runWrangler("worker-namespace get")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 1"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			        "
+			        wrangler worker-namespace get <name>
+
+			        Get information about a Worker namespace
+
+			        Positionals:
+			          name  Name of the Worker 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 () => {
+			const namespaceName = "my-namespace";
+			const requests = mockInfoRequest(namespaceName);
+			await runWrangler(`worker-namespace get ${namespaceName}`);
+			expect(requests.count).toBe(1);
+
+			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", () => {
+		function mockListRequest() {
+			const requests = { count: 0 };
+			setMockResponse(
+				"/accounts/:accountId/workers/dispatch/namespaces",
+				([_url, _, _page, _perPage], _init) => {
+					requests.count += 1;
+
+					return [
+						{
+							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",
+						},
+					];
+				}
+			);
+			return requests;
+		}
+
+		it("should list all namespaces", async () => {
+			const requests = mockListRequest();
+			await runWrangler("worker-namespace list");
+			expect(requests.count).toBe(1);
+			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", () => {
+		function mockRenameRequest(expectedName: string) {
+			const requests = { count: 0 };
+			setMockResponse(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceName",
+				([_url, _, namespaceName], init) => {
+					requests.count += 1;
+
+					expect(init.method).toEqual("PUT");
+					expect(namespaceName).toEqual(expectedName);
+
+					return {
+						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",
+					};
+				}
+			);
+			return requests;
+		}
+
+		it("should display help for rename", async () => {
+			await expect(
+				runWrangler("worker-namespace rename")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 2"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler worker-namespace rename <old-name> <new-name>
+
+			Rename a Worker namespace
+
+			Positionals:
+			  old-name  Name of the Worker namespace  [string] [required]
+			  new-name  New name of the Worker 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 namespaceName = "my-namespace";
+			const newName = "new-namespace";
+			const requests = mockRenameRequest(namespaceName);
+			await runWrangler(`worker-namespace rename ${namespaceName} ${newName}`);
+			expect(requests.count).toBe(1);
+			expect(std.out).toMatchInlineSnapshot(
+				`"Renamed Worker 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,86 @@
+import { startDev } from "../dev";
+import { logger } from "../logger";
+
+import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli";
+import type { RequestInit, Response } from "undici";
+
+interface DevOptions {
+	env?: string;
+	ip?: string;
+	port?: number;
+	localProtocol?: "http" | "https";
+	assets?: string;
+	site?: string;
+	siteInclude?: string[];
+	siteExclude?: string[];
+	nodeCompat?: boolean;
+	compatibilityDate?: string;
+	experimentalEnableLocalPersistence?: boolean;
+	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;
+	}[];
+	showInteractiveDevSession?: boolean;
+	logLevel?: "none" | "error" | "log" | "warn" | "debug";
+	logPrefix?: string;
+	inspect?: boolean;
+	forceLocal?: boolean;
+	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
+	_?: (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,
+	disableExperimentalWarning?: boolean
+) {
+	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),
+			});
+		}).then((devServer) => {
+			resolve({
+				stop: devServer.stop,
+				fetch: devServer.fetch,
+				waitUntilExit: devServer.devReactElement.waitUntilExit,
+			});
+		});
+	});
+}

package/src/api/index.ts

@@ -0,0 +1 @@
+export { unstable_dev } 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}`);
+}

package/src/bundle.ts

@@ -0,0 +1,236 @@
+import assert from "node:assert";
+import * as fs from "node:fs";
+import { builtinModules } from "node:module";
+import * as path from "node:path";
+import NodeGlobalsPolyfills from "@esbuild-plugins/node-globals-polyfill";
+import NodeModulesPolyfills from "@esbuild-plugins/node-modules-polyfill";
+import * as esbuild from "esbuild";
+import createModuleCollector from "./module-collection";
+import type { Config } from "./config";
+import type { Entry } from "./entry";
+import type { CfModule } from "./worker";
+
+type BundleResult = {
+	modules: CfModule[];
+	resolvedEntryPointPath: string;
+	bundleType: "esm" | "commonjs";
+	stop: (() => void) | undefined;
+};
+
+/**
+ * Searches for any uses of node's builtin modules, and throws an error if it
+ * finds anything. This plugin is only used when nodeCompat is not enabled.
+ * Supports both regular node builtins, and the new "node:<MODULE>" format.
+ */
+const checkForNodeBuiltinsPlugin = {
+	name: "checkForNodeBuiltins",
+	setup(build: esbuild.PluginBuild) {
+		build.onResolve(
+			{
+				filter: new RegExp(
+					"^(" +
+						builtinModules.join("|") +
+						"|" +
+						builtinModules.map((module) => "node:" + module).join("|") +
+						")$"
+				),
+			},
+			() => {
+				throw new Error(
+					`Detected a Node builtin module import while Node compatibility is disabled.\nAdd node_compat = true to your wrangler.toml file to enable Node compatibility.`
+				);
+			}
+		);
+	},
+};
+
+/**
+ * Generate a bundle for the worker identified by the arguments passed in.
+ */
+export async function bundleWorker(
+	entry: Entry,
+	destination: string,
+	options: {
+		serveAssetsFromWorker: boolean;
+		jsxFactory: string | undefined;
+		jsxFragment: string | undefined;
+		rules: Config["rules"];
+		watch?: esbuild.WatchMode;
+		tsconfig: string | undefined;
+		minify: boolean | undefined;
+		nodeCompat: boolean | undefined;
+		define: Config["define"];
+		checkFetch: boolean;
+	}
+): Promise<BundleResult> {
+	const {
+		serveAssetsFromWorker,
+		jsxFactory,
+		jsxFragment,
+		rules,
+		watch,
+		tsconfig,
+		minify,
+		nodeCompat,
+		checkFetch,
+	} = options;
+	const entryDirectory = path.dirname(entry.file);
+	const moduleCollector = createModuleCollector({
+		wrangler1xlegacyModuleReferences: {
+			rootDirectory: entryDirectory,
+			fileNames: new Set(
+				fs
+					.readdirSync(entryDirectory, { withFileTypes: true })
+					.filter(
+						(dirEntry) =>
+							dirEntry.isFile() && dirEntry.name !== path.basename(entry.file)
+					)
+					.map((dirEnt) => dirEnt.name)
+			),
+		},
+		format: entry.format,
+		rules,
+	});
+
+	// In dev, we want to patch `fetch()` with a special version that looks
+	// for bad usages and can warn the user about them; so we inject
+	// `checked-fetch.js` to do so. However, with yarn 3 style pnp,
+	// we need to extract that file to an accessible place before injecting
+	// it in, hence this code here.
+	const checkedFetchFileToInject = path.join(
+		destination,
+		"--temp-wrangler-files--",
+		"checked-fetch.js"
+	);
+
+	if (checkFetch) {
+		fs.mkdirSync(path.join(destination, "--temp-wrangler-files--"), {
+			recursive: true,
+		});
+		fs.writeFileSync(
+			checkedFetchFileToInject,
+			fs.readFileSync(path.resolve(__dirname, "../templates/checked-fetch.js"))
+		);
+	}
+	// TODO: we need to have similar logic like above for other files
+	// like the static asset facade, and other middleware that we
+	// plan on injecting/referencing.
+
+	const result = await esbuild.build({
+		...getEntryPoint(entry.file, serveAssetsFromWorker),
+		bundle: true,
+		absWorkingDir: entry.directory,
+		outdir: destination,
+		inject: checkFetch ? [checkedFetchFileToInject] : [],
+		external: ["__STATIC_CONTENT_MANIFEST"],
+		format: entry.format === "modules" ? "esm" : "iife",
+		target: "es2020",
+		sourcemap: true,
+		minify,
+		metafile: true,
+		conditions: ["worker", "browser"],
+		...(process.env.NODE_ENV && {
+			define: {
+				// use process.env["NODE_ENV" + ""] so that esbuild doesn't replace it
+				// when we do a build of wrangler. (re: https://github.com/cloudflare/wrangler2/issues/1477)
+				"process.env.NODE_ENV": `"${process.env["NODE_ENV" + ""]}"`,
+				...(nodeCompat ? { global: "globalThis" } : {}),
+				...(checkFetch ? { fetch: "checkedFetch" } : {}),
+				...options.define,
+			},
+		}),
+		loader: {
+			".js": "jsx",
+			".mjs": "jsx",
+			".cjs": "jsx",
+		},
+		plugins: [
+			moduleCollector.plugin,
+			...(nodeCompat
+				? [NodeGlobalsPolyfills({ buffer: true }), NodeModulesPolyfills()]
+				: // we use checkForNodeBuiltinsPlugin to throw a nicer error
+				  // if we find node builtins when nodeCompat isn't turned on
+				  [checkForNodeBuiltinsPlugin]),
+		],
+		...(jsxFactory && { jsxFactory }),
+		...(jsxFragment && { jsxFragment }),
+		...(tsconfig && { tsconfig }),
+		watch,
+	});
+
+	const entryPointOutputs = Object.entries(result.metafile.outputs).filter(
+		([_path, output]) => output.entryPoint !== undefined
+	);
+	assert(
+		entryPointOutputs.length > 0,
+		`Cannot find entry-point "${entry.file}" in generated bundle.` +
+			listEntryPoints(entryPointOutputs)
+	);
+	assert(
+		entryPointOutputs.length < 2,
+		"More than one entry-point found for generated bundle." +
+			listEntryPoints(entryPointOutputs)
+	);
+
+	const entryPointExports = entryPointOutputs[0][1].exports;
+	const bundleType = entryPointExports.length > 0 ? "esm" : "commonjs";
+
+	return {
+		modules: moduleCollector.modules,
+		resolvedEntryPointPath: path.resolve(
+			entry.directory,
+			entryPointOutputs[0][0]
+		),
+		bundleType,
+		stop: result.stop,
+	};
+}
+
+type EntryPoint = { stdin: esbuild.StdinOptions } | { entryPoints: string[] };
+
+/**
+ * Create an object that describes the entry point for esbuild.
+ *
+ * If we are using the experimental asset handling, then the entry point is
+ * actually a shim worker that will either return an asset from a KV store,
+ * or delegate to the actual worker.
+ */
+function getEntryPoint(
+	entryFile: string,
+	serveAssetsFromWorker: boolean
+): EntryPoint {
+	if (serveAssetsFromWorker) {
+		return {
+			stdin: {
+				contents: fs
+					.readFileSync(
+						path.join(__dirname, "../templates/static-asset-facade.js"),
+						"utf8"
+					)
+					// on windows, escape backslashes in the path (`\`)
+					.replace("__ENTRY_POINT__", entryFile.replaceAll("\\", "\\\\"))
+					.replace(
+						"__KV_ASSET_HANDLER__",
+						path
+							.join(__dirname, "../kv-asset-handler.js")
+							.replaceAll("\\", "\\\\")
+					),
+				sourcefile: "static-asset-facade.js",
+				resolveDir: path.dirname(entryFile),
+			},
+		};
+	} else {
+		return { entryPoints: [entryFile] };
+	}
+}
+
+/**
+ * Generate a string that describes the entry-points that were identified by esbuild.
+ */
+function listEntryPoints(
+	outputs: [string, ValueOf<esbuild.Metafile["outputs"]>][]
+): string {
+	return outputs.map(([_input, output]) => output.entryPoint).join("\n");
+}
+
+type ValueOf<T> = T[keyof T];