wrangler 2.0.3 → 2.0.7

package/src/__tests__/publish.test.ts

@@ -12,6 +12,7 @@ import {
   unsetMockFetchKVGetValues,
 } from "./helpers/mock-cfetch";
 import { mockConsoleMethods, normalizeSlashes } from "./helpers/mock-console";
+import { mockConfirm } from "./helpers/mock-dialogs";
 import { useMockIsTTY } from "./helpers/mock-istty";
 import { mockKeyListRequest } from "./helpers/mock-kv";
 import { mockOAuthFlow } from "./helpers/mock-oauth-flow";
@@ -470,7 +471,10 @@ describe("publish", () => {
     mockSubDomainRequest();
     await runWrangler("publish ./some-path/worker/index.js");
     expect(std.out).toMatchInlineSnapshot(`
-      "Uploaded test-name (TIMINGS)
+      "Your worker has access to the following bindings:
+      - Vars:
+        - xyz: \\"123\\"
+      Uploaded test-name (TIMINGS)
       Published test-name (TIMINGS)
         test-name.test-sub-domain.workers.dev"
     `);
@@ -645,6 +649,136 @@ describe("publish", () => {
       await runWrangler("publish ./index --env dev --legacy-env false");
     });
 
+    describe("custom domains", () => {
+      it("should publish routes marked with 'custom_domain' as seperate custom domains", async () => {
+        writeWranglerToml({
+          routes: [{ pattern: "api.example.com", custom_domain: true }],
+        });
+        writeWorkerSource();
+        mockUpdateWorkerRequest({ enabled: false });
+        mockUploadWorkerRequest({ expectedType: "esm" });
+        mockPublishCustomDomainsRequest({
+          publishFlags: {
+            override_scope: true,
+            override_existing_origin: false,
+            override_existing_dns_record: false,
+          },
+          domains: [{ hostname: "api.example.com" }],
+        });
+        await runWrangler("publish ./index");
+        expect(std.out).toContain("api.example.com (custom domain)");
+      });
+
+      it("should allow retrying if publish fails with a conflicting custom domain error", async () => {
+        writeWranglerToml({
+          routes: [{ pattern: "api.example.com", custom_domain: true }],
+        });
+        writeWorkerSource();
+        mockUpdateWorkerRequest({ enabled: false });
+        mockUploadWorkerRequest({ expectedType: "esm" });
+        mockPublishCustomDomainsRequestConflictWithoutOverride({
+          originConflicts: true,
+          domains: [{ hostname: "api.example.com" }],
+        });
+        mockConfirm({
+          text: `Custom Domains already exist for these domains: "api.example.com"\nUpdate them to point to this script instead?`,
+          result: true,
+        });
+        await runWrangler("publish ./index");
+        expect(std.out).toContain("api.example.com (custom domain)");
+      });
+
+      it("should allow retrying if publish fails with a conflicting DNS record error", async () => {
+        writeWranglerToml({
+          routes: [{ pattern: "api.example.com", custom_domain: true }],
+        });
+        writeWorkerSource();
+        mockUpdateWorkerRequest({ enabled: false });
+        mockUploadWorkerRequest({ expectedType: "esm" });
+        mockPublishCustomDomainsRequestConflictWithoutOverride({
+          dnsRecordConflicts: true,
+          domains: [{ hostname: "api.example.com" }],
+        });
+        mockConfirm({
+          text: `You already have conflicting DNS records for these domains: "api.example.com"\nUpdate them to point to this script instead?`,
+          result: true,
+        });
+        await runWrangler("publish ./index");
+        expect(std.out).toContain("api.example.com (custom domain)");
+      });
+
+      it("should allow retrying for conflicting custom domains and then again for conflicting dns", async () => {
+        writeWranglerToml({
+          routes: [{ pattern: "api.example.com", custom_domain: true }],
+        });
+        writeWorkerSource();
+        mockUpdateWorkerRequest({ enabled: false });
+        mockUploadWorkerRequest({ expectedType: "esm" });
+        mockPublishCustomDomainsRequestConflictWithoutOverride({
+          originConflicts: true,
+          dnsRecordConflicts: true,
+          domains: [{ hostname: "api.example.com" }],
+        });
+        mockConfirm(
+          {
+            text: `Custom Domains already exist for these domains: "api.example.com"\nUpdate them to point to this script instead?`,
+            result: true,
+          },
+          {
+            text: `You already have conflicting DNS records for these domains: "api.example.com"\nUpdate them to point to this script instead?`,
+            result: true,
+          }
+        );
+        await runWrangler("publish ./index");
+        expect(std.out).toContain("api.example.com (custom domain)");
+      });
+
+      it("should throw if an invalid custom domain is requested", async () => {
+        writeWranglerToml({
+          routes: [{ pattern: "*.example.com", custom_domain: true }],
+        });
+        writeWorkerSource();
+        await expect(
+          runWrangler("publish ./index")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Cannot use \\"*.example.com\\" as a Custom Domain; wildcard operators (*) are not allowed"`
+        );
+
+        writeWranglerToml({
+          routes: [
+            { pattern: "api.example.com/at/a/path", custom_domain: true },
+          ],
+        });
+        writeWorkerSource();
+        await expect(
+          runWrangler("publish ./index")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Cannot use \\"api.example.com/at/a/path\\" as a Custom Domain; paths are not allowed"`
+        );
+      });
+
+      it("should not retry publish on error if user does not confirm", async () => {
+        writeWranglerToml({
+          routes: [{ pattern: "api.example.com", custom_domain: true }],
+        });
+        writeWorkerSource();
+        mockUpdateWorkerRequest({ enabled: false });
+        mockUploadWorkerRequest({ expectedType: "esm" });
+        mockPublishCustomDomainsRequestConflictWithoutOverride({
+          dnsRecordConflicts: true,
+          domains: [{ hostname: "api.example.com" }],
+        });
+        mockConfirm({
+          text: `You already have conflicting DNS records for these domains: "api.example.com"\nUpdate them to point to this script instead?`,
+          result: false,
+        });
+        await runWrangler("publish ./index");
+        expect(std.out).toContain(
+          'Publishing to Custom Domain "api.example.com" was skipped, fix conflict and try again'
+        );
+      });
+    });
+
     it.todo("should error if it's a workers.dev route");
   });
 
@@ -2698,13 +2832,22 @@ addEventListener('fetch', event => {});`
       mockUploadWorkerRequest();
       await runWrangler("publish index.js");
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded test-name (TIMINGS)
+        "Your worker has access to the following bindings:
+        - Durable Objects:
+          - SOMENAME: SomeClass
+        Uploaded test-name (TIMINGS)
         Published test-name (TIMINGS)
           test-name.test-sub-domain.workers.dev"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`
-        "▲ [WARNING] In wrangler.toml, you have configured [durable_objects] exported by this Worker (SomeClass), but no [migrations] for them. This may not work as expected until you add a [migrations] section to your wrangler.toml. Refer to https://developers.cloudflare.com/workers/learning/using-durable-objects/#durable-object-migrations-in-wranglertoml for more details.
+        "▲ [WARNING] Processing wrangler.toml configuration:
+
+            - In wrangler.toml, you have configured [durable_objects] exported by this Worker (SomeClass),
+          but no [migrations] for them. This may not work as expected until you add a [migrations] section
+          to your wrangler.toml. Refer to
+          https://developers.cloudflare.com/workers/learning/using-durable-objects/#durable-object-migrations-in-wranglertoml
+          for more details.
 
         "
       `);
@@ -2730,7 +2873,10 @@ addEventListener('fetch', event => {});`
       mockUploadWorkerRequest();
       await runWrangler("publish index.js");
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded test-name (TIMINGS)
+        "Your worker has access to the following bindings:
+        - Durable Objects:
+          - SOMENAME: SomeClass (defined in some-script)
+        Uploaded test-name (TIMINGS)
         Published test-name (TIMINGS)
           test-name.test-sub-domain.workers.dev"
       `);
@@ -2769,7 +2915,11 @@ addEventListener('fetch', event => {});`
 
       await runWrangler("publish index.js");
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded test-name (TIMINGS)
+        "Your worker has access to the following bindings:
+        - Durable Objects:
+          - SOMENAME: SomeClass
+          - SOMEOTHERNAME: SomeOtherClass
+        Uploaded test-name (TIMINGS)
         Published test-name (TIMINGS)
           test-name.test-sub-domain.workers.dev"
       `);
@@ -2815,7 +2965,11 @@ addEventListener('fetch', event => {});`
         Object {
           "debug": "",
           "err": "",
-          "out": "Uploaded test-name (TIMINGS)
+          "out": "Your worker has access to the following bindings:
+        - Durable Objects:
+          - SOMENAME: SomeClass
+          - SOMEOTHERNAME: SomeOtherClass
+        Uploaded test-name (TIMINGS)
         Published test-name (TIMINGS)
           test-name.test-sub-domain.workers.dev",
           "warn": "",
@@ -2854,7 +3008,11 @@ addEventListener('fetch', event => {});`
         Object {
           "debug": "",
           "err": "",
-          "out": "Uploaded test-name (TIMINGS)
+          "out": "Your worker has access to the following bindings:
+        - Durable Objects:
+          - SOMENAME: SomeClass
+          - SOMEOTHERNAME: SomeOtherClass
+        Uploaded test-name (TIMINGS)
         Published test-name (TIMINGS)
           test-name.test-sub-domain.workers.dev",
           "warn": "",
@@ -2895,7 +3053,11 @@ addEventListener('fetch', event => {});`
 
         await runWrangler("publish index.js --legacy-env false");
         expect(std.out).toMatchInlineSnapshot(`
-          "Uploaded test-name (TIMINGS)
+          "Your worker has access to the following bindings:
+          - Durable Objects:
+            - SOMENAME: SomeClass
+            - SOMEOTHERNAME: SomeOtherClass
+          Uploaded test-name (TIMINGS)
           Published test-name (TIMINGS)
             test-name.test-sub-domain.workers.dev"
         `);
@@ -2953,7 +3115,11 @@ addEventListener('fetch', event => {});`
 
         await runWrangler("publish index.js --legacy-env false --env xyz");
         expect(std.out).toMatchInlineSnapshot(`
-          "Uploaded test-name (xyz) (TIMINGS)
+          "Your worker has access to the following bindings:
+          - Durable Objects:
+            - SOMENAME: SomeClass
+            - SOMEOTHERNAME: SomeOtherClass
+          Uploaded test-name (xyz) (TIMINGS)
           Published test-name (xyz) (TIMINGS)
             xyz.test-name.test-sub-domain.workers.dev"
         `);
@@ -3007,7 +3173,11 @@ addEventListener('fetch', event => {});`
           Object {
             "debug": "",
             "err": "",
-            "out": "Uploaded test-name (TIMINGS)
+            "out": "Your worker has access to the following bindings:
+          - Durable Objects:
+            - SOMENAME: SomeClass
+            - SOMEOTHERNAME: SomeOtherClass
+          Uploaded test-name (TIMINGS)
           Published test-name (TIMINGS)
             test-name.test-sub-domain.workers.dev",
             "warn": "▲ [WARNING] Processing wrangler.toml configuration:
@@ -3071,7 +3241,11 @@ addEventListener('fetch', event => {});`
           Object {
             "debug": "",
             "err": "",
-            "out": "Uploaded test-name (xyz) (TIMINGS)
+            "out": "Your worker has access to the following bindings:
+          - Durable Objects:
+            - SOMENAME: SomeClass
+            - SOMEOTHERNAME: SomeOtherClass
+          Uploaded test-name (xyz) (TIMINGS)
           Published test-name (xyz) (TIMINGS)
             xyz.test-name.test-sub-domain.workers.dev",
             "warn": "▲ [WARNING] Processing wrangler.toml configuration:
@@ -3106,6 +3280,7 @@ addEventListener('fetch', event => {});`
               name: "DURABLE_OBJECT_TWO",
               class_name: "AnotherDurableObject",
               script_name: "another-durable-object-worker",
+              environment: "staging",
             },
           ],
         },
@@ -3164,6 +3339,12 @@ addEventListener('fetch', event => {});`
       mockUploadWorkerRequest({
         expectedType: "sw",
         expectedBindings: [
+          { json: 123, name: "ENV_VAR_ONE", type: "json" },
+          {
+            name: "ENV_VAR_TWO",
+            text: "Hello, I'm an environment variable",
+            type: "plain_text",
+          },
           {
             name: "KV_NAMESPACE_ONE",
             namespace_id: "kv-ns-one-id",
@@ -3182,6 +3363,7 @@ addEventListener('fetch', event => {});`
           },
           {
             class_name: "AnotherDurableObject",
+            environment: "staging",
             name: "DURABLE_OBJECT_TWO",
             script_name: "another-durable-object-worker",
             type: "durable_object_namespace",
@@ -3196,12 +3378,6 @@ addEventListener('fetch', event => {});`
             name: "R2_BUCKET_TWO",
             type: "r2_bucket",
           },
-          { json: 123, name: "ENV_VAR_ONE", type: "json" },
-          {
-            name: "ENV_VAR_TWO",
-            text: "Hello, I'm an environment variable",
-            type: "plain_text",
-          },
           {
             name: "WASM_MODULE_ONE",
             part: "WASM_MODULE_ONE",
@@ -3233,7 +3409,32 @@ addEventListener('fetch', event => {});`
 
       await expect(runWrangler("publish index.js")).resolves.toBeUndefined();
       expect(std.out).toMatchInlineSnapshot(`
-        "Uploaded test-name (TIMINGS)
+        "Your worker has access to the following bindings:
+        - Data Blobs:
+          - DATA_BLOB_ONE: some-data-blob.bin
+          - DATA_BLOB_TWO: more-data-blob.bin
+        - Durable Objects:
+          - DURABLE_OBJECT_ONE: SomeDurableObject (defined in some-durable-object-worker)
+          - DURABLE_OBJECT_TWO: AnotherDurableObject (defined in another-durable-object-worker) - staging
+        - KV Namespaces:
+          - KV_NAMESPACE_ONE: kv-ns-one-id
+          - KV_NAMESPACE_TWO: kv-ns-two-id
+        - R2 Buckets:
+          - R2_BUCKET_ONE: r2-bucket-one-name
+          - R2_BUCKET_TWO: r2-bucket-two-name
+        - Text Blobs:
+          - TEXT_BLOB_ONE: my-entire-app-depends-on-this.cfg
+          - TEXT_BLOB_TWO: the-entirety-of-human-knowledge.txt
+        - Unsafe:
+          - some unsafe thing: UNSAFE_BINDING_ONE
+          - another unsafe thing: UNSAFE_BINDING_TWO
+        - Vars:
+          - ENV_VAR_ONE: \\"123\\"
+          - ENV_VAR_TWO: \\"Hello, I'm an environment variable\\"
+        - Wasm Modules:
+          - WASM_MODULE_ONE: some_wasm.wasm
+          - WASM_MODULE_TWO: more_wasm.wasm
+        Uploaded test-name (TIMINGS)
         Published test-name (TIMINGS)
           test-name.test-sub-domain.workers.dev"
       `);
@@ -3609,10 +3810,13 @@ addEventListener('fetch', event => {});`
         mockSubDomainRequest();
         await runWrangler("publish index.js");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - Wasm Modules:
+            - TESTWASMNAME: path/to/test.wasm
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
@@ -3675,10 +3879,13 @@ addEventListener('fetch', event => {});`
         mockSubDomainRequest();
         await runWrangler("publish index.js --config ./path/to/wrangler.toml");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - Wasm Modules:
+            - TESTWASMNAME: path/to/and/the/path/to/test.wasm
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
@@ -3740,10 +3947,13 @@ addEventListener('fetch', event => {});`
         mockSubDomainRequest();
         await runWrangler("publish index.js");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - Text Blobs:
+            - TESTTEXTBLOBNAME: path/to/text.file
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
@@ -3810,10 +4020,13 @@ addEventListener('fetch', event => {});`
         mockSubDomainRequest();
         await runWrangler("publish index.js --config ./path/to/wrangler.toml");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - Text Blobs:
+            - TESTTEXTBLOBNAME: path/to/and/the/path/to/text.file
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
@@ -3843,10 +4056,13 @@ addEventListener('fetch', event => {});`
         mockSubDomainRequest();
         await runWrangler("publish index.js");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - Data Blobs:
+            - TESTDATABLOBNAME: path/to/data.bin
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
@@ -3913,10 +4129,13 @@ addEventListener('fetch', event => {});`
         mockSubDomainRequest();
         await runWrangler("publish index.js --config ./path/to/wrangler.toml");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - Data Blobs:
+            - TESTDATABLOBNAME: path/to/and/the/path/to/data.bin
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
@@ -3947,10 +4166,15 @@ addEventListener('fetch', event => {});`
 
         await runWrangler("publish index.js");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - Vars:
+            - text: \\"plain ol' string\\"
+            - count: \\"1\\"
+            - complex: \\"[object Object]\\"
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
@@ -3971,10 +4195,13 @@ addEventListener('fetch', event => {});`
 
         await runWrangler("publish index.js");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - R2 Buckets:
+            - FOO: foo-bucket
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
@@ -4013,10 +4240,13 @@ addEventListener('fetch', event => {});`
 
         await runWrangler("publish index.js");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - Durable Objects:
+            - EXAMPLE_DO_BINDING: ExampleDurableObject
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
@@ -4049,10 +4279,13 @@ addEventListener('fetch', event => {});`
 
         await runWrangler("publish index.js");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - Durable Objects:
+            - EXAMPLE_DO_BINDING: ExampleDurableObject (defined in example-do-binding-worker)
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
@@ -4090,10 +4323,13 @@ addEventListener('fetch', event => {});`
 
         await runWrangler("publish index.js");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - Durable Objects:
+            - EXAMPLE_DO_BINDING: ExampleDurableObject
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
@@ -4123,6 +4359,50 @@ addEventListener('fetch', event => {});`
       });
     });
 
+    describe("[services]", () => {
+      it("should support service bindings", async () => {
+        writeWranglerToml({
+          services: [
+            {
+              binding: "FOO",
+              service: "foo-service",
+              environment: "production",
+            },
+          ],
+        });
+        writeWorkerSource();
+        mockSubDomainRequest();
+        mockUploadWorkerRequest({
+          expectedBindings: [
+            {
+              type: "service",
+              name: "FOO",
+              service: "foo-service",
+              environment: "production",
+            },
+          ],
+        });
+
+        await runWrangler("publish index.js");
+        expect(std.out).toMatchInlineSnapshot(`
+          "Your worker has access to the following bindings:
+          - Services:
+            - FOO: foo-service - production
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`
+          "▲ [WARNING] Processing wrangler.toml configuration:
+
+              - \\"services\\" fields are experimental and may change or break at any time.
+
+          "
+        `);
+      });
+    });
+
     describe("[unsafe]", () => {
       it("should warn if using unsafe bindings", async () => {
         writeWranglerToml({
@@ -4150,10 +4430,13 @@ addEventListener('fetch', event => {});`
 
         await runWrangler("publish index.js");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - Unsafe:
+            - binding-type: my-binding
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`
           "▲ [WARNING] Processing wrangler.toml configuration:
@@ -4189,10 +4472,13 @@ addEventListener('fetch', event => {});`
 
         await runWrangler("publish index.js");
         expect(std.out).toMatchInlineSnapshot(`
-                  "Uploaded test-name (TIMINGS)
-                  Published test-name (TIMINGS)
-                    test-name.test-sub-domain.workers.dev"
-              `);
+          "Your worker has access to the following bindings:
+          - Unsafe:
+            - plain_text: my-binding
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.warn).toMatchInlineSnapshot(`
           "▲ [WARNING] Processing wrangler.toml configuration:
@@ -4625,14 +4911,25 @@ addEventListener('fetch', event => {});`
 
   describe("--dry-run", () => {
     it("should not publish the worker if --dry-run is specified", async () => {
-      writeWranglerToml();
+      writeWranglerToml({
+        // add a durable object with migrations
+        // to make sure we _don't_ fetch migration status
+        durable_objects: {
+          bindings: [{ name: "NAME", class_name: "SomeClass" }],
+        },
+        migrations: [{ tag: "v1", new_classes: ["SomeClass"] }],
+      });
       writeWorkerSource();
+      process.env.CLOUDFLARE_ACCOUNT_ID = "";
       await runWrangler("publish index.js --dry-run");
       expect(std).toMatchInlineSnapshot(`
         Object {
           "debug": "",
           "err": "",
-          "out": "--dry-run: exiting now.",
+          "out": "Your worker has access to the following bindings:
+        - Durable Objects:
+          - NAME: SomeClass
+        --dry-run: exiting now.",
           "warn": "",
         }
       `);
@@ -4656,6 +4953,27 @@ addEventListener('fetch', event => {});`
       `);
     });
 
+    it("should recommend node compatibility mode when using node builtins and node-compat isn't enabled", async () => {
+      writeWranglerToml();
+      fs.writeFileSync(
+        "index.js",
+        `
+      import path from 'path';
+      console.log(path.join("some/path/to", "a/file.txt"));
+      export default {}
+      `
+      );
+      let err: Error | undefined;
+      try {
+        await runWrangler("publish index.js --dry-run"); // expecting this to throw, as node compatibility isn't enabled
+      } catch (e) {
+        err = e as Error;
+      }
+      expect(err?.message).toMatch(
+        `Detected a Node builtin module import while Node compatibility is disabled.\nAdd node_compat = true to your wrangler.toml file to enable Node compatibility.`
+      );
+    });
+
     it("should polyfill node builtins when enabled", async () => {
       writeWranglerToml();
       fs.writeFileSync(
@@ -4850,6 +5168,102 @@ function mockPublishRoutesRequest({
   );
 }
 
+function mockPublishCustomDomainsRequest({
+  publishFlags,
+  domains = [],
+  env = undefined,
+  legacyEnv = false,
+}: {
+  publishFlags: {
+    override_scope: boolean;
+    override_existing_origin: boolean;
+    override_existing_dns_record: boolean;
+  };
+  domains: Array<
+    { hostname: string } & ({ zone_id?: string } | { zone_name?: string })
+  >;
+  env?: string | undefined;
+  legacyEnv?: boolean | undefined;
+}) {
+  const servicesOrScripts = env && !legacyEnv ? "services" : "scripts";
+  const environment = env && !legacyEnv ? "/environments/:envName" : "";
+
+  setMockResponse(
+    `/accounts/:accountId/workers/${servicesOrScripts}/:scriptName${environment}/domains`,
+    "PUT",
+    ([_url, accountId, scriptName, envName], { body }) => {
+      expect(accountId).toEqual("some-account-id");
+      expect(scriptName).toEqual(
+        legacyEnv && env ? `test-name-${env}` : "test-name"
+      );
+      if (!legacyEnv) {
+        expect(envName).toEqual(env);
+      }
+
+      expect(JSON.parse(body as string)).toEqual({
+        ...publishFlags,
+        origins: domains,
+      });
+
+      return null;
+    }
+  );
+}
+
+function mockPublishCustomDomainsRequestConflictWithoutOverride({
+  domains = [],
+  originConflicts = false,
+  dnsRecordConflicts = false,
+  env = undefined,
+  legacyEnv = false,
+}: {
+  originConflicts?: boolean;
+  dnsRecordConflicts?: boolean;
+  domains: Array<
+    { hostname: string } & ({ zone_id?: string } | { zone_name?: string })
+  >;
+  env?: string | undefined;
+  legacyEnv?: boolean | undefined;
+}) {
+  const servicesOrScripts = env && !legacyEnv ? "services" : "scripts";
+  const environment = env && !legacyEnv ? "/environments/:envName" : "";
+
+  setMockRawResponse(
+    `/accounts/:accountId/workers/${servicesOrScripts}/:scriptName${environment}/domains`,
+    "PUT",
+    ([_url, accountId, scriptName, envName], { body }) => {
+      expect(accountId).toEqual("some-account-id");
+      expect(scriptName).toEqual(
+        legacyEnv && env ? `test-name-${env}` : "test-name"
+      );
+      if (!legacyEnv) {
+        expect(envName).toEqual(env);
+      }
+
+      const parsed = JSON.parse(body as string);
+      expect(parsed.origins).toEqual(domains);
+
+      if (originConflicts && !parsed.override_existing_origin) {
+        return createFetchResult(null, false, [
+          {
+            code: 100116,
+            message: `Cannot create Custom Domain "${domains[0].hostname}": Custom Domain already exists and points to a different script; retry and use option "override_existing_origin" to override`,
+          },
+        ]);
+      }
+      if (dnsRecordConflicts && !parsed.override_existing_dns_record) {
+        return createFetchResult(null, false, [
+          {
+            code: 100117,
+            message: `Cannot create Custom Domain "${domains[0].hostname}": a DNS record already exists for this origin; retry and use option "override_existing_dns_record" to override`,
+          },
+        ]);
+      }
+      return createFetchResult(null, true);
+    }
+  );
+}
+
 /** Create a mock handler for the request to get a list of all KV namespaces. */
 function mockListKVNamespacesRequest(...namespaces: KVNamespaceInfo[]) {
   setMockResponse(