wrangler 0.0.0-e043479 → 0.0.0-e09abbc

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

@@ -1,66 +1,85 @@
 import { writeFile } from "fs/promises";
 import path from "path";
-import guessWorkerFormat from "../guess-worker-format";
+import guessWorkerFormat from "../entry";
+import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 
 describe("guess worker format", () => {
-  runInTempDir();
-  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(
-      {
-        file: path.join(process.cwd(), "./index.ts"),
-        directory: 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(
-      {
-        file: path.join(process.cwd(), "./index.ts"),
-        directory: 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(
-        {
-          file: path.join(process.cwd(), "./index.ts"),
-          directory: 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 ES module exports. 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(
-        {
-          file: path.join(process.cwd(), "./index.ts"),
-          directory: 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("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

@@ -1,3 +1,5 @@
+import { reinitialiseAuthTokens } from "../../user";
+
 const ORIGINAL_CLOUDFLARE_API_TOKEN = process.env.CLOUDFLARE_API_TOKEN;
 const ORIGINAL_CLOUDFLARE_ACCOUNT_ID = process.env.CLOUDFLARE_ACCOUNT_ID;
 
@@ -8,18 +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;
-    }
-  });
-  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;
+	});
 }
 
 /**
@@ -29,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-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, "");
+	};
 }

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

@@ -1,24 +1,24 @@
 import { URL, URLSearchParams } from "node:url";
 import { pathToRegexp } from "path-to-regexp";
 import { getCloudflareApiBaseUrl } from "../../cfetch";
-import type { FetchResult } from "../../cfetch";
+import type { FetchResult, FetchError } from "../../cfetch";
 import type { RequestInit } from "undici";
 
 /**
  * The signature of the function that will handle a mock request.
  */
 export type MockHandler<ResponseType> = (
-  uri: RegExpExecArray,
-  init: RequestInit,
-  queryParams: URLSearchParams
+	uri: RegExpExecArray,
+	init: RequestInit,
+	queryParams: URLSearchParams
 ) => ResponseType | Promise<ResponseType>;
 
 type RemoveMockFn = () => void;
 
 interface MockFetch<ResponseType> {
-  regexp: RegExp;
-  method: string | undefined;
-  handler: MockHandler<ResponseType>;
+	regexp: RegExp;
+	method: string | undefined;
+	handler: MockHandler<ResponseType>;
 }
 const mocks: MockFetch<unknown>[] = [];
 
@@ -30,23 +30,23 @@ const mocks: MockFetch<unknown>[] = [];
  * Once found the handler will be used to generate a mock response.
  */
 export async function mockFetchInternal(
-  resource: string,
-  init: RequestInit = {},
-  queryParams: URLSearchParams = new URLSearchParams()
+	resource: string,
+	init: RequestInit = {},
+	queryParams: URLSearchParams = new URLSearchParams()
 ) {
-  for (const { regexp, method, handler } of mocks) {
-    const resourcePath = new URL(resource, getCloudflareApiBaseUrl()).pathname;
-    const uri = regexp.exec(resourcePath);
-    // Do the resource path and (if specified) the HTTP method match?
-    if (uri !== null && (!method || method === (init.method ?? "GET"))) {
-      // The `resource` regular expression will extract the labelled groups from the URL.
-      // These are passed through to the `handler` call, to allow it to do additional checks or behaviour.
-      return await handler(uri, init, queryParams); // TODO: should we have some kind of fallthrough system? we'll see.
-    }
-  }
-  throw new Error(
-    `no mocks found for ${init.method ?? "any HTTP"} request to ${resource}`
-  );
+	for (const { regexp, method, handler } of mocks) {
+		const resourcePath = new URL(resource, getCloudflareApiBaseUrl()).pathname;
+		const uri = regexp.exec(resourcePath);
+		// Do the resource path and (if specified) the HTTP method match?
+		if (uri !== null && (!method || method === (init.method ?? "GET"))) {
+			// The `resource` regular expression will extract the labelled groups from the URL.
+			// These are passed through to the `handler` call, to allow it to do additional checks or behaviour.
+			return await handler(uri, init, queryParams); // TODO: should we have some kind of fallthrough system? we'll see.
+		}
+	}
+	throw new Error(
+		`no mocks found for ${init.method ?? "any HTTP"} request to ${resource}`
+	);
 }
 
 /**
@@ -57,8 +57,8 @@ export async function mockFetchInternal(
  * @param handler The function that will generate the mock response for this request.
  */
 export function setMockRawResponse<ResponseType>(
-  resource: string,
-  handler: MockHandler<ResponseType>
+	resource: string,
+	handler: MockHandler<ResponseType>
 ): RemoveMockFn;
 /**
  * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
@@ -69,32 +69,32 @@ export function setMockRawResponse<ResponseType>(
  * @param handler The function that will generate the mock response for this request.
  */
 export function setMockRawResponse<ResponseType>(
-  resource: string,
-  method: string,
-  handler: MockHandler<ResponseType>
+	resource: string,
+	method: string,
+	handler: MockHandler<ResponseType>
 ): RemoveMockFn;
 /**
  * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
  */
 export function setMockRawResponse<ResponseType>(
-  resource: string,
-  ...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
+	resource: string,
+	...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
 ): RemoveMockFn {
-  const handler = args.pop() as MockHandler<ResponseType>;
-  const method = args.pop() as string;
-  const mock = {
-    resource,
-    method,
-    handler,
-    regexp: pathToRegexp(resource),
-  };
-  mocks.push(mock);
-  return () => {
-    const mockIndex = mocks.indexOf(mock);
-    if (mockIndex !== -1) {
-      mocks.splice(mockIndex, 1);
-    }
-  };
+	const handler = args.pop() as MockHandler<ResponseType>;
+	const method = args.pop() as string;
+	const mock = {
+		resource,
+		method,
+		handler,
+		regexp: pathToRegexp(resource),
+	};
+	mocks.push(mock);
+	return () => {
+		const mockIndex = mocks.indexOf(mock);
+		if (mockIndex !== -1) {
+			mocks.splice(mockIndex, 1);
+		}
+	};
 }
 
 /**
@@ -107,8 +107,8 @@ export function setMockRawResponse<ResponseType>(
  * @param handler The function that will generate the mock response for this request.
  */
 export function setMockResponse<ResponseType>(
-  resource: string,
-  handler: MockHandler<ResponseType>
+	resource: string,
+	handler: MockHandler<ResponseType>
 ): RemoveMockFn;
 /**
  * Specify an expected resource path that is to be handled, resulting in a FetchRequest..
@@ -119,48 +119,48 @@ export function setMockResponse<ResponseType>(
  * @param handler The function that will generate the mock response for this request.
  */
 export function setMockResponse<ResponseType>(
-  resource: string,
-  method: string,
-  handler: MockHandler<ResponseType>
+	resource: string,
+	method: string,
+	handler: MockHandler<ResponseType>
 ): RemoveMockFn;
 /**
  * Specify an expected resource path that is to be handled, resulting in a FetchRequest.
  */
 export function setMockResponse<ResponseType>(
-  resource: string,
-  ...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
+	resource: string,
+	...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
 ): RemoveMockFn {
-  const handler = args.pop() as MockHandler<ResponseType>;
-  const method = args.pop() as string;
-  return setMockRawResponse(resource, method, (...handlerArgs) =>
-    createFetchResult(handler(...handlerArgs))
-  );
+	const handler = args.pop() as MockHandler<ResponseType>;
+	const method = args.pop() as string;
+	return setMockRawResponse(resource, method, (...handlerArgs) =>
+		createFetchResult(handler(...handlerArgs))
+	);
 }
 
 /**
  * A helper to make it easier to create `FetchResult` objects in tests.
  */
 export async function createFetchResult<ResponseType>(
-  result: ResponseType | Promise<ResponseType>,
-  success = true,
-  errors = [],
-  messages = [],
-  result_info?: unknown
+	result: ResponseType | Promise<ResponseType>,
+	success = true,
+	errors: FetchError[] = [],
+	messages: string[] = [],
+	result_info?: unknown
 ): Promise<FetchResult<ResponseType>> {
-  return result_info
-    ? {
-        result: await result,
-        success,
-        errors,
-        messages,
-        result_info,
-      }
-    : {
-        result: await result,
-        success,
-        errors,
-        messages,
-      };
+	return result_info
+		? {
+				result: await result,
+				success,
+				errors,
+				messages,
+				result_info,
+		  }
+		: {
+				result: await result,
+				success,
+				errors,
+				messages,
+		  };
 }
 
 /**
@@ -169,7 +169,7 @@ export async function createFetchResult<ResponseType>(
  * This should be called in an `afterEach()` block to ensure that mock handlers do not leak between tests.
  */
 export function unsetAllMocks() {
-  mocks.length = 0;
+	mocks.length = 0;
 }
 
 /**
@@ -179,29 +179,33 @@ export function unsetAllMocks() {
  * special-case mocking it here.
  */
 
-const kvGetMocks = new Map<string, string>();
+const kvGetMocks = new Map<string, string | Buffer>();
 
+/**
+ * @mocked typeof fetchKVGetValue
+ */
 export function mockFetchKVGetValue(
-  accountId: string,
-  namespaceId: string,
-  key: string
+	accountId: string,
+	namespaceId: string,
+	key: string
 ) {
-  const mapKey = `${accountId}/${namespaceId}/${key}`;
-  if (kvGetMocks.has(mapKey)) {
-    return kvGetMocks.get(mapKey);
-  }
-  throw new Error(`no mock value found for \`kv:key get\` - ${mapKey}`);
+	const mapKey = `${accountId}/${namespaceId}/${key}`;
+	if (kvGetMocks.has(mapKey)) {
+		const value = kvGetMocks.get(mapKey);
+		if (value !== undefined) return Promise.resolve(value);
+	}
+	throw new Error(`no mock value found for \`kv:key get\` - ${mapKey}`);
 }
 
 export function setMockFetchKVGetValue(
-  accountId: string,
-  namespaceId: string,
-  key: string,
-  value: string
+	accountId: string,
+	namespaceId: string,
+	key: string,
+	value: string | Buffer
 ) {
-  kvGetMocks.set(`${accountId}/${namespaceId}/${key}`, value);
+	kvGetMocks.set(`${accountId}/${namespaceId}/${key}`, value);
 }
 
 export function unsetMockFetchKVGetValues() {
-  kvGetMocks.clear();
+	kvGetMocks.clear();
 }