wrangler 0.0.0-e95bea2 → 0.0.0-e95e5a0

package/src/entry.ts

@@ -3,6 +3,7 @@ import { existsSync } 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";
@@ -20,7 +21,7 @@ export type Entry = { file: string; directory: string; format: CfScriptFormat };
 export async function getEntry(
   args: { script?: string; format?: CfScriptFormat | undefined },
   config: Config,
-  command: string
+  command: "dev" | "publish"
 ): Promise<Entry> {
   let file: string;
   let directory = process.cwd();
@@ -28,9 +29,17 @@ export async function getEntry(
     // If the script name comes from the command line it is relative to the current working directory.
     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);
@@ -46,8 +55,37 @@ export async function getEntry(
   const format = await guessWorkerFormat(
     file,
     directory,
-    args.format ?? config.build?.upload?.format
+    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(
+      `${errorMessage}\n${addScriptName}\n${addScriptNameExamples}\n${migrateText}\n${migrateUrl}`
+    );
+  }
+
   return { file, directory, format };
 }
 
@@ -57,12 +95,13 @@ export async function runCustomBuild(
 ) {
   if (build?.command) {
     // TODO: add a deprecation message here?
-    console.log("running:", build.command);
+    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",
-      timeout: 1000 * 30,
       ...(build.cwd && { cwd: build.cwd }),
     });
 
@@ -88,7 +127,8 @@ export async function runCustomBuild(
 export default async function guessWorkerFormat(
   entryFile: string,
   entryWorkingDirectory: string,
-  hint: CfScriptFormat | undefined
+  hint: CfScriptFormat | undefined,
+  tsconfig?: string | undefined
 ): Promise<CfScriptFormat> {
   const result = await esbuild.build({
     entryPoints: [entryFile],
@@ -96,7 +136,14 @@ export default async function guessWorkerFormat(
     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
@@ -114,14 +161,30 @@ export default async function guessWorkerFormat(
     "More than one entry-point found for generated bundle." +
       listEntryPoints(entryPoints)
   );
-  const guessedWorkerFormat =
-    entryPoints[0][1].exports.length > 0 ? "modules" : "service-worker";
+
+  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 ES module exports. Please pass `--format modules`, or simply remove the configuration."
+          "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(
@@ -157,3 +220,48 @@ 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");
+}

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

@@ -2,6 +2,7 @@ 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.
@@ -26,7 +27,7 @@ export async function getHttpsOptions() {
     hasCertificateExpired(keyPath, certPath);
 
   if (regenerate) {
-    console.log("Generating new self-signed certificate...");
+    logger.log("Generating new self-signed certificate...");
     const { key, cert } = await generateCertificate();
     try {
       // Write certificate files so we can reuse them later.
@@ -35,7 +36,7 @@ export async function getHttpsOptions() {
       fs.writeFileSync(certPath, cert, "utf8");
     } catch (e) {
       const message = e instanceof Error ? e.message : `${e}`;
-      console.warn(
+      logger.warn(
         `Unable to cache generated self-signed certificate in ${certDirectory}.\n${message}`
       );
     }