wrangler 0.0.0-ece06ea → 0.0.0-edc4b53

package/src/__tests__/mock-cfetch.ts

@@ -0,0 +1,171 @@
+import type { RequestInit } from "node-fetch";
+import type { 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;
+
+type RemoveMockFn = () => void;
+
+interface MockFetch<ResponseType> {
+  regexp: RegExp;
+  method: string | undefined;
+  handler: MockHandler<ResponseType>;
+}
+const mocks: MockFetch<unknown>[] = [];
+
+/**
+ * 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 = {},
+  queryParams?: URLSearchParams
+) {
+  for (const { regexp, method, handler } of mocks) {
+    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, queryParams); // TODO: should we have some kind of fallthrough system? we'll see.
+    }
+  }
+  throw new Error(`no mocks found for ${init.method}: ${resource}`);
+}
+
+/**
+ * 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 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<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>]
+): 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);
+    }
+  };
+}
+
+/**
+ * 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,
+      };
+}
+
+/**
+ * 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__/mock-dialogs.ts

@@ -0,0 +1,65 @@
+import { confirm, prompt } from "../dialogs";
+
+/**
+ * The expected values for a confirmation request.
+ */
+export interface ConfirmExpectation {
+  /** The text expected to be seen in the confirmation dialog. */
+  text: string;
+  /** The mock response send back from the confirmation dialog. */
+  result: boolean;
+}
+
+/**
+ * Mock the implementation of `confirm()` that will respond with configured results
+ * for configured confirmation text messages.
+ *
+ * If there is a call to `confirm()` that does not match any of the expectations
+ * then an error is thrown.
+ */
+export function mockConfirm(...expectations: ConfirmExpectation[]) {
+  (confirm as jest.Mock).mockImplementation((text: string) => {
+    for (const { text: expectedText, result } of expectations) {
+      if (text === expectedText) {
+        return Promise.resolve(result);
+      }
+    }
+    throw new Error(`Unexpected confirmation message: ${text}`);
+  });
+}
+
+/**
+ * The expected values for a prompt request.
+ */
+export interface PromptExpectation {
+  /** The text expected to be seen in the prompt dialog. */
+  text: string;
+  /** The type of the prompt. */
+  type: "text" | "password";
+  /** The mock response send back from the prompt dialog. */
+  result: string;
+}
+
+/**
+ * Mock the implementation of `prompt()` that will respond with configured results
+ * for configured prompt text messages.
+ *
+ * If there is a call to `prompt()` that does not match any of the expectations
+ * then an error is thrown.
+ */
+export function mockPrompt(...expectations: PromptExpectation[]) {
+  (prompt as jest.Mock).mockImplementation(
+    (text: string, type: "text" | "password") => {
+      for (const {
+        text: expectedText,
+        type: expectedType,
+        result,
+      } of expectations) {
+        if (text === expectedText && type == expectedType) {
+          return Promise.resolve(result);
+        }
+      }
+      throw new Error(`Unexpected confirmation message: ${text}`);
+    }
+  );
+}

package/src/__tests__/run-in-tmp.ts

@@ -0,0 +1,19 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import * as fs from "fs";
+
+const originalCwd = process.cwd();
+
+export function runInTempDir() {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wrangler-tests"));
+    process.chdir(tmpDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+}

package/src/__tests__/run-wrangler.ts

@@ -0,0 +1,32 @@
+import { main } from "../index";
+
+/**
+ * Run the wrangler CLI tool in tests, capturing the logging output.
+ */
+export async function runWrangler(cmd?: string) {
+  const logSpy = jest.spyOn(console, "log").mockImplementation();
+  const errorSpy = jest.spyOn(console, "error").mockImplementation();
+  const warnSpy = jest.spyOn(console, "warn").mockImplementation();
+  try {
+    let error: unknown = undefined;
+    try {
+      await main(cmd?.split(" ") ?? []);
+    } catch (e) {
+      error = e;
+    }
+    return {
+      error,
+      stdout: captureCalls(logSpy),
+      stderr: captureCalls(errorSpy),
+      warnings: captureCalls(warnSpy),
+    };
+  } finally {
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    warnSpy.mockRestore();
+  }
+}
+
+function captureCalls(spy: jest.SpyInstance): string {
+  return spy.mock.calls.flat(2).join("\n");
+}

package/src/api/form_data.ts

@@ -1,72 +1,11 @@
 import type {
   CfWorkerInit,
   CfModuleType,
-  CfVariable,
   CfModule,
+  CfDurableObjectMigrations,
 } from "./worker.js";
 import { FormData, Blob } from "formdata-node";
 
-// Credit: https://stackoverflow.com/a/9458996
-function toBase64(source: BufferSource): string {
-  let result = "";
-  const buffer = source instanceof ArrayBuffer ? source : source.buffer;
-  const bytes = new Uint8Array(buffer);
-  for (let i = 0; i < bytes.byteLength; i++) {
-    result += String.fromCharCode(bytes[i]);
-  }
-  return btoa(result);
-}
-
-function toBinding(
-  name: string,
-  variable: CfVariable
-): Record<string, unknown> {
-  if (typeof variable === "string") {
-    return { name, type: "plain_text", text: variable };
-  }
-
-  if ("namespaceId" in variable) {
-    return {
-      name,
-      type: "kv_namespace",
-      namespace_id: variable.namespaceId,
-    };
-  }
-
-  if ("class_name" in variable) {
-    return {
-      name,
-      type: "durable_object_namespace",
-      class_name: variable.class_name,
-      ...(variable.script_name && {
-        script_name: variable.script_name,
-      }),
-    };
-  }
-
-  const { format, algorithm, usages, data } = variable;
-  if (format) {
-    let key_base64;
-    let key_jwk;
-    if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
-      key_base64 = toBase64(data);
-    } else {
-      key_jwk = data;
-    }
-    return {
-      name,
-      type: "secret_key",
-      format,
-      algorithm,
-      usages,
-      key_base64,
-      key_jwk,
-    };
-  }
-
-  throw new TypeError("Unsupported variable: " + variable);
-}
-
 export function toMimeType(type: CfModuleType): string {
   switch (type) {
     case "esm":
@@ -84,13 +23,36 @@ 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);
 
   return new Blob([content], { type });
 }
 
+interface WorkerMetadata {
+  compatibility_date?: string;
+  compatibility_flags?: string[];
+  usage_model?: "bundled" | "unbound";
+  migrations?: CfDurableObjectMigrations;
+  bindings: (
+    | { type: "kv_namespace"; name: string; namespace_id: string }
+    | { type: "plain_text"; name: string; text: string }
+    | {
+        type: "durable_object_namespace";
+        name: string;
+        class_name: string;
+        script_name?: string;
+      }
+    | {
+        type: "service";
+        name: string;
+        service: string;
+        environment: string;
+      }
+  )[];
+}
+
 /**
  * Creates a `FormData` upload from a `CfWorkerInit`.
  */
@@ -99,50 +61,61 @@ export function toFormData(worker: CfWorkerInit): FormData {
   const {
     main,
     modules,
-    variables,
+    bindings,
     migrations,
     usage_model,
     compatibility_date,
     compatibility_flags,
   } = worker;
-  const { name, type: mainType } = main;
 
-  const bindings = [];
-  for (const [name, variable] of Object.entries(variables ?? {})) {
-    const binding = toBinding(name, variable);
-    bindings.push(binding);
-  }
+  const metadataBindings: WorkerMetadata["bindings"] = [];
 
-  const metadata =
-    mainType !== "commonjs"
-      ? {
-          main_module: name,
-          bindings,
-        }
-      : {
-          body_part: name,
-          bindings,
-        };
-  if (compatibility_date) {
-    // @ts-expect-error - we should type metadata
-    metadata.compatibility_date = compatibility_date;
-  }
-  if (compatibility_flags) {
-    // @ts-expect-error - we should type metadata
-    metadata.compatibility_flags = compatibility_flags;
-  }
-  if (usage_model) {
-    // @ts-expect-error - we should type metadata
-    metadata.usage_model = usage_model;
-  }
-  if (migrations) {
-    // @ts-expect-error - we should type metadata
-    metadata.migrations = migrations;
-  }
+  bindings.kv_namespaces?.forEach(({ id, binding }) => {
+    metadataBindings.push({
+      name: binding,
+      type: "kv_namespace",
+      namespace_id: id,
+    });
+  });
+
+  bindings.durable_objects?.bindings.forEach(
+    ({ name, class_name, script_name }) => {
+      metadataBindings.push({
+        name,
+        type: "durable_object_namespace",
+        class_name: class_name,
+        ...(script_name && { script_name }),
+      });
+    }
+  );
+
+  Object.entries(bindings.vars || {})?.forEach(([key, value]) => {
+    metadataBindings.push({ name: key, type: "plain_text", text: value });
+  });
+
+  bindings.services?.forEach(({ name, service, environment }) => {
+    metadataBindings.push({
+      name,
+      type: "service",
+      service,
+      environment,
+    });
+  });
+
+  const metadata: WorkerMetadata = {
+    ...(main.type !== "commonjs"
+      ? { main_module: main.name }
+      : { body_part: main.name }),
+    bindings: metadataBindings,
+    ...(compatibility_date && { compatibility_date }),
+    ...(compatibility_flags && { compatibility_flags }),
+    ...(usage_model && { usage_model }),
+    ...(migrations && { migrations }),
+  };
 
   formData.set("metadata", JSON.stringify(metadata));
 
-  if (mainType === "commonjs" && modules && modules.length > 0) {
+  if (main.type === "commonjs" && modules && modules.length > 0) {
     throw new TypeError(
       "More than one module can only be specified when type = 'esm'"
     );
@@ -150,7 +123,7 @@ export function toFormData(worker: CfWorkerInit): FormData {
 
   for (const module of [main].concat(modules || [])) {
     const { name } = module;
-    const blob = toModule(module, mainType ?? "esm");
+    const blob = toModule(module, main.type ?? "esm");
     formData.set(name, blob, name);
   }
 

package/src/api/preview.ts

@@ -1,5 +1,5 @@
-import cfetch from "../cfetch";
-import { fetchJson } from "../util/fetch";
+import fetch from "node-fetch";
+import { fetchResult } from "../cfetch";
 import { toFormData } from "./form_data";
 import type { CfAccount, CfWorkerInit } from "./worker";
 
@@ -9,7 +9,7 @@ import type { CfAccount, CfWorkerInit } from "./worker";
  * * If true, then using a `workers.dev` subdomain.
  * * Otherwise, a list of routes under a single zone.
  */
-export type CfPreviewMode = { workers_dev: boolean } | { routes: string[] };
+type CfPreviewMode = { workers_dev: boolean } | { routes: string[] };
 
 /**
  * A preview token.
@@ -60,17 +60,17 @@ async function sessionToken(account: CfAccount): Promise<CfPreviewToken> {
     ? `/zones/${zoneId}/workers/edge-preview`
     : `/accounts/${accountId}/workers/subdomain/edge-preview`;
 
-  const { exchange_url: tokenUrl } = await cfetch<{ exchange_url: string }>(
-    initUrl
-  );
-  const { inspector_websocket: url, token } = await fetchJson()(tokenUrl);
-  const { host } = new URL(url);
+  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 };
+  const { host } = new URL(inspector_websocket);
   const query = `cf_workers_preview_token=${token}`;
 
   return {
     value: token,
     host,
-    inspectorUrl: new URL(`${url}?${query}`),
+    inspectorUrl: new URL(`${inspector_websocket}?${query}`),
     prewarmUrl: new URL(
       `https://${host}/cdn-cgi/workers/preview/prewarm?${query}`
     ),
@@ -96,27 +96,32 @@ export async function previewToken(
   const { value, host, inspectorUrl, prewarmUrl } = await sessionToken(account);
 
   const { accountId, zoneId } = account;
-  const scriptId = zoneId ? randomId() : host.split(".")[0];
+  const scriptId = zoneId ? randomId() : worker.name || host.split(".")[0];
   const url = `/accounts/${accountId}/workers/scripts/${scriptId}/edge-preview`;
 
-  const mode = zoneId ? { routes: ["*/*"] } : { workers_dev: true };
+  const mode: CfPreviewMode = zoneId
+    ? { routes: ["*/*"] }
+    : { workers_dev: true };
+
   const formData = toFormData(worker);
   formData.set("wrangler-session-config", JSON.stringify(mode));
 
-  const { preview_token: token } = await cfetch<{ preview_token: string }>(
-    url,
-    {
-      method: "POST",
-      // @ts-expect-error TODO: fix this
-      body: formData,
-      headers: {
-        "cf-preview-upload-config-token": value,
-      },
-    }
-  );
+  const { preview_token } = await fetchResult<{ preview_token: string }>(url, {
+    method: "POST",
+    // @ts-expect-error TODO: fix this
+    body: formData,
+    headers: {
+      "cf-preview-upload-config-token": value,
+    },
+  });
+
   return {
-    value: token,
-    host,
+    value: preview_token,
+    // TODO: verify this works with zoned workers
+    host:
+      worker.name && !zoneId
+        ? `${worker.name}.${host.split(".").slice(1).join(".")}`
+        : host,
     inspectorUrl,
     prewarmUrl,
   };