wrangler 0.0.0-e3cab74 → 0.0.0-e452a35

package/src/dialogs.tsx

@@ -1,24 +1,28 @@
+import chalk from "chalk";
 import { Box, Text, useInput, render } from "ink";
 import TextInput from "ink-text-input";
 import * as React from "react";
 import { useState } from "react";
+import { logger } from "./logger";
 type ConfirmProps = {
   text: string;
   onConfirm: (answer: boolean) => void;
 };
 function Confirm(props: ConfirmProps) {
-  useInput((input: string) => {
-    if (input === "y") {
+  useInput((input: string, key) => {
+    if (input === "y" || key.return === true) {
       props.onConfirm(true);
     } else if (input === "n") {
       props.onConfirm(false);
     } else {
-      console.log("Unrecognised input");
+      logger.warn("Unrecognised input:", input);
     }
   });
   return (
     <Box>
-      <Text>{props.text} (y/n) </Text>
+      <Text>
+        {props.text} ({chalk.bold("y")}/n)
+      </Text>
     </Box>
   );
 }
@@ -39,12 +43,13 @@ export function confirm(text: string): Promise<boolean> {
 
 type PromptProps = {
   text: string;
+  defaultValue?: string;
   type?: "text" | "password";
   onSubmit: (text: string) => void;
 };
 
 function Prompt(props: PromptProps) {
-  const [value, setValue] = useState("");
+  const [value, setValue] = useState(props.defaultValue || "");
 
   return (
     <Box>
@@ -61,11 +66,16 @@ function Prompt(props: PromptProps) {
   );
 }
 
-export async function prompt(text: string, type: "text" | "password" = "text") {
+export async function prompt(
+  text: string,
+  type: "text" | "password" = "text",
+  defaultValue?: string
+): Promise<string> {
   return new Promise((resolve) => {
     const { unmount } = render(
       <Prompt
         text={text}
+        defaultValue={defaultValue}
         type={type}
         onSubmit={(inputText) => {
           unmount();

package/src/durable.ts

@@ -0,0 +1,102 @@
+import assert from "node:assert";
+import { fetchResult } from "./cfetch";
+import { logger } from "./logger";
+import type { Config } from "./config";
+import type { CfWorkerInit } from "./worker";
+
+/**
+ * For a given Worker + migrations config, figure out which migrations
+ * to upload based on the current migration tag of the deployed Worker.
+ */
+export async function getMigrationsToUpload(
+  scriptName: string,
+  props: {
+    accountId: string | undefined;
+    config: Config;
+    legacyEnv: boolean | undefined;
+    env: string | undefined;
+  }
+): Promise<CfWorkerInit["migrations"]> {
+  const { config, accountId } = props;
+
+  assert(accountId, "Missing accountId");
+  // if config.migrations
+  let migrations;
+  if (config.migrations.length > 0) {
+    // get current migration tag
+    type ScriptData = { id: string; migration_tag?: string };
+    let script: ScriptData | undefined;
+    if (!props.legacyEnv) {
+      try {
+        if (props.env) {
+          const scriptData = await fetchResult<{
+            script: ScriptData;
+          }>(
+            `/accounts/${accountId}/workers/services/${scriptName}/environments/${props.env}`
+          );
+          script = scriptData.script;
+        } else {
+          const scriptData = await fetchResult<{
+            default_environment: {
+              script: ScriptData;
+            };
+          }>(`/accounts/${accountId}/workers/services/${scriptName}`);
+          script = scriptData.default_environment.script;
+        }
+      } catch (err) {
+        if (
+          ![
+            10090, // corresponds to workers.api.error.service_not_found, so the script wasn't previously published at all
+            10092, // workers.api.error.environment_not_found, so the script wasn't published to this environment yet
+          ].includes((err as { code: number }).code)
+        ) {
+          throw err;
+        }
+        // else it's a 404, no script found, and we can proceed
+      }
+    } else {
+      const scripts = await fetchResult<ScriptData[]>(
+        `/accounts/${accountId}/workers/scripts`
+      );
+      script = scripts.find(({ id }) => id === scriptName);
+    }
+
+    if (script?.migration_tag) {
+      // was already published once
+      const scriptMigrationTag = script.migration_tag;
+      const foundIndex = config.migrations.findIndex(
+        (migration) => migration.tag === scriptMigrationTag
+      );
+      if (foundIndex === -1) {
+        logger.warn(
+          `The published script ${scriptName} has a migration tag "${script.migration_tag}, which was not found in wrangler.toml. You may have already deleted it. Applying all available migrations to the script...`
+        );
+        migrations = {
+          old_tag: script.migration_tag,
+          new_tag: config.migrations[config.migrations.length - 1].tag,
+          steps: config.migrations.map(({ tag: _tag, ...rest }) => rest),
+        };
+      } else {
+        if (foundIndex !== config.migrations.length - 1) {
+          // there are new migrations to send up
+          migrations = {
+            old_tag: script.migration_tag,
+            new_tag: config.migrations[config.migrations.length - 1].tag,
+            steps: config.migrations
+              .slice(foundIndex + 1)
+              .map(({ tag: _tag, ...rest }) => rest),
+          };
+        }
+        // else, we're up to date, no migrations to send
+      }
+    } else {
+      // first time publishing durable objects to this script,
+      // so we send all the migrations
+      migrations = {
+        new_tag: config.migrations[config.migrations.length - 1].tag,
+        steps: config.migrations.map(({ tag: _tag, ...rest }) => rest),
+      };
+    }
+  }
+  return migrations;
+}

package/src/entry.ts

@@ -1,44 +1,217 @@
-import { existsSync } from "node:fs";
+import assert from "node:assert";
+import { existsSync, statSync } from "node:fs";
 import path from "node:path";
+import * as esbuild from "esbuild";
+import { execaCommand } from "execa";
+import { logger } from "./logger";
 import type { Config } from "./config";
+import type { CfScriptFormat } from "./worker";
+import type { Metafile } from "esbuild";
 
 /**
  * An entry point for the Worker.
  *
  * It consists not just of a `file`, but also of a `directory` that is used to resolve relative paths.
  */
-export type Entry = { file: string; directory: string };
+export type Entry = { file: string; directory: string; format: CfScriptFormat };
 
 /**
  * Compute the entry-point for the Worker.
  */
-export function getEntry(
+export async function getEntry(
+  args: { script?: string; format?: CfScriptFormat | undefined },
   config: Config,
-  command: string,
-  script?: string
-): Entry {
+  command: "dev" | "publish"
+): Promise<Entry> {
   let file: string;
   let directory = process.cwd();
-  if (script) {
+  if (args.script) {
     // If the script name comes from the command line it is relative to the current working directory.
-    file = path.resolve(script);
+    file = path.resolve(args.script);
   } else if (config.main === undefined) {
-    throw new Error(
-      `Missing entry-point: The entry-point should be specified via the command line (e.g. \`wrangler ${command} path/to/script\`) or the \`main\` config field.`
-    );
+    if (config.site?.["entry-point"]) {
+      directory = path.resolve(path.dirname(config.configPath ?? "."));
+      file = path.extname(config.site?.["entry-point"])
+        ? path.resolve(config.site?.["entry-point"])
+        : // site.entry-point could be a directory
+          path.resolve(config.site?.["entry-point"], "index.js");
+    } else {
+      throw new Error(
+        `Missing entry-point: The entry-point should be specified via the command line (e.g. \`wrangler ${command} path/to/script\`) or the \`main\` config field.`
+      );
+    }
   } else {
     directory = path.resolve(path.dirname(config.configPath ?? "."));
     file = path.resolve(directory, config.main);
   }
 
-  if (!config.build?.command && fileExists(file) === false) {
+  const relativeFile = path.relative(directory, file) || ".";
+  await runCustomBuild(file, relativeFile, config.build);
+
+  if (fileExists(file) === false) {
+    throw new Error(
+      getMissingEntryPointMessage(
+        `The entry-point file at "${relativeFile}" was not found.`,
+        file,
+        relativeFile
+      )
+    );
+  }
+  const format = await guessWorkerFormat(
+    file,
+    directory,
+    args.format ?? config.build?.upload?.format,
+    config.tsconfig
+  );
+
+  const { localBindings, remoteBindings } =
+    partitionDurableObjectBindings(config);
+
+  if (command === "dev" && remoteBindings.length > 0) {
+    logger.warn(
+      "WARNING: You have Durable Object bindings that are not defined locally in the worker being developed.\n" +
+        "Be aware that changes to the data stored in these Durable Objects will be permanent and affect the live instances.\n" +
+        "Remote Durable Objects that are affected:\n" +
+        remoteBindings.map((b) => `- ${JSON.stringify(b)}`).join("\n")
+    );
+  }
+
+  if (format === "service-worker" && localBindings.length > 0) {
+    const errorMessage =
+      "You seem to be trying to use Durable Objects in a Worker written as a service-worker.";
+    const addScriptName =
+      "You can use Durable Objects defined in other Workers by specifying a `script_name` in your wrangler.toml, where `script_name` is the name of the Worker that implements that Durable Object. For example:";
+    const addScriptNameExamples = generateAddScriptNameExamples(localBindings);
+    const migrateText =
+      "Alternatively, migrate your worker to ES Module syntax to implement a Durable Object in this Worker:";
+    const migrateUrl =
+      "https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/";
     throw new Error(
-      `Could not resolve "${path.relative(process.cwd(), file)}".`
+      `${errorMessage}\n${addScriptName}\n${addScriptNameExamples}\n${migrateText}\n${migrateUrl}`
     );
   }
-  return { file, directory };
+
+  return { file, directory, format };
+}
+
+export async function runCustomBuild(
+  expectedEntryAbsolute: string,
+  expectedEntryRelative: string,
+  build: Config["build"]
+) {
+  if (build?.command) {
+    // TODO: add a deprecation message here?
+    logger.log("Running custom build:", build.command);
+    await execaCommand(build.command, {
+      shell: true,
+      // we keep these two as "inherit" so that
+      // logs are still visible.
+      stdout: "inherit",
+      stderr: "inherit",
+      ...(build.cwd && { cwd: build.cwd }),
+    });
+
+    if (fileExists(expectedEntryAbsolute) === false) {
+      throw new Error(
+        getMissingEntryPointMessage(
+          `The expected output file at "${expectedEntryRelative}" was not found after running custom build: ${build.command}.\n` +
+            "The `main` property in wrangler.toml should point to the file generated by the custom build.",
+          expectedEntryAbsolute,
+          expectedEntryRelative
+        )
+      );
+    }
+  }
+}
+
+/**
+ * A function to "guess" the type of worker.
+ * We do this by running a lightweight build of the actual script,
+ * and looking at the metafile generated by esbuild. If it has a default
+ * export (or really, any exports), that means it's a "modules" worker.
+ * Else, it's a "service-worker" worker. This seems hacky, but works remarkably
+ * well in practice.
+ */
+export default async function guessWorkerFormat(
+  entryFile: string,
+  entryWorkingDirectory: string,
+  hint: CfScriptFormat | undefined,
+  tsconfig?: string | undefined
+): Promise<CfScriptFormat> {
+  const result = await esbuild.build({
+    entryPoints: [entryFile],
+    absWorkingDir: entryWorkingDirectory,
+    metafile: true,
+    bundle: false,
+    format: "esm",
+    target: "es2020",
+    write: false,
+    loader: {
+      ".js": "jsx",
+      ".mjs": "jsx",
+      ".cjs": "jsx",
+    },
+    ...(tsconfig && { tsconfig }),
+  });
+  // result.metafile is defined because of the `metafile: true` option above.
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const metafile = result.metafile!;
+  const entryPoints = Object.entries(metafile.outputs).filter(
+    ([_path, output]) => output.entryPoint !== undefined
+  );
+  assert(
+    entryPoints.length > 0,
+    `Cannot find entry-point "${entryFile}" in generated bundle.` +
+      listEntryPoints(entryPoints)
+  );
+  assert(
+    entryPoints.length < 2,
+    "More than one entry-point found for generated bundle." +
+      listEntryPoints(entryPoints)
+  );
+
+  let guessedWorkerFormat: CfScriptFormat;
+  const scriptExports = entryPoints[0][1].exports;
+  if (scriptExports.length > 0) {
+    if (scriptExports.includes("default")) {
+      guessedWorkerFormat = "modules";
+    } else {
+      logger.warn(
+        `The entrypoint ${path.relative(
+          process.cwd(),
+          entryFile
+        )} has exports like an ES Module, but hasn't defined a default export like a module worker normally would. Building the worker using "service-worker" format...`
+      );
+      guessedWorkerFormat = "service-worker";
+    }
+  } else {
+    guessedWorkerFormat = "service-worker";
+  }
+
+  if (hint) {
+    if (hint !== guessedWorkerFormat) {
+      if (hint === "service-worker") {
+        throw new Error(
+          "You configured this worker to be a 'service-worker', but the file you are trying to build appears to have a `default` export like a module worker. Please pass `--format modules`, or simply remove the configuration."
+        );
+      } else {
+        throw new Error(
+          "You configured this worker to be 'modules', but the file you are trying to build doesn't export a handler. Please pass `--format service-worker`, or simply remove the configuration."
+        );
+      }
+    }
+  }
+  return guessedWorkerFormat;
+}
+
+function listEntryPoints(
+  outputs: [string, ValueOf<Metafile["outputs"]>][]
+): string {
+  return outputs.map(([_input, output]) => output.entryPoint).join("\n");
 }
 
+type ValueOf<T> = T[keyof T];
+
 /**
  * Returns true if the given `filePath` exists as-is,
  * or if some version of it (by appending a common extension) exists.
@@ -55,3 +228,95 @@ export function fileExists(filePath: string): boolean {
   }
   return false;
 }
+
+type DurableObjectBindings = Config["durable_objects"]["bindings"];
+
+/**
+ * Groups the durable object bindings into two lists:
+ * those that are defined locally and those that refer to a durable object defined in another script.
+ */
+function partitionDurableObjectBindings(config: Config): {
+  localBindings: DurableObjectBindings;
+  remoteBindings: DurableObjectBindings;
+} {
+  const localBindings: DurableObjectBindings = [];
+  const remoteBindings: DurableObjectBindings = [];
+  for (const binding of config.durable_objects.bindings) {
+    if (binding.script_name === undefined) {
+      localBindings.push(binding);
+    } else {
+      remoteBindings.push(binding);
+    }
+  }
+  return { localBindings, remoteBindings };
+}
+
+/**
+ * Generates some help text based on the Durable Object bindings in a given
+ * config indicating how the user can add a `script_name` field to bind an
+ * externally defined Durable Object.
+ */
+function generateAddScriptNameExamples(
+  localBindings: DurableObjectBindings
+): string {
+  function exampleScriptName(binding_name: string): string {
+    return `${binding_name.toLowerCase().replaceAll("_", "-")}-worker`;
+  }
+
+  return localBindings
+    .map(({ name, class_name }) => {
+      const script_name = exampleScriptName(name);
+      const currentBinding = `{ name = ${name}, class_name = ${class_name} }`;
+      const fixedBinding = `{ name = ${name}, class_name = ${class_name}, script_name = ${script_name} }`;
+
+      return `${currentBinding} ==> ${fixedBinding}`;
+    })
+    .join("\n");
+}
+
+/**
+ * Generate an appropriate message for when the entry-point is missing.
+ *
+ * To be more helpful to developers, we check whether there is a suitable file
+ * nearby to the expected file path.
+ */
+function getMissingEntryPointMessage(
+  message: string,
+  absoluteEntryPointPath: string,
+  relativeEntryPointPath: string
+): string {
+  if (
+    existsSync(absoluteEntryPointPath) &&
+    statSync(absoluteEntryPointPath).isDirectory()
+  ) {
+    // The expected entry-point is a directory, so offer further guidance.
+    message += `\nThe provided entry-point path, "${relativeEntryPointPath}", points to a directory, rather than a file.\n`;
+
+    // Perhaps we can even guess what the correct path should be...
+    const possiblePaths: string[] = [];
+    for (const basenamePath of [
+      "worker",
+      "dist/worker",
+      "index",
+      "dist/index",
+    ]) {
+      for (const extension of [".ts", ".tsx", ".js", ".jsx"]) {
+        const filePath = basenamePath + extension;
+        if (fileExists(path.resolve(absoluteEntryPointPath, filePath))) {
+          possiblePaths.push(path.join(relativeEntryPointPath, filePath));
+        }
+      }
+    }
+
+    if (possiblePaths.length > 0) {
+      message +=
+        `\nDid you mean to set the main field to${
+          possiblePaths.length > 1 ? " one of" : ""
+        }:\n` +
+        "```\n" +
+        possiblePaths.map((filePath) => `main = "./${filePath}"\n`).join("") +
+        "```";
+    }
+  }
+  return message;
+}

package/src/environment-variables.ts

@@ -1,3 +1,5 @@
+import { logger } from "./logger";
+
 /**
  * Create a function used to access an environment variable.
  *
@@ -21,7 +23,7 @@ export function getEnvironmentVariableFactory({
       if (!hasWarned) {
         // Only show the warning once.
         hasWarned = true;
-        console.warn(
+        logger.warn(
           `Using "${deprecatedName}" environment variable. This is deprecated. Please use "${variableName}", instead.`
         );
       }

package/src/errors.ts

@@ -0,0 +1,11 @@
+export class DeprecationError extends Error {
+  constructor(message: string) {
+    super(`Deprecation:\n${message}`);
+  }
+}
+
+export class FatalError extends Error {
+  constructor(message?: string, readonly code?: number) {
+    super(message);
+  }
+}

package/src/https-options.ts

@@ -0,0 +1,123 @@
+import * as fs from "node:fs";
+import { homedir, networkInterfaces } from "node:os";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import { logger } from "./logger";
+import type { Attributes, Options } from "selfsigned";
+
+// Most of this file has been borrowed from the implementation in Miniflare.
+// See https://github.com/cloudflare/miniflare/blob/870b401ef5/packages/http-server/src/plugin.ts#L313-L397
+// Thanks @mrbbot.
+const CERT_EXPIRY_DAYS = 30;
+const ONE_DAY_IN_MS = 86400000;
+
+/**
+ * Get the options (i.e. SSL certificates) for running an HTTPS server.
+ *
+ * The certificates are self-signed and generated locally, and cached in the `CERT_ROOT` directory.
+ */
+export async function getHttpsOptions() {
+  const certDirectory = path.join(homedir(), ".wrangler/local-cert");
+  const keyPath = path.join(certDirectory, "key.pem");
+  const certPath = path.join(certDirectory, "cert.pem");
+
+  const regenerate =
+    !fs.existsSync(keyPath) ||
+    !fs.existsSync(certPath) ||
+    hasCertificateExpired(keyPath, certPath);
+
+  if (regenerate) {
+    logger.log("Generating new self-signed certificate...");
+    const { key, cert } = await generateCertificate();
+    try {
+      // Write certificate files so we can reuse them later.
+      fs.mkdirSync(certDirectory, { recursive: true });
+      fs.writeFileSync(keyPath, key, "utf8");
+      fs.writeFileSync(certPath, cert, "utf8");
+    } catch (e) {
+      const message = e instanceof Error ? e.message : `${e}`;
+      logger.warn(
+        `Unable to cache generated self-signed certificate in ${certDirectory}.\n${message}`
+      );
+    }
+    return { key, cert };
+  } else {
+    return {
+      key: fs.readFileSync(keyPath, "utf8"),
+      cert: fs.readFileSync(certPath, "utf8"),
+    };
+  }
+}
+
+/**
+ * Determine if the certificate defined in `keyPath` and `certPath` files
+ * have expired based on the date when they were last modified.
+ */
+function hasCertificateExpired(keyPath: string, certPath: string): boolean {
+  const keyStat = fs.statSync(keyPath);
+  const certStat = fs.statSync(certPath);
+  const created = Math.max(keyStat.mtimeMs, certStat.mtimeMs);
+  return Date.now() - created > (CERT_EXPIRY_DAYS - 2) * ONE_DAY_IN_MS;
+}
+
+/**
+ * Generate a new self-signed certificate and cache it in `CERT_ROOT` directory.
+ */
+async function generateCertificate() {
+  // `selfsigned` imports `node-forge`, which is a pretty big library.
+  // To reduce startup time, only load this dynamically when needed.
+  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+  const generate: typeof import("selfsigned").generate = promisify(
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    require("selfsigned").generate
+  );
+
+  const certAttrs: Attributes = [{ name: "commonName", value: "localhost" }];
+
+  const certOptions: Options = {
+    algorithm: "sha256",
+    days: CERT_EXPIRY_DAYS,
+    keySize: 2048,
+    extensions: [
+      { name: "basicConstraints", cA: true },
+      {
+        name: "keyUsage",
+        keyCertSign: true,
+        digitalSignature: true,
+        nonRepudiation: true,
+        keyEncipherment: true,
+        dataEncipherment: true,
+      },
+      {
+        name: "extKeyUsage",
+        serverAuth: true,
+        clientAuth: true,
+        codeSigning: true,
+        timeStamping: true,
+      },
+      {
+        name: "subjectAltName",
+        altNames: [
+          { type: 2, value: "localhost" },
+          ...getAccessibleHosts().map((ip) => ({ type: 7, ip })),
+        ],
+      },
+    ],
+  };
+
+  const { private: key, cert } = await generate(certAttrs, certOptions);
+  return { key, cert };
+}
+
+/**
+ * Ask the OS for the addresses of locally accessible hosts.
+ */
+function getAccessibleHosts(ipv4 = false): string[] {
+  const hosts: string[] = [];
+  Object.values(networkInterfaces()).forEach((net) =>
+    net?.forEach(({ family, address }) => {
+      if (!ipv4 || family === "IPv4") hosts.push(address);
+    })
+  );
+  return hosts;
+}