feat: RFC compliant typed headers

packages/relic/test/headers/header_test.dart

@@ -190,16 +190,22 @@ void main() {
       Headers.accessControlAllowOrigin,
       Headers.accessControlExposeHeaders,
       Headers.accessControlRequestHeaders,
+      Headers.cacheControl,
+      Headers.connection,
       Headers.contentDisposition,
+      Headers.contentEncoding,
       Headers.contentLanguage,
       Headers.contentLocation,
       Headers.contentSecurityPolicy,
+      Headers.expect,
+      Headers.from,
       Headers.host,
       Headers.location,
       Headers.origin,
       Headers.permissionsPolicy,
       Headers.referer,
       Headers.server,
+      Headers.setCookie,
       Headers.te,
       Headers.trailer,
       Headers.upgrade,
@@ -602,7 +608,7 @@ void main() {
         Headers.accessControlAllowOrigin,
         (final h) =>
             h.accessControlAllowOrigin = AccessControlAllowOriginHeader.origin(
-              origin: Uri.parse('https://example.com'),
+              origin: Origin.parse('https://example.com'),
             ),
       ),
       (
@@ -703,7 +709,7 @@ void main() {
       ),
       (
         Headers.contentRange,
-        (final h) => h.contentRange = ContentRangeHeader(),
+        (final h) => h.contentRange = ContentRangeHeader(size: 1234),
       ),
       (
         Headers.contentSecurityPolicy,
@@ -739,7 +745,7 @@ void main() {
       (Headers.expires, (final h) => h.expires = DateTime.utc(2025, 9, 23)),
       (
         Headers.from,
-        (final h) => h.from = FromHeader.emails(['info@serverpod.com']),
+        (final h) => h.from = const FromHeader('info@serverpod.com'),
       ),
       (Headers.host, (final h) => h.host = HostHeader('www.example.com', 80)),
       (

packages/relic/test/headers/typed/accept_encoding_header_test.dart

@@ -37,24 +37,24 @@ void main() {
       },
     );
 
-    test('when an Accept-Encoding header with invalid quality values is passed '
-        'then the server responds with a bad request including a message that '
-        'states the quality value is invalid', () async {
-      expect(
-        getServerRequestHeaders(
+    test(
+      'when an Accept-Encoding header with a malformed quality value is '
+      'passed then the weight defaults to 1.0 instead of being rejected',
+      () async {
+        final headers = await getServerRequestHeaders(
           server: server,
           headers: {'accept-encoding': 'gzip;q=abc'},
           touchHeaders: (final h) => h.acceptEncoding,
-        ),
-        throwsA(
-          isA<BadRequestException>().having(
-            (final e) => e.message,
-            'message',
-            contains('Invalid quality value'),
-          ),
-        ),
-      );
-    });
+        );
+
+        expect(
+          headers.acceptEncoding?.encodings
+              .map((final e) => e.quality)
+              .toList(),
+          equals([1.0]),
+        );
+      },
+    );
 
     test(
       'when an Accept-Encoding header with wildcard (*) and other encodings is '
@@ -349,18 +349,25 @@ void main() {
     });
 
     group(
-      'when Accept-Encoding headers with invalid quality values are passed',
+      'when Accept-Encoding headers with a malformed quality value are passed',
       () {
-        test('then it should return null', () async {
-          final headers = await getServerRequestHeaders(
-            server: server,
-            touchHeaders: (_) {},
-            headers: {'accept-encoding': 'gzip;q=abc, deflate, br'},
-          );
-
-          expect(Headers.acceptEncoding[headers].valueOrNullIfInvalid, isNull);
-          expect(() => headers.acceptEncoding, throwsInvalidHeader);
-        });
+        test(
+          'then the header still parses and the weight defaults to 1.0',
+          () async {
+            final headers = await getServerRequestHeaders(
+              server: server,
+              touchHeaders: (_) {},
+              headers: {'accept-encoding': 'gzip;q=abc, deflate, br'},
+            );
+
+            expect(
+              headers.acceptEncoding?.encodings
+                  .map((final e) => e.quality)
+                  .toList(),
+              equals([1.0, 1.0, 1.0]),
+            );
+          },
+        );
       },
     );
   });

packages/relic/test/headers/typed/accept_header_test.dart

@@ -37,35 +37,26 @@ void main() {
       },
     );
 
-    test(
-      'when an Accept header with invalid quality value is passed then the server '
-      'should respond with a bad request including a message that states the '
-      'quality value is invalid',
-      () async {
-        expect(
-          getServerRequestHeaders(
-            server: server,
-            touchHeaders: (final h) => h.accept,
-            headers: {'accept': 'text/html;q=abc'},
-          ),
-          throwsA(
-            isA<BadRequestException>().having(
-              (final e) => e.message,
-              'message',
-              contains('Invalid quality value'),
-            ),
-          ),
-        );
-      },
-    );
+    test('when an Accept header with a malformed quality value is passed '
+        'then the weight defaults to 1.0 instead of being rejected', () async {
+      final headers = await getServerRequestHeaders(
+        server: server,
+        touchHeaders: (final h) => h.accept,
+        headers: {'accept': 'text/html;q=abc'},
+      );
+
+      final mediaRanges = headers.accept?.mediaRanges;
+      expect(mediaRanges?.length, equals(1));
+      expect(mediaRanges?[0].quality, equals(1.0));
+    });
 
     test('when an Accept header with an invalid value is passed '
         'then the server does not respond with a bad request if the headers '
         'is not actually used', () async {
       final headers = await getServerRequestHeaders(
         server: server,
         touchHeaders: (_) {},
-        headers: {'accept': 'text/html;q=abc'},
+        headers: {'accept': 'invalid'},
       );
 
       expect(headers, isNotNull);
@@ -146,25 +137,22 @@ void main() {
 
     group('when multiple Accept media ranges are passed', () {
       test(
-        'with invalid quality values are passed then the server should respond with a bad request '
-        'including a message that states the quality value is invalid',
+        'with malformed quality values then those weights default to 1.0 and '
+        'valid weights are preserved',
         () async {
-          expect(
-            getServerRequestHeaders(
-              server: server,
-              touchHeaders: (final h) => h.accept,
-              headers: {
-                'accept': 'text/html;q=test, application/json;q=abc, */*;q=0.5',
-              },
-            ),
-            throwsA(
-              isA<BadRequestException>().having(
-                (final e) => e.message,
-                'message',
-                contains('Invalid quality value'),
-              ),
-            ),
+          final headers = await getServerRequestHeaders(
+            server: server,
+            touchHeaders: (final h) => h.accept,
+            headers: {
+              'accept': 'text/html;q=test, application/json;q=abc, */*;q=0.5',
+            },
           );
+
+          final mediaRanges = headers.accept?.mediaRanges;
+          expect(mediaRanges?.length, equals(3));
+          expect(mediaRanges?[0].quality, equals(1.0));
+          expect(mediaRanges?[1].quality, equals(1.0));
+          expect(mediaRanges?[2].quality, equals(0.5));
         },
       );
       test(
@@ -219,12 +207,12 @@ void main() {
 
     tearDown(() => server.close());
 
-    group('when an Accept header with invalid quality value is passed', () {
+    group('when an Accept header with an invalid value is passed', () {
       test('then it should return null', () async {
         final headers = await getServerRequestHeaders(
           server: server,
           touchHeaders: (_) {},
-          headers: {'accept': 'text/html;q=abc'},
+          headers: {'accept': 'invalid'},
         );
 
         expect(Headers.accept[headers].valueOrNullIfInvalid, isNull);

packages/relic/test/headers/typed/accept_language_test.dart

@@ -38,24 +38,24 @@ void main() {
       },
     );
 
-    test('when an Accept-Language header with invalid quality values is passed '
-        'then the server responds with a bad request including a message that '
-        'states the quality value is invalid', () async {
-      expect(
-        getServerRequestHeaders(
+    test(
+      'when an Accept-Language header with a malformed quality value is '
+      'passed then the weight defaults to 1.0 instead of being rejected',
+      () async {
+        final headers = await getServerRequestHeaders(
           server: server,
           touchHeaders: (final h) => h.acceptLanguage,
           headers: {'accept-language': 'en;q=abc'},
-        ),
-        throwsA(
-          isA<BadRequestException>().having(
-            (final e) => e.message,
-            'message',
-            contains('Invalid quality value'),
-          ),
-        ),
-      );
-    });
+        );
+
+        expect(
+          headers.acceptLanguage?.languages
+              .map((final e) => e.quality)
+              .toList(),
+          equals([1.0]),
+        );
+      },
+    );
 
     test(
       'when an Accept-Language header with wildcard (*) and other languages is '
@@ -373,18 +373,25 @@ void main() {
     });
 
     group(
-      'when Accept-Language headers with invalid quality values are passed',
+      'when Accept-Language headers with a malformed quality value are passed',
       () {
-        test('then it should return null', () async {
-          final headers = await getServerRequestHeaders(
-            server: server,
-            touchHeaders: (_) {},
-            headers: {'accept-language': 'en;q=abc, fr, de'},
-          );
-
-          expect(Headers.acceptLanguage[headers].valueOrNullIfInvalid, isNull);
-          expect(() => headers.acceptLanguage, throwsInvalidHeader);
-        });
+        test(
+          'then the header still parses and the weight defaults to 1.0',
+          () async {
+            final headers = await getServerRequestHeaders(
+              server: server,
+              touchHeaders: (_) {},
+              headers: {'accept-language': 'en;q=abc, fr, de'},
+            );
+
+            expect(
+              headers.acceptLanguage?.languages
+                  .map((final e) => e.quality)
+                  .toList(),
+              equals([1.0, 1.0, 1.0]),
+            );
+          },
+        );
       },
     );
   });

packages/relic/test/headers/typed/accept_ranges_header_test.dart

@@ -58,7 +58,24 @@ void main() {
           headers: {'accept-ranges': 'bytes'},
         );
 
-        expect(headers.acceptRanges?.rangeUnit, equals('bytes'));
+        expect(headers.acceptRanges?.rangeUnits, equals(['bytes']));
+        expect(headers.acceptRanges?.isBytes, isTrue);
+      },
+    );
+
+    test(
+      'when multiple range units are passed then they are all parsed',
+      () async {
+        final headers = await getServerRequestHeaders(
+          server: server,
+          touchHeaders: (final h) => h.acceptRanges,
+          headers: {'accept-ranges': 'bytes, custom-unit'},
+        );
+
+        expect(
+          headers.acceptRanges?.rangeUnits,
+          equals(['bytes', 'custom-unit']),
+        );
         expect(headers.acceptRanges?.isBytes, isTrue);
       },
     );
@@ -72,7 +89,7 @@ void main() {
           headers: {'accept-ranges': 'none'},
         );
 
-        expect(headers.acceptRanges?.rangeUnit, equals('none'));
+        expect(headers.acceptRanges?.rangeUnits, equals(['none']));
         expect(headers.acceptRanges?.isNone, isTrue);
       },
     );

packages/relic/test/headers/typed/access_control_allow_headers_header_test.dart

@@ -87,7 +87,7 @@ void main() {
         expect(allowedHeaders?.length, equals(2));
         expect(
           allowedHeaders,
-          containsAll(['Content-Type', 'X-Custom-Header']),
+          containsAll(['content-type', 'x-custom-header']),
         );
       },
     );