wrangler 0.0.0-e1b8ac4 → 0.0.0-e1c2f5b9

package/src/__tests__/dialogs.test.tsx

@@ -0,0 +1,40 @@
+jest.unmock("../dialogs");
+import { fromDashMessagePrompt } from "../dialogs";
+import { CI } from "../is-ci";
+
+describe("fromDashMessagePrompt", () => {
+	it("should return undefined in CI when last deployed from api", async () => {
+		//in CI
+		jest.spyOn(CI, "isCI").mockReturnValue(true);
+		const result = await fromDashMessagePrompt("api");
+		expect(result).toBe(undefined);
+	});
+
+	it("should return undefined in CI when last deployed from wrangler", async () => {
+		//in CI
+		jest.spyOn(CI, "isCI").mockReturnValue(true);
+		const result = await fromDashMessagePrompt("wrangler");
+		expect(result).toBe(undefined);
+	});
+
+	it("should return true in CI when last deployed from dash", async () => {
+		//in CI
+		jest.spyOn(CI, "isCI").mockReturnValue(true);
+		const result = await fromDashMessagePrompt("dash");
+		expect(result).toBe(true);
+	});
+
+	it("should return undefined when last deployed from api", async () => {
+		//not in CI
+		jest.spyOn(CI, "isCI").mockReturnValue(false);
+		const result = await fromDashMessagePrompt("api");
+		expect(result).toBe(undefined);
+	});
+
+	it("should return undefined when last deployed from wrangler", async () => {
+		//not in CI
+		jest.spyOn(CI, "isCI").mockReturnValue(false);
+		const result = await fromDashMessagePrompt("wrangler");
+		expect(result).toBe(undefined);
+	});
+});

package/src/__tests__/generate.test.ts

