fix(config): reject over-int connect_timeout instead of wrapping through (int) cast

Both ws config paths read connect_timeout via view.getLong and cast to
int: connect_timeout=4294967297 silently became a 1 ms timeout, and
2147483648 wrapped to Integer.MIN_VALUE, producing the misleading
'connect_timeout must be > 0: -2147483648'.

- ConfigView.getInt now parses in the long domain: schema range still
  reports first (tighter, key-specific), then an over-int value fails
  with the actual limit ('connect_timeout must be <= 2147483647: ...')
  instead of a generic 'invalid' or a wrapped value.
- Sender.fromConfigWebSocket and QwpQueryClient.fromConfig/validateConfig
  read connect_timeout via getInt, aligning with the legacy http/tcp
  parseIntValue path that already rejected over-int values.

Covered at ConfigView level (ConfigViewTest) and end-to-end on both
facades (QwpConfigKeysTest.testConnectTimeoutOverIntRejectedOnBoth).

Author: bluestreak01

core/src/main/java/io/questdb/client/Sender.java

@@ -3599,7 +3599,9 @@ private LineSenderBuilder fromConfigWebSocket(CharSequence configurationString)
                     authTimeoutMillis(view.getLong("auth_timeout_ms", 0));
                 }
                 if (view.has("connect_timeout")) {
-                    connectTimeoutMillis((int) view.getLong("connect_timeout", 0));
+                    // getInt (not getLong + cast): connectTimeoutMillis takes an
+                    // int, and an over-int value must reject, not wrap.
+                    connectTimeoutMillis(view.getInt("connect_timeout", 0));
                 }
 
                 s = view.getStr("auto_flush_rows");

core/src/main/java/io/questdb/client/cutlass/qwp/client/QwpQueryClient.java

@@ -390,7 +390,9 @@ public static QwpQueryClient fromConfig(CharSequence configurationString) {
         Long failoverMaxDurationMs = view.has("failover_max_duration_ms")
                 ? view.getLong("failover_max_duration_ms", 0) : null;
         Long authTimeoutMs = view.has("auth_timeout_ms") ? view.getLong("auth_timeout_ms", 0) : null;
-        Integer connectTimeout = view.has("connect_timeout") ? (int) view.getLong("connect_timeout", 0) : null;
+        // getInt (not getLong + cast): withConnectTimeout takes an int, and an
+        // over-int value must reject, not wrap.
+        Integer connectTimeout = view.has("connect_timeout") ? view.getInt("connect_timeout", 0) : null;
         Long initialCredit = view.has("initial_credit") ? view.getLong("initial_credit", 0) : null;
         int poolSize = view.getInt("buffer_pool_size", DEFAULT_IO_BUFFER_POOL_SIZE);
         String compression = view.getEnum("compression");
@@ -504,7 +506,9 @@ public static void validateConfig(ConfigView view, boolean tls) {
         view.getLong("failover_max_duration_ms", -1);
         view.getLong("initial_credit", -1);
         view.getLong("auth_timeout_ms", -1);
-        view.getLong("connect_timeout", -1);
+        // getInt: connect_timeout feeds an int API, so validation must also
+        // reject values that fit a long but not an int.
+        view.getInt("connect_timeout", -1);
         String username = view.getStr("username");
         String password = view.getStr("password");
         String token = view.getStr("token");

core/src/main/java/io/questdb/client/impl/ConfigView.java

@@ -178,17 +178,29 @@ public int getInt(String key, int unset) {
         if (v == null) {
             return unset;
         }
-        int parsed;
+        // Parse in the long domain so a numeric-but-over-int value (e.g.
+        // 4294967297) is distinguishable from garbage: it must fail with the
+        // actual int limit, not wrap through an (int) cast or report a generic
+        // "invalid" for a perfectly numeric string.
+        long parsed;
         try {
-            parsed = Numbers.parseInt(v);
+            parsed = Numbers.parseLong(v);
         } catch (NumericException e) {
             throw new IllegalArgumentException("invalid " + key + ": " + v);
         }
         ConfigSchema.KeySpec spec = ConfigSchema.spec(key);
+        // Schema range first: it is the tighter, key-specific constraint, so
+        // "compression_level=4294967297" says "must be in [1, 22]".
         if (outOfRange(spec, parsed)) {
             throw new IllegalArgumentException(rangeMessage(spec));
         }
-        return parsed;
+        if (parsed > Integer.MAX_VALUE) {
+            throw new IllegalArgumentException(key + " must be <= " + Integer.MAX_VALUE + ": " + v);
+        }
+        if (parsed < Integer.MIN_VALUE) {
+            throw new IllegalArgumentException(key + " must be >= " + Integer.MIN_VALUE + ": " + v);
+        }
+        return (int) parsed;
     }
 
     public long getLong(String key, long unset) {

core/src/test/java/io/questdb/client/test/impl/ConfigViewTest.java

@@ -115,6 +115,29 @@ public void testGetLongStrictLowerBound() {
                 "auth_timeout_ms must be > 0");
     }
 
+    @Test
+    public void testGetIntOverIntRangeRejectedActionably() {
+        // An int key fed a numeric value beyond int range must name the real
+        // limit -- not report a wrapped/garbage value. 2^32+1 would wrap to 1
+        // (a silent 1 ms timeout) through a bare (int) cast; 2^31 would wrap
+        // to Integer.MIN_VALUE and produce a misleading "must be > 0" error.
+        assertParseError("ws::addr=h:9000;connect_timeout=4294967297;",
+                v -> v.getInt("connect_timeout", -1),
+                "connect_timeout must be <= 2147483647: 4294967297");
+        assertParseError("ws::addr=h:9000;connect_timeout=2147483648;",
+                v -> v.getInt("connect_timeout", -1),
+                "connect_timeout must be <= 2147483647: 2147483648");
+    }
+
+    @Test
+    public void testGetIntSpecRangeStillWinsOverIntBound() {
+        // A value that is both over the schema max and over int range reports
+        // the schema range -- the tighter, key-specific constraint.
+        assertParseError("ws::addr=h:9000;compression_level=4294967297;",
+                v -> v.getInt("compression_level", -1),
+                "compression_level must be in [1, 22]");
+    }
+
     @Test
     public void testGetIntNonNumericRejected() {
         assertParseError("ws::addr=h:9000;compression_level=abc;",

core/src/test/java/io/questdb/client/test/impl/QwpConfigKeysTest.java

@@ -54,6 +54,26 @@ public void testEverySchemaKeyIsRecognizedByBothClients() throws Exception {
         });
     }
 
+    @Test
+    public void testConnectTimeoutOverIntRejectedOnBoth() throws Exception {
+        TestUtils.assertMemoryLeak(() -> {
+            // connect_timeout flows into an int API on both clients. A bare
+            // (int) cast would silently wrap 2^32+1 to a 1 ms timeout and turn
+            // 2^31 into a misleading "must be > 0: -2147483648" error. Both
+            // must reject up front, naming the actual limit.
+            assertRejected("ws::addr=h:9000;connect_timeout=4294967297;",
+                    "connect_timeout must be <= 2147483647: 4294967297");
+            assertRejected("ws::addr=h:9000;connect_timeout=2147483648;",
+                    "connect_timeout must be <= 2147483647: 2147483648");
+            // The schema lower bound is intact end-to-end...
+            assertRejected("ws::addr=h:9000;connect_timeout=0;",
+                    "connect_timeout must be > 0");
+            // ...and a valid value still builds on both clients.
+            Sender.builder("ws::addr=h:9000;connect_timeout=7000;");
+            QwpQueryClient.fromConfig("ws::addr=h:9000;connect_timeout=7000;").close();
+        });
+    }
+
     @Test
     public void testJunkKeyRejectedOnBoth() throws Exception {
         TestUtils.assertMemoryLeak(() -> {