fix(postgrest): override limit and offset instead of appending duplicates

limit() and range() built their query params with appendSearchParams, so
chaining or re-applying them on a shared builder emitted duplicate,
single-valued params, e.g. select().limit(5).range(0,9) produced
limit=5&limit=10&offset=0 and limit(1).limit(2) produced limit=1&limit=2.
PostgREST treats limit/offset as single-valued, so override them (last
call wins), matching postgrest-js and the select()/order() handling in
the same file.

Author: AndroidPoet

packages/postgrest/lib/src/postgrest_builder.dart

@@ -402,10 +402,11 @@ class PostgrestBuilder<T, S, R> implements Future<T> {
   /// Get new Uri with overridden queryParams
   ///
   /// [url] may be used to update based on a different url than the current one
-  Uri overrideSearchParams(String key, String value) {
-    final searchParams = Map<String, dynamic>.of(_url.queryParametersAll);
+  Uri overrideSearchParams(String key, String value, [Uri? url]) {
+    final searchParams =
+        Map<String, dynamic>.of((url ?? _url).queryParametersAll);
     searchParams[key] = value;
-    return _url.replace(queryParameters: searchParams);
+    return (url ?? _url).replace(queryParameters: searchParams);
   }
 
   /// Convert list filter to query params string

packages/postgrest/lib/src/postgrest_transform_builder.dart

@@ -106,7 +106,9 @@ class PostgrestTransformBuilder<T> extends RawPostgrestBuilder<T, T, T> {
   PostgrestTransformBuilder<T> limit(int count, {String? referencedTable}) {
     final key = referencedTable == null ? 'limit' : '$referencedTable.limit';
 
-    final url = appendSearchParams(key, '$count');
+    // `limit` is single-valued in PostgREST, so a later call must replace an
+    // earlier one rather than appending a second `limit` query param.
+    final url = overrideSearchParams(key, '$count');
     return PostgrestTransformBuilder(copyWithUrl(url));
   }
 
@@ -134,8 +136,11 @@ class PostgrestTransformBuilder<T> extends RawPostgrestBuilder<T, T, T> {
     final keyLimit =
         referencedTable == null ? 'limit' : '$referencedTable.limit';
 
-    var url = appendSearchParams(keyOffset, '$from');
-    url = appendSearchParams(keyLimit, '${to - from + 1}', url);
+    // `offset` and `limit` are single-valued in PostgREST; override so a
+    // later range()/limit() call replaces the earlier value instead of
+    // appending a duplicate query param.
+    var url = overrideSearchParams(keyOffset, '$from');
+    url = overrideSearchParams(keyLimit, '${to - from + 1}', url);
     return PostgrestTransformBuilder(copyWithUrl(url));
   }
 

packages/postgrest/test/limit_range_test.dart

@@ -0,0 +1,65 @@
+import 'dart:convert';
+
+import 'package:http/http.dart';
+import 'package:postgrest/postgrest.dart';
+import 'package:test/test.dart';
+
+/// Captures the URL of the request the builder generates and returns an empty
+/// result set, so we can assert on the query string without a live server.
+class _CapturingClient extends BaseClient {
+  Uri? lastUrl;
+
+  @override
+  Future<StreamedResponse> send(BaseRequest request) async {
+    lastUrl = request.url;
+    return StreamedResponse(
+      Stream.value(utf8.encode('[]')),
+      200,
+      request: request,
+      headers: {'content-type': 'application/json'},
+    );
+  }
+}
+
+void main() {
+  late _CapturingClient mock;
+  late PostgrestClient client;
+
+  setUp(() {
+    mock = _CapturingClient();
+    client = PostgrestClient('http://localhost:3000', httpClient: mock);
+  });
+
+  test('a later limit() replaces the earlier one', () async {
+    await client.from('t').select().limit(1).limit(2);
+
+    // `limit` is single-valued in PostgREST; the second call must win rather
+    // than emitting `limit=1&limit=2`.
+    expect(mock.lastUrl!.queryParametersAll['limit'], ['2']);
+  });
+
+  test('range() overrides a preceding limit() instead of duplicating it',
+      () async {
+    await client.from('t').select().limit(5).range(0, 9);
+
+    expect(mock.lastUrl!.queryParametersAll['limit'], ['10']);
+    expect(mock.lastUrl!.queryParametersAll['offset'], ['0']);
+  });
+
+  test('a later range() replaces the earlier one', () async {
+    await client.from('t').select().range(0, 9).range(10, 19);
+
+    expect(mock.lastUrl!.queryParametersAll['offset'], ['10']);
+    expect(mock.lastUrl!.queryParametersAll['limit'], ['10']);
+  });
+
+  test('referencedTable limit is scoped and single-valued', () async {
+    await client
+        .from('t')
+        .select('messages(*)')
+        .limit(1, referencedTable: 'messages')
+        .limit(2, referencedTable: 'messages');
+
+    expect(mock.lastUrl!.queryParametersAll['messages.limit'], ['2']);
+  });
+}