Upper case all http methods in fetch API with compat flag (#2913)

src/workerd/api/BUILD.bazel

@@ -556,3 +556,9 @@ wd_test(
     args = ["--experimental"],
     data = ["tests/no-to-string-tag-test.js"],
 )
+
+wd_test(
+    src = "tests/fetch-test.wd-test",
+    args = ["--experimental"],
+    data = ["tests/fetch-test.js"],
+)

src/workerd/api/http.c++

@@ -1002,12 +1002,16 @@ jsg::Ref<Request> Request::constructor(
         }
 
         KJ_IF_SOME(m, initDict.method) {
-          auto originalMethod = kj::str(m);
           KJ_IF_SOME(code, tryParseHttpMethod(m)) {
             method = code;
-          } else {
-            KJ_IF_SOME(code, kj::tryParseHttpMethod(toUpper(kj::mv(m)))) {
-              method = code;
+          } else KJ_IF_SOME(code, kj::tryParseHttpMethod(toUpper(m))) {
+            method = code;
+            if (!FeatureFlags::get(js).getUpperCaseAllHttpMethods()) {
+              // This is actually the spec defined behavior. We're expected to only
+              // upper case get, post, put, delete, head, and options per the spec.
+              // Other methods, even if they would be recognized if they were uppercased,
+              // are supposed to be rejected.
+              // Refs: https://fetch.spec.whatwg.org/#methods
               switch (method) {
                 case kj::HttpMethod::GET:
                 case kj::HttpMethod::POST:
@@ -1017,12 +1021,11 @@ jsg::Ref<Request> Request::constructor(
                 case kj::HttpMethod::OPTIONS:
                   break;
                 default:
-                  JSG_FAIL_REQUIRE(
-                      TypeError, kj::str("Invalid HTTP method string: ", originalMethod));
+                  JSG_FAIL_REQUIRE(TypeError, kj::str("Invalid HTTP method string: ", m));
               }
-            } else {
-              JSG_FAIL_REQUIRE(TypeError, kj::str("Invalid HTTP method string: ", originalMethod));
             }
+          } else {
+            JSG_FAIL_REQUIRE(TypeError, kj::str("Invalid HTTP method string: ", m));
           }
         }
 

src/workerd/api/tests/fetch-test.js

@@ -0,0 +1,24 @@
+import { strictEqual, throws } from 'assert';
+
+// Test depends on the setting of the upper_case_all_http_methods compatibility flag.
+strictEqual(
+  globalThis.Cloudflare.compatibilityFlags['upper_case_all_http_methods'],
+  true
+);
+
+export const test = {
+  test() {
+    // Verify that lower-cased method names are converted to upper-case.
+    // even though the Fetch API doesn't do this in general for all methods.
+    // Note that the upper_case_all_http_methods compat flag is intentionally
+    // diverging from the Fetch API here.
+    const req = new Request('https://example.com', { method: 'patch' });
+    strictEqual(req.method, 'PATCH');
+
+    // Unrecognized methods error as expected, with the error message
+    // showing the original-cased method name.
+    throws(() => new Request('http://example.org', { method: 'patchy' }), {
+      message: /^Invalid HTTP method string: patchy$/,
+    });
+  },
+};

src/workerd/api/tests/fetch-test.wd-test

@@ -0,0 +1,15 @@
+using Workerd = import "/workerd/workerd.capnp";
+
+const unitTests :Workerd.Config = (
+  services = [
+    ( name = "fetch-test",
+      worker = (
+        modules = [
+          (name = "worker", esModule = embed "fetch-test.js")
+        ],
+        compatibilityDate = "2024-10-01",
+        compatibilityFlags = ["nodejs_compat", "upper_case_all_http_methods"],
+      )
+    ),
+  ],
+);

src/workerd/io/compatibility-date.capnp

@@ -639,4 +639,16 @@ struct CompatibilityFlags @0x8f8c1b68151b6cef {
   # fix several spec compliance bugs. Unfortunately it turns out that was more breaking
   # than expected. This flag restores the original behavior for compat dates before
   # 2024-09-26
+
+  upperCaseAllHttpMethods @65 :Bool
+      $compatEnableFlag("upper_case_all_http_methods")
+      $compatDisableFlag("no_upper_case_all_http_methods")
+      $compatEnableDate("2024-10-14");
+  # HTTP methods are expected to be upper-cased. Per the fetch spec, if the methods
+  # is specified as `get`, `post`, `put`, `delete`, `head`, or `options`, implementations
+  # are expected to uppercase the method. All other method names would generally be
+  # expected to throw as unrecognized (e.g. `patch` would be an error while `PATCH` is
+  # accepted). This is a bit restrictive, even if it is in the spec. This flag modifies
+  # the behavior to uppercase all methods prior to parsing to that the method is always
+  # recognized if it is a known method.
 }

src/workerd/util/strings.c++

@@ -63,6 +63,10 @@ kj::String toLower(kj::ArrayPtr<const char> ptr) {
   return toLower(kj::str(ptr));
 }
 
+kj::String toUpper(kj::ArrayPtr<const char> ptr) {
+  return toUpper(kj::str(ptr));
+}
+
 kj::ArrayPtr<const char> trimLeadingAndTrailingWhitespace(kj::ArrayPtr<const char> ptr) {
   size_t start = 0;
   auto end = ptr.size();

src/workerd/util/strings.h

@@ -84,6 +84,7 @@ kj::String toUpper(kj::String&& str);
 
 // Copy the input and convert ASCII alpha characters in the given string to lowercase.
 kj::String toLower(kj::ArrayPtr<const char> ptr);
+kj::String toUpper(kj::ArrayPtr<const char> ptr);
 
 kj::ArrayPtr<const char> trimLeadingAndTrailingWhitespace(kj::ArrayPtr<const char> ptr);
 kj::ArrayPtr<const char> trimTailingWhitespace(kj::ArrayPtr<const char> ptr);