wrangler 0.0.0-e151223 → 0.0.0-e29a241

package/src/package-manager.ts

@@ -0,0 +1,126 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { execa, execaCommandSync } from "execa";
+
+export interface PackageManager {
+  cwd: string;
+  type: "npm" | "yarn";
+  addDevDeps(...packages: string[]): Promise<void>;
+  install(): Promise<void>;
+}
+
+export async function getPackageManager(cwd: string): Promise<PackageManager> {
+  const [hasYarn, hasNpm] = await Promise.all([supportsYarn(), supportsNpm()]);
+  const hasYarnLock = existsSync(join(cwd, "yarn.lock"));
+  const hasNpmLock = existsSync(join(cwd, "package-lock.json"));
+
+  if (hasNpmLock) {
+    if (hasNpm) {
+      console.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(
+        "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(
+        "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(
+        "There is already a yarn.lock file but could not find yarn on the PATH."
+      );
+      return { ...NpmPackageManager, cwd };
+    }
+  }
+
+  if (hasNpm) {
+    console.log("Using npm as package manager.");
+    return { ...NpmPackageManager, cwd };
+  } else if (hasYarn) {
+    console.log("Using yarn as package manager.");
+    return { ...YarnPackageManager, cwd };
+  } else {
+    throw new Error(
+      "Unable to find a package manager. Supported managers are: npm and yarn."
+    );
+  }
+}
+
+/**
+ * Get the name of the given `packageManager`.
+ */
+export function getPackageManagerName(packageManager: PackageManager): string {
+  return packageManager.type ?? "unknown";
+}
+
+/**
+ * Manage packages using npm
+ */
+const NpmPackageManager: PackageManager = {
+  cwd: process.cwd(),
+  type: "npm",
+  /** Add and install a new devDependency into the local package.json. */
+  async addDevDeps(...packages: string[]): Promise<void> {
+    await execa("npm", ["install", ...packages, "--save-dev"], {
+      stdio: "inherit",
+      cwd: this.cwd,
+    });
+  },
+
+  /** Install all the dependencies in the local package.json. */
+  async install(): Promise<void> {
+    await execa("npm", ["install"], {
+      stdio: "inherit",
+      cwd: this.cwd,
+    });
+  },
+};
+
+/**
+ * Manage packages using yarn
+ */
+const YarnPackageManager: PackageManager = {
+  cwd: process.cwd(),
+  type: "yarn",
+  /** Add and install a new devDependency into the local package.json. */
+  async addDevDeps(...packages: string[]): Promise<void> {
+    await execa("yarn", ["add", ...packages, "--dev"], {
+      stdio: "inherit",
+      cwd: this.cwd,
+    });
+  },
+
+  /** Install all the dependencies in the local package.json. */
+  async install(): Promise<void> {
+    await execa("yarn", ["install"], {
+      stdio: "inherit",
+      cwd: this.cwd,
+    });
+  },
+};
+
+async function supports(name: string): Promise<boolean> {
+  try {
+    execaCommandSync(`${name} --version`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function supportsYarn(): Promise<boolean> {
+  return supports("yarn");
+}
+
+function supportsNpm(): Promise<boolean> {
+  return supports("npm");
+}

package/src/pages.tsx

@@ -7,10 +7,10 @@ import { join } from "node:path";
 import { URL } from "node:url";
 import { watch } from "chokidar";
 import { getType } from "mime";
-import open from "open";
 import { buildWorker } from "../pages/functions/buildWorker";
 import { generateConfigFromFileTree } from "../pages/functions/filepath-routing";
 import { writeRoutesModule } from "../pages/functions/routes";
+import openInBrowser from "./open-in-browser";
 import { toUrlPath } from "./paths";
 import type { Config } from "../pages/functions/routes";
 import type { Headers, Request, fetch } from "@miniflare/core";
@@ -771,7 +771,7 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
         kv: kvs = [],
         do: durableObjects = [],
         "live-reload": liveReload,
-        "--": remaining = [],
+        _: [_pages, _dev, ...remaining],
       }) => {
         if (!local) {
           console.error("Only local mode is supported at the moment.");
@@ -795,8 +795,8 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
 
         let miniflareArgs: MiniflareOptions = {};
 
-        let scriptReadyResolve;
-        const scriptReadyPromise = new Promise(
+        let scriptReadyResolve: () => void;
+        const scriptReadyPromise = new Promise<void>(
           (resolve) => (scriptReadyResolve = resolve)
         );
 
@@ -830,6 +830,9 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
             scriptPath,
           };
         } else {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          scriptReadyResolve!();
+
           const scriptPath =
             directory !== undefined
               ? join(directory, singleWorkerScriptPath)
@@ -852,7 +855,6 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
               }
             }`,
             };
-            scriptReadyResolve();
           }
         }
 
@@ -893,13 +895,13 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
           // User bindings
           bindings: {
             ...Object.fromEntries(
-              bindings.map((binding) => binding.toString().split("="))
+              bindings.map((binding) => binding.toString().split("=", 1))
             ),
           },
 
           // env.ASSETS.fetch
           serviceBindings: {
-            async ASSETS(request) {
+            async ASSETS(request: Request) {
               if (proxyPort) {
                 try {
                   const url = new URL(request.url);
@@ -944,9 +946,7 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
           console.log(`Serving at http://localhost:${port}/`);
 
           if (process.env.BROWSER !== "none") {
-            const childProcess = await open(`http://localhost:${port}/`);
-            // fail silently if the open command doesn't work (e.g. in GitHub Codespaces)
-            childProcess.on("error", (_err) => {});
+            await openInBrowser(`http://localhost:${port}/`);
           }
 
           if (directory !== undefined && liveReload) {
@@ -963,7 +963,7 @@ export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
             miniflare.dispose().catch((err) => miniflare.log.error(err));
           });
         } catch (e) {
-          miniflare.log.error(e);
+          miniflare.log.error(e as Error);
           EXIT("Could not start Miniflare.", 1);
         }
       }

package/src/parse.ts

@@ -0,0 +1,183 @@
+import * as fs from "node:fs";
+import { resolve } from "node:path";
+import TOML from "@iarna/toml";
+import { formatMessagesSync } from "esbuild";
+
+export type Message = {
+  text: string;
+  location?: Location;
+  notes?: Message[];
+  kind?: "warning" | "error";
+};
+
+export type Location = File & {
+  line: number;
+  column: number;
+  length?: number;
+  lineText?: string;
+  suggestion?: string;
+};
+
+export type File = {
+  file?: string;
+  fileText?: string;
+};
+
+/**
+ * Formats a `Message` using esbuild's pretty-printing algorithm.
+ */
+export function formatMessage(
+  { text, notes, location, kind = "error" }: Message,
+  color = true
+): string {
+  const input = { text, notes, location };
+  delete input.location?.fileText;
+  for (const note of notes ?? []) {
+    delete note.location?.fileText;
+  }
+  const lines = formatMessagesSync([input], {
+    color,
+    kind: kind,
+    terminalWidth: process.stderr.columns,
+  });
+  return lines.join("\n");
+}
+
+/**
+ * An error that's thrown when something fails to parse.
+ */
+export class ParseError extends Error implements Message {
+  readonly text: string;
+  readonly notes: Message[];
+  readonly location?: Location;
+  readonly kind: "warning" | "error";
+
+  constructor({ text, notes, location, kind }: Message) {
+    super(text);
+    this.name = this.constructor.name;
+    this.text = text;
+    this.notes = notes ?? [];
+    this.location = location;
+    this.kind = kind ?? "error";
+  }
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+const TOML_ERROR_NAME = "TomlError";
+const TOML_ERROR_SUFFIX = " at row ";
+
+type TomlError = Error & {
+  line: number;
+  col: number;
+};
+
+/**
+ * A wrapper around `TOML.parse` that throws a `ParseError`.
+ */
+export function parseTOML(input: string, file?: string): object {
+  try {
+    return TOML.parse(input);
+  } catch (err) {
+    const { name, message, line, col } = err as TomlError;
+    if (name !== TOML_ERROR_NAME) {
+      throw err;
+    }
+    const text = message.substring(0, message.lastIndexOf(TOML_ERROR_SUFFIX));
+    const lineText = input.split("\n")[line];
+    const location = {
+      lineText,
+      line: line + 1,
+      column: col - 1,
+      file,
+      fileText: input,
+    };
+    throw new ParseError({ text, location });
+  }
+}
+
+const JSON_ERROR_SUFFIX = " in JSON at position ";
+
+/**
+ * A wrapper around `JSON.parse` that throws a `ParseError`.
+ */
+export function parseJSON(input: string, file?: string): any {
+  try {
+    return JSON.parse(input);
+  } catch (err) {
+    const { message } = err as Error;
+    const index = message.lastIndexOf(JSON_ERROR_SUFFIX);
+    if (index < 0) {
+      throw err;
+    }
+    const text = message.substring(0, index);
+    const position = parseInt(
+      message.substring(index + JSON_ERROR_SUFFIX.length)
+    );
+    const location = indexLocation({ file, fileText: input }, position);
+    throw new ParseError({ text, location });
+  }
+}
+
+/**
+ * Reads a file and parses it based on its type.
+ */
+export function readFileSync(file: string): string {
+  try {
+    return fs.readFileSync(file, { encoding: "utf-8" });
+  } catch (err) {
+    const { message } = err as Error;
+    throw new ParseError({
+      text: `Could not read file: ${file}`,
+      notes: [
+        {
+          text: message.replace(file, resolve(file)),
+        },
+      ],
+    });
+  }
+}
+
+/**
+ * Calculates the line and column location from an index.
+ */
+export function indexLocation(file: File, index: number): Location {
+  let lineText,
+    line = 0,
+    column = 0,
+    cursor = 0;
+  const { fileText = "" } = file;
+  for (const row of fileText.split("\n")) {
+    line++;
+    cursor += row.length + 1;
+    if (cursor >= index) {
+      lineText = row;
+      column = row.length - (cursor - index);
+      break;
+    }
+  }
+  return { lineText, line, column, ...file };
+}
+
+/**
+ * Guesses the line and column location of a search query.
+ */
+export function searchLocation(file: File, query: unknown): Location {
+  let lineText,
+    length,
+    line = 0,
+    column = 0;
+  const queryText = String(query);
+  const { fileText = "" } = file;
+  for (const content of fileText.split("\n")) {
+    line++;
+    const index = content.indexOf(queryText);
+    if (index >= 0) {
+      lineText = content;
+      column = index;
+      length = queryText.length;
+      break;
+    }
+  }
+  return { lineText, line, column, length, ...file };
+}