wrangler 0.0.0-e9a1820 → 0.0.0-e9ab55a

package/src/__tests__/mock-cfetch.ts

@@ -1,47 +1,84 @@
-// This file mocks ../cfetch.ts
-// so we can insert whatever responses we want from it
+import type { RequestInit } from "node-fetch";
+import { URLSearchParams } from "node:url";
 import { pathToRegexp } from "path-to-regexp";
+import { CF_API_BASE_URL } from "../cfetch";
+import type { FetchResult } from "../cfetch";
+
+/**
+ * The signature of the function that will handle a mock request.
+ */
+export type MockHandler<ResponseType> = (
+  uri: RegExpExecArray,
+  init: RequestInit,
+  queryParams: URLSearchParams
+) => ResponseType;
 
-// Sadly we cannot give use the correct `RequestInit` type from node-fetch.
-// Jest needs to transform the code as part of the module mocking, and it doesn't know how to cope with such types.
-type RequestInit = { method: string; body: string };
-type MockHandler = (uri: RegExpExecArray, init?: RequestInit) => unknown;
-type MockFetch = {
-  regexp: RegExp;
-  method: string | undefined;
-  handler: MockHandler;
-};
 type RemoveMockFn = () => void;
 
-let mocks: MockFetch[] = [];
+interface MockFetch<ResponseType> {
+  regexp: RegExp;
+  method: string | undefined;
+  handler: MockHandler<ResponseType>;
+}
+const mocks: MockFetch<unknown>[] = [];
 
