wrangler 0.0.0-e3e3243 → 0.0.0-e4047cab

package/src/cfetch/index.ts

@@ -1,6 +1,7 @@
 import { URLSearchParams } from "node:url";
+import { logger } from "../logger";
 import { ParseError } from "../parse";
-import { fetchInternal } from "./internal";
+import { fetchInternal, performApiFetch } from "./internal";
 import type { RequestInit } from "undici";
 
 // Check out https://api.cloudflare.com/ for API docs.
@@ -8,15 +9,16 @@ import type { RequestInit } from "undici";
 export { getCloudflareAPIBaseURL as getCloudflareApiBaseUrl } from "./internal";
 
 export interface FetchError {
-  code: number;
-  message: string;
+	code: number;
+	message: string;
+	error_chain?: FetchError[];
 }
 export interface FetchResult<ResponseType = unknown> {
-  success: boolean;
-  result: ResponseType;
-  errors: FetchError[];
-  messages: string[];
-  result_info?: unknown;
+	success: boolean;
+	result: ResponseType;
+	errors: FetchError[];
+	messages: string[];
+	result_info?: unknown;
 }
 
 export { fetchKVGetValue } from "./internal";
@@ -25,20 +27,22 @@ 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
+	resource: string,
+	init: RequestInit = {},
+	queryParams?: URLSearchParams,
+	abortSignal?: AbortSignal
 ): Promise<ResponseType> {
-  const json = await fetchInternal<FetchResult<ResponseType>>(
-    resource,
-    init,
-    queryParams
-  );
-  if (json.success) {
-    return json.result;
-  } else {
-    throwFetchError(resource, json);
-  }
+	const json = await fetchInternal<FetchResult<ResponseType>>(
+		resource,
+		init,
+		queryParams,
+		abortSignal
+	);
+	if (json.success) {
+		return json.result;
+	} else {
+		throwFetchError(resource, json);
+	}
 }
 
 /**
@@ -47,58 +51,110 @@ export async function fetchResult<ResponseType>(
  * and repeating the request if the results are paginated.
  */
 export async function fetchListResult<ResponseType>(
-  resource: string,
-  init: RequestInit = {},
-  queryParams?: URLSearchParams
+	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;
+	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>
+	resource: string,
+	response: FetchResult<unknown>
 ): never {
-  const error = new ParseError({
-    text: "Received a bad response from the API",
-    notes: response.errors.map((err) => ({
-      text: err.code ? `${err.message} [code: ${err.code}]` : err.message,
-    })),
-  });
-  // 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;
+	const error = new ParseError({
+		text: `A request to the Cloudflare API (${resource}) failed.`,
+		notes: response.errors.map((err) => ({
+			text: renderError(err),
+		})),
+	});
+	// 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 !== "";
+	const cursor = (result_info as { cursor: string } | undefined)?.cursor;
+	return cursor !== undefined && cursor !== null && cursor !== "";
+}
+
+function renderError(err: FetchError, level = 0): string {
+	const chainedMessages =
+		err.error_chain
+			?.map(
+				(chainedError) =>
+					`\n${"  ".repeat(level)}- ${renderError(chainedError, level + 1)}`
+			)
+			.join("\n") ?? "";
+	return (
+		(err.code ? `${err.message} [code: ${err.code}]` : err.message) +
+		chainedMessages
+	);
+}
+
+/**
+ * Fetch the raw script content of a Worker
+ * Note, this will concatenate the files of multi-module workers
+ */
+export async function fetchScriptContent(
+	resource: string,
+	init: RequestInit = {},
+	queryParams?: URLSearchParams,
+	abortSignal?: AbortSignal
+): Promise<string> {
+	const response = await performApiFetch(
+		resource,
+		init,
+		queryParams,
+		abortSignal
+	);
+
+	logger.debug(
+		"-- START CF API RESPONSE:",
+		response.statusText,
+		response.status
+	);
+
+	logger.debug("HEADERS:", { ...response.headers });
+	// logger.debug("RESPONSE:", text);
+	logger.debug("-- END CF API RESPONSE");
+	const contentType = response.headers.get("content-type");
+
+	const usesModules = contentType?.startsWith("multipart");
+	if (usesModules && contentType) {
+		const form = await response.formData();
+		const entries = Array.from(form.entries());
+		return entries.map((e) => e[1]).join("\n");
+	} else {
+		return await response.text();
+	}
 }