@@ -0,0 +1,235 @@
+import fs from "node:fs";
+import path from "node:path";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { mockConfirm, clearConfirmMocks } from "./helpers/mock-dialogs";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+
+describe("generate", () => {
+	runInTempDir();
+	const std = mockConsoleMethods();
+
+	describe("cli functionality", () => {
+		afterEach(() => {
+			clearConfirmMocks();
+		});
+
+		it("defers to `wrangler init` when no template is given", async () => {
+			mockConfirm(
+				{
+					text: "Would you like to use git to manage this Worker?",
+					result: false,
+				},
+				{
+					text: "No package.json found. Would you like to create one?",
+					result: false,
+				}
+			);
+			await runWrangler("generate no-template");
+			expect(std.out).toMatchInlineSnapshot(
+				`"✨ Created no-template/wrangler.toml"`
+			);
+		});
+
+		it("complains when given the --type argument", async () => {
+			await expect(
+				runWrangler("generate worker-name worker-template --type rust")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"The --type option is no longer supported."`
+			);
+		});
+
+		it("complains when given the --site argument", async () => {
+			await expect(runWrangler("generate worker-name worker-template --site"))
+				.rejects.toThrowErrorMatchingInlineSnapshot(`
+					"The --site option is no longer supported.
+					If you wish to create a brand new Worker Sites project then clone the \`worker-sites-template\` starter repository:
+
+					\`\`\`
+					git clone --depth=1 --branch=wrangler2 https://github.com/cloudflare/worker-sites-template worker-name
+					cd worker-name
+					\`\`\`
+
+					Find out more about how to create and maintain Sites projects at https://developers.cloudflare.com/workers/platform/sites.
+					Have you considered using Cloudflare Pages instead? See https://pages.cloudflare.com/."
+				`);
+		});
+
+		it.skip("auto-increments the worker directory name", async () => {
+			fs.mkdirSync("my-worker");
+
+			expect(fs.existsSync("my-worker-1")).toBe(false);
+
+			await expect(
+				runWrangler("generate my-worker worker-typescript")
+			).resolves.toBeUndefined();
+
+			expect(std.out).toStrictEqual(expect.stringContaining("my-worker-1"));
+
+			expect(readDirectory("my-worker-1")).toMatchObject<Directory>({
+				".git": expect.any(Object),
+				".gitignore": expect.any(String),
+				"README.md": expect.stringContaining("Template: worker-typescript"),
+				"jest.config.json": expect.any(String),
+				"package.json": expect.stringContaining("@cloudflare/workers-types"),
+				src: expect.objectContaining({ "index.ts": expect.any(String) }),
+				test: expect.objectContaining({
+					"index.test.ts": expect.any(String),
+				}),
+				"tsconfig.json": expect.any(String),
+				"wrangler.toml": expect.any(String),
+			});
+			expect(fs.existsSync("my-worker-2")).toBe(false);
+
+			await expect(
+				runWrangler("generate my-worker worker-typescript")
+			).resolves.toBeUndefined();
+
+			expect(std.out).toStrictEqual(expect.stringContaining("my-worker-2"));
+
+			expect(readDirectory("my-worker-2")).toMatchObject<Directory>({
+				".git": expect.any(Object),
+				".gitignore": expect.any(String),
+				"README.md": expect.stringContaining("Template: worker-typescript"),
+				"jest.config.json": expect.any(String),
+				"package.json": expect.stringContaining("@cloudflare/workers-types"),
+				src: expect.objectContaining({ "index.ts": expect.any(String) }),
+				test: expect.objectContaining({
+					"index.test.ts": expect.any(String),
+				}),
+				"tsconfig.json": expect.any(String),
+				"wrangler.toml": expect.any(String),
+			});
+		});
+	});
+
+	describe("cloning", () => {
+		it.skip("clones a cloudflare template with sparse checkouts", async () => {
+			await expect(
+				runWrangler("generate my-worker worker-typescript")
+			).resolves.toBeUndefined();
+
+			expect(readDirectory("my-worker")).toMatchObject<Directory>({
+				".git": expect.any(Object),
+				".gitignore": expect.any(String),
+				"README.md": expect.stringContaining("Template: worker-typescript"),
+				"jest.config.json": expect.any(String),
+				"package.json": expect.stringContaining("@cloudflare/workers-types"),
+				src: expect.objectContaining({ "index.ts": expect.any(String) }),
+				test: expect.objectContaining({
+					"index.test.ts": expect.any(String),
+				}),
+				"tsconfig.json": expect.any(String),
+				"wrangler.toml": expect.any(String),
+			});
+		});
+
+		// mocking out calls to either `isGitInstalled` or `execa("git", ["--version"])`
+		// was harder than i thought, leaving this for now.
+		it.todo("clones a cloudflare template with full checkouts");
+
+		it("clones a user/repo template", async () => {
+			await expect(
+				runWrangler("generate my-worker caass/wrangler-generate-test-template")
+			).resolves.toBeUndefined();
+
+			expect(readDirectory("my-worker")).toMatchObject<Directory>({
+				".git": expect.any(Object),
+				".gitignore": expect.any(String),
+				"package.json": expect.stringContaining("@cloudflare/workers-types"),
+				src: expect.objectContaining({ "index.ts": expect.any(String) }),
+				"tsconfig.json": expect.any(String),
+				"wrangler.toml": expect.any(String),
+			});
+		});
+
+		it.skip("clones a user/repo/path/to/subdirectory template", async () => {
+			await expect(
+				runWrangler("generate my-worker cloudflare/templates/worker-typescript")
+			).resolves.toBeUndefined();
+
+			expect(readDirectory("my-worker")).toMatchObject<Directory>({
+				".git": expect.any(Object),
+				".gitignore": expect.any(String),
+				"README.md": expect.stringContaining("Template: worker-typescript"),
+				"jest.config.json": expect.any(String),
+				"package.json": expect.stringContaining("@cloudflare/workers-types"),
+				src: expect.objectContaining({ "index.ts": expect.any(String) }),
+				test: expect.objectContaining({
+					"index.test.ts": expect.any(String),
+				}),
+				"tsconfig.json": expect.any(String),
+				"wrangler.toml": expect.any(String),
+			});
+		});
+
+		it.skip("clones a git@github.com/user/repo template", async () => {
+			await expect(
+				runWrangler(
+					"generate my-worker git@github.com:caass/wrangler-generate-test-template"
+				)
+			).resolves.toBeUndefined();
+
+			expect(readDirectory("my-worker")).toMatchObject<Directory>({
+				".git": expect.any(Object),
+				".gitignore": expect.any(String),
+				"package.json": expect.stringContaining("@cloudflare/workers-types"),
+				src: expect.objectContaining({ "index.ts": expect.any(String) }),
+				"tsconfig.json": expect.any(String),
+				"wrangler.toml": expect.any(String),
+			});
+		});
+
+		it.skip("clones a git@github.com/user/repo/path/to/subdirectory template", async () => {
+			await expect(
+				runWrangler(
+					"generate my-worker git@github.com:cloudflare/templates/worker-typescript"
+				)
+			).resolves.toBeUndefined();
+
+			expect(readDirectory("my-worker")).toMatchObject<Directory>({
+				".git": expect.any(Object),
+				".gitignore": expect.any(String),
+				"README.md": expect.stringContaining("Template: worker-typescript"),
+				"jest.config.json": expect.any(String),
+				"package.json": expect.stringContaining("@cloudflare/workers-types"),
+				src: expect.objectContaining({ "index.ts": expect.any(String) }),
+				test: expect.objectContaining({
+					"index.test.ts": expect.any(String),
+				}),
+				"tsconfig.json": expect.any(String),
+				"wrangler.toml": expect.any(String),
+			});
+		});
+	});
+});
+
+type FileName = string;
+type FileContents = string;
+type Directory = { [key: FileName]: FileContents | Directory };
+
+function readDirectory(directoryPath: string): Directory {
+	if (!fs.existsSync(directoryPath)) {
+		throw new Error(`${directoryPath} does not exist!`);
+	}
+
+	if (!fs.lstatSync(directoryPath).isDirectory()) {
+		throw new Error(`${directoryPath} is not a directory!`);
+	}
+
+	return fs
+		.readdirSync(directoryPath, { withFileTypes: true })
+		.reduce((output, child) => {
+			const childPath = path.join(directoryPath, child.name);
+
+			if (child.isDirectory()) {
+				output[child.name] = readDirectory(childPath);
+			} else if (child.isFile()) {
+				output[child.name] = fs.readFileSync(childPath, { encoding: "utf-8" });
+			} else {
+				throw new Error(`${childPath} was not a file or directory!`);
+			}
+
+			return output;
+		}, {} as Directory);
+}