-export default function mockCfetch(
+/**
+ * The mock implementation of `cfApi.fetch()`.
+ *
+ * This function will attempt to match the given request to one of the mock handlers configured by calls to `setMock`.
+ *
+ * Once found the handler will be used to generate a mock response.
+ */
+export async function mockFetchInternal(
   resource: string,
-  init: RequestInit
-): unknown {
+  init: RequestInit = {},
+  queryParams: URLSearchParams = new URLSearchParams()
+) {
   for (const { regexp, method, handler } of mocks) {
-    const uri = regexp.exec(resource);
+    const resourcePath = new URL(resource, CF_API_BASE_URL).pathname;
+    const uri = regexp.exec(resourcePath);
     // Do the resource path and (if specified) the HTTP method match?
     if (uri !== null && (!method || method === init.method)) {
       // 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 handler(uri, init); // TODO: should we have some kind of fallthrough system? we'll see.
+      return handler(uri, init, queryParams); // TODO: should we have some kind of fallthrough system? we'll see.
     }
   }
-  throw new Error(`no mocks found for ${resource}`);
+  throw new Error(`no mocks found for ${init.method}: ${resource}`);
 }
 
 /**
- * Specify an expected resource path that is to be handled.
+ * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
+ *
+ * @param resource The path of the resource to be matched.
+ * This can include wildcards whose value will be passed to the `handler`.
+ * @param handler The function that will generate the mock response for this request.
  */
-export function setMock(
+export function setMockRawResponse<ResponseType>(
+  resource: string,
+  handler: MockHandler<ResponseType>
+): RemoveMockFn;
+/**
+ * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
+ *
+ * @param resource The path of the resource to be matched.
+ * This can include wildcards whose value will be passed to the `handler`.
+ * @param method The HTTP method (e.g. GET, POST, etc) that the request must have to match this mock handler.
+ * @param handler The function that will generate the mock response for this request.
+ */
+export function setMockRawResponse<ResponseType>(
   resource: string,
   method: string,
-  handler: MockHandler
+  handler: MockHandler<ResponseType>
 ): RemoveMockFn;
-export function setMock(resource: string, handler: MockHandler): RemoveMockFn;
-export function setMock(resource: string, ...args: unknown[]): RemoveMockFn {
-  const handler = args.pop() as MockHandler;
+/**
+ * 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>]
+): RemoveMockFn {
+  const handler = args.pop() as MockHandler<ResponseType>;
   const method = args.pop() as string;
   const mock = {
     resource,
@@ -51,13 +88,84 @@ export function setMock(resource: string, ...args: unknown[]): RemoveMockFn {
   };
   mocks.push(mock);
   return () => {
-    mocks = mocks.filter((x) => x !== mock);
+    const mockIndex = mocks.indexOf(mock);
+    if (mockIndex !== -1) {
+      mocks.splice(mockIndex, 1);
+    }
   };
 }
 
-export function unsetAllMocks() {
-  mocks = [];
+/**
+ * Specify an expected resource path that is to be handled, resulting in a `FetchRequest`.
+ *
+ * The mock `handler` should return the `result`, which will then be wrapped in a `FetchRequest` object.
+ *
+ * @param resource The path of the resource to be matched.
+ * This can include wildcards whose value will be passed to the `handler`.
+ * @param handler The function that will generate the mock response for this request.
+ */
+export function setMockResponse<ResponseType>(
+  resource: string,
+  handler: MockHandler<ResponseType>
+): RemoveMockFn;
+/**
+ * Specify an expected resource path that is to be handled, resulting in a FetchRequest..
+ *
+ * @param resource The path of the resource to be matched.
+ * This can include wildcards whose value will be passed to the `handler`.
+ * @param method The HTTP method (e.g. GET, POST, etc) that the request must have to match this mock handler.
+ * @param handler The function that will generate the mock response for this request.
+ */
+export function setMockResponse<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>]
+): RemoveMockFn {
+  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 function createFetchResult<ResponseType>(
+  result: ResponseType,
+  success = true,
+  errors = [],
+  messages = [],
+  result_info?: unknown
+): FetchResult<ResponseType> {
+  return result_info
+    ? {
+        result,
+        success,
+        errors,
+        messages,
+        result_info,
+      }
+    : {
+        result,
+        success,
+        errors,
+        messages,
+      };
 }
 
-export const CF_API_BASE_URL =
-  process.env.CF_API_BASE_URL || "https://api.cloudflare.com/client/v4";
+/**
+ * Remove all the configured mock handlers.
+ *
+ * This should be called in an `afterEach()` block to ensure that mock handlers do not leak between tests.
+ */
+export function unsetAllMocks() {
+  mocks.length = 0;
+}

package/src/__tests__/publish.test.ts

@@ -0,0 +1,102 @@
+import * as fs from "node:fs";
+import { setMockResponse } from "./mock-cfetch";
+import { runInTempDir } from "./run-in-tmp";
+import { runWrangler } from "./run-wrangler";
+
+describe("publish", () => {
+  runInTempDir();
+
+  it("should be able to use `index` with no extension as the entry-point", async () => {
+    writeWranglerToml();
+    writeEsmWorkerSource();
+    mockUploadWorkerRequest();
+    mockSubDomainRequest();
+
+    const { stdout, stderr, error } = await runWrangler("publish ./index");
+
+    expect(stdout).toMatchInlineSnapshot(`
+      "Uploaded
+      test-name
+      (0.00 sec)
+      Deployed
+      test-name
+      (0.00 sec)
+       
+      test-name.test-sub-domain.workers.dev"
+    `);
+    expect(stderr).toMatchInlineSnapshot(`""`);
+    expect(error).toMatchInlineSnapshot(`undefined`);
+  });
+
+  it("should be able to use the `build.upload.main` config as the entry-point for ESM sources", async () => {
+    writeWranglerToml("./index.js");
+    writeEsmWorkerSource();
+    mockUploadWorkerRequest();
+    mockSubDomainRequest();
+
+    const { stdout, stderr, error } = await runWrangler("publish");
+
+    expect(stdout).toMatchInlineSnapshot(`
+      "Uploaded
+      test-name
+      (0.00 sec)
+      Deployed
+      test-name
+      (0.00 sec)
+       
+      test-name.test-sub-domain.workers.dev"
+    `);
+    expect(stderr).toMatchInlineSnapshot(`""`);
+    expect(error).toMatchInlineSnapshot(`undefined`);
+  });
+});
+
+/** Write a mock wrangler.toml file to disk. */
+function writeWranglerToml(main?: string) {
+  fs.writeFileSync(
+    "./wrangler.toml",
+    [
+      `compatibility_date = "2022-01-12"`,
+      `name = "test-name"`,
+      main !== undefined ? `[build.upload]\nmain = "${main}"` : "",
+    ].join("\n"),
+    "utf-8"
+  );
+}
+
+/** Write a mock Worker script to disk. */
+function writeEsmWorkerSource() {
+  fs.writeFileSync(
+    "index.js",
+    [
+      `import { foo } from "./another";`,
+      `export default {`,
+      `  async fetch(request) {`,
+      `    return new Response('Hello' + foo);`,
+      `  },`,
+      `};`,
+    ].join("\n")
+  );
+  fs.writeFileSync("another.js", `export const foo = 100;`);
+}
+
+/** Create a mock handler for the request to upload a worker script. */
+function mockUploadWorkerRequest(available_on_subdomain = true) {
+  setMockResponse(
+    "/accounts/:accountId/workers/scripts/:scriptName",
+    "PUT",
+    ([_url, accountId, scriptName], _init, queryParams) => {
+      expect(accountId).toEqual("some-account-id");
+      expect(scriptName).toEqual("test-name");
+      expect(queryParams.get("available_on_subdomains")).toEqual("true");
+      return { available_on_subdomain };
+    }
+  );
+}
+
+/** Create a mock handler the request for the account's subdomain. */
+function mockSubDomainRequest(subdomain = "test-sub-domain") {
+  setMockResponse("/accounts/:accountId/workers/subdomain", () => {
+    return { subdomain };
+  });
+}

package/src/api/form_data.ts

@@ -23,7 +23,7 @@ export function toMimeType(type: CfModuleType): string {
   }
 }
 
-function toModule(module: CfModule, entryType?: CfModuleType): Blob {
+function toModule(module: CfModule, entryType: CfModuleType): Blob {
   const { type: moduleType, content } = module;
   const type = toMimeType(moduleType ?? entryType);
 

package/src/api/preview.ts

@@ -1,7 +1,7 @@
-import cfetch from "../cfetch";
+import fetch from "node-fetch";
+import { fetchResult } from "../cfetch";
 import { toFormData } from "./form_data";
 import type { CfAccount, CfWorkerInit } from "./worker";
-import fetch from "node-fetch";
 
 /**
  * A preview mode.
@@ -60,7 +60,7 @@ async function sessionToken(account: CfAccount): Promise<CfPreviewToken> {
     ? `/zones/${zoneId}/workers/edge-preview`
     : `/accounts/${accountId}/workers/subdomain/edge-preview`;
 
-  const { exchange_url } = await cfetch<{ exchange_url: string }>(initUrl);
+  const { exchange_url } = await fetchResult<{ exchange_url: string }>(initUrl);
   const { inspector_websocket, token } = (await (
     await fetch(exchange_url)
   ).json()) as { inspector_websocket: string; token: string };
@@ -106,7 +106,7 @@ export async function previewToken(
   const formData = toFormData(worker);
   formData.set("wrangler-session-config", JSON.stringify(mode));
 
-  const { preview_token } = await cfetch<{ preview_token: string }>(url, {
+  const { preview_token } = await fetchResult<{ preview_token: string }>(url, {
     method: "POST",
     // @ts-expect-error TODO: fix this
     body: formData,

package/src/api/worker.ts

@@ -112,7 +112,7 @@ export interface CfWorkerInit {
   /**
    * The name of the worker.
    */
-  name: string | void;
+  name: string | undefined;
   /**
    * The entrypoint module.
    */
@@ -120,7 +120,7 @@ export interface CfWorkerInit {
   /**
    * The list of additional modules.
    */
-  modules: void | CfModule[];
+  modules: undefined | CfModule[];
   /**
    * All the bindings
    */
@@ -130,10 +130,10 @@ export interface CfWorkerInit {
     vars?: CfVars;
     services?: CfService[];
   };
-  migrations: void | CfDurableObjectMigrations;
-  compatibility_date: string | void;
-  compatibility_flags: void | string[];
-  usage_model: void | "bundled" | "unbound";
+  migrations: undefined | CfDurableObjectMigrations;
+  compatibility_date: string | undefined;
+  compatibility_flags: undefined | string[];
+  usage_model: undefined | "bundled" | "unbound";
 }
 
 /**

package/src/cfetch/index.ts

@@ -0,0 +1,102 @@
+import type { RequestInit } from "node-fetch";
+import { URLSearchParams } from "url";
+import { fetchInternal } from "./internal";
+
+// Check out https://api.cloudflare.com/ for API docs.
+
+export { CF_API_BASE_URL } from "./internal";
+
+export interface FetchError {
+  code: number;
+  message: string;
+}
+export interface FetchResult<ResponseType = unknown> {
+  success: boolean;
+  result: ResponseType;
+  errors: FetchError[];
+  messages: string[];
+  result_info?: unknown;
+}
+
+/**
+ * Make a fetch request for a raw JSON value.
+ */
+export async function fetchRaw<ResponseType>(
+  resource: string,
+  init: RequestInit = {},
+  queryParams?: URLSearchParams
+): Promise<ResponseType> {
+  return fetchInternal<ResponseType>(resource, init, queryParams);
+}
+
+/**
+ * Make a fetch request, and extract the `result` from the JSON response.
+ */
+export async function fetchResult<ResponseType>(
+  resource: string,
+  init: RequestInit = {},
+  queryParams?: URLSearchParams
+): Promise<ResponseType> {
+  const json = await fetchInternal<FetchResult<ResponseType>>(
+    resource,
+    init,
+    queryParams
+  );
+  if (json.success) {
+    return json.result;
+  } else {
+    throwFetchError(resource, json);
+  }
+}
+
+/**
+ * Make a fetch request for a list of values,
+ * extracting the `result` from the JSON response,
+ * and repeating the request if the results are paginated.
+ */
+export async function fetchListResult<ResponseType>(
+  resource: string,
+  init: RequestInit = {},
+  queryParams?: URLSearchParams
+): Promise<ResponseType[]> {
+  const results: ResponseType[] = [];
+  let getMoreResults = true;
+  let cursor: string | undefined;
+  while (getMoreResults) {
+    if (cursor) {
+      queryParams = new URLSearchParams(queryParams);
+      queryParams.set("cursor", cursor);
+    }
+    const json = await fetchInternal<FetchResult<ResponseType[]>>(
+      resource,
+      init,
+      queryParams
+    );
+    if (json.success) {
+      results.push(...json.result);
+      if (hasCursor(json.result_info)) {
+        cursor = json.result_info?.cursor;
+      } else {
+        getMoreResults = false;
+      }
+    } else {
+      throwFetchError(resource, json);
+    }
+  }
+  return results;
+}
+
+function throwFetchError(
+  resource: string,
+  response: FetchResult<unknown>
+): never {
+  response.messages.forEach((message) => console.warn(message));
+  const errors = response.errors
+    .map((error) => `${error.code}: ${error.message}`)
+    .join("\n");
+  throw new Error(`Failed to fetch ${resource} - ${errors}`);
+}
+
+function hasCursor(result_info: unknown): result_info is { cursor: string } {
+  return (result_info as { cursor } | undefined)?.cursor !== undefined;
+}

package/src/cfetch/internal.ts

@@ -0,0 +1,69 @@
+import fetch from "node-fetch";
+import type { RequestInit, HeadersInit } from "node-fetch";
+import { getAPIToken, loginOrRefreshIfRequired } from "../user";
+
+export const CF_API_BASE_URL =
+  process.env.CF_API_BASE_URL || "https://api.cloudflare.com/client/v4";
+
+/**
+ * Make a fetch request to the Cloudflare API.
+ *
+ * This function handles acquiring the API token and logging the caller in, as necessary.
+ *
+ * Check out https://api.cloudflare.com/ for API docs.
+ *
+ * This function should not be used directly, instead use the functions in `cfetch/index.ts`.
+ */
+export async function fetchInternal<ResponseType>(
+  resource: string,
+  init: RequestInit = {},
+  queryParams?: URLSearchParams
+): Promise<ResponseType> {
+  await requireLoggedIn();
+  const apiToken = requireApiToken();
+  const headers = cloneHeaders(init.headers);
+  addAuthorizationHeader(headers, apiToken);
+
+  const queryString = queryParams ? `?${queryParams.toString()}` : "";
+  const response = await fetch(`${CF_API_BASE_URL}${resource}${queryString}`, {
+    method: "GET",
+    ...init,
+    headers,
+  });
+
+  if (response.ok) {
+    return (await response.json()) as ResponseType;
+  } else {
+    throw new Error(
+      `Failed to fetch ${resource} - ${response.status}: ${response.statusText}`
+    );
+  }
+}
+
+function cloneHeaders(headers: HeadersInit | undefined): HeadersInit {
+  return { ...headers };
+}
+
+async function requireLoggedIn(): Promise<void> {
+  const loggedIn = await loginOrRefreshIfRequired();
+  if (!loggedIn) {
+    throw new Error("Not logged in.");
+  }
+}
+
+function requireApiToken(): string {
+  const apiToken = getAPIToken();
+  if (!apiToken) {
+    throw new Error("No API token found.");
+  }
+  return apiToken;
+}
+
+function addAuthorizationHeader(headers: HeadersInit, apiToken: string): void {
+  if (headers["Authorization"]) {
+    throw new Error(
+      "The request already specifies an authorisation header - cannot add a new one."
+    );
+  }
+  headers["Authorization"] = `Bearer ${apiToken}`;
+}