package/src/cfetch/internal.ts

@@ -1,20 +1,60 @@
-import { fetch, Headers } from "undici";
+import assert from "node:assert";
+import { fetch, File, Headers } from "undici";
+import { version as wranglerVersion } from "../../package.json";
 import { getEnvironmentVariableFactory } from "../environment-variables";
+import { logger } from "../logger";
 import { ParseError, parseJSON } from "../parse";
-import { reportError } from "../reporting";
-import { getAPIToken, loginOrRefreshIfRequired } from "../user";
+import { loginOrRefreshIfRequired, requireApiToken } from "../user";
+import type { ApiCredentials } from "../user";
 import type { URLSearchParams } from "node:url";
-import type { RequestInit, HeadersInit } from "undici";
+import type { RequestInit, HeadersInit, Response } from "undici";
 
 /**
  * Get the URL to use to access the Cloudflare API.
  */
 export const getCloudflareAPIBaseURL = getEnvironmentVariableFactory({
-  variableName: "CLOUDFLARE_API_BASE_URL",
-  deprecatedName: "CF_API_BASE_URL",
-  defaultValue: "https://api.cloudflare.com/client/v4",
+	variableName: "CLOUDFLARE_API_BASE_URL",
+	deprecatedName: "CF_API_BASE_URL",
+	defaultValue: "https://api.cloudflare.com/client/v4",
 });
 
