wrangler 0.0.7 → 0.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wrangler",
-  "version": "0.0.7",
+  "version": "0.0.12",
   "author": "wrangler@cloudflare.com",
   "description": "Command-line interface for all things Cloudflare Workers",
   "bin": {
@@ -37,9 +37,10 @@
   ],
   "dependencies": {
     "esbuild": "0.14.1",
-    "miniflare": "2.0.0-rc.5",
+    "miniflare": "2.2.0",
     "path-to-regexp": "^6.2.0",
-    "semiver": "^1.1.0"
+    "semiver": "^1.1.0",
+    "xxhash-addon": "^1.4.0"
   },
   "optionalDependencies": {
     "fsevents": "~2.3.2"
@@ -47,8 +48,8 @@
   "devDependencies": {
     "@babel/types": "^7.16.0",
     "@iarna/toml": "^2.2.5",
-    "@types/mime": "^2.0.3",
     "@types/estree": "^0.0.50",
+    "@types/mime": "^2.0.3",
     "@types/react": "^17.0.37",
     "@types/serve-static": "^1.13.10",
     "@types/signal-exit": "^3.0.1",
@@ -59,17 +60,20 @@
     "chokidar": "^3.5.2",
     "clipboardy": "^3.0.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",
+    "ignore": "^5.2.0",
     "ink": "^3.2.0",
     "ink-select-input": "^4.2.1",
     "ink-table": "^3.0.0",
+    "ink-testing-library": "^2.1.0",
     "ink-text-input": "^4.0.2",
     "mime": "^3.0.0",
-    "node-fetch": "^3.1.0",
+    "node-fetch": "3.1.1",
     "open": "^8.4.0",
     "react": "^17.0.2",
     "react-error-boundary": "^3.1.4",
@@ -95,7 +99,8 @@
     "bundle": "node -r esbuild-register scripts/bundle.ts",
     "build": "npm run clean && npm run bundle",
     "start": "npm run bundle && NODE_OPTIONS=--enable-source-maps ./bin/wrangler.js",
-    "test": "CF_API_TOKEN=some-api-token CF_ACCOUNT_ID=some-account-id jest --silent=false --verbose=true"
+    "test": "CF_API_TOKEN=some-api-token CF_ACCOUNT_ID=some-account-id jest --silent=false --verbose=true",
+    "test-watch": "npm run test -- --runInBand --testTimeout=50000 --watch"
   },
   "engines": {
     "node": ">=16.7.0"

package/pages/functions/buildWorker.ts

@@ -6,6 +6,7 @@ type Options = {
   outfile: string;
   minify?: boolean;
   sourcemap?: boolean;
+  fallbackService?: string;
   watch?: boolean;
   onEnd?: () => void;
 };
@@ -15,6 +16,7 @@ export function buildWorker({
   outfile = "bundle.js",
   minify = false,
   sourcemap = false,
+  fallbackService = "ASSETS",
   watch = false,
   onEnd = () => {},
 }: Options) {
@@ -31,6 +33,9 @@ export function buildWorker({
     sourcemap,
     watch,
     allowOverwrite: true,
+    define: {
+      __FALLBACK_SERVICE__: JSON.stringify(fallbackService),
+    },
     plugins: [
       {
         name: "wrangler notifier and monitor",

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

@@ -1,8 +1,15 @@
 import { compareRoutes } from "./filepath-routing";
 
 describe("compareRoutes()", () => {
+  test("routes / last", () => {
+    expect(compareRoutes("/", "/foo")).toBeGreaterThanOrEqual(1);
+    expect(compareRoutes("/", "/:foo")).toBeGreaterThanOrEqual(1);
+    expect(compareRoutes("/", "/:foo*")).toBeGreaterThanOrEqual(1);
+  });
+
   test("routes with fewer segments come after those with more segments", () => {
-    expect(compareRoutes("/foo", "/foo/bar")).toBe(1);
+    expect(compareRoutes("/foo", "/foo/bar")).toBeGreaterThanOrEqual(1);
+    expect(compareRoutes("/foo", "/foo/bar/cat")).toBeGreaterThanOrEqual(1);
   });
 
   test("routes with wildcard segments come after those without", () => {

package/pages/functions/filepath-routing.ts

@@ -3,9 +3,8 @@ import fs from "fs/promises";
 import { transform } from "esbuild";
 import * as acorn from "acorn";
 import * as acornWalk from "acorn-walk";
-import type { Config } from "./routes";
-import type { Identifier } from "estree";
-import type { ExportNamedDeclaration } from "@babel/types";
+import type { Config, RouteConfig } from "./routes";
+import type { ExportNamedDeclaration, Identifier } from "estree";
 
 type Arguments = {
   baseDir: string;
@@ -16,10 +15,7 @@ export async function generateConfigFromFileTree({
   baseDir,
   baseURL,
 }: Arguments) {
-  let routeEntries: [
-    string,
-    { [key in "module" | "middleware"]?: string[] }
-  ][] = [] as any;
+  let routeEntries: [string, RouteConfig][] = [];
 
   if (!baseURL.startsWith("/")) {
     baseURL = `/${baseURL}`;
@@ -31,7 +27,7 @@ export async function generateConfigFromFileTree({
 
   await forEachFile(baseDir, async (filepath) => {
     const ext = path.extname(filepath);
-    if (/\.(mjs|js|ts)/.test(ext)) {
+    if (/^\.(mjs|js|ts|tsx|jsx)$/.test(ext)) {
       // transform the code to ensure we're working with vanilla JS + ESM
       const { code } = await transform(await fs.readFile(filepath, "utf-8"), {
         loader: ext === ".ts" ? "ts" : "js",
@@ -43,8 +39,10 @@ export async function generateConfigFromFileTree({
         sourceType: "module",
       });
       acornWalk.simple(ast, {
-        ExportNamedDeclaration(_node) {
-          const node: ExportNamedDeclaration = _node as any;
+        ExportNamedDeclaration(_node: unknown) {
+          // This dynamic cast assumes that the AST generated by acornWalk will generate nodes that
+          // are compatible with the eslint AST nodes.
+          const node = _node as ExportNamedDeclaration;
 
           // this is an array because multiple things can be exported from a single statement
           // i.e. `export {foo, bar}` or `export const foo = "f", bar = "b"`
@@ -54,7 +52,7 @@ export async function generateConfigFromFileTree({
             const declaration = node.declaration;
 
             // `export async function onRequest() {...}`
-            if (declaration.type === "FunctionDeclaration") {
+            if (declaration.type === "FunctionDeclaration" && declaration.id) {
               exportNames.push(declaration.id.name);
             }
 
@@ -157,14 +155,14 @@ export async function generateConfigFromFileTree({
 // more specific routes aren't occluded from matching due to
 // less specific routes appearing first in the route list.
 export function compareRoutes(a: string, b: string) {
-  function parseRoutePath(routePath: string) {
-    let [method, segmentedPath] = routePath.split(" ");
-    if (!segmentedPath) {
-      segmentedPath = method;
-      method = null;
-    }
-
-    const segments = segmentedPath.slice(1).split("/");
+  function parseRoutePath(routePath: string): [string | null, string[]] {
+    const parts = routePath.split(" ", 2);
+    // split() will guarantee at least one element.
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const segmentedPath = parts.pop()!;
+    const method = parts.pop() ?? null;
+
+    const segments = segmentedPath.slice(1).split("/").filter(Boolean);
     return [method, segments];
   }
 
@@ -206,7 +204,7 @@ async function forEachFile<T>(
   const searchPaths = [baseDir];
   const returnValues: T[] = [];
 
-  while (searchPaths.length) {
+  while (isNotEmpty(searchPaths)) {
     const cwd = searchPaths.shift();
     const dir = await fs.readdir(cwd, { withFileTypes: true });
     for (const entry of dir) {
@@ -221,3 +219,10 @@ async function forEachFile<T>(
 
   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

@@ -68,7 +68,7 @@ export const validIdentifierRegex = new RegExp(
   "u"
 );
 
-export const isValidIdentifer = (identifier: string) =>
+export const isValidIdentifier = (identifier: string) =>
   validIdentifierRegex.test(identifier);
 
 export const normalizeIdentifier = (identifier: string) =>

package/pages/functions/routes.ts

@@ -1,6 +1,6 @@
 import path from "path";
 import fs from "fs/promises";
-import { isValidIdentifer, normalizeIdentifier } from "./identifiers";
+import { isValidIdentifier, normalizeIdentifier } from "./identifiers";
 
 export const HTTP_METHODS = [
   "HEAD",
@@ -15,7 +15,7 @@ export type HTTPMethod = typeof HTTP_METHODS[number];
 export function isHTTPMethod(
   maybeHTTPMethod: string
 ): maybeHTTPMethod is HTTPMethod {
-  return HTTP_METHODS.includes(maybeHTTPMethod as any);
+  return (HTTP_METHODS as readonly string[]).includes(maybeHTTPMethod);
 }
 
 export type RoutesCollection = Array<{
@@ -27,14 +27,16 @@ export type RoutesCollection = Array<{
 
 export type Config = {
   routes?: RoutesConfig;
-  schedules?: any;
+  schedules?: unknown;
 };
 
 export type RoutesConfig = {
-  [route: string]: {
-    middleware?: string | string[];
-    module?: string | string[];
-  };
+  [route: string]: RouteConfig;
+};
+
+export type RouteConfig = {
+  middleware?: string | string[];
+  module?: string | string[];
 };
 
 type ImportMap = Map<
@@ -91,7 +93,7 @@ export function parseConfig(config: Config, baseDir: string) {
       }
 
       // ensure the module name (if provided) is a valid identifier to guard against injection attacks
-      if (name !== "default" && !isValidIdentifer(name)) {
+      if (name !== "default" && !isValidIdentifier(name)) {
         throw new Error(`Invalid module identifier "${name}"`);
       }
 
@@ -112,7 +114,7 @@ export function parseConfig(config: Config, baseDir: string) {
     });
   }
 
-  for (const [route, props] of Object.entries(config.routes)) {
+  for (const [route, props] of Object.entries(config.routes ?? {})) {
     let [_methods, routePath] = route.split(" ");
     if (!routePath) {
       routePath = _methods;

package/pages/functions/template-worker.ts

@@ -2,11 +2,11 @@ import { match } from "path-to-regexp";
 import type { HTTPMethod } from "./routes";
 
 /* TODO: Grab these from @cloudflare/workers-types instead */
-type Params<P extends string = any> = Record<P, string | string[]>;
+type Params<P extends string = string> = Record<P, string | string[]>;
 
 type EventContext<Env, P extends string, Data> = {
   request: Request;
-  waitUntil: (promise: Promise<any>) => void;
+  waitUntil: (promise: Promise<unknown>) => void;
   next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
   env: Env & { ASSETS: { fetch: typeof fetch } };
   params: Params<P>;
@@ -15,7 +15,7 @@ type EventContext<Env, P extends string, Data> = {
 
 declare type PagesFunction<
   Env = unknown,
-  P extends string = any,
+  P extends string = string,
   Data extends Record<string, unknown> = Record<string, unknown>
 > = (context: EventContext<Env, P, Data>) => Response | Promise<Response>;
 /* end @cloudflare/workers-types */
@@ -29,22 +29,24 @@ type RouteHandler = {
 
 // inject `routes` via ESBuild
 declare const routes: RouteHandler[];
+// define `__FALLBACK_SERVICE__` via ESBuild
+declare const __FALLBACK_SERVICE__: string;
 
 // expect an ASSETS fetcher binding pointing to the asset-server stage
-type Env = {
-  [name: string]: any;
-  ASSETS: { fetch(url: string, init: RequestInit): Promise<Response> };
+type FetchEnv = {
+  [name: string]: { fetch: typeof fetch };
+  ASSETS: { fetch: typeof fetch };
 };
 
 type WorkerContext = {
-  waitUntil: (promise: Promise<any>) => void;
+  waitUntil: (promise: Promise<unknown>) => void;
 };
 
-function* executeRequest(request: Request, env: Env) {
+function* executeRequest(request: Request, _env: FetchEnv) {
   const requestPath = new URL(request.url).pathname;
 
-  // First, iterate through the routes and execute "middlewares" on partial route matches
-  for (const route of routes) {
+  // First, iterate through the routes (backwards) and execute "middlewares" on partial route matches
+  for (const route of [...routes].reverse()) {
     if (
       route.methods.length &&
       !route.methods.includes(request.method as HTTPMethod)
@@ -85,16 +87,10 @@ function* executeRequest(request: Request, env: Env) {
       break;
     }
   }
-
-  // Finally, yield to the asset-server
-  return {
-    handler: () => env.ASSETS.fetch(request.url, request),
-    params: {} as Params,
-  };
 }
 
 export default {
-  async fetch(request: Request, env: Env, workerContext: WorkerContext) {
+  async fetch(request: Request, env: FetchEnv, workerContext: WorkerContext) {
     const handlerIterator = executeRequest(request, env);
     const data = {}; // arbitrary data the user can set between functions
     const next = async (input?: RequestInfo, init?: RequestInit) => {
@@ -102,10 +98,11 @@ export default {
         request = new Request(input, init);
       }
 
-      const { value } = handlerIterator.next();
-      if (value) {
-        const { handler, params } = value;
-        const context: EventContext<unknown, any, any> = {
+      const result = handlerIterator.next();
+      // Note we can't use `!result.done` because this doesn't narrow to the correct type
+      if (result.done == false) {
+        const { handler, params } = result.value;
+        const context = {
           request: new Request(request.clone()),
           next,
           params,
@@ -121,6 +118,12 @@ export default {
           [101, 204, 205, 304].includes(response.status) ? null : response.body,
           response
         );
+      } else if (__FALLBACK_SERVICE__) {
+        // There are no more handlers so finish with the fallback service (`env.ASSETS.fetch` in Pages' case)
+        return env[__FALLBACK_SERVICE__].fetch(request);
+      } else {
+        // There was not fallback service so actually make the request to the origin.
+        return fetch(request);
       }
     };
 

package/src/__tests__/dev.test.tsx

@@ -0,0 +1,67 @@
+import { render } from "ink-testing-library";
+import patchConsole from "patch-console";
+import React from "react";
+import Dev from "../dev";
+import type { DevProps } from "../dev";
+
+describe("Dev component", () => {
+  let restoreConsole;
+  beforeEach(() => (restoreConsole = patchConsole(() => {})));
+  afterEach(() => restoreConsole());
+
+  it("should throw if format is service-worker and there is a public directory", () => {
+    const { lastFrame } = renderDev({
+      format: "service-worker",
+      accountId: "some-account-id",
+      public: "some/public/path",
+    });
+    expect(lastFrame()?.split("\n").slice(0, 2).join("\n"))
+      .toMatchInlineSnapshot(`
+      "Something went wrong:
+      Error: You cannot use the service worker format with a \`public\` directory."
+    `);
+  });
+});
+
+/**
+ * Helper function to make it easier to setup and render the `Dev` component.
+ *
+ * All the `Dev` props are optional here, with sensible defaults for testing.
+ */
+function renderDev({
+  name,
+  entry = "some/entry.ts",
+  port,
+  format,
+  accountId,
+  initialMode = "remote",
+  jsxFactory,
+  jsxFragment,
+  bindings = {},
+  public: publicDir,
+  assetPaths,
+  compatibilityDate,
+  compatibilityFlags,
+  usageModel,
+  buildCommand = {},
+}: Partial<DevProps>) {
+  return render(
+    <Dev
+      name={name}
+      entry={entry}
+      port={port}
+      buildCommand={buildCommand}
+      format={format}
+      initialMode={initialMode}
+      jsxFactory={jsxFactory}
+      jsxFragment={jsxFragment}
+      accountId={accountId}
+      assetPaths={assetPaths}
+      public={publicDir}
+      compatibilityDate={compatibilityDate}
+      compatibilityFlags={compatibilityFlags}
+      usageModel={usageModel}
+      bindings={bindings}
+    />
+  );
+}

package/src/__tests__/index.test.ts

@@ -17,6 +17,7 @@ describe("wrangler", () => {
 
         Commands:
           wrangler init [name]       📥 Create a wrangler.toml configuration file
+          wrangler whoami            🕵️  Retrieve your user info and test your auth config
           wrangler dev <filename>    👂 Start a local server for developing your worker
           wrangler publish [script]  🆙 Publish your Worker to Cloudflare.
           wrangler tail [name]       🦚 Starts a log tailing session for a deployed Worker.
@@ -49,6 +50,7 @@ describe("wrangler", () => {
 
         Commands:
           wrangler init [name]       📥 Create a wrangler.toml configuration file
+          wrangler whoami            🕵️  Retrieve your user info and test your auth config
           wrangler dev <filename>    👂 Start a local server for developing your worker
           wrangler publish [script]  🆙 Publish your Worker to Cloudflare.
           wrangler tail [name]       🦚 Starts a log tailing session for a deployed Worker.

package/src/__tests__/jest.setup.ts

@@ -1,6 +1,10 @@
+import { mockFetchInternal } from "./mock-cfetch";
 import { confirm, prompt } from "../dialogs";
+import { fetchInternal } from "../cfetch/internal";
+
+jest.mock("../cfetch/internal");
+(fetchInternal as jest.Mock).mockImplementation(mockFetchInternal);
 
-jest.mock("../cfetch", () => jest.requireActual("./mock-cfetch"));
 jest.mock("../dialogs");
 
 // By default (if not configured by mockConfirm()) calls to `confirm()` should throw.