Serialize token-store long fields as digits

FileTokenStore.putLongMember wrote a long field via sink.put(long),
which routes through Numbers.append(..., checkNaN=true) and renders
Long.MIN_VALUE as the literal JSON null. The two long fields
(expires_at_millis, token_ttl_millis) are present, non-nullable
integers, so a bare null there breaks the frozen cross-language format
(serialize() omits absent fields rather than writing null, so a null is
indistinguishable from absent) and round-trips back to 0 on read via
parseLongOrZero -- a silent corruption a Python peer would also diverge
on.

putLongMember now calls Numbers.append(sink, value, false), which emits
the full number, so every long value round-trips verbatim. The path is
reachable only through the public FileTokenStore.save(...) SPI;
OidcDeviceAuth clamps both fields to a non-negative range before
persisting, so the OIDC flow never hits it.

Add testLongFieldsSerializeAsDigitsNotBareNull: it saves Long.MIN_VALUE
in both long fields, asserts the on-disk JSON carries the digits rather
than a bare null, and that load() round-trips them instead of
collapsing to 0. The test fails on the pre-fix code and passes with the
fix.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: glasstiger

core/src/main/java/io/questdb/client/cutlass/auth/FileTokenStore.java

@@ -402,7 +402,12 @@ private static void putBooleanMember(StringSink sink, String name, boolean value
     private static void putLongMember(StringSink sink, String name, long value) {
         sink.put(',');
         putName(sink, name);
-        sink.put(value);
+        // write the digits unconditionally. sink.put(long) routes through Numbers.append(..., checkNaN=true),
+        // which renders Long.MIN_VALUE as the literal JSON null - a bare null for a present, non-nullable
+        // integer field would break the frozen cross-language contract (serialize() OMITS absent fields rather
+        // than writing null, so a null here is indistinguishable from absent) and round-trips back to 0 via
+        // parseLongOrZero. checkNaN=false emits the full number, so every long value round-trips verbatim.
+        Numbers.append(sink, value, false);
     }
 
     private static void putName(StringSink sink, String name) {

core/src/test/java/io/questdb/client/test/cutlass/auth/FileTokenStoreTest.java

@@ -682,6 +682,32 @@ public void testLockFilePermissionsOwnerOnly() throws Exception {
         });
     }
 
+    @Test
+    public void testLongFieldsSerializeAsDigitsNotBareNull() throws Exception {
+        assertMemoryLeak(() -> {
+            Path dir = storeDir();
+            FileTokenStore store = new FileTokenStore(dir);
+            TokenStoreKey key = sampleKey();
+            // the two long fields are present, non-nullable integers, so Long.MIN_VALUE must serialize as its
+            // digits. serialize() reserves an omitted member (not a bare null) for an absent value, so a null
+            // here would be indistinguishable from absent and breaks the frozen cross-language contract; the
+            // reader would also round-trip that null back to 0 (parseLongOrZero), a silent corruption.
+            store.save(key, new PersistedToken("ACCESS-1", null, "REFRESH-1", Long.MIN_VALUE, Long.MIN_VALUE));
+
+            String json = new String(Files.readAllBytes(tokenFile(dir, key)), StandardCharsets.UTF_8);
+            Assert.assertTrue("expires_at_millis must be written as digits, not a bare null [json=" + json + ']',
+                    json.contains("\"expires_at_millis\":-9223372036854775808"));
+            Assert.assertTrue("token_ttl_millis must be written as digits, not a bare null [json=" + json + ']',
+                    json.contains("\"token_ttl_millis\":-9223372036854775808"));
+
+            // and the extreme value round-trips verbatim rather than collapsing to 0 on read
+            PersistedToken loaded = store.load(key);
+            Assert.assertNotNull(loaded);
+            Assert.assertEquals(Long.MIN_VALUE, loaded.getExpiresAtMillis());
+            Assert.assertEquals(Long.MIN_VALUE, loaded.getTokenTtlMillis());
+        });
+    }
+
     @Test
     public void testNoLeftoverTempFileAfterSave() throws Exception {
         assertMemoryLeak(() -> {