+/*
+ * performApiFetch does everything required to make a CF API request,
+ * but doesn't parse the response as JSON. For normal V4 API responses,
+ * use `fetchInternal`
+ * */
+export async function performApiFetch(
+	resource: string,
+	init: RequestInit = {},
+	queryParams?: URLSearchParams,
+	abortSignal?: AbortSignal
+) {
+	const method = init.method ?? "GET";
+	assert(
+		resource.startsWith("/"),
+		`CF API fetch - resource path must start with a "/" but got "${resource}"`
+	);
+	await requireLoggedIn();
+	const apiToken = requireApiToken();
+	const headers = cloneHeaders(init.headers);
+	addAuthorizationHeaderIfUnspecified(headers, apiToken);
+	addUserAgent(headers);
+
+	const queryString = queryParams ? `?${queryParams.toString()}` : "";
+	logger.debug(
+		`-- START CF API REQUEST: ${method} ${getCloudflareAPIBaseURL()}${resource}${queryString}`
+	);
+	logger.debug("HEADERS:", JSON.stringify(headers, null, 2));
+	logger.debug("INIT:", JSON.stringify(init, null, 2));
+	logger.debug("-- END CF API REQUEST");
+	return await fetch(`${getCloudflareAPIBaseURL()}${resource}${queryString}`, {
+		method,
+		...init,
+		headers,
+		signal: abortSignal,
+	});
+}
+
 /**
  * Make a fetch request to the Cloudflare API.
  *
@@ -25,87 +65,86 @@ export const getCloudflareAPIBaseURL = getEnvironmentVariableFactory({
  * 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
+	resource: string,
+	init: RequestInit = {},
+	queryParams?: URLSearchParams,
+	abortSignal?: AbortSignal
 ): Promise<ResponseType> {
-  await requireLoggedIn();
-  const apiToken = requireApiToken();
-  const headers = cloneHeaders(init.headers);
-  addAuthorizationHeader(headers, apiToken);
-
-  const queryString = queryParams ? `?${queryParams.toString()}` : "";
-  const method = init.method ?? "GET";
-  const response = await fetch(
-    `${getCloudflareAPIBaseURL()}${resource}${queryString}`,
-    {
-      method,
-      ...init,
-      headers,
-    }
-  );
-  const jsonText = await response.text();
-  try {
-    return parseJSON(jsonText) as ResponseType;
-  } catch (err) {
-    await reportError(err as Error);
-    throw new ParseError({
-      text: "Received a malformed response from the API",
-      notes: [
-        {
-          text: truncate(jsonText, 100),
-        },
-        {
-          text: `${method} ${resource} -> ${response.status} ${response.statusText}`,
-        },
-      ],
-    });
-  }
+	const method = init.method ?? "GET";
+	const response = await performApiFetch(
+		resource,
+		init,
+		queryParams,
+		abortSignal
+	);
+	const jsonText = await response.text();
+	logger.debug(
+		"-- START CF API RESPONSE:",
+		response.statusText,
+		response.status
+	);
+	logger.debug("HEADERS:", JSON.stringify(response.headers, null, 2));
+	logger.debug("RESPONSE:", jsonText);
+	logger.debug("-- END CF API RESPONSE");
+
+	try {
+		return parseJSON<ResponseType>(jsonText);
+	} catch (err) {
+		throw new ParseError({
+			text: "Received a malformed response from the API",
+			notes: [
+				{
+					text: truncate(jsonText, 100),
+				},
+				{
+					text: `${method} ${resource} -> ${response.status} ${response.statusText}`,
+				},
+			],
+		});
+	}
 }
 
 function truncate(text: string, maxLength: number): string {
-  const { length } = text;
-  if (length <= maxLength) {
-    return text;
-  }
-  return `${text.substring(0, maxLength)}... (length = ${length})`;
+	const { length } = text;
+	if (length <= maxLength) {
+		return text;
+	}
+	return `${text.substring(0, maxLength)}... (length = ${length})`;
 }
 
 function cloneHeaders(
-  headers: HeadersInit | undefined
+	headers: HeadersInit | undefined
 ): Record<string, string> {
-  return headers instanceof Headers
-    ? Object.fromEntries(headers.entries())
-    : Array.isArray(headers)
-    ? Object.fromEntries(headers)
-    : { ...headers };
+	return headers instanceof Headers
+		? Object.fromEntries(headers.entries())
+		: Array.isArray(headers)
+		? Object.fromEntries(headers)
+		: { ...headers };
 }
 
 async function requireLoggedIn(): Promise<void> {
-  const loggedIn = await loginOrRefreshIfRequired();
-  if (!loggedIn) {
-    throw new Error("Not logged in.");
-  }
+	const loggedIn = await loginOrRefreshIfRequired();
+	if (!loggedIn) {
+		throw new Error("Not logged in.");
+	}
 }
 
-function requireApiToken(): string {
-  const authToken = getAPIToken();
-  if (!authToken) {
-    throw new Error("No API token found.");
-  }
-  return authToken;
+function addAuthorizationHeaderIfUnspecified(
+	headers: Record<string, string>,
+	auth: ApiCredentials
+): void {
+	if (!("Authorization" in headers)) {
+		if ("apiToken" in auth) {
+			headers["Authorization"] = `Bearer ${auth.apiToken}`;
+		} else {
+			headers["X-Auth-Key"] = auth.authKey;
+			headers["X-Auth-Email"] = auth.authEmail;
+		}
+	}
 }
 
-function addAuthorizationHeader(
-  headers: Record<string, string>,
-  apiToken: string
-): void {
-  if ("Authorization" in headers) {
-    throw new Error(
-      "The request already specifies an authorisation header - cannot add a new one."
-    );
-  }
-  headers["Authorization"] = `Bearer ${apiToken}`;
+function addUserAgent(headers: Record<string, string>): void {
+	headers["User-Agent"] = `wrangler/${wranglerVersion}`;
 }
 
 /**
@@ -114,26 +153,111 @@ function addAuthorizationHeader(
  * 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.
+ *
+ * Note: any calls to fetchKVGetValue must call encodeURIComponent on key
+ * before passing it
  */
-
 export async function fetchKVGetValue(
-  accountId: string,
-  namespaceId: string,
-  key: string
+	accountId: string,
+	namespaceId: string,
+	key: string
+): Promise<ArrayBuffer> {
+	await requireLoggedIn();
+	const auth = requireApiToken();
+	const headers: Record<string, string> = {};
+	addAuthorizationHeaderIfUnspecified(headers, auth);
+	const resource = `${getCloudflareAPIBaseURL()}/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}`;
+	const response = await fetch(resource, {
+		method: "GET",
+		headers,
+	});
+	if (response.ok) {
+		return await response.arrayBuffer();
+	} else {
+		throw new Error(
+			`Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
+		);
+	}
+}
+
+/**
+ * The implementation for fetching a R2 object from Cloudflare API.
+ * We have a special implementation to handle the non-standard API response
+ * that doesn't return JSON, likely due to the streaming nature.
+ *
+ * note: The implementation should be called from light wrappers for
+ * different methods (GET, PUT)
+ */
+type ResponseWithBody = Response & { body: NonNullable<Response["body"]> };
+export async function fetchR2Objects(
+	resource: string,
+	bodyInit: RequestInit = {}
+): Promise<ResponseWithBody> {
+	await requireLoggedIn();
+	const auth = requireApiToken();
+	const headers = cloneHeaders(bodyInit.headers);
+	addAuthorizationHeaderIfUnspecified(headers, auth);
+	addUserAgent(headers);
+
+	const response = await fetch(`${getCloudflareAPIBaseURL()}${resource}`, {
+		...bodyInit,
+		headers,
+	});
+
+	if (response.ok && response.body) {
+		return response as ResponseWithBody;
+	} else {
+		throw new Error(
+			`Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
+		);
+	}
+}
+
+/**
+ * This is a wrapper STOPGAP for getting the script which returns a raw text response.
+ */
+export async function fetchDashboardScript(
+	resource: string,
+	bodyInit: RequestInit = {}
 ): Promise<string> {
-  await requireLoggedIn();
-  const apiToken = requireApiToken();
-  const headers = { Authorization: `Bearer ${apiToken}` };
-  const resource = `${getCloudflareAPIBaseURL()}/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});`
-    );
-  }
+	await requireLoggedIn();
+	const auth = requireApiToken();
+	const headers = cloneHeaders(bodyInit.headers);
+	addAuthorizationHeaderIfUnspecified(headers, auth);
+	addUserAgent(headers);
+
+	const response = await fetch(`${getCloudflareAPIBaseURL()}${resource}`, {
+		...bodyInit,
+		headers,
+	});
+
+	if (!response.ok || !response.body) {
+		throw new Error(
+			`Failed to fetch ${resource} - ${response.status}: ${response.statusText});`
+		);
+	}
+
+	const usesModules = response.headers
+		.get("content-type")
+		?.startsWith("multipart");
+
+	if (usesModules) {
+		// Response from edge contains generic "name = worker.js" for dashboard created scripts
+		const form = await response.formData();
+		const entries = Array.from(form.entries());
+		if (entries.length > 1)
+			throw new RangeError("Expected only one entry in multipart response");
+		const [_, file] = entries[0];
+
+		if (file instanceof File) {
+			return await file.text();
+		}
+
+		return file ?? "";
+
+		// Follow up on issue in Undici about multipart/form-data support & replace the workaround: https://github.com/nodejs/undici/issues/974
+		// This should be using a builtin formData() parser pattern.
+	} else {
+		return response.text();
+	}
 }

package/src/cli.ts

@@ -1,19 +1,28 @@
 import process from "process";
 import { hideBin } from "yargs/helpers";
-import { reportError, initReporting } from "./reporting";
+import { unstable_dev } from "./api";
+import { FatalError } from "./errors";
 import { main } from ".";
 
-try {
-  initReporting();
-} catch (error) {}
+import type { UnstableDevWorker } from "./api";
+/**
+ * The main entrypoint for the CLI.
+ * main only gets called when the script is run directly, not when it's imported as a module.
+ */
+if (typeof jest === "undefined" && require.main === module) {
+	main(hideBin(process.argv)).catch((e) => {
+		// 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.
+		const exitCode = (e instanceof FatalError && e.code) || 1;
+		process.exit(exitCode);
+	});
+}
 
-process.on("uncaughtExceptionMonitor", async (err, origin) => {
-  await reportError(err, origin);
-});
-
-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);
-});
+/**
+ * This is how we're exporting the API.
+ * It makes it possible to import wrangler from 'wrangler',
+ * and call wrangler.unstable_dev().
+ */
+export { unstable_dev };
+export type { UnstableDevWorker };

package/src/config/README.md

@@ -48,7 +48,7 @@ This function will return:
 - a `Diagnostics` object, which contains any errors or warnings from the validation process
 
 The field values may have been parsed directly from the `RawConfig`, inherited into a named environment from the top-level environment, or given a default value.
-Generally, if there are any warnings they should be presented to the user via `console.warn()` messages,
+Generally, if there are any warnings they should be presented to the user via `logger.warn()` messages,
 and if there are any errors then an `Error` should be thrown describing these errors.
 
 The `Diagnostics` object is hierarchical: each `Diagnostics` instance can contain a collection of child `Diagnostics` instance.