wrangler 0.0.0-e178d6fb → 0.0.0-e19903d7

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

@@ -1,327 +0,0 @@
-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

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

package/src/api/dev.ts

@@ -1,86 +0,0 @@
-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

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

package/src/bundle-reporter.tsx

@@ -1,29 +0,0 @@
-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

@@ -1,236 +0,0 @@
-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];