wrangler 0.0.0-e14e589 → 0.0.0-e2a26a0

package/src/api/worker.ts

@@ -1,6 +1,6 @@
-import type { CfPreviewToken } from "./preview";
+import { fetch } from "undici";
 import { previewToken } from "./preview";
-import fetch from "node-fetch";
+import type { CfPreviewToken } from "./preview";
 
 /**
  * A Cloudflare account.
@@ -53,7 +53,7 @@ export interface CfModule {
    *   }
    * }
    */
-  content: string | BufferSource;
+  content: string | Buffer;
   /**
    * The module type.
    *
@@ -62,49 +62,57 @@ export interface CfModule {
   type?: CfModuleType;
 }
 
+/**
+ * A map of variable names to values.
+ */
+interface CfVars {
+  [key: string]: string;
+}
+
 /**
  * A KV namespace.
  */
-export interface CfKvNamespace {
-  /**
-   * The namespace ID.
-   */
-  namespaceId: string;
+interface CfKvNamespace {
+  binding: string;
+  id: string;
 }
 
 /**
- * A `WebCrypto` key.
- *
- * @link https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey
+ * A Durable Object.
  */
-export interface CfCryptoKey {
-  /**
-   * The format.
-   */
-  format: string;
-  /**
-   * The algorithm.
-   */
-  algorithm: string;
-  /**
-   * The usages.
-   */
-  usages: string[];
-  /**
-   * The data.
-   */
-  data: BufferSource | JsonWebKey;
+interface CfDurableObject {
+  name: string;
+  class_name: string;
+  script_name?: string;
 }
 
 /**
- * A variable (aka. environment variable).
+ * A Service.
  */
-export type CfVariable = string | CfKvNamespace | CfCryptoKey;
+interface CfService {
+  name: string;
+  service: string;
+  environment: string;
+}
+
+export interface CfDurableObjectMigrations {
+  old_tag?: string;
+  new_tag: string;
+  steps: {
+    new_classes?: string[];
+    renamed_classes?: string[];
+    deleted_classes?: string[];
+  }[];
+}
 
 /**
  * Options for creating a `CfWorker`.
  */
 export interface CfWorkerInit {
+  /**
+   * The name of the worker.
+   */
+  name: string | undefined;
   /**
    * The entrypoint module.
    */
@@ -112,13 +120,20 @@ export interface CfWorkerInit {
   /**
    * The list of additional modules.
    */
-  modules: void | CfModule[];
+  modules: undefined | CfModule[];
   /**
-   * The map of names to variables. (aka. environment variables)
+   * All the bindings
    */
-  variables?: { [name: string]: CfVariable };
-  compatibility_date?: string;
-  usage_model?: void | "bundled" | "unbound";
+  bindings: {
+    kv_namespaces?: CfKvNamespace[];
+    durable_objects?: { bindings: CfDurableObject[] };
+    vars?: CfVars;
+    services?: CfService[];
+  };
+  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 { URLSearchParams } from "node:url";
+import { fetchInternal } from "./internal";
+import type { RequestInit } from "undici";
+
+// 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;
+}
+
+export { fetchKVGetValue } from "./internal";
+
+/**
+ * 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");
+  const error = new Error(`Failed to fetch ${resource} - \n${errors}`);
+  // add the first error code directly to this error
+  // so consumers can use it for specific behaviour
+  const code = response.errors[0]?.code;
+  if (code) {
+    //@ts-expect-error non-standard property on Error
+    error.code = code;
+  }
+  throw error;
+}
+
+function hasCursor(result_info: unknown): result_info is { cursor: string } {
+  const cursor = (result_info as { cursor: string } | undefined)?.cursor;
+  return cursor !== undefined && cursor !== null && cursor !== "";
+}

package/src/cfetch/internal.ts

@@ -0,0 +1,101 @@
+import { fetch } from "undici";
+import { getAPIToken, loginOrRefreshIfRequired } from "../user";
+import type { URLSearchParams } from "node:url";
+import type { RequestInit, HeadersInit } from "undici";
+
+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,
+  });
+  const jsonText = await response.text();
+  try {
+    const json = JSON.parse(jsonText);
+    return json as ResponseType;
+  } catch (e) {
+    throw new Error(
+      `Failed to fetch ${resource} - ${response.status}: ${response.statusText}\nInvalid JSON response:\n${jsonText}`
+    );
+  }
+}
+
+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}`;
+}
+
+/**
+ * The implementation for fetching a kv value from the cloudflare API.
+ * We special-case this one call, because it's the only API call that
+ * doesn't return json. We inline the implementation and try not to share
+ * any code with the other calls. We should push back on any new APIs that
+ * try to introduce non-"standard" response structures.
+ */
+
+export async function fetchKVGetValue(
+  accountId: string,
+  namespaceId: string,
+  key: string
+): Promise<string> {
+  await requireLoggedIn();
+  const apiToken = requireApiToken();
+  const headers = { Authorization: `Bearer ${apiToken}` };
+  const resource = `${CF_API_BASE_URL}/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}`;
+  const response = await fetch(resource, {
+    method: "GET",
+    headers,
+  });
+  if (response.ok) {
+    return await response.text();
+  } else {
+    throw new Error(
+      `Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
+    );
+  }
+}

package/src/cli.ts

@@ -1,10 +1,9 @@
+import { hideBin } from "yargs/helpers";
 import { main } from ".";
 
-main(process.argv.slice(2)).catch((cause) => {
-  const { name, message } = cause;
-  if (name === "CloudflareError") {
-    console.error("\x1b[31m", message);
-    return;
-  }
-  throw cause;
+main(hideBin(process.argv)).catch(() => {
+  // The logging of any error that was thrown from `main()` is handled in the `yargs.fail()` handler.
+  // Here we just want to ensure that the process exits with a non-zero code.
+  // We don't want to do this inside the `main()` function, since that would kill the process when running our tests.
+  process.exit(1);
 });