package/src/__tests__/get-host-from-url.test.ts

@@ -0,0 +1,16 @@
+import { getHostFromUrl } from "../zones";
+
+//return the host given a url-like string
+describe("getHostFromUrl", () => {
+	it("should return the host from a url", () => {
+		expect(getHostFromUrl("https://www.example.com")).toBe("www.example.com");
+	});
+
+	it("should return the host from a url using wildcard *.", () => {
+		expect(getHostFromUrl("*.example.com")).toBe("example.com");
+	});
+
+	it("should return the host from a url using wildcard *", () => {
+		expect(getHostFromUrl("*example.com")).toBe("example.com");
+	});
+});

package/src/__tests__/guess-worker-format.test.ts

@@ -5,81 +5,81 @@ import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 
 describe("guess worker format", () => {
-  runInTempDir();
-  const std = mockConsoleMethods();
-  it('should detect a "modules" worker', async () => {
-    await writeFile("./index.ts", "export default {};");
-    // Note that this isn't actually a valid worker, because it's missing
-    // a fetch handler. Regardless, our heuristic is simply to check for exports.
-    const guess = await guessWorkerFormat(
-      path.join(process.cwd(), "./index.ts"),
-      process.cwd(),
-      undefined
-    );
-    expect(guess).toBe("modules");
-  });
+	runInTempDir();
+	const std = mockConsoleMethods();
+	it('should detect a "modules" worker', async () => {
+		await writeFile("./index.ts", "export default {};");
+		// Note that this isn't actually a valid worker, because it's missing
+		// a fetch handler. Regardless, our heuristic is simply to check for exports.
+		const guess = await guessWorkerFormat(
+			path.join(process.cwd(), "./index.ts"),
+			process.cwd(),
+			undefined
+		);
+		expect(guess).toBe("modules");
+	});
 
-  it('should detect a "service-worker" worker', async () => {
-    await writeFile("./index.ts", "");
-    // Note that this isn't actually a valid worker, because it's missing
-    // a fetch listener. Regardless, our heuristic is simply to check for
-    // the lack of exports.
-    const guess = await guessWorkerFormat(
-      path.join(process.cwd(), "./index.ts"),
-      process.cwd(),
-      undefined
-    );
-    expect(guess).toBe("service-worker");
-  });
+	it('should detect a "service-worker" worker', async () => {
+		await writeFile("./index.ts", "");
+		// Note that this isn't actually a valid worker, because it's missing
+		// a fetch listener. Regardless, our heuristic is simply to check for
+		// the lack of exports.
+		const guess = await guessWorkerFormat(
+			path.join(process.cwd(), "./index.ts"),
+			process.cwd(),
+			undefined
+		);
+		expect(guess).toBe("service-worker");
+	});
 
-  it("should throw an error when the hint doesn't match the guess (modules - service-worker)", async () => {
-    await writeFile("./index.ts", "export default {};");
-    await expect(
-      guessWorkerFormat(
-        path.join(process.cwd(), "./index.ts"),
-        process.cwd(),
-        "service-worker"
-      )
-    ).rejects.toThrow(
-      "You configured this worker to be a 'service-worker', but the file you are trying to build appears to have a `default` export like a module worker. Please pass `--format modules`, or simply remove the configuration."
-    );
-  });
+	it("should throw an error when the hint doesn't match the guess (modules - service-worker)", async () => {
+		await writeFile("./index.ts", "export default {};");
+		await expect(
+			guessWorkerFormat(
+				path.join(process.cwd(), "./index.ts"),
+				process.cwd(),
+				"service-worker"
+			)
+		).rejects.toThrow(
+			"You configured this worker to be a 'service-worker', but the file you are trying to build appears to have a `default` export like a module worker. Please pass `--format modules`, or simply remove the configuration."
+		);
+	});
 
-  it("should throw an error when the hint doesn't match the guess (service-worker - modules)", async () => {
-    await writeFile("./index.ts", "");
-    await expect(
-      guessWorkerFormat(
-        path.join(process.cwd(), "./index.ts"),
-        process.cwd(),
-        "modules"
-      )
-    ).rejects.toThrow(
-      "You configured this worker to be 'modules', but the file you are trying to build doesn't export a handler. Please pass `--format service-worker`, or simply remove the configuration."
-    );
-  });
+	it("should throw an error when the hint doesn't match the guess (service-worker - modules)", async () => {
+		await writeFile("./index.ts", "");
+		await expect(
+			guessWorkerFormat(
+				path.join(process.cwd(), "./index.ts"),
+				process.cwd(),
+				"modules"
+			)
+		).rejects.toThrow(
+			"You configured this worker to be 'modules', but the file you are trying to build doesn't export a handler. Please pass `--format service-worker`, or simply remove the configuration."
+		);
+	});
 
-  it("should not error if a .js entry point has jsx", async () => {
-    await writeFile("./index.js", "console.log(<div/>)");
-    const guess = await guessWorkerFormat(
-      path.join(process.cwd(), "./index.js"),
-      process.cwd(),
-      undefined
-    );
-    expect(guess).toBe("service-worker");
-  });
+	it("should not error if a .js entry point has jsx", async () => {
+		await writeFile("./index.js", "console.log(<div/>)");
+		const guess = await guessWorkerFormat(
+			path.join(process.cwd(), "./index.js"),
+			process.cwd(),
+			undefined
+		);
+		expect(guess).toBe("service-worker");
+	});
 
-  it("logs a warning when a worker has exports, but not a default one", async () => {
-    await writeFile("./index.ts", "export const foo = 1;");
-    const guess = await guessWorkerFormat(
-      path.join(process.cwd(), "./index.ts"),
-      process.cwd(),
-      undefined
-    );
-    expect(guess).toBe("service-worker");
-    expect(std.warn).toMatchInlineSnapshot(`
+	it("logs a warning when a worker has exports, but not a default one", async () => {
+		await writeFile("./index.ts", "export const foo = 1;");
+		const guess = await guessWorkerFormat(
+			path.join(process.cwd(), "./index.ts"),
+			process.cwd(),
+			undefined
+		);
+		expect(guess).toBe("service-worker");
+		expect(std.warn).toMatchInlineSnapshot(`
       "▲ [WARNING] The entrypoint index.ts has exports like an ES Module, but hasn't defined a default export like a module worker normally would. Building the worker using \\"service-worker\\" format...
 
       "
     `);
-  });
+	});
 });

package/src/__tests__/helpers/cmd-shim.d.ts

@@ -2,10 +2,10 @@
  * The typings file available at `@types/cmd-shim` are out of date.
  */
 module "cmd-shim" {
-  /**
-   *
-   * Create a cmd shim at `to` for the command line program at `from`.
-   *
-   */
-  export default function cmdShim(from: string, to: string): Promise<void>;
+	/**
+	 *
+	 * Create a cmd shim at `to` for the command line program at `from`.
+	 *
+	 */
+	export default function cmdShim(from: string, to: string): Promise<void>;
 }

package/src/__tests__/helpers/mock-account-id.ts

@@ -10,20 +10,20 @@ const ORIGINAL_CLOUDFLARE_ACCOUNT_ID = process.env.CLOUDFLARE_ACCOUNT_ID;
  * This is useful if a higher `describe()` block has already called `mockApiToken()`.
  */
 export function mockApiToken({
-  apiToken = "some-api-token",
+	apiToken = "some-api-token",
 }: { apiToken?: string | null } = {}) {
-  beforeEach(() => {
-    if (apiToken === null) {
-      delete process.env.CLOUDFLARE_API_TOKEN;
-    } else {
-      process.env.CLOUDFLARE_API_TOKEN = apiToken;
-    }
-    // Now we have updated the environment, we must reinitialize the user auth state.
-    reinitialiseAuthTokens();
-  });
-  afterEach(() => {
-    process.env.CLOUDFLARE_API_TOKEN = ORIGINAL_CLOUDFLARE_API_TOKEN;
-  });
+	beforeEach(() => {
+		if (apiToken === null) {
+			delete process.env.CLOUDFLARE_API_TOKEN;
+		} else {
+			process.env.CLOUDFLARE_API_TOKEN = apiToken;
+		}
+		// Now we have updated the environment, we must reinitialize the user auth state.
+		reinitialiseAuthTokens();
+	});
+	afterEach(() => {
+		process.env.CLOUDFLARE_API_TOKEN = ORIGINAL_CLOUDFLARE_API_TOKEN;
+	});
 }
 
 /**
@@ -33,16 +33,16 @@ export function mockApiToken({
  * This is useful if a higher `describe()` block has already called `mockAccountId()`.
  */
 export function mockAccountId({
-  accountId = "some-account-id",
+	accountId = "some-account-id",
 }: { accountId?: string | null } = {}) {
-  beforeEach(() => {
-    if (accountId === null) {
-      delete process.env.CLOUDFLARE_ACCOUNT_ID;
-    } else {
-      process.env.CLOUDFLARE_ACCOUNT_ID = accountId;
-    }
-  });
-  afterEach(() => {
-    process.env.CLOUDFLARE_ACCOUNT_ID = ORIGINAL_CLOUDFLARE_ACCOUNT_ID;
-  });
+	beforeEach(() => {
+		if (accountId === null) {
+			delete process.env.CLOUDFLARE_ACCOUNT_ID;
+		} else {
+			process.env.CLOUDFLARE_ACCOUNT_ID = accountId;
+		}
+	});
+	afterEach(() => {
+		process.env.CLOUDFLARE_ACCOUNT_ID = ORIGINAL_CLOUDFLARE_ACCOUNT_ID;
+	});
 }

package/src/__tests__/helpers/mock-auth-domain.ts

@@ -0,0 +1,20 @@
+const ORIGINAL_WRANGLER_AUTH_DOMAIN = process.env.WRANGLER_AUTH_DOMAIN;
+
+/**
+ * Mock the Auth URL domain so that we can control where we attempt to login.
+ *
+ * Note that you can remove any API token from the environment by setting the value to `null`.
+ * This is useful if a higher `describe()` block has already called `mockAuthDomain()`.
+ */
+export function mockAuthDomain({ domain }: { domain: string | null }) {
+	beforeEach(() => {
+		if (domain === null) {
+			delete process.env.WRANGLER_AUTH_DOMAIN;
+		} else {
+			process.env.WRANGLER_AUTH_DOMAIN = domain;
+		}
+	});
+	afterEach(() => {
+		process.env.WRANGLER_AUTH_DOMAIN = ORIGINAL_WRANGLER_AUTH_DOMAIN;
+	});
+}

package/src/__tests__/helpers/mock-bin.ts

@@ -8,29 +8,29 @@ const nodeShebang = "#!/usr/bin/env node";
  * Create a binary file in a temp directory and make it available on the PATH.
  */
 export async function mockBinary(
-  binaryName: string,
-  code: string
+	binaryName: string,
+	code: string
 ): Promise<() => void> {
-  // Ensure there is a directory to put the mock binary in.
-  const tmpDir = resolve(mkdtempSync(".mock-binary-"));
+	// Ensure there is a directory to put the mock binary in.
+	const tmpDir = resolve(mkdtempSync(".mock-binary-"));
 
-  // Use a fake extension on Windows because we will create a cmd-shim to run the binary.
-  const extension = process.platform === "win32" ? ".x-mock-bin" : "";
-  const filePath = resolve(tmpDir, `${binaryName}${extension}`);
-  writeFileSync(filePath, nodeShebang + "\n" + code);
-  chmodSync(filePath, 0o777);
+	// Use a fake extension on Windows because we will create a cmd-shim to run the binary.
+	const extension = process.platform === "win32" ? ".x-mock-bin" : "";
+	const filePath = resolve(tmpDir, `${binaryName}${extension}`);
+	writeFileSync(filePath, nodeShebang + "\n" + code);
+	chmodSync(filePath, 0o777);
 
-  if (process.platform === "win32") {
-    await cmdShim(filePath, basename(filePath, ".x-mock-bin"));
-  }
+	if (process.platform === "win32") {
+		await cmdShim(filePath, basename(filePath, ".x-mock-bin"));
+	}
 
-  // Update PATH using the appropriate separator for the platform.
-  const oldPath = process.env.PATH;
-  const sep = process.platform === "win32" ? ";" : ":";
-  process.env.PATH = tmpDir + sep + oldPath;
+	// Update PATH using the appropriate separator for the platform.
+	const oldPath = process.env.PATH;
+	const sep = process.platform === "win32" ? ";" : ":";
+	process.env.PATH = tmpDir + sep + oldPath;
 
-  return function unMock() {
-    rmSync(tmpDir, { recursive: true });
-    process.env.PATH = process.env.PATH?.replace(tmpDir + sep, "");
-  };
+	return function unMock() {
+		rmSync(tmpDir, { recursive: true });
+		process.env.PATH = process.env.PATH?.replace(tmpDir + sep, "");
+	};
 }