wrangler 0.0.0-eee5c78 → 0.0.0-ef9dac8

package/bin/wrangler.js

@@ -9,7 +9,10 @@ const MIN_NODE_VERSION = "16.7.0";
 
 let wranglerProcess;
 
-async function main() {
+/**
+ * Executes ../wrangler-dist/cli.js
+ */
+function runWrangler() {
   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
@@ -46,7 +49,7 @@ Consider using a Node.js version manager such as https://volta.sh/ or https://gi
     pathToCACerts = certPath;
   }
 
-  wranglerProcess = spawn(
+  return spawn(
     process.execPath,
     [
       ...(semiver(process.versions.node, "18.0.0") >= 0
@@ -70,11 +73,65 @@ Consider using a Node.js version manager such as https://volta.sh/ or https://gi
   );
 }
 
+/**
+ * Runs a locally-installed version of wrangler, delegating from this version.
+ * @throws {MODULE_NOT_FOUND} if there isn't a locally installed version of wrangler.
+ */
+function runDelegatedWrangler() {
+  const packageJsonPath = require.resolve("wrangler/package.json", {
+    paths: [process.cwd()],
+  });
+  const {
+    bin: { wrangler: binaryPath },
+    version,
+  } = JSON.parse(fs.readFileSync(packageJsonPath));
+  const resolvedBinaryPath = path.resolve(packageJsonPath, "..", binaryPath);
+
+  console.log(
+    `Delegating to locally-installed version of wrangler @ v${version}`
+  );
+  // this call to `spawn` is simpler because the delegated version will do all
+  // of the other work.
+  return spawn(
+    process.execPath,
+    [resolvedBinaryPath, ...process.argv.slice(2)],
+    {
+      stdio: "inherit",
+    }
+  ).on("exit", (code) =>
+    process.exit(code === undefined || code === null ? 0 : code)
+  );
+}
+
+/**
+ * Indicates if this invocation of `wrangler` should delegate
+ * to a locally-installed version.
+ */
+function shouldDelegate() {
+  try {
+    // `require.resolve` will throw if it can't find
+    // a locally-installed version of `wrangler`
+    const delegatedPackageJson = require.resolve("wrangler/package.json", {
+      paths: [process.cwd()],
+    });
+    const thisPackageJson = path.resolve(__dirname, "..", "package.json");
+    // if it's the same path, then we're already a local install -- no need to delegate
+    return thisPackageJson !== delegatedPackageJson;
+  } catch (e) {
+    // there's no local version to delegate to -- `require.resolve` threw
+    return false;
+  }
+}
+
+async function main() {
+  wranglerProcess = shouldDelegate() ? runDelegatedWrangler() : runWrangler();
+}
+
 process.on("SIGINT", () => {
-  wranglerProcess.kill();
+  wranglerProcess?.kill();
 });
 process.on("SIGTERM", () => {
-  wranglerProcess.kill();
+  wranglerProcess?.kill();
 });
 
 void main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wrangler",
-  "version": "0.0.0-eee5c78",
+  "version": "0.0.0-ef9dac8",
   "author": "wrangler@cloudflare.com",
   "description": "Command-line interface for all things Cloudflare Workers",
   "bin": {
@@ -41,7 +41,7 @@
     "@esbuild-plugins/node-modules-polyfill": "^0.1.4",
     "blake3-wasm": "^2.1.5",
     "esbuild": "0.14.34",
-    "miniflare": "^2.5.0",
+    "miniflare": "^2.5.1",
     "nanoid": "^3.3.3",
     "path-to-regexp": "^6.2.0",
     "selfsigned": "^2.0.1",
@@ -68,6 +68,7 @@
     "clipboardy": "^3.0.0",
     "cmd-shim": "^4.1.0",
     "command-exists": "^1.2.9",
+    "concurrently": "^7.2.2",
     "devtools-protocol": "^0.0.955664",
     "dotenv": "^16.0.0",
     "execa": "^6.1.0",
@@ -99,7 +100,7 @@
     "timeago.js": "^4.0.2",
     "tmp-promise": "^3.0.3",
     "ts-dedent": "^2.2.0",
-    "undici": "^5.3.0",
+    "undici": "^5.5.1",
     "update-check": "^1.5.4",
     "ws": "^8.5.0",
     "yargs": "^17.4.1"
@@ -107,7 +108,6 @@
   "files": [
     "src",
     "bin",
-    "pages",
     "miniflare-config-stubs",
     "miniflare-dist",
     "wrangler-dist",
@@ -122,6 +122,7 @@
     "check:type": "tsc",
     "bundle": "node -r esbuild-register scripts/bundle.ts",
     "build": "npm run clean && npm run bundle",
+    "dev": "npm run clean && concurrently -c black,blue 'npm run bundle -- --watch' 'npm run check:type -- --watch --preserveWatchOutput'",
     "prepublishOnly": "SOURCEMAPS=false npm run build",
     "start": "npm run bundle && NODE_OPTIONS=--enable-source-maps ./bin/wrangler.js",
     "test": "jest --silent=false --verbose=true",

package/src/__tests__/configuration.test.ts

@@ -412,6 +412,67 @@ describe("normalizeAndValidateConfig()", () => {
       });
     });
 
+    describe("assets", () => {
+      it("should error if `assets` config is missing `bucket`", () => {
+        const expectedConfig: RawConfig = {
+          // @ts-expect-error we're intentionally passing an invalid configuration here
+          assets: {
+            include: ["INCLUDE_1", "INCLUDE_2"],
+            exclude: ["EXCLUDE_1", "EXCLUDE_2"],
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(expect.objectContaining(expectedConfig));
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.hasErrors()).toBe(true);
+
+        expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - \\"assets\\" fields are experimental and may change or break at any time."
+        `);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - \\"assets.bucket\\" is a required field."
+        `);
+      });
+
+      it("should error on invalid `assets` values", () => {
+        const expectedConfig = {
+          assets: {
+            bucket: "BUCKET",
+            include: [222, 333],
+            exclude: [444, 555],
+          },
+        };
+
+        const { config, diagnostics } = normalizeAndValidateConfig(
+          expectedConfig as unknown as RawConfig,
+          undefined,
+          { env: undefined }
+        );
+
+        expect(config).toEqual(expect.objectContaining(expectedConfig));
+        expect(diagnostics.hasWarnings()).toBe(true);
+        expect(diagnostics.renderWarnings()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - \\"assets\\" fields are experimental and may change or break at any time."
+        `);
+        expect(diagnostics.renderErrors()).toMatchInlineSnapshot(`
+          "Processing wrangler configuration:
+            - Expected \\"assets.include.[0]\\" to be of type string but got 222.
+            - Expected \\"assets.include.[1]\\" to be of type string but got 333.
+            - Expected \\"assets.exclude.[0]\\" to be of type string but got 444.
+            - Expected \\"assets.exclude.[1]\\" to be of type string but got 555."
+        `);
+      });
+    });
+
     it("should map `wasm_module` paths from relative to the config path to relative to the cwd", () => {
       const expectedConfig: RawConfig = {
         wasm_modules: {

package/src/__tests__/dev.test.tsx

@@ -403,6 +403,46 @@ describe("wrangler dev", () => {
     });
   });
 
+  describe("local upstream", () => {
+    it("should use dev.host from toml by default", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        dev: {
+          host: `2.some-host.com`,
+        },
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev --local");
+      expect((Dev as jest.Mock).mock.calls[0][0].localUpstream).toEqual(
+        "2.some-host.com"
+      );
+    });
+
+    it("should use route from toml by default", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        route: "https://4.some-host.com/some/path/*",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev --local");
+      expect((Dev as jest.Mock).mock.calls[0][0].host).toEqual(
+        "4.some-host.com"
+      );
+    });
+
+    it("should respect the option when provided", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        route: `2.some-host.com`,
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev --local-upstream some-host.com --local");
+      expect((Dev as jest.Mock).mock.calls[0][0].localUpstream).toEqual(
+        "some-host.com"
+      );
+    });
+  });
+
   describe("custom builds", () => {
     it("should run a custom build before starting `dev`", async () => {
       writeWranglerToml({
@@ -799,7 +839,7 @@ describe("wrangler dev", () => {
     });
   });
 
-  describe("site", () => {
+  describe("serve static assets", () => {
     it("should error if --site is used with no value", async () => {
       await expect(
         runWrangler("dev --site")
@@ -839,7 +879,8 @@ describe("wrangler dev", () => {
               --routes, --route                            Routes to upload  [array]
               --host                                       Host to forward requests to, defaults to the zone of project  [string]
               --local-protocol                             Protocol to listen to requests on, defaults to http.  [choices: \\"http\\", \\"https\\"]
-              --experimental-public                        Static assets to be served  [string]
+              --local-upstream                             Host to act as origin in local mode, defaults to dev.host or route  [string]
+              --assets                                     Static assets to be served  [string]
               --site                                       Root folder of static assets for Workers Sites  [string]
               --site-include                               Array of .gitignore-style patterns that match file or directory names from the sites directory. Only matched items will be uploaded.  [array]
               --site-exclude                               Array of .gitignore-style patterns that match file or directory names from the sites directory. Matched items will not be uploaded.  [array]
@@ -856,6 +897,119 @@ describe("wrangler dev", () => {
         }
       `);
     });
+
+    it("should error if --assets and --site are used together", async () => {
+      writeWranglerToml({
+        main: "./index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await expect(
+        runWrangler("dev --assets abc --site xyz")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Cannot use Assets and Workers Sites in the same Worker."`
+      );
+    });
+
+    it("should error if --assets and config.site are used together", async () => {
+      writeWranglerToml({
+        main: "./index.js",
+        site: {
+          bucket: "xyz",
+        },
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await expect(
+        runWrangler("dev --assets abc")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Cannot use Assets and Workers Sites in the same Worker."`
+      );
+    });
+
+    it("should error if config.assets and --site are used together", async () => {
+      writeWranglerToml({
+        main: "./index.js",
+        assets: "abc",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await expect(
+        runWrangler("dev --site xyz")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Cannot use Assets and Workers Sites in the same Worker."`
+      );
+    });
+
+    it("should error if config.assets and config.site are used together", async () => {
+      writeWranglerToml({
+        main: "./index.js",
+        assets: "abc",
+        site: {
+          bucket: "xyz",
+        },
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await expect(
+        runWrangler("dev --assets abc")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Cannot use Assets and Workers Sites in the same Worker."`
+      );
+    });
+
+    it("should indicate whether Sites is being used", async () => {
+      writeWranglerToml({
+        main: "index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+
+      await runWrangler("dev");
+      expect((Dev as jest.Mock).mock.calls[0][0].isWorkersSite).toEqual(false);
+
+      await runWrangler("dev --site abc");
+      expect((Dev as jest.Mock).mock.calls[1][0].isWorkersSite).toEqual(true);
+
+      await runWrangler("dev --assets abc");
+      expect((Dev as jest.Mock).mock.calls[2][0].isWorkersSite).toEqual(false);
+    });
+
+    it("should warn if --assets is used", async () => {
+      writeWranglerToml({
+        main: "./index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+
+      await runWrangler('dev --assets "./assets"');
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "",
+          "warn": "▲ [WARNING] The --assets argument is experimental and may change or break at any time
+
+        ",
+        }
+      `);
+    });
+
+    it("should warn if config.assets is used", async () => {
+      writeWranglerToml({
+        main: "./index.js",
+        assets: "./assets",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+
+      await runWrangler("dev");
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "",
+          "warn": "▲ [WARNING] Processing wrangler.toml configuration:
+
+            - \\"assets\\" fields are experimental and may change or break at any time.
+
+        ",
+        }
+      `);
+    });
   });
 
   describe("--inspect", () => {

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

@@ -179,7 +179,7 @@ export function unsetAllMocks() {
  * special-case mocking it here.
  */
 
-const kvGetMocks = new Map<string, string>();
+const kvGetMocks = new Map<string, string | Buffer>();
 
 /**
  * @mocked typeof fetchKVGetValue
@@ -201,7 +201,7 @@ export function setMockFetchKVGetValue(
   accountId: string,
   namespaceId: string,
   key: string,
-  value: string
+  value: string | Buffer
 ) {
   kvGetMocks.set(`${accountId}/${namespaceId}/${key}`, value);
 }

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

@@ -28,7 +28,9 @@ const std = {
 
 function normalizeOutput(spy: jest.SpyInstance): string {
   return normalizeErrorMarkers(
-    stripTrailingWhitespace(normalizeSlashes(stripTimings(captureCalls(spy))))
+    replaceByte(
+      stripTrailingWhitespace(normalizeSlashes(stripTimings(captureCalls(spy))))
+    )
   );
 }
 
@@ -85,3 +87,11 @@ export function stripTimings(stdout: string): string {
 export function stripTrailingWhitespace(str: string): string {
   return str.replace(/[^\S\n]+\n/g, "\n");
 }
+
+/**
+ * Removing leading kilobit (tenth of a byte) from test output due to
+ * variation causing every few tests the value to change by ± .01
+ */
+function replaceByte(stdout: string): string {
+  return stdout.replaceAll(/.[0-9][0-9] KiB/g, "xx KiB");
+}

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

@@ -20,13 +20,22 @@ export interface ConfirmExpectation {
  */
 export function mockConfirm(...expectations: ConfirmExpectation[]) {
   (confirm as jest.Mock).mockImplementation((text: string) => {
-    for (const { text: expectedText, result } of expectations) {
-      if (normalizeSlashes(text) === normalizeSlashes(expectedText)) {
-        return Promise.resolve(result);
+    for (const expectation of expectations) {
+      if (normalizeSlashes(text) === normalizeSlashes(expectation.text)) {
+        expectations = expectations.filter((e) => e !== expectation);
+        return Promise.resolve(expectation.result);
       }
     }
     throw new Error(`Unexpected confirmation message: ${text}`);
   });
+  return () => {
+    if (expectations.length > 0) {
+      throw new Error(
+        "The following expected confirmation dialogs were not used:\n" +
+          expectations.map((e) => `- "${e.text}"`).join("\n")
+      );
+    }
+  };
 }
 
 export function clearConfirmMocks() {
@@ -63,18 +72,23 @@ export interface PromptExpectation {
 export function mockPrompt(...expectations: PromptExpectation[]) {
   (prompt as jest.Mock).mockImplementation(
     (text: string, type: "text" | "password") => {
-      for (const {
-        text: expectedText,
-        type: expectedType,
-        result,
-      } of expectations) {
-        if (text === expectedText && type == expectedType) {
-          return Promise.resolve(result);
+      for (const expectation of expectations) {
+        if (text === expectation.text && type == expectation.type) {
+          expectations = expectations.filter((e) => e !== expectation);
+          return Promise.resolve(expectation.result);
         }
       }
       throw new Error(`Unexpected confirmation message: ${text}`);
     }
   );
+  return () => {
+    if (expectations.length > 0) {
+      throw new Error(
+        "The following expected prompt dialogs were not used:\n" +
+          expectations.map((e) => `- "${e.text}"`).join("\n")
+      );
+    }
+  };
 }
 
 export function clearPromptMocks() {
@@ -108,13 +122,22 @@ export interface SelectExpectation {
  */
 export function mockSelect(...expectations: SelectExpectation[]) {
   (select as jest.Mock).mockImplementation((text: string) => {
-    for (const { text: expectedText, result } of expectations) {
-      if (normalizeSlashes(text) === normalizeSlashes(expectedText)) {
-        return Promise.resolve(result);
+    for (const expectation of expectations) {
+      if (normalizeSlashes(text) === normalizeSlashes(expectation.text)) {
+        expectations = expectations.filter((e) => e !== expectation);
+        return Promise.resolve(expectation.result);
       }
     }
     throw new Error(`Unexpected select message: ${text}`);
   });
+  return () => {
+    if (expectations.length > 0) {
+      throw new Error(
+        "The following expected select dialogs were not used:\n" +
+          expectations.map((e) => `- "${e.text}"`).join("\n")
+      );
+    }
+  };
 }
 
 export function clearSelectMocks() {

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

@@ -8,9 +8,14 @@ export function useMockIsTTY() {
   /**
    * Explicitly set `process.stdout.isTTY` to a given value
    */
-  const setIsTTY = (isTTY: boolean) => {
-    process.stdout.isTTY = isTTY;
-    process.stdin.isTTY = isTTY;
+  const setIsTTY = (isTTY: boolean | { stdin: boolean; stdout: boolean }) => {
+    if (typeof isTTY === "boolean") {
+      process.stdout.isTTY = isTTY;
+      process.stdin.isTTY = isTTY;
+    } else {
+      process.stdin.isTTY = isTTY.stdin;
+      process.stdout.isTTY = isTTY.stdout;
+    }
   };
 
   beforeEach(() => {

package/src/__tests__/helpers/mock-oauth-flow.ts

@@ -1,9 +1,27 @@
 import fetchMock from "jest-fetch-mock";
 import { Request } from "undici";
-import { getCloudflareApiBaseUrl } from "../../cfetch";
 import openInBrowser from "../../open-in-browser";
+import {
+  createFetchResult,
+  setMockRawResponse,
+  setMockResponse,
+} from "./mock-cfetch";
 import { mockHttpServer } from "./mock-http-server";
 
+export function mockGetMemberships(
+  accounts: { id: string; account: { id: string; name: string } }[]
+) {
+  setMockResponse("/memberships", "GET", () => {
+    return accounts;
+  });
+}
+
+export function mockGetMembershipsFail() {
+  setMockRawResponse("/memberships", () => {
+    return createFetchResult([], false);
+  });
+}
+
 // the response to send when wrangler wants an oauth grant
 let oauthGrantResponse: GrantResponseOptions | "timeout" = {};
 
@@ -86,28 +104,6 @@ export const mockOAuthFlow = () => {
     return outcome;
   };
 
-  const mockGetMemberships = (args: {
-    success: boolean;
-    result: { id: string; account: { id: string; name: string } }[];
-  }) => {
-    const outcome = {
-      actual: new Request("https://example.org"),
-      expected: new Request(`${getCloudflareApiBaseUrl()}/memberships`, {
-        method: "GET",
-      }),
-    };
-
-    fetchMock.mockIf(outcome.expected.url, async (req) => {
-      outcome.actual = req;
-      return {
-        status: 200,
-        body: JSON.stringify(args),
-      };
-    });
-
-    return outcome;
-  };
-
   const mockGrantAccessToken = ({
     respondWith,
   }: {
@@ -173,7 +169,6 @@ export const mockOAuthFlow = () => {
   };
 
   return {
-    mockGetMemberships,
     mockGrantAccessToken,
     mockGrantAuthorization,
     mockOAuthServerCallback,

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

@@ -0,0 +1,39 @@
+/**
+ * We use this module to mock process methods (write only for now),
+ * and optionally assert on the values they're called with in our tests.
+ */
+
+let writeSpy: jest.SpyInstance;
+
+function captureLastWriteCall(spy: jest.SpyInstance): Buffer {
+  const calls = spy.mock.calls;
+  if (calls.length > 1) {
+    throw new Error(
+      "Unexpected calls to `stdout.write()`: " + JSON.stringify(calls)
+    );
+  }
+  const buffer = calls[0]?.[0] ?? Buffer.alloc(0);
+  if (buffer instanceof Buffer) {
+    return buffer;
+  } else {
+    throw new Error(
+      `Unexpected non-Buffer passed to \`stdout.write()\`: "${JSON.stringify(
+        buffer
+      )}"`
+    );
+  }
+}
+
+export function mockProcess() {
+  beforeEach(() => {
+    writeSpy = jest.spyOn(process.stdout, "write").mockImplementation();
+  });
+  afterEach(() => {
+    writeSpy.mockRestore();
+  });
+  return {
+    get write() {
+      return captureLastWriteCall(writeSpy);
+    },
+  };
+}

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

@@ -100,4 +100,9 @@ class MockStdIn {
     }
     return this.chunks.shift() ?? null;
   }
+
+  /**
+   * Used by Ink.js to set the encoding of the stdout.
+   */
+  setEncoding() {}
 }

package/src/__tests__/index.test.ts

@@ -247,7 +247,8 @@ describe("wrangler", () => {
         Attempting to run \`wrangler publish --dry-run --outdir=dist\` for you instead:
 
 
-      --dry-run: exiting now."
+      --dry-run: exiting now.
+      Total Upload: 0xx KiB / gzip: 0xx KiB"
     `);
   });
 });