wrangler 0.0.12 → 0.0.16

package/bin/wrangler.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-const { spawn } = require("child_process");
-const { join } = require("path");
+const { spawn } = require("node:child_process");
+const { join } = require("node:path");
 const semiver = require("semiver");
 
 const MIN_NODE_VERSION = "16.7.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wrangler",
-  "version": "0.0.12",
+  "version": "0.0.16",
   "author": "wrangler@cloudflare.com",
   "description": "Command-line interface for all things Cloudflare Workers",
   "bin": {
@@ -36,11 +36,11 @@
     "cli"
   ],
   "dependencies": {
-    "esbuild": "0.14.1",
+    "esbuild": "0.14.14",
     "miniflare": "2.2.0",
     "path-to-regexp": "^6.2.0",
     "semiver": "^1.1.0",
-    "xxhash-addon": "^1.4.0"
+    "xxhash-wasm": "^1.0.1"
   },
   "optionalDependencies": {
     "fsevents": "~2.3.2"
@@ -59,28 +59,28 @@
     "acorn-walk": "^8.2.0",
     "chokidar": "^3.5.2",
     "clipboardy": "^3.0.0",
+    "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",
     "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",
+    "jest-fetch-mock": "^3.0.3",
     "mime": "^3.0.0",
-    "node-fetch": "3.1.1",
     "open": "^8.4.0",
     "react": "^17.0.2",
     "react-error-boundary": "^3.1.4",
     "serve-static": "^1.14.1",
     "signal-exit": "^3.0.6",
     "tmp-promise": "^3.0.3",
-    "undici": "^4.11.1",
+    "undici": "4.13.0",
     "ws": "^8.3.0",
     "yargs": "^17.3.0"
   },
@@ -90,16 +90,17 @@
     "pages",
     "miniflare-config-stubs",
     "wrangler-dist",
-    "static-asset-facade.js",
+    "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 && 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": "jest --silent=false --verbose=true",
     "test-watch": "npm run test -- --runInBand --testTimeout=50000 --watch"
   },
   "engines": {
@@ -107,12 +108,13 @@
   },
   "jest": {
     "restoreMocks": true,
+    "testTimeout": 30000,
     "testRegex": ".*.(test|spec)\\.[jt]sx?$",
     "transformIgnorePatterns": [
-      "node_modules/(?!node-fetch|fetch-blob|find-up|locate-path|p-locate|p-limit|yocto-queue|path-exists|data-uri-to-buffer|formdata-polyfill|execa|strip-final-newline|npm-run-path|path-key|onetime|mimic-fn|human-signals|is-stream)"
+      "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)"
     ],
     "moduleNameMapper": {
-      "clipboardy": "<rootDir>/src/__tests__/clipboardy-mock.js"
+      "clipboardy": "<rootDir>/src/__tests__/helpers/clipboardy-mock.js"
     },
     "transform": {
       "^.+\\.c?(t|j)sx?$": [

package/pages/functions/buildWorker.ts

@@ -1,4 +1,4 @@
-import path from "path";
+import path from "node:path";
 import { build } from "esbuild";
 
 type Options = {

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

@@ -1,39 +1,66 @@
+import { toUrlPath } from "../../src/paths";
 import { compareRoutes } from "./filepath-routing";
+import type { HTTPMethod, RouteConfig } from "./routes";
 
 describe("compareRoutes()", () => {
   test("routes / last", () => {
-    expect(compareRoutes("/", "/foo")).toBeGreaterThanOrEqual(1);
-    expect(compareRoutes("/", "/:foo")).toBeGreaterThanOrEqual(1);
-    expect(compareRoutes("/", "/:foo*")).toBeGreaterThanOrEqual(1);
+    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("/foo", "/foo/bar")).toBeGreaterThanOrEqual(1);
-    expect(compareRoutes("/foo", "/foo/bar/cat")).toBeGreaterThanOrEqual(1);
+    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("/:foo*", "/foo")).toBe(1);
-    expect(compareRoutes("/:foo*", "/:foo")).toBe(1);
+    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("/:foo", "/foo")).toBe(1);
+    expect(compareRoutes(routeConfig("/:foo"), routeConfig("/foo"))).toBe(1);
   });
 
-  test("routes with dynamic segments occuring earlier come after those with dynamic segments in later positions", () => {
-    expect(compareRoutes("/foo/:id/bar", "/foo/bar/:id")).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("/foo", "GET /foo")).toBe(1);
+    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("GET /foo", "GET /foo")).toBe(0);
+    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("GET /foo", "/foo")).toBe(-1);
+    expect(compareRoutes(routeConfig("/foo", "GET"), routeConfig("/foo"))).toBe(
+      -1
+    );
   });
 });
+
+function routeConfig(routePath: string, method?: string): RouteConfig {
+  return {
+    routePath: toUrlPath(routePath),
+    method: method as HTTPMethod,
+  };
+}

package/pages/functions/filepath-routing.ts

@@ -1,28 +1,28 @@
-import path from "path";
-import fs from "fs/promises";
-import { transform } from "esbuild";
+import fs from "node:fs/promises";
+import path from "node:path";
 import * as acorn from "acorn";
 import * as acornWalk from "acorn-walk";
-import type { Config, RouteConfig } from "./routes";
+import { transform } from "esbuild";
+import { toUrlPath } from "../../src/paths";
+import type { UrlPath } from "../../src/paths";
+import type { HTTPMethod, RouteConfig } from "./routes";
 import type { ExportNamedDeclaration, Identifier } from "estree";
 
-type Arguments = {
-  baseDir: string;
-  baseURL: string;
-};
-
 export async function generateConfigFromFileTree({
   baseDir,
   baseURL,
-}: Arguments) {
-  let routeEntries: [string, RouteConfig][] = [];
+}: {
+  baseDir: string;
+  baseURL: UrlPath;
+}) {
+  let routeEntries: RouteConfig[] = [];
 
   if (!baseURL.startsWith("/")) {
-    baseURL = `/${baseURL}`;
+    baseURL = `/${baseURL}` as UrlPath;
   }
 
   if (baseURL.endsWith("/")) {
-    baseURL = baseURL.slice(0, -1);
+    baseURL = baseURL.slice(0, -1) as UrlPath;
   }
 
   await forEachFile(baseDir, async (filepath) => {
@@ -78,10 +78,9 @@ export async function generateConfigFromFileTree({
           }
 
           for (const exportName of exportNames) {
-            const [match, method] =
-              exportName.match(
-                /^onRequest(Get|Post|Put|Patch|Delete|Options|Head)?$/
-              ) ?? [];
+            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);
@@ -108,18 +107,15 @@ export async function generateConfigFromFileTree({
               routePath = routePath.replace(/\[\[(.+)]]/g, ":$1*"); // transform [[id]] => :id*
               routePath = routePath.replace(/\[(.+)]/g, ":$1"); // transform [id] => :id
 
-              if (method) {
-                routePath = `${method.toUpperCase()} ${routePath}`;
-              }
+              const routeEntry: RouteConfig = {
+                routePath: toUrlPath(routePath),
+                method: method.toUpperCase() as HTTPMethod,
+                [isMiddlewareFile ? "middleware" : "module"]: [
+                  `${path.relative(baseDir, filepath)}:${exportName}`,
+                ],
+              };
 
-              routeEntries.push([
-                routePath,
-                {
-                  [isMiddlewareFile ? "middleware" : "module"]: [
-                    `${path.relative(baseDir, filepath)}:${exportName}`,
-                  ],
-                },
-              ]);
+              routeEntries.push(routeEntry);
             }
           }
         },
@@ -129,45 +125,40 @@ export async function generateConfigFromFileTree({
 
   // Combine together any routes (index routes) which contain both a module and a middleware
   routeEntries = routeEntries.reduce(
-    (acc: typeof routeEntries, [routePath, routeHandler]) => {
+    (acc: typeof routeEntries, { routePath, ...rest }) => {
       const existingRouteEntry = acc.find(
-        (routeEntry) => routeEntry[0] === routePath
+        (routeEntry) => routeEntry.routePath === routePath
       );
       if (existingRouteEntry !== undefined) {
-        existingRouteEntry[1] = {
-          ...existingRouteEntry[1],
-          ...routeHandler,
-        };
+        Object.assign(existingRouteEntry, rest);
       } else {
-        acc.push([routePath, routeHandler]);
+        acc.push({ routePath, ...rest });
       }
       return acc;
     },
     []
   );
 
-  routeEntries.sort(([pathA], [pathB]) => compareRoutes(pathA, pathB));
+  routeEntries.sort((a, b) => compareRoutes(a, b));
 
-  return { routes: Object.fromEntries(routeEntries) } as Config;
+  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(a: string, b: string) {
-  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];
+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 [methodA, segmentsA] = parseRoutePath(a);
-  const [methodB, segmentsB] = parseRoutePath(b);
+  const segmentsA = parseRoutePath(routePathA);
+  const segmentsB = parseRoutePath(routePathB);
 
   // sort routes with fewer segments after those with more segments
   if (segmentsA.length !== segmentsB.length) {
@@ -193,8 +184,8 @@ export function compareRoutes(a: string, b: string) {
   if (methodA && !methodB) return -1;
   if (!methodA && methodB) return 1;
 
-  // all else equal, just sort them lexicographically
-  return a.localeCompare(b);
+  // all else equal, just sort the paths lexicographically
+  return routePathA.localeCompare(routePathB);
 }
 
 async function forEachFile<T>(

package/pages/functions/routes.ts

@@ -1,6 +1,7 @@
-import path from "path";
-import fs from "fs/promises";
+import fs from "node:fs/promises";
+import path from "node:path";
 import { isValidIdentifier, normalizeIdentifier } from "./identifiers";
+import type { UrlPath } from "../../src/paths";
 
 export const HTTP_METHODS = [
   "HEAD",
@@ -19,22 +20,20 @@ export function isHTTPMethod(
 }
 
 export type RoutesCollection = Array<{
-  routePath: string;
-  methods: HTTPMethod[];
+  routePath: UrlPath;
+  method?: HTTPMethod;
   modules: string[];
   middlewares: string[];
 }>;
 
 export type Config = {
-  routes?: RoutesConfig;
+  routes?: RouteConfig[];
   schedules?: unknown;
 };
 
-export type RoutesConfig = {
-  [route: string]: RouteConfig;
-};
-
 export type RouteConfig = {
+  routePath: UrlPath;
+  method?: HTTPMethod;
   middleware?: string | string[];
   module?: string | string[];
 };
@@ -114,16 +113,10 @@ export function parseConfig(config: Config, baseDir: string) {
     });
   }
 
-  for (const [route, props] of Object.entries(config.routes ?? {})) {
-    let [_methods, routePath] = route.split(" ");
-    if (!routePath) {
-      routePath = _methods;
-      _methods = "";
-    }
-
+  for (const { routePath, method, ...props } of config.routes ?? []) {
     routes.push({
       routePath,
-      methods: _methods.split("|").filter(isHTTPMethod),
+      method,
       middlewares: parseModuleIdentifiers(props.middleware),
       modules: parseModuleIdentifiers(props.module),
     });
@@ -148,7 +141,7 @@ export const routes = [
     .map(
       (route) => `  {
       routePath: "${route.routePath}",
-      methods: ${JSON.stringify(route.methods)},
+      method: "${route.method}",
       middlewares: [${route.middlewares.join(", ")}],
       modules: [${route.modules.join(", ")}],
     },`

package/pages/functions/template-worker.ts

@@ -22,7 +22,7 @@ declare type PagesFunction<
 
 type RouteHandler = {
   routePath: string;
-  methods: HTTPMethod[];
+  method?: HTTPMethod;
   modules: PagesFunction[];
   middlewares: PagesFunction[];
 };
@@ -47,10 +47,7 @@ function* executeRequest(request: Request, _env: FetchEnv) {
 
   // 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)
-    ) {
+    if (route.method && route.method !== request.method) {
       continue;
     }
 
@@ -68,10 +65,7 @@ function* executeRequest(request: Request, _env: FetchEnv) {
 
   // Then look for the first exact route match and execute its "modules"
   for (const route of routes) {
-    if (
-      route.methods.length &&
-      !route.methods.includes(request.method as HTTPMethod)
-    ) {
+    if (route.method && route.method !== request.method) {
       continue;
     }
 

package/src/__tests__/dev.test.tsx

@@ -44,11 +44,14 @@ function renderDev({
   compatibilityFlags,
   usageModel,
   buildCommand = {},
+  enableLocalPersistence = false,
+  env = undefined,
 }: Partial<DevProps>) {
   return render(
     <Dev
       name={name}
       entry={entry}
+      env={env}
       port={port}
       buildCommand={buildCommand}
       format={format}
@@ -62,6 +65,7 @@ function renderDev({
       compatibilityFlags={compatibilityFlags}
       usageModel={usageModel}
       bindings={bindings}
+      enableLocalPersistence={enableLocalPersistence}
     />
   );
 }

package/src/__tests__/helpers/cmd-shim.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The typings file available at `@types/cmd-shim` are out of date.
+ */
+module "cmd-shim" {
+  /**
+   *
+   * Create a cmd shim at `to` for the command line program at `from`.
+   *
+   */
+  export default function cmdShim(from: string, to: string): Promise<void>;
+}

package/src/__tests__/helpers/mock-account-id.ts

@@ -0,0 +1,30 @@
+const ORIGINAL_CF_API_TOKEN = process.env.CF_API_TOKEN;
+const ORIGINAL_CF_ACCOUNT_ID = process.env.CF_ACCOUNT_ID;
+
+/**
+ * Mock the API token so that we don't need to read it from user configuration files.
+ */
+export function mockApiToken({
+  apiToken = "some-api-token",
+}: { apiToken?: string } = {}) {
+  beforeEach(() => {
+    process.env.CF_API_TOKEN = apiToken;
+  });
+  afterEach(() => {
+    process.env.CF_API_TOKEN = ORIGINAL_CF_API_TOKEN;
+  });
+}
+
+/**
+ * Mock the current account ID so that we don't need to read it from configuration files.
+ */
+export function mockAccountId({
+  accountId = "some-account-id",
+}: { accountId?: string } = {}) {
+  beforeEach(() => {
+    process.env.CF_ACCOUNT_ID = accountId;
+  });
+  afterEach(() => {
+    process.env.CF_ACCOUNT_ID = ORIGINAL_CF_ACCOUNT_ID;
+  });
+}

package/src/__tests__/helpers/mock-bin.ts

@@ -0,0 +1,33 @@
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import cmdShim from "cmd-shim";
+
+const nodeShebang = "#!/usr/bin/env node";
+
+/**
+ * Create a binary file in a temp directory and make it available on the PATH.
+ */
+export async function mockBinary(binaryName: string, code: string) {
+  // Ensure there is a directory to put the mock binary in.
+  const tmpDir = resolve(mkdtempSync(".mock-binary-"));
+
+  // Use a fake extension on Windows because we will create a cmd-shim to run the binary.
+  const extension = process.platform === "win32" ? ".x-mock-bin" : "";
+  const filePath = resolve(tmpDir, `${binaryName}${extension}`);
+  writeFileSync(filePath, nodeShebang + "\n" + code);
+  chmodSync(filePath, 0o777);
+
+  if (process.platform === "win32") {
+    await cmdShim(filePath, basename(filePath, ".x-mock-bin"));
+  }
+
+  // Update PATH using the appropriate separator for the platform.
+  const oldPath = process.env.PATH;
+  const sep = process.platform === "win32" ? ";" : ":";
+  process.env.PATH = tmpDir + sep + oldPath;
+
+  return function unMock() {
+    rmSync(tmpDir, { recursive: true });
+    process.env.PATH = process.env.PATH?.replace(tmpDir + sep, "");
+  };
+}

package/src/__tests__/{mock-cfetch.ts → helpers/mock-cfetch.ts}

@@ -1,8 +1,8 @@
-import type { RequestInit } from "node-fetch";
-import { URLSearchParams } from "node:url";
+import { URL, URLSearchParams } from "node:url";
 import { pathToRegexp } from "path-to-regexp";
-import { CF_API_BASE_URL } from "../cfetch";
-import type { FetchResult } from "../cfetch";
+import { CF_API_BASE_URL } from "../../cfetch";
+import type { FetchResult } from "../../cfetch";
+import type { RequestInit } from "undici";
 
 /**
  * The signature of the function that will handle a mock request.
@@ -11,7 +11,7 @@ export type MockHandler<ResponseType> = (
   uri: RegExpExecArray,
   init: RequestInit,
   queryParams: URLSearchParams
-) => ResponseType;
+) => ResponseType | Promise<ResponseType>;
 
 type RemoveMockFn = () => void;
 
@@ -41,7 +41,7 @@ export async function mockFetchInternal(
     if (uri !== null && (!method || method === (init.method ?? "GET"))) {
       // The `resource` regular expression will extract the labelled groups from the URL.
       // These are passed through to the `handler` call, to allow it to do additional checks or behaviour.
-      return handler(uri, init, queryParams); // TODO: should we have some kind of fallthrough system? we'll see.
+      return await handler(uri, init, queryParams); // TODO: should we have some kind of fallthrough system? we'll see.
     }
   }
   throw new Error(
@@ -140,23 +140,23 @@ export function setMockResponse<ResponseType>(
 /**
  * A helper to make it easier to create `FetchResult` objects in tests.
  */
-export function createFetchResult<ResponseType>(
-  result: ResponseType,
+export async function createFetchResult<ResponseType>(
+  result: ResponseType | Promise<ResponseType>,
   success = true,
   errors = [],
   messages = [],
   result_info?: unknown
-): FetchResult<ResponseType> {
+): Promise<FetchResult<ResponseType>> {
   return result_info
     ? {
-        result,
+        result: await result,
         success,
         errors,
         messages,
         result_info,
       }
     : {
-        result,
+        result: await result,
         success,
         errors,
         messages,
@@ -171,3 +171,37 @@ export function createFetchResult<ResponseType>(
 export function unsetAllMocks() {
   mocks.length = 0;
 }
+
+/**
+ * We special-case fetching the request for `kv:key get`, because it's
+ * the only cloudflare API endpoint that returns a plain string as the
+ * value, and not as the "standard" FetchResult-style json. Hence, we also
+ * special-case mocking it here.
+ */
+
+const kvGetMocks = new Map<string, string>();
+
+export function mockFetchKVGetValue(
+  accountId: string,
+  namespaceId: string,
+  key: string
+) {
+  const mapKey = `${accountId}/${namespaceId}/${key}`;
+  if (kvGetMocks.has(mapKey)) {
+    return kvGetMocks.get(mapKey);
+  }
+  throw new Error(`no mock value found for \`kv:key get\` - ${mapKey}`);
+}
+
+export function setMockFetchKVGetValue(
+  accountId: string,
+  namespaceId: string,
+  key: string,
+  value: string
+) {
+  kvGetMocks.set(`${accountId}/${namespaceId}/${key}`, value);
+}
+
+export function unsetMockFetchKVGetValues() {
+  kvGetMocks.clear();
+}