wrangler 0.0.0-e61907d → 0.0.0-e95bea2

package/README.md

@@ -0,0 +1,51 @@
+## 🤠 wrangler
+
+`wrangler` is a command line tool for building [Cloudflare Workers](https://workers.cloudflare.com/).
+
+[(Read the full stack week launch blog post.)](https://blog.cloudflare.com/wrangler-v2-beta/)
+
+**DISCLAIMER**: This is a work in progress, and is NOT recommended for use in production. We are opening this preview for feedback from the community, and to openly share our [roadmap](https://github.com/cloudflare/wrangler2/issues/12) for the future. As such, expect APIs and documentation to change before the end of the preview.
+
+Further, we will NOT do a general release until we are both feature complete, and have a full backward compatibility and incremental migration plan in place. For more details, follow the [parent roadmap issue](https://github.com/cloudflare/wrangler2/issues/12).
+
+## Quick Start
+
+```bash
+# Make a javascript file
+$ echo "export default { fetch() { return new Response('hello world') } }" > index.js
+# try it out
+$ npx wrangler@beta dev index.js
+# and then publish it
+$ npx wrangler@beta publish index.js --name my-worker
+# visit https://my-worker.<your workers subdomain>.workers.dev
+```
+
+## Installation:
+
+```bash
+$ npm install wrangler@beta
+```
+
+## Commands
+
+### `wrangler init [name]`
+
+Creates a `wrangler.toml` configuration file. For more details on the configuration keys and values, refer to the [documentation](https://developers.cloudflare.com/workers/cli-wrangler/configuration).
+
+### `wrangler dev [script]`
+
+Start a local development server, with live reloading and devtools.
+
+### `wrangler publish [script] --name [name]`
+
+Publish the given script to the worldwide Cloudflare network.
+
+For more commands and options, refer to the [documentation](https://developers.cloudflare.com/workers/cli-wrangler/commands).
+
+### `wrangler pages dev [directory] [-- command]`
+
+Either serves a static build asset directory, or proxies itself in front of a command.
+
+Builds and runs functions from a `./functions` directory or uses a `_worker.js` file inside the static build asset directory.
+
+For more commands and options, refer to the [documentation](https://developers.cloudflare.com/pages/platform/functions#develop-and-preview-locally) or run `wrangler pages dev --help`.

package/bin/wrangler.js

@@ -1,2 +1,36 @@
-#!/usr/bin/env node --no-warnings
-require("../wrangler-dist/index_node.js");
+#!/usr/bin/env node
+const { spawn } = require("node:child_process");
+const { join } = require("node:path");
+const semiver = require("semiver");
+
+const MIN_NODE_VERSION = "16.7.0";
+
+async function main() {
+  if (semiver(process.versions.node, MIN_NODE_VERSION) < 0) {
+    // Note Volta and nvm are also recommended in the official docs:
+    // https://developers.cloudflare.com/workers/get-started/guide#2-install-the-workers-cli
+    console.error(
+      `Wrangler requires at least Node.js v${MIN_NODE_VERSION}. You are using v${process.versions.node}.
+You should use the latest Node.js version if possible, as Cloudflare Workers use a very up-to-date version of V8.
+Consider using a Node.js version manager such as https://volta.sh/ or https://github.com/nvm-sh/nvm.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  spawn(
+    process.execPath,
+    [
+      "--no-warnings",
+      "--experimental-vm-modules",
+      ...process.execArgv,
+      join(__dirname, "../wrangler-dist/cli.js"),
+      ...process.argv.slice(2),
+    ],
+    { stdio: "inherit" }
+  ).on("exit", (code) =>
+    process.exit(code === undefined || code === null ? 0 : code)
+  );
+}
+
+void main();

package/import_meta_url.js

@@ -0,0 +1,3 @@
+// as per https://github.com/evanw/esbuild/issues/1492
+// to make some libs work
+export const import_meta_url = require("url").pathToFileURL(__filename);

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "wrangler",
-  "version": "0.0.0-e61907d",
+  "version": "0.0.0-e95bea2",
   "author": "wrangler@cloudflare.com",
   "description": "Command-line interface for all things Cloudflare Workers",
-  "bin": "./bin/wrangler.js",
+  "bin": {
+    "wrangler": "./bin/wrangler.js",
+    "wrangler2": "./bin/wrangler.js"
+  },
   "license": "MIT OR Apache-2.0",
   "bugs": {
     "url": "https://github.com/cloudflare/wrangler/issues"
@@ -33,52 +36,107 @@
     "cli"
   ],
   "dependencies": {
-    "esbuild": "^0.13.12",
-    "miniflare": "^1.4.1",
-    "yargs": "^17.2.1"
+    "esbuild": "0.14.23",
+    "miniflare": "2.3.0",
+    "path-to-regexp": "^6.2.0",
+    "selfsigned": "^2.0.0",
+    "semiver": "^1.1.0",
+    "xxhash-wasm": "^1.0.1"
   },
   "optionalDependencies": {
     "fsevents": "~2.3.2"
   },
   "devDependencies": {
     "@iarna/toml": "^2.2.5",
-    "@types/cloudflare": "^2.7.6",
-    "@types/react": "^17.0.34",
+    "@sentry/cli": "^1.71.0",
+    "@sentry/integrations": "^6.17.6",
+    "@sentry/node": "^6.17.6",
+    "@types/command-exists": "^1.2.0",
+    "@types/glob-to-regexp": "0.4.1",
+    "@types/mime": "^2.0.3",
+    "@types/prompts": "^2.0.14",
+    "@types/react": "^17.0.37",
+    "@types/react-test-renderer": "^17.0.1",
+    "@types/serve-static": "^1.13.10",
     "@types/signal-exit": "^3.0.1",
-    "@types/ws": "^8.2.0",
-    "@types/yargs": "^17.0.5",
+    "@types/ws": "^8.2.1",
+    "@types/yargs": "^17.0.7",
+    "chokidar": "^3.5.2",
     "clipboardy": "^3.0.0",
-    "cloudflare": "^2.9.1",
+    "cmd-shim": "^4.1.0",
     "command-exists": "^1.2.9",
+    "devtools-protocol": "^0.0.955664",
+    "execa": "^6.0.0",
+    "faye-websocket": "^0.11.4",
     "finalhandler": "^1.1.2",
     "find-up": "^6.2.0",
-    "formdata-node": "^4.3.1",
-    "http-proxy": "^1.18.1",
+    "get-port": "^6.1.2",
+    "glob-to-regexp": "0.4.1",
+    "ignore": "^5.2.0",
     "ink": "^3.2.0",
+    "ink-select-input": "^4.2.1",
     "ink-table": "^3.0.0",
-    "ink-text-input": "^4.0.1",
-    "node-fetch": "github:tekwiz/node-fetch#fix/redirect-with-empty-chunked-transfer-encoding",
+    "ink-testing-library": "^2.1.0",
+    "ink-text-input": "^4.0.2",
+    "jest-fetch-mock": "^3.0.3",
+    "jest-websocket-mock": "^2.3.0",
+    "mime": "^3.0.0",
     "open": "^8.4.0",
+    "prompts": "^2.4.2",
     "react": "^17.0.2",
+    "react-test-renderer": "^17.0.2",
+    "react-error-boundary": "^3.1.4",
     "serve-static": "^1.14.1",
-    "signal-exit": "^3.0.5",
+    "signal-exit": "^3.0.6",
     "tmp-promise": "^3.0.3",
-    "ws": "^8.2.3"
+    "undici": "4.13.0",
+    "ws": "^8.3.0",
+    "yargs": "^17.3.0"
   },
   "files": [
+    "src",
     "bin",
+    "pages",
     "miniflare-config-stubs",
     "wrangler-dist",
-    "static-asset-facade.js",
-    "vendor"
+    "templates",
+    "vendor",
+    "import_meta_url.js"
   ],
   "scripts": {
     "clean": "rm -rf wrangler-dist",
+    "check:type": "tsc",
     "bundle": "node -r esbuild-register scripts/bundle.ts",
     "build": "npm run clean && npm run bundle",
-    "start": "npm run bundle && ./bin/wrangler.js"
+    "prepublishOnly": "npm run build",
+    "start": "npm run bundle && NODE_OPTIONS=--enable-source-maps ./bin/wrangler.js",
+    "test": "jest --silent=false --verbose=true",
+    "test-watch": "npm run test -- --runInBand --testTimeout=50000 --watch"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=16.7.0"
+  },
+  "jest": {
+    "restoreMocks": true,
+    "testTimeout": 30000,
+    "testRegex": ".*.(test|spec)\\.[jt]sx?$",
+    "transformIgnorePatterns": [
+      "node_modules/(?!find-up|locate-path|p-locate|p-limit|yocto-queue|path-exists|execa|strip-final-newline|npm-run-path|path-key|onetime|mimic-fn|human-signals|is-stream|get-port)"
+    ],
+    "moduleNameMapper": {
+      "clipboardy": "<rootDir>/src/__tests__/helpers/clipboardy-mock.js",
+      "miniflare/cli": "<rootDir>/../../node_modules/miniflare/dist/src/cli.js"
+    },
+    "transform": {
+      "^.+\\.c?(t|j)sx?$": [
+        "esbuild-jest",
+        {
+          "sourcemap": true
+        }
+      ]
+    },
+    "setupFilesAfterEnv": [
+      "<rootDir>/src/__tests__/jest.setup.ts"
+    ]
   }
-}
+}

package/pages/functions/buildWorker.ts

@@ -0,0 +1,62 @@
+import path from "node:path";
+import { build } from "esbuild";
+
+type Options = {
+  routesModule: string;
+  outfile: string;
+  minify?: boolean;
+  sourcemap?: boolean;
+  fallbackService?: string;
+  watch?: boolean;
+  onEnd?: () => void;
+};
+
+export function buildWorker({
+  routesModule,
+  outfile = "bundle.js",
+  minify = false,
+  sourcemap = false,
+  fallbackService = "ASSETS",
+  watch = false,
+  onEnd = () => {},
+}: Options) {
+  return build({
+    entryPoints: [
+      path.resolve(__dirname, "../pages/functions/template-worker.ts"),
+    ],
+    inject: [routesModule],
+    bundle: true,
+    format: "esm",
+    target: "esnext",
+    outfile,
+    minify,
+    sourcemap,
+    watch,
+    allowOverwrite: true,
+    define: {
+      __FALLBACK_SERVICE__: JSON.stringify(fallbackService),
+    },
+    plugins: [
+      {
+        name: "wrangler notifier and monitor",
+        setup(pluginBuild) {
+          pluginBuild.onEnd((result) => {
+            if (result.errors.length > 0) {
+              console.error(
+                `${result.errors.length} error(s) and ${result.warnings.length} warning(s) when compiling Worker.`
+              );
+            } else if (result.warnings.length > 0) {
+              console.warn(
+                `${result.warnings.length} warning(s) when compiling Worker.`
+              );
+              onEnd();
+            } else {
+              console.log("Compiled Worker successfully.");
+              onEnd();
+            }
+          });
+        },
+      },
+    ],
+  });
+}

package/pages/functions/filepath-routing.test.ts

@@ -0,0 +1,123 @@
+import { writeFileSync } from "fs";
+import { runInTempDir } from "../../src/__tests__/helpers/run-in-tmp";
+import { toUrlPath } from "../../src/paths";
+import { compareRoutes, generateConfigFromFileTree } from "./filepath-routing";
+import type { UrlPath } from "../../src/paths";
+import type { HTTPMethod, RouteConfig } from "./routes";
+
+describe("filepath-routing", () => {
+  describe("compareRoutes()", () => {
+    test("routes / last", () => {
+      expect(
+        compareRoutes(routeConfig("/"), routeConfig("/foo"))
+      ).toBeGreaterThanOrEqual(1);
+      expect(
+        compareRoutes(routeConfig("/"), routeConfig("/:foo"))
+      ).toBeGreaterThanOrEqual(1);
+      expect(
+        compareRoutes(routeConfig("/"), routeConfig("/:foo*"))
+      ).toBeGreaterThanOrEqual(1);
+    });
+
+    test("routes with fewer segments come after those with more segments", () => {
+      expect(
+        compareRoutes(routeConfig("/foo"), routeConfig("/foo/bar"))
+      ).toBeGreaterThanOrEqual(1);
+      expect(
+        compareRoutes(routeConfig("/foo"), routeConfig("/foo/bar/cat"))
+      ).toBeGreaterThanOrEqual(1);
+    });
+
+    test("routes with wildcard segments come after those without", () => {
+      expect(compareRoutes(routeConfig("/:foo*"), routeConfig("/foo"))).toBe(1);
+      expect(compareRoutes(routeConfig("/:foo*"), routeConfig("/:foo"))).toBe(
+        1
+      );
+    });
+
+    test("routes with dynamic segments come after those without", () => {
+      expect(compareRoutes(routeConfig("/:foo"), routeConfig("/foo"))).toBe(1);
+    });
+
+    test("routes with dynamic segments occurring earlier come after those with dynamic segments in later positions", () => {
+      expect(
+        compareRoutes(routeConfig("/foo/:id/bar"), routeConfig("/foo/bar/:id"))
+      ).toBe(1);
+    });
+
+    test("routes with no HTTP method come after those specifying a method", () => {
+      expect(
+        compareRoutes(routeConfig("/foo"), routeConfig("/foo", "GET"))
+      ).toBe(1);
+    });
+
+    test("two equal routes are sorted according to their original position in the list", () => {
+      expect(
+        compareRoutes(routeConfig("/foo", "GET"), routeConfig("/foo", "GET"))
+      ).toBe(0);
+    });
+
+    test("it returns -1 if the first argument should appear first in the list", () => {
+      expect(
+        compareRoutes(routeConfig("/foo", "GET"), routeConfig("/foo"))
+      ).toBe(-1);
+    });
+  });
+
+  describe("generateConfigFromFileTree", () => {
+    runInTempDir();
+
+    it("should generate a route entry for each file in the tree", async () => {
+      writeFileSync(
+        "foo.ts",
+        `
+      export function onRequestGet() {}
+      export function onRequestPost() {}
+      `
+      );
+      writeFileSync(
+        "bar.ts",
+        `
+      export function onRequestPut() {}
+      export function onRequestDelete() {}
+      `
+      );
+
+      const entries = await generateConfigFromFileTree({
+        baseDir: ".",
+        baseURL: "/base" as UrlPath,
+      });
+      expect(entries).toEqual({
+        routes: [
+          {
+            method: "DELETE",
+            module: ["bar.ts:onRequestDelete"],
+            routePath: "/base/bar",
+          },
+          {
+            method: "PUT",
+            module: ["bar.ts:onRequestPut"],
+            routePath: "/base/bar",
+          },
+          {
+            method: "GET",
+            module: ["foo.ts:onRequestGet"],
+            routePath: "/base/foo",
+          },
+          {
+            method: "POST",
+            module: ["foo.ts:onRequestPost"],
+            routePath: "/base/foo",
+          },
+        ],
+      });
+    });
+  });
+});
+
+function routeConfig(routePath: string, method?: string): RouteConfig {
+  return {
+    routePath: toUrlPath(routePath),
+    method: method as HTTPMethod,
+  };
+}

package/pages/functions/filepath-routing.ts

@@ -0,0 +1,178 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { build } from "esbuild";
+import { toUrlPath } from "../../src/paths";
+import type { UrlPath } from "../../src/paths";
+import type { HTTPMethod, RouteConfig } from "./routes";
+
+export async function generateConfigFromFileTree({
+  baseDir,
+  baseURL,
+}: {
+  baseDir: string;
+  baseURL: UrlPath;
+}) {
+  let routeEntries: RouteConfig[] = [];
+
+  if (!baseURL.startsWith("/")) {
+    baseURL = `/${baseURL}` as UrlPath;
+  }
+
+  if (baseURL.endsWith("/")) {
+    baseURL = baseURL.slice(0, -1) as UrlPath;
+  }
+
+  await forEachFile(baseDir, async (filepath) => {
+    const ext = path.extname(filepath);
+    if (/^\.(mjs|js|ts|tsx|jsx)$/.test(ext)) {
+      const { metafile } = await build({
+        metafile: true,
+        write: false,
+        bundle: false,
+        entryPoints: [path.resolve(filepath)],
+      });
+      const exportNames: string[] = [];
+      if (metafile) {
+        for (const output in metafile?.outputs) {
+          exportNames.push(...metafile.outputs[output].exports);
+        }
+      }
+      for (const exportName of exportNames) {
+        const [match, method = ""] = (exportName.match(
+          /^onRequest(Get|Post|Put|Patch|Delete|Options|Head)?$/
+        ) ?? []) as (string | undefined)[];
+
+        if (match) {
+          const basename = path.basename(filepath).slice(0, -ext.length);
+
+          const isIndexFile = basename === "index";
+          // TODO: deprecate _middleware_ in favor of _middleware
+          const isMiddlewareFile =
+            basename === "_middleware" || basename === "_middleware_";
+
+          let routePath = path
+            .relative(baseDir, filepath)
+            .slice(0, -ext.length);
+
+          if (isIndexFile || isMiddlewareFile) {
+            routePath = path.dirname(routePath);
+          }
+
+          if (routePath === ".") {
+            routePath = "";
+          }
+
+          routePath = `${baseURL}/${routePath}`;
+
+          routePath = routePath.replace(/\[\[(.+)]]/g, ":$1*"); // transform [[id]] => :id*
+          routePath = routePath.replace(/\[(.+)]/g, ":$1"); // transform [id] => :id
+
+          const routeEntry: RouteConfig = {
+            routePath: toUrlPath(routePath),
+            method: method.toUpperCase() as HTTPMethod,
+            [isMiddlewareFile ? "middleware" : "module"]: [
+              `${path.relative(baseDir, filepath)}:${exportName}`,
+            ],
+          };
+
+          routeEntries.push(routeEntry);
+        }
+      }
+    }
+  });
+  // Combine together any routes (index routes) which contain both a module and a middleware
+  routeEntries = routeEntries.reduce(
+    (acc: typeof routeEntries, { routePath, ...rest }) => {
+      const existingRouteEntry = acc.find(
+        (routeEntry) =>
+          routeEntry.routePath === routePath &&
+          routeEntry.method === rest.method
+      );
+      if (existingRouteEntry !== undefined) {
+        Object.assign(existingRouteEntry, rest);
+      } else {
+        acc.push({ routePath, ...rest });
+      }
+      return acc;
+    },
+    []
+  );
+
+  routeEntries.sort((a, b) => compareRoutes(a, b));
+
+  return {
+    routes: routeEntries,
+  };
+}
+
+// Ensure routes are produced in order of precedence so that
+// more specific routes aren't occluded from matching due to
+// less specific routes appearing first in the route list.
+export function compareRoutes(
+  { routePath: routePathA, method: methodA }: RouteConfig,
+  { routePath: routePathB, method: methodB }: RouteConfig
+) {
+  function parseRoutePath(routePath: UrlPath): string[] {
+    return routePath.slice(1).split("/").filter(Boolean);
+  }
+
+  const segmentsA = parseRoutePath(routePathA);
+  const segmentsB = parseRoutePath(routePathB);
+
+  // sort routes with fewer segments after those with more segments
+  if (segmentsA.length !== segmentsB.length) {
+    return segmentsB.length - segmentsA.length;
+  }
+
+  for (let i = 0; i < segmentsA.length; i++) {
+    const isWildcardA = segmentsA[i].includes("*");
+    const isWildcardB = segmentsB[i].includes("*");
+    const isParamA = segmentsA[i].includes(":");
+    const isParamB = segmentsB[i].includes(":");
+
+    // sort wildcard segments after non-wildcard segments
+    if (isWildcardA && !isWildcardB) return 1;
+    if (!isWildcardA && isWildcardB) return -1;
+
+    // sort dynamic param segments after non-param segments
+    if (isParamA && !isParamB) return 1;
+    if (!isParamA && isParamB) return -1;
+  }
+
+  // sort routes that specify an HTTP before those that don't
+  if (methodA && !methodB) return -1;
+  if (!methodA && methodB) return 1;
+
+  // all else equal, just sort the paths lexicographically
+  return routePathA.localeCompare(routePathB);
+}
+
+async function forEachFile<T>(
+  baseDir: string,
+  fn: (filepath: string) => T | Promise<T>
+) {
+  const searchPaths = [baseDir];
+  const returnValues: T[] = [];
+
+  while (isNotEmpty(searchPaths)) {
+    const cwd = searchPaths.shift();
+    const dir = await fs.readdir(cwd, { withFileTypes: true });
+    for (const entry of dir) {
+      const pathname = path.join(cwd, entry.name);
+      if (entry.isDirectory()) {
+        searchPaths.push(pathname);
+      } else if (entry.isFile()) {
+        returnValues.push(await fn(pathname));
+      }
+    }
+  }
+
+  return returnValues;
+}
+
+interface NonEmptyArray<T> extends Array<T> {
+  shift(): T;
+}
+function isNotEmpty<T>(array: T[]): array is NonEmptyArray<T> {
+  return array.length > 0;
+}

package/pages/functions/identifiers.ts

@@ -0,0 +1,78 @@
+export const RESERVED_KEYWORDS = [
+  "do",
+  "if",
+  "in",
+  "for",
+  "let",
+  "new",
+  "try",
+  "var",
+  "case",
+  "else",
+  "enum",
+  "eval",
+  "null",
+  "this",
+  "true",
+  "void",
+  "with",
+  "await",
+  "break",
+  "catch",
+  "class",
+  "const",
+  "false",
+  "super",
+  "throw",
+  "while",
+  "yield",
+  "delete",
+  "export",
+  "import",
+  "public",
+  "return",
+  "static",
+  "switch",
+  "typeof",
+  "default",
+  "extends",
+  "finally",
+  "package",
+  "private",
+  "continue",
+  "debugger",
+  "function",
+  "arguments",
+  "interface",
+  "protected",
+  "implements",
+  "instanceof",
+  "NaN",
+  "Infinity",
+  "undefined",
+];
+
+export const reservedKeywordRegex = new RegExp(
+  `^${RESERVED_KEYWORDS.join("|")}$`
+);
+
+export const identifierStartRegex = /[$_\p{ID_Start}]/u;
+
+export const identifierPartRegex = /[$_\u200C\u200D\p{ID_Continue}]/u;
+
+export const identifierNameRegex =
+  /^(?:[$_\p{ID_Start}])(?:[$_\u200C\u200D\p{ID_Continue}])*$/u;
+
+export const validIdentifierRegex = new RegExp(
+  `(?!(${reservedKeywordRegex.source})$)${identifierNameRegex.source}`,
+  "u"
+);
+
+export const isValidIdentifier = (identifier: string) =>
+  validIdentifierRegex.test(identifier);
+
+export const normalizeIdentifier = (identifier: string) =>
+  identifier.replace(
+    /(?:^[^$_\p{ID_Start}])|[^$_\u200C\u200D\p{ID_Continue}]/gu,
+    "_"
+  );