wrangler 0.0.0-e2a26a0 → 0.0.0-e3a458e

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 { waitForPortToBeAvailable } from "./proxy";
 import type Protocol from "devtools-protocol";
 import type { IncomingMessage, Server, ServerResponse } from "node:http";
 import type { MessageEvent } from "ws";
@@ -153,7 +154,14 @@ export default function useInspector(props: InspectorProps) {
    * of the component lifecycle. Convenient.
    */
   useEffect(() => {
-    server.listen(props.port);
+    async function startInspectorProxy() {
+      await waitForPortToBeAvailable(props.port, {
+        retryPeriod: 200,
+        timeout: 2000,
+      });
+      server.listen(props.port);
+    }
+    startInspectorProxy().catch((err) => console.error(err));
     return () => {
       server.close();
       // Also disconnect any open websockets/devtools connections
@@ -367,7 +375,10 @@ export default function useInspector(props: InspectorProps) {
         );
         remoteWebSocket.send(event.data);
       } catch (e) {
-        if (e.message !== "WebSocket is not open: readyState 0 (CONNECTING)") {
+        if (
+          (e as Error).message !==
+          "WebSocket is not open: readyState 0 (CONNECTING)"
+        ) {
           /**
            * ^ this just means we haven't opened a websocket yet
            * usually happens until there's at least one request
@@ -587,8 +598,18 @@ function logConsoleMessage(evt: Protocol.Runtime.ConsoleAPICalledEvent): void {
   const method = mapConsoleAPIMessageTypeToConsoleMethod[evt.type];
 
   if (method in console) {
-    // eslint-disable-next-line prefer-spread
-    console[method].apply(console, args);
+    switch (method) {
+      case "dir":
+        console.dir(args);
+        break;
+      case "table":
+        console.table(args);
+        break;
+      default:
+        // eslint-disable-next-line prefer-spread
+        console[method].apply(console, args);
+        break;
+    }
   } else {
     console.warn(`Unsupported console method: ${method}`);
     console.log("console event:", evt);

package/src/{kv.tsx → kv.ts}

@@ -1,13 +1,18 @@
 import { URLSearchParams } from "node:url";
 import { fetchListResult, fetchResult, fetchKVGetValue } from "./cfetch";
-import type { Config } from "./config";
+import type { Config, Environment } from "./config";
+
+/** The largest number of kv items we can pass to the API in a single request. */
+const API_MAX = 10000;
+// The const below are halved from the API's true capacity to help avoid
+// hammering it with large requests.
+const BATCH_KEY_MAX = API_MAX / 2;
 
 type KvArgs = {
   binding?: string;
   "namespace-id"?: string;
   env?: string;
   preview?: boolean;
-  config?: Config;
 };
 
 /**
@@ -91,26 +96,64 @@ export async function listNamespaceKeys(
   );
 }
 
+/**
+ * Information about a key-value pair, including its "metadata" fields.
+ */
+export interface KeyValue {
+  key: string;
+  value: string;
+  expiration?: number;
+  expiration_ttl?: number;
+  metadata?: object;
+  base64?: boolean;
+}
+
+const KeyValueKeys = new Set([
+  "key",
+  "value",
+  "expiration",
+  "expiration_ttl",
+  "metadata",
+  "base64",
+]);
+
+/**
+ * Is the given object a valid `KeyValue` type?
+ */
+export function isKeyValue(keyValue: object): keyValue is KeyValue {
+  const props = Object.keys(keyValue);
+  if (!props.includes("key") || !props.includes("value")) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Get all the properties on the `keyValue` that are not expected.
+ */
+export function unexpectedKeyValueProps(keyValue: KeyValue): string[] {
+  const props = Object.keys(keyValue);
+  return props.filter((prop) => !KeyValueKeys.has(prop));
+}
+
 export async function putKeyValue(
   accountId: string,
   namespaceId: string,
-  key: string,
-  value: string,
-  args?: { expiration?: number; expiration_ttl?: number }
+  keyValue: KeyValue
 ) {
   let searchParams: URLSearchParams | undefined;
-  if (args) {
+  if (keyValue.expiration || keyValue.expiration_ttl) {
     searchParams = new URLSearchParams();
-    if (args.expiration) {
-      searchParams.set("expiration", `${args.expiration}`);
+    if (keyValue.expiration) {
+      searchParams.set("expiration", `${keyValue.expiration}`);
     }
-    if (args.expiration_ttl) {
-      searchParams.set("expiration_ttl", `${args.expiration_ttl}`);
+    if (keyValue.expiration_ttl) {
+      searchParams.set("expiration_ttl", `${keyValue.expiration_ttl}`);
     }
   }
   return await fetchResult(
-    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}`,
-    { method: "PUT", body: value },
+    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${keyValue.key}`,
+    { method: "PUT", body: keyValue.value },
     searchParams
   );
 }
@@ -126,40 +169,57 @@ export async function getKeyValue(
 export async function putBulkKeyValue(
   accountId: string,
   namespaceId: string,
-  keyvalueStr: string
+  keyValues: KeyValue[],
+  progressCallback: (index: number, total: number) => void
 ) {
-  return await fetchResult(
-    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
-    {
-      method: "PUT",
-      body: keyvalueStr,
-      headers: { "Content-Type": "application/json" },
+  for (let index = 0; index < keyValues.length; index += BATCH_KEY_MAX) {
+    if (progressCallback && keyValues.length > BATCH_KEY_MAX) {
+      progressCallback(index, keyValues.length);
     }
-  );
+
+    await fetchResult(
+      `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
+      {
+        method: "PUT",
+        body: JSON.stringify(keyValues.slice(index, index + BATCH_KEY_MAX)),
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+  if (progressCallback && keyValues.length > BATCH_KEY_MAX) {
+    progressCallback(keyValues.length, keyValues.length);
+  }
 }
 
 export async function deleteBulkKeyValue(
   accountId: string,
   namespaceId: string,
-  keyStr: string
+  keys: string[],
+  progressCallback: (index: number, total: number) => void
 ) {
-  return await fetchResult(
-    `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
-    {
-      method: "DELETE",
-      body: keyStr,
-      headers: { "Content-Type": "application/json" },
+  for (let index = 0; index < keys.length; index += BATCH_KEY_MAX) {
+    if (progressCallback && keys.length > BATCH_KEY_MAX) {
+      progressCallback(index, keys.length);
     }
-  );
+
+    await fetchResult(
+      `/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/bulk`,
+      {
+        method: "DELETE",
+        body: JSON.stringify(keys.slice(index, index + BATCH_KEY_MAX)),
+        headers: { "Content-Type": "application/json" },
+      }
+    );
+  }
+  if (progressCallback && keys.length > BATCH_KEY_MAX) {
+    progressCallback(keys.length, keys.length);
+  }
 }
 
-export function getNamespaceId({
-  preview,
-  binding,
-  config,
-  "namespace-id": namespaceId,
-  env,
-}: KvArgs): string {
+export function getNamespaceId(
+  { preview, binding, "namespace-id": namespaceId, env }: KvArgs,
+  configOrEnv: Config | Environment | undefined
+): string {
   // nice
   if (namespaceId) {
     return namespaceId;
@@ -167,13 +227,13 @@ export function getNamespaceId({
 
   // begin pre-flight checks
 
-  // `--binding` is only valid if there's a wrangler configuration file.
-  if (binding && !config) {
+  // `--binding` is only valid if there's a wrangler configuration.
+  if (binding && !configOrEnv) {
     throw new Error("--binding specified, but no config file was found.");
   }
 
   // there's no config. abort here
-  if (!config) {
+  if (!configOrEnv) {
     throw new Error(
       "Failed to find a config file.\n" +
         "Either use --namespace-id to upload directly or create a configuration file with a binding."
@@ -182,36 +242,31 @@ export function getNamespaceId({
 
   // they want to use an environment, actually
   if (env) {
-    if (!config.env || !config.env[env]) {
+    if (!("env" in configOrEnv) || !configOrEnv.env[env]) {
       throw new Error(
         `Failed to find environment "${env}" in configuration file!`
       );
     }
-
-    // TODO: either a bespoke arg type for this function to avoid `undefined`s or an `EnvOrConfig` type
-    return getNamespaceId({
-      binding,
-      "namespace-id": namespaceId,
-      env: undefined,
-      preview,
-      config: {
-        env: undefined,
-        build: undefined,
-        name: undefined,
-        account_id: undefined,
-        ...config.env[env],
+    return getNamespaceId(
+      {
+        binding,
+        "namespace-id": namespaceId,
+        preview,
       },
-    });
+      configOrEnv.env[env]
+    );
   }
 
   // there's no KV namespaces
-  if (!config.kv_namespaces || config.kv_namespaces.length === 0) {
+  if (!configOrEnv.kv_namespaces || configOrEnv.kv_namespaces.length === 0) {
     throw new Error(
       "No KV Namespaces configured! Either use --namespace-id to upload directly or add a KV namespace to your wrangler config file."
     );
   }
 
-  const namespace = config.kv_namespaces.find((ns) => ns.binding === binding);
+  const namespace = configOrEnv.kv_namespaces.find(
+    (ns) => ns.binding === binding
+  );
 
   // we couldn't find a namespace with that binding
   if (!namespace) {

package/src/module-collection.ts

@@ -1,21 +1,96 @@
 import crypto from "node:crypto";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import type { CfModule } from "./api/worker";
+import globToRegExp from "glob-to-regexp";
+import type { Config, ConfigModuleRuleType } from "./config";
+import type { CfModule, CfModuleType, CfScriptFormat } from "./worker";
 import type esbuild from "esbuild";
 
+const RuleTypeToModuleType: Record<ConfigModuleRuleType, CfModuleType> = {
+  ESModule: "esm",
+  CommonJS: "commonjs",
+  CompiledWasm: "compiled-wasm",
+  Data: "buffer",
+  Text: "text",
+};
+
 // This is a combination of an esbuild plugin and a mutable array
 // that we use to collect module references from source code.
 // There will be modules that _shouldn't_ be inlined directly into
 // the bundle. (eg. wasm modules, some text files, etc). We can include
-// those files as modules in the multi part forker form upload. This
+// those files as modules in the multi part worker form upload. This
 // plugin+array is used to collect references to these modules, reference
 // them correctly in the bundle, and add them to the form upload.
 
-export default function makeModuleCollector(): {
+export const DEFAULT_MODULE_RULES: Config["rules"] = [
+  { type: "Text", globs: ["**/*.txt", "**/*.html"] },
+  { type: "Data", globs: ["**/*.bin"] },
+  { type: "CompiledWasm", globs: ["**/*.wasm"] },
+];
+
+export default function createModuleCollector(props: {
+  format: CfScriptFormat;
+  rules?: Config["rules"];
+  // a collection of "legacy" style module references, which are just file names
+  // we will eventually deprecate this functionality, hence the verbose greppable name
+  wrangler1xlegacyModuleReferences: {
+    rootDirectory: string;
+    fileNames: Set<string>;
+  };
+}): {
   modules: CfModule[];
   plugin: esbuild.Plugin;
 } {
+  const rules: Config["rules"] = [
+    ...(props.rules || []),
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    ...DEFAULT_MODULE_RULES!,
+  ];
+
+  // First, we want to add some validations to the module rules
+  // We want to warn if rules are accidentally configured in such a way that
+  // subsequent rules will never match because `fallthrough` hasn't been set
+
+  const completedRuleLocations: Record<string, number> = {};
+  let index = 0;
+  const rulesToRemove: Config["rules"] = [];
+  for (const rule of rules) {
+    if (rule.type in completedRuleLocations) {
+      if (rules[completedRuleLocations[rule.type]].fallthrough !== false) {
+        if (index < (props.rules || []).length) {
+          console.warn(
+            `The module rule at position ${index} (${JSON.stringify(
+              rule
+            )}) has the same type as a previous rule (at position ${
+              completedRuleLocations[rule.type]
+            }, ${JSON.stringify(
+              rules[completedRuleLocations[rule.type]]
+            )}). 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(
+            `The default module rule ${JSON.stringify(
+              rule
+            )} has the same type as a previous rule (at position ${
+              completedRuleLocations[rule.type]
+            }, ${JSON.stringify(
+              rules[completedRuleLocations[rule.type]]
+            )}). This rule will be ignored. To the previous rule, add \`fallthrough = true\` to allow the default one to also be used, or \`fallthrough = false\` to silence this warning.`
+          );
+        }
+      }
+
+      rulesToRemove.push(rule);
+    }
+    if (!(rule.type in completedRuleLocations) && rule.fallthrough !== true) {
+      completedRuleLocations[rule.type] = index;
+    }
+    index++;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  rulesToRemove.forEach((rule) => rules!.splice(rules!.indexOf(rule), 1));
+
   const modules: CfModule[] = [];
   return {
     modules,
@@ -23,40 +98,155 @@ export default function makeModuleCollector(): {
       name: "wrangler-module-collector",
       setup(build) {
         build.onStart(() => {
-          // reset the moduels collection
+          // reset the module collection array
           modules.splice(0);
         });
 
+        // ~ 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
+
+        const rulesMatchers = rules.flatMap((rule) => {
+          return rule.globs.map((glob) => {
+            const regex = globToRegExp(glob);
+            return {
+              regex,
+              rule,
+            };
+          });
+        });
+
         build.onResolve(
-          // filter on "known" file types,
-          // we can expand this list later
-          { filter: /.*\.(wasm)$/ },
+          {
+            filter: new RegExp(
+              [...props.wrangler1xlegacyModuleReferences.fileNames]
+                .map((fileName) => `^${fileName}$`)
+                .join("|")
+            ),
+          },
           async (args: esbuild.OnResolveArgs) => {
+            if (
+              args.kind !== "import-statement" &&
+              args.kind !== "require-call"
+            ) {
+              return;
+            }
+            // In the future, this will simply throw an error
+            console.warn(
+              `Deprecation warning: detected a legacy module import in "./${path.relative(
+                process.cwd(),
+                args.importer
+              )}". This will stop working in the future. Replace references to "${
+                args.path
+              }" with "./${args.path}";`
+            );
+
             // take the file and massage it to a
             // transportable/manageable format
-            const filePath = path.join(args.resolveDir, args.path);
+            const filePath = path.join(
+              props.wrangler1xlegacyModuleReferences.rootDirectory,
+              args.path
+            );
             const fileContent = await readFile(filePath);
             const fileHash = crypto
               .createHash("sha1")
               .update(fileContent)
               .digest("hex");
-            const fileName = `${fileHash}-${path.basename(args.path)}`;
-
-            // add the module to the array
-            modules.push({
-              name: fileName,
-              content: fileContent,
-              type: "compiled-wasm",
-            });
+            const fileName = `./${fileHash}-${path.basename(args.path)}`;
 
-            return {
-              path: fileName, // change the reference to the changed module
-              external: true, // mark it as external in the bundle
-              namespace: "wrangler-module-collector-ns", // just a tag, this isn't strictly necessary
-              watchFiles: [filePath], // we also add the file to esbuild's watch list
-            };
+            const { rule } =
+              rulesMatchers.find(({ regex }) => regex.test(fileName)) || {};
+            if (rule) {
+              // add the module to the array
+              modules.push({
+                name: fileName,
+                content: fileContent,
+                type: RuleTypeToModuleType[rule.type],
+              });
+              return {
+                path: fileName, // change the reference to the changed module
+                external: props.format === "modules", // mark it as external in the bundle
+                namespace: `wrangler-module-${rule.type}`, // just a tag, this isn't strictly necessary
+                watchFiles: [filePath], // we also add the file to esbuild's watch list
+              };
+            }
           }
         );
+        // ~ end legacy module specifier support ~
+
+        rules?.forEach((rule) => {
+          if (rule.type === "ESModule" || rule.type === "CommonJS") return; // TODO: we should treat these as js files, and use the jsx loader
+
+          rule.globs.forEach((glob) => {
+            build.onResolve(
+              { filter: globToRegExp(glob) },
+              async (args: esbuild.OnResolveArgs) => {
+                // take the file and massage it to a
+                // transportable/manageable format
+
+                const filePath = path.join(args.resolveDir, args.path);
+                const fileContent = await readFile(filePath);
+                const fileHash = crypto
+                  .createHash("sha1")
+                  .update(fileContent)
+                  .digest("hex");
+                const fileName = `./${fileHash}-${path.basename(args.path)}`;
+
+                // add the module to the array
+                modules.push({
+                  name: fileName,
+                  content: fileContent,
+                  type: RuleTypeToModuleType[rule.type],
+                });
+
+                return {
+                  path: fileName, // change the reference to the changed module
+                  external: props.format === "modules", // mark it as external in the bundle
+                  namespace: `wrangler-module-${rule.type}`, // just a tag, this isn't strictly necessary
+                  watchFiles: [filePath], // we also add the file to esbuild's watch list
+                };
+              }
+            );
+
+            if (props.format === "service-worker") {
+              build.onLoad(
+                { filter: globToRegExp(glob) },
+                async (args: esbuild.OnLoadArgs) => {
+                  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
+                    // 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,
+                      "_"
+                    )};`,
+                  };
+                }
+              );
+            }
+          });
+        });
+
+        rulesToRemove.forEach((rule) => {
+          rule.globs.forEach((glob) => {
+            build.onResolve(
+              { filter: globToRegExp(glob) },
+              async (args: esbuild.OnResolveArgs) => {
+                throw new Error(
+                  `The file ${
+                    args.path
+                  } matched a module rule in your configuration (${JSON.stringify(
+                    rule
+                  )}), but was ignored because a previous rule with the same type was not marked as \`fallthrough = true\`.`
+                );
+              }
+            );
+          });
+        });
       },
     },
   };

package/src/open-in-browser.ts

@@ -0,0 +1,25 @@
+import open from "open";
+
+/**
+ * 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.
+ *
+ * @param url the URL to point the browser at
+ * @param options open a chromium-based browser instead of the default
+ */
+export default async function openInBrowser(
+  url: string,
+  { forceChromium }: { forceChromium: boolean } = { forceChromium: false }
+): Promise<void> {
+  const options: open.Options | undefined = forceChromium
+    ? {
+        app: [{ name: open.apps.chrome }, { name: open.apps.edge }],
+      }
+    : undefined;
+  const childProcess = await open(url, options);
+  childProcess.on("error", () => {
+    console.warn(`Failed to open ${url} in a browser`);
+  });
+}