wrangler 0.0.0-e88a54e → 0.0.0-e95e5a0

package/src/inspect.ts

@@ -5,6 +5,7 @@ import { URL } from "node:url";
 import { useEffect, useRef, useState } from "react";
 import WebSocket, { WebSocketServer } from "ws";
 import { version } from "../package.json";
+import { logger } from "./logger";
 import { waitForPortToBeAvailable } from "./proxy";
 import type Protocol from "devtools-protocol";
 import type { IncomingMessage, Server, ServerResponse } from "node:http";
@@ -42,7 +43,7 @@ interface InspectorProps {
   /**
    * The websocket URL exposed by Workers that the inspector should connect to.
    */
-  inspectorUrl: undefined | string;
+  inspectorUrl: string | undefined;
   /**
    * Whether console statements and exceptions should be logged to the terminal.
    * (We don't log them in local mode because they're already getting
@@ -134,7 +135,7 @@ export default function useInspector(props: InspectorProps) {
   wsServer.on("connection", (ws: WebSocket) => {
     if (wsServer.clients.size > 1) {
       /** We only want to have one active Devtools instance at a time. */
-      console.error(
+      logger.error(
         "Tried to open a new devtools window when a previous one was already open."
       );
       ws.close(1013, "Too many clients; only one can be connected at a time");
@@ -154,19 +155,26 @@ export default function useInspector(props: InspectorProps) {
    * of the component lifecycle. Convenient.
    */
   useEffect(() => {
+    const abortController = new AbortController();
     async function startInspectorProxy() {
       await waitForPortToBeAvailable(props.port, {
         retryPeriod: 200,
         timeout: 2000,
+        abortSignal: abortController.signal,
       });
       server.listen(props.port);
     }
-    startInspectorProxy().catch((err) => console.error(err));
+    startInspectorProxy().catch((err) => {
+      if ((err as { code: string }).code !== "ABORT_ERR") {
+        logger.error("Failed to start inspector:", err);
+      }
+    });
     return () => {
       server.close();
       // Also disconnect any open websockets/devtools connections
       wsServer.clients.forEach((ws) => ws.close());
       wsServer.close();
+      abortController.abort();
     };
   }, [props.port, server, wsServer]);
 
@@ -247,9 +255,7 @@ export default function useInspector(props: InspectorProps) {
           const evt = JSON.parse(event.data);
           if (evt.method === "Runtime.exceptionThrown") {
             const params = evt.params as Protocol.Runtime.ExceptionThrownEvent;
-            console.error(
-              "🚨", // cheesy, but it works
-              // maybe we could use color here too.
+            logger.error(
               params.exceptionDetails.text,
               params.exceptionDetails.exception?.description ?? ""
             );
@@ -261,7 +267,7 @@ export default function useInspector(props: InspectorProps) {
           }
         } else {
           // We should never get here, but who know is 2022...
-          console.error("unrecognised devtools event:", event);
+          logger.error("Unrecognised devtools event:", event);
         }
       });
     }
@@ -280,7 +286,7 @@ export default function useInspector(props: InspectorProps) {
     });
 
     ws.on("unexpected-response", () => {
-      console.log("waiting for connection...");
+      logger.log("Waiting for connection...");
       /**
        * This usually means the worker is not "ready" yet
        * so we'll just retry the connection process
@@ -386,7 +392,7 @@ export default function useInspector(props: InspectorProps) {
            * happens on the first request. Maybe we should buffer
            * these messages too?
            */
-          console.error(e);
+          logger.error(e);
         }
       }
     }
@@ -611,7 +617,7 @@ function logConsoleMessage(evt: Protocol.Runtime.ConsoleAPICalledEvent): void {
         break;
     }
   } else {
-    console.warn(`Unsupported console method: ${method}`);
-    console.log("console event:", evt);
+    logger.warn(`Unsupported console method: ${method}`);
+    logger.warn("console event:", evt);
   }
 }

package/src/intl-polyfill.d.ts

@@ -0,0 +1,139 @@
+/**
+ * TODO Remove once https://github.com/microsoft/TypeScript/pull/47254 lands
+ */
+declare namespace Intl {
+  interface DateTimeFormatOptions {
+    formatMatcher?: "basic" | "best fit" | "best fit" | undefined;
+    dateStyle?: "full" | "long" | "medium" | "short" | undefined;
+    timeStyle?: "full" | "long" | "medium" | "short" | undefined;
+    dayPeriod?: "narrow" | "short" | "long" | undefined;
+    fractionalSecondDigits?: 0 | 1 | 2 | 3 | undefined;
+  }
+
+  interface ResolvedDateTimeFormatOptions {
+    formatMatcher?: "basic" | "best fit" | "best fit";
+    dateStyle?: "full" | "long" | "medium" | "short";
+    timeStyle?: "full" | "long" | "medium" | "short";
+    hourCycle?: "h11" | "h12" | "h23" | "h24";
+    dayPeriod?: "narrow" | "short" | "long";
+    fractionalSecondDigits?: 0 | 1 | 2 | 3;
+  }
+
+  interface NumberFormat {
+    formatRange(startDate: number | bigint, endDate: number | bigint): string;
+    formatRangeToParts(
+      startDate: number | bigint,
+      endDate: number | bigint
+    ): NumberFormatPart[];
+  }
+
+  /**
+   * The locale matching algorithm to use.
+   *
+   * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation).
+   */
+  type ListFormatLocaleMatcher = "lookup" | "best fit";
+
+  /**
+   * The format of output message.
+   *
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters).
+   */
+  type ListFormatType = "conjunction" | "disjunction" | "unit";
+
+  /**
+   * The length of the formatted message.
+   *
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters).
+   */
+  type ListFormatStyle = "long" | "short" | "narrow";
+
+  /**
+   * An object with some or all properties of the `Intl.ListFormat` constructor `options` parameter.
+   *
+   * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters).
+   */
+  interface ListFormatOptions {
+    /** The locale matching algorithm to use. For information about this option, see [Intl page](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation). */
+    localeMatcher?: ListFormatLocaleMatcher;
+    /** The format of output message. */
+    type?: ListFormatType;
+    /** The length of the internationalized message. */
+    style?: ListFormatStyle;
+  }
+
+  interface ListFormat {
+    /**
+     * Returns a string with a language-specific representation of the list.
+     *
+     * @param list - An iterable object, such as an [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array).
+     *
+     * @throws `TypeError` if `list` includes something other than the possible values.
+     *
+     * @returns {string} A language-specific formatted string representing the elements of the list.
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/format).
+     */
+    format(list: Iterable<string>): string;
+
+    /**
+     * Returns an Array of objects representing the different components that can be used to format a list of values in a locale-aware fashion.
+     *
+     * @param list - An iterable object, such as an [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array), to be formatted according to a locale.
+     *
+     * @throws `TypeError` if `list` includes something other than the possible values.
+     *
+     * @returns {{ type: "element" | "literal", value: string; }[]} An Array of components which contains the formatted parts from the list.
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/formatToParts).
+     */
+    formatToParts(
+      list: Iterable<string>
+    ): { type: "element" | "literal"; value: string }[];
+  }
+
+  const ListFormat: {
+    prototype: ListFormat;
+
+    /**
+     * Creates [Intl.ListFormat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) objects that
+     * enable language-sensitive list formatting.
+     *
+     * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings.
+     *  For the general form and interpretation of the `locales` argument,
+     *  see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation).
+     *
+     * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat#parameters)
+     *  with some or all options of `ListFormatOptions`.
+     *
+     * @returns [Intl.ListFormatOptions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat) object.
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat).
+     */
+    new (
+      locales?: BCP47LanguageTag | BCP47LanguageTag[],
+      options?: ListFormatOptions
+    ): ListFormat;
+
+    /**
+     * Returns an array containing those of the provided locales that are
+     * supported in list formatting without having to fall back to the runtime's default locale.
+     *
+     * @param locales - A string with a [BCP 47 language tag](http://tools.ietf.org/html/rfc5646), or an array of such strings.
+     *  For the general form and interpretation of the `locales` argument,
+     *  see the [`Intl` page](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_identification_and_negotiation).
+     *
+     * @param options - An [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/supportedLocalesOf#parameters).
+     *  with some or all possible options.
+     *
+     * @returns An array of strings representing a subset of the given locale tags that are supported in list
+     *  formatting without having to fall back to the runtime's default locale.
+     *
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/supportedLocalesOf).
+     */
+    supportedLocalesOf(
+      locales: BCP47LanguageTag | BCP47LanguageTag[],
+      options?: Pick<ListFormatOptions, "localeMatcher">
+    ): BCP47LanguageTag[];
+  };
+}

package/src/logger.ts

@@ -0,0 +1,66 @@
+import { format } from "node:util";
+import { formatMessagesSync } from "esbuild";
+
+const LOGGER_LEVELS = {
+  error: 0,
+  warn: 1,
+  log: 2,
+  debug: 3,
+} as const;
+
+type LoggerLevel = keyof typeof LOGGER_LEVELS;
+
+/** A map from LOGGER_LEVEL to the error `kind` needed by `formatMessagesSync()`. */
+const LOGGER_LEVEL_FORMAT_TYPE_MAP = {
+  error: "error",
+  warn: "warning",
+  log: undefined,
+  debug: undefined,
+} as const;
+
+class Logger {
+  constructor(public loggerLevel: LoggerLevel = "log") {}
+
+  columns = process.stdout.columns;
+
+  debug = (...args: unknown[]) => this.doLog("debug", args);
+  log = (...args: unknown[]) => this.doLog("log", args);
+  warn = (...args: unknown[]) => this.doLog("warn", args);
+  error = (...args: unknown[]) => this.doLog("error", args);
+
+  private doLog(messageLevel: LoggerLevel, args: unknown[]) {
+    if (LOGGER_LEVELS[this.loggerLevel] >= LOGGER_LEVELS[messageLevel]) {
+      console[messageLevel](this.formatMessage(messageLevel, format(...args)));
+    }
+  }
+
+  private formatMessage(level: LoggerLevel, message: string): string {
+    const kind = LOGGER_LEVEL_FORMAT_TYPE_MAP[level];
+    if (kind) {
+      // Format the message using the esbuild formatter.
+      // The first line of the message is the main `text`,
+      // subsequent lines are put into the `notes`.
+      const [firstLine, ...otherLines] = message.split("\n");
+      const notes =
+        otherLines.length > 0
+          ? otherLines.map((text) => ({ text }))
+          : undefined;
+      return formatMessagesSync([{ text: firstLine, notes }], {
+        color: true,
+        kind,
+        terminalWidth: this.columns,
+      })[0];
+    } else {
+      return message;
+    }
+  }
+}
+
+/**
+ * A drop-in replacement for `console` for outputting logging messages.
+ *
+ * Errors and Warnings will get additional formatting to highlight them to the user.
+ * You can also set a `logger.loggerLevel` value to one of "debug", "log", "warn" or "error",
+ * to filter out logging messages.
+ */
+export const logger = new Logger();

package/src/miniflare-cli/index.ts

@@ -2,6 +2,7 @@ import { Log, LogLevel, Miniflare } from "miniflare";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { enumKeys } from "./enum-keys";
+import { getRequestContextCheckOptions } from "./request-context";
 
 async function main() {
   const args = await yargs(hideBin(process.argv))
@@ -12,8 +13,10 @@ async function main() {
     }).argv;
 
   const logLevel = LogLevel[args.log ?? "INFO"];
+  const requestContextCheckOptions = await getRequestContextCheckOptions();
   const config = {
     ...JSON.parse((args._[0] as string) ?? "{}"),
+    ...requestContextCheckOptions,
     log: new Log(logLevel),
   };
 
@@ -26,6 +29,7 @@ async function main() {
   try {
     // Start Miniflare development server
     await mf.startServer();
+    await mf.startScheduler();
   } catch (e) {
     mf.log.error(e as Error);
     process.exitCode = 1;

package/src/miniflare-cli/request-context.ts

@@ -0,0 +1,40 @@
+import type { MiniflareOptions } from "miniflare";
+
+/**
+ * Certain runtime APIs are only available to workers during the "request context",
+ * which is any code that returns after receiving a request and before returning
+ * a response.
+ *
+ * Miniflare emulates this behavior by using an [`AsyncLocalStorage`](https://nodejs.org/api/async_context.html#class-asynclocalstorage) and
+ * [checking at runtime](https://github.com/cloudflare/miniflare/blob/master/packages/shared/src/context.ts#L21-L36)
+ * to see if you're using those APIs during the request context.
+ *
+ * In certain environments `AsyncLocalStorage` is unavailable, such as in a
+ * [webcontainer](https://github.com/stackblitz/webcontainer-core).
+ * This function figures out if we're able to run those "request context" checks
+ * and returns [a set of options](https://miniflare.dev/core/standards#global-functionality-limits)
+ * that indicate to miniflare whether to run the checks or not.
+ */
+export const getRequestContextCheckOptions = async (): Promise<
+  Pick<MiniflareOptions, "globalAsyncIO" | "globalTimers" | "globalRandom">
+> => {
+  // check that there's an implementation of AsyncLocalStorage
+  let hasAsyncLocalStorage = true;
+  try {
+    // ripped from  the example here https://nodejs.org/api/async_context.html#class-asynclocalstorage
+    const { AsyncLocalStorage } = await import("node:async_hooks");
+    const storage = new AsyncLocalStorage<string>();
+
+    hasAsyncLocalStorage = storage.run("some-value", () => {
+      return storage.getStore() === "some-value";
+    });
+  } catch (e) {
+    hasAsyncLocalStorage = false;
+  }
+
+  return {
+    globalAsyncIO: hasAsyncLocalStorage,
+    globalRandom: hasAsyncLocalStorage,
+    globalTimers: hasAsyncLocalStorage,
+  };
+};

package/src/module-collection.ts

@@ -2,6 +2,7 @@ import crypto from "node:crypto";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import globToRegExp from "glob-to-regexp";
+import { logger } from "./logger";
 import type { Config, ConfigModuleRuleType } from "./config";
 import type { CfModule, CfModuleType, CfScriptFormat } from "./worker";
 import type esbuild from "esbuild";
@@ -58,7 +59,7 @@ export default function createModuleCollector(props: {
     if (rule.type in completedRuleLocations) {
       if (rules[completedRuleLocations[rule.type]].fallthrough !== false) {
         if (index < (props.rules || []).length) {
-          console.warn(
+          logger.warn(
             `The module rule at position ${index} (${JSON.stringify(
               rule
             )}) has the same type as a previous rule (at position ${
@@ -68,7 +69,7 @@ export default function createModuleCollector(props: {
             )}). This rule will be ignored. To the previous rule, add \`fallthrough = true\` to allow this one to also be used, or \`fallthrough = false\` to silence this warning.`
           );
         } else {
-          console.warn(
+          logger.warn(
             `The default module rule ${JSON.stringify(
               rule
             )} has the same type as a previous rule (at position ${
@@ -102,7 +103,7 @@ export default function createModuleCollector(props: {
           modules.splice(0);
         });
 
-        // ~ start  legacy module specifier support ~
+        // ~ start legacy module specifier support ~
 
         // This section detects usage of "legacy" 1.x style module specifiers
         // and modifies them so they "work" in wrangler v2, but with a warning
@@ -136,8 +137,8 @@ export default function createModuleCollector(props: {
                 return;
               }
               // In the future, this will simply throw an error
-              console.warn(
-                `Deprecation warning: detected a legacy module import in "./${path.relative(
+              logger.warn(
+                `Deprecation: detected a legacy module import in "./${path.relative(
                   process.cwd(),
                   args.importer
                 )}". This will stop working in the future. Replace references to "${
@@ -221,10 +222,9 @@ export default function createModuleCollector(props: {
                   return {
                     // We replace the the module with an identifier
                     // that we'll separately add to the form upload
-                    // as part of [wasm_modules]/[text_blobs]. This identifier has to be a valid
+                    // as part of [wasm_modules]/[text_blobs]/[data_blobs]. This identifier has to be a valid
                     // JS identifier, so we replace all non alphanumeric characters
                     // with an underscore.
-                    // TODO: what of "Data"?
                     contents: `export default ${args.path.replace(
                       /[^a-zA-Z0-9_$]/g,
                       "_"

package/src/open-in-browser.ts

@@ -1,13 +1,14 @@
 import open from "open";
+import { logger } from "./logger";
 
 /**
  * An extremely simple wrapper around the open command.
  * Specifically, it adds an 'error' event handler so that when this function
- * is called in environments where we can't open the browser (e.g. github codespaces,
- * stackblitz, remote servers), it doesn't just crash the process.
+ * is called in environments where we can't open the browser (e.g. GitHub Codespaces,
+ * StackBlitz, remote servers), it doesn't just crash the process.
  *
  * @param url the URL to point the browser at
- * @param options open a chromium-based browser instead of the default
+ * @param options open a Chromium-based browser instead of the default
  */
 export default async function openInBrowser(
   url: string,
@@ -20,6 +21,6 @@ export default async function openInBrowser(
     : undefined;
   const childProcess = await open(url, options);
   childProcess.on("error", () => {
-    console.warn(`Failed to open ${url} in a browser`);
+    logger.warn(`Failed to open ${url} in a browser.`);
   });
 }

package/src/package-manager.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { execa, execaCommandSync } from "execa";
+import { logger } from "./logger";
 
 export interface PackageManager {
   cwd: string;
@@ -16,26 +17,26 @@ export async function getPackageManager(cwd: string): Promise<PackageManager> {
 
   if (hasNpmLock) {
     if (hasNpm) {
-      console.log(
+      logger.log(
         "Using npm as package manager, as there is already a package-lock.json file."
       );
       return { ...NpmPackageManager, cwd };
     } else if (hasYarn) {
-      console.log("Using yarn as package manager.");
-      console.warn(
+      logger.log("Using yarn as package manager.");
+      logger.warn(
         "There is already a package-lock.json file but could not find npm on the PATH."
       );
       return { ...YarnPackageManager, cwd };
     }
   } else if (hasYarnLock) {
     if (hasYarn) {
-      console.log(
+      logger.log(
         "Using yarn as package manager, as there is already a yarn.lock file."
       );
       return { ...YarnPackageManager, cwd };
     } else if (hasNpm) {
-      console.log("Using npm as package manager.");
-      console.warn(
+      logger.log("Using npm as package manager.");
+      logger.warn(
         "There is already a yarn.lock file but could not find yarn on the PATH."
       );
       return { ...NpmPackageManager, cwd };
@@ -43,10 +44,10 @@ export async function getPackageManager(cwd: string): Promise<PackageManager> {
   }
 
   if (hasNpm) {
-    console.log("Using npm as package manager.");
+    logger.log("Using npm as package manager.");
     return { ...NpmPackageManager, cwd };
   } else if (hasYarn) {
-    console.log("Using yarn as package manager.");
+    logger.log("Using yarn as package manager.");
     return { ...YarnPackageManager, cwd };
   } else {
     throw new Error(