wrangler 0.0.0-e2a26a0 → 0.0.0-e3cab74

package/src/entry.ts

@@ -0,0 +1,57 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import type { Config } from "./config";
+
+/**
+ * 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 };
+
+/**
+ * Compute the entry-point for the Worker.
+ */
+export function getEntry(
+  config: Config,
+  command: string,
+  script?: string
+): Entry {
+  let file: string;
+  let directory = process.cwd();
+  if (script) {
+    // If the script name comes from the command line it is relative to the current working directory.
+    file = path.resolve(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.`
+    );
+  } else {
+    directory = path.resolve(path.dirname(config.configPath ?? "."));
+    file = path.resolve(directory, config.main);
+  }
+
+  if (!config.build?.command && fileExists(file) === false) {
+    throw new Error(
+      `Could not resolve "${path.relative(process.cwd(), file)}".`
+    );
+  }
+  return { file, directory };
+}
+
+/**
+ * Returns true if the given `filePath` exists as-is,
+ * or if some version of it (by appending a common extension) exists.
+ */
+export function fileExists(filePath: string): boolean {
+  if (path.extname(filePath) !== "") {
+    return existsSync(filePath);
+  }
+  const base = path.join(path.dirname(filePath), path.basename(filePath));
+  for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+    if (existsSync(base + ext)) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/environment-variables.ts

@@ -0,0 +1,33 @@
+/**
+ * Create a function used to access an environment variable.
+ *
+ * This is not memoized to allow us to change the value at runtime, such as in testing.
+ * A warning is shown if the client is using a deprecated version - but only once.
+ */
+export function getEnvironmentVariableFactory({
+  variableName,
+  deprecatedName,
+  defaultValue,
+}: {
+  variableName: string;
+  deprecatedName?: string;
+  defaultValue?: string;
+}) {
+  let hasWarned = false;
+  return () => {
+    if (process.env[variableName]) {
+      return process.env[variableName];
+    } else if (deprecatedName && process.env[deprecatedName]) {
+      if (!hasWarned) {
+        // Only show the warning once.
+        hasWarned = true;
+        console.warn(
+          `Using "${deprecatedName}" environment variable. This is deprecated. Please use "${variableName}", instead.`
+        );
+      }
+      return process.env[deprecatedName];
+    } else {
+      return defaultValue;
+    }
+  };
+}

package/src/guess-worker-format.ts

@@ -0,0 +1,68 @@
+import assert from "node:assert";
+import { build } from "esbuild";
+import type { CfScriptFormat } from "./api/worker";
+import type { Entry } from "./entry";
+import type { Metafile } from "esbuild";
+
+/**
+ * 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(
+  entry: Entry,
+  hint: CfScriptFormat | undefined
+): Promise<CfScriptFormat> {
+  const result = await build({
+    entryPoints: [entry.file],
+    absWorkingDir: entry.directory,
+    metafile: true,
+    bundle: false,
+    format: "esm",
+    write: false,
+  });
+  // 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 "${entry.file}" in generated bundle.` +
+      listEntryPoints(entryPoints)
+  );
+  assert(
+    entryPoints.length < 2,
+    "More than one entry-point found for generated bundle." +
+      listEntryPoints(entryPoints)
+  );
+  const guessedWorkerFormat =
+    entryPoints[0][1].exports.length > 0 ? "modules" : "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."
+        );
+      } 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];