fix: Use ISO-8601 date format in MongoDB to BigQuery template

MongoDB ISODate fields were being serialized using the JVM's default
locale, resulting in descriptive date formats like "Feb 3, 2026, 3:31:41 PM"
instead of ISO-8601 format.

This change configures MongoDB's JsonWriterSettings to use JsonMode.RELAXED,
which outputs dates in ISO-8601 format: {"$date": "2026-02-03T15:31:41.924Z"}.

Changes:
- Added EXTENDED_JSON_WRITER_SETTINGS constant to MongoDbUtils
- Updated getTableSchema() to use MongoDB JsonWriterSettings for all user
  options (FLATTEN, JSON, NONE)
- Updated JavascriptDocumentTransformer to use consistent date serialization
- Added unit tests to verify ISO-8601 date format
- Updated integration test for consistency

Fixes locale-dependent date serialization issues in BigQuery output.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: pilis

v2/mongodb-to-googlecloud/src/main/java/com/google/cloud/teleport/v2/mongodb/templates/MongoDbUtils.java

@@ -54,6 +54,8 @@
 import org.apache.beam.sdk.io.fs.MatchResult.Status;
 import org.apache.beam.vendor.guava.v32_1_2_jre.com.google.common.io.CharStreams;
 import org.bson.Document;
+import org.bson.json.JsonMode;
+import org.bson.json.JsonWriterSettings;
 import org.openjdk.nashorn.api.scripting.ScriptObjectMirror;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -73,6 +75,13 @@ public class MongoDbUtils implements Serializable {
 
   static final Gson GSON = new GsonBuilder().serializeSpecialFloatingPointValues().create();
 
+  /**
+   * JsonWriterSettings configured to output Relaxed JSON format for consistent ISO-8601 date
+   * serialization.
+   */
+  public static final JsonWriterSettings EXTENDED_JSON_WRITER_SETTINGS =
+      JsonWriterSettings.builder().outputMode(JsonMode.RELAXED).build();
+
   public static TableSchema getTableFieldSchema(
       String uri, String database, String collection, String userOption) {
     List<TableFieldSchema> bigquerySchemaFields = new ArrayList<>();
@@ -141,16 +150,30 @@ public static TableRow getTableSchema(Document document, String userOption) {
                 row.set(key, value);
                 break;
               case "org.bson.Document":
-                String data = GSON.toJson(value);
+                String data = ((Document) value).toJson(EXTENDED_JSON_WRITER_SETTINGS);
                 row.set(key, data);
                 break;
+              case "java.util.Date":
+                // Format dates as ISO-8601 strings
+                Document tempDoc = new Document("date", value);
+                String dateJson = tempDoc.toJson(EXTENDED_JSON_WRITER_SETTINGS);
+                // Extract just the date value from {"date":{"$date":"2026-02-03T15:31:41.924Z"}}
+                try {
+                  JsonObject dateObj = GSON.fromJson(dateJson, JsonObject.class);
+                  String dateStr = dateObj.getAsJsonObject("date").get("$date").getAsString();
+                  row.set(key, dateStr);
+                } catch (Exception e) {
+                  row.set(key, value.toString());
+                }
+                break;
               default:
                 row.set(key, value.toString());
             }
           });
       row.set("timestamp", localDate.format(TIMEFORMAT));
     } else if (userOption.equals("JSON")) {
-      JsonObject sourceDataJsonObject = GSON.toJsonTree(document).getAsJsonObject();
+      String jsonString = document.toJson(EXTENDED_JSON_WRITER_SETTINGS);
+      JsonObject sourceDataJsonObject = GSON.fromJson(jsonString, JsonObject.class);
 
       // Convert to a Map
       Map<String, Object> sourceDataMap =
@@ -160,7 +183,7 @@ public static TableRow getTableSchema(Document document, String userOption) {
           .set("source_data", sourceDataMap)
           .set("timestamp", localDate.format(TIMEFORMAT));
     } else {
-      String sourceData = GSON.toJson(document);
+      String sourceData = document.toJson(EXTENDED_JSON_WRITER_SETTINGS);
 
       row.set("id", document.get("_id").toString())
           .set("source_data", sourceData)
@@ -188,7 +211,8 @@ public static TableSchema getTableFieldSchemaForUDF(
     }
 
     Document doc;
-    Object result = invocable.invokeFunction(udfFunctionName, document.toJson());
+    Object result =
+        invocable.invokeFunction(udfFunctionName, document.toJson(EXTENDED_JSON_WRITER_SETTINGS));
     if (result == null || ScriptObjectMirror.isUndefined(result)) {
       return null;
     } else if (result instanceof Document) {

v2/mongodb-to-googlecloud/src/main/java/com/google/cloud/teleport/v2/transforms/JavascriptDocumentTransformer.java

@@ -18,6 +18,7 @@
 import static org.apache.beam.vendor.guava.v32_1_2_jre.com.google.common.base.Preconditions.checkArgument;
 
 import com.google.auto.value.AutoValue;
+import com.google.cloud.teleport.v2.mongodb.templates.MongoDbUtils;
 import java.io.IOException;
 import java.io.Reader;
 import java.io.UncheckedIOException;
@@ -147,7 +148,9 @@ public Document invoke(Document data)
         throw new RuntimeException("No udf was loaded");
       }
 
-      Object result = getInvocable().invokeFunction(functionName(), data.toJson());
+      Object result =
+          getInvocable()
+              .invokeFunction(functionName(), data.toJson(MongoDbUtils.EXTENDED_JSON_WRITER_SETTINGS));
       if (result == null || ScriptObjectMirror.isUndefined(result)) {
         return null;
       } else if (result instanceof Document) {

v2/mongodb-to-googlecloud/src/test/java/com/google/cloud/teleport/v2/mongodb/templates/MongoDbToBigQueryIT.java

@@ -215,7 +215,8 @@ private void mongoDbToBigQueryBase(String userOption, boolean applyUdf, boolean
     Map<String, JSONObject> mongoMap = new HashMap<>();
     mongoDocuments.forEach(
         mongoDocument -> {
-          JSONObject mongoDbJson = new JSONObject(mongoDocument.toJson());
+          JSONObject mongoDbJson =
+              new JSONObject(mongoDocument.toJson(MongoDbUtils.EXTENDED_JSON_WRITER_SETTINGS));
           String mongoId = mongoDbJson.getJSONObject(MONGO_DB_FLATTEN_ID).getString("$oid");
           if (applyUdf) {
             mongoDbJson.put("udf", "out");

v2/mongodb-to-googlecloud/src/test/java/com/google/cloud/teleport/v2/mongodb/templates/MongoDbUtilsTest.java

@@ -15,10 +15,13 @@
  */
 package com.google.cloud.teleport.v2.mongodb.templates;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 
 import com.google.api.services.bigquery.model.TableRow;
+import java.util.Date;
 import org.bson.Document;
 import org.junit.Test;
 
@@ -69,4 +72,55 @@ public void testGsonSerializesSpecialFloatingPointValues() {
     assertTrue("JSON should contain Infinity", jsonString.contains("Infinity"));
     assertTrue("JSON should contain NaN", jsonString.contains("NaN"));
   }
+
+  @Test
+  public void testExtendedJsonDateSerialization() {
+    // Create document with date field
+    Date testDate = new Date(1738598501924L); // 2026-02-03T15:31:41.924Z
+    Document document = new Document();
+    document.put("_id", "test-id");
+    document.put("createdAt", testDate);
+
+    // Serialize with EXTENDED_JSON_WRITER_SETTINGS
+    String jsonString = document.toJson(MongoDbUtils.EXTENDED_JSON_WRITER_SETTINGS);
+
+    // Verify Extended JSON format with ISO-8601
+    assertNotNull("JSON string should not be null", jsonString);
+    assertTrue("Should contain $date key", jsonString.contains("\"$date\""));
+    assertTrue(
+        "Should contain ISO-8601 formatted date",
+        jsonString.matches(
+            ".*\"\\$date\"\\s*:\\s*\"\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z\".*"));
+    assertFalse(
+        "Should NOT contain locale-based date format",
+        jsonString.matches(".*[A-Z][a-z]{2}\\s+\\d+,\\s+\\d{4}.*"));
+
+    // Verify round-trip conversion
+    Document parsedDocument = Document.parse(jsonString);
+    assertEquals("Document ID should match", "test-id", parsedDocument.get("_id"));
+  }
+
+  @Test
+  public void testExtendedJsonWithMultipleDateTypes() {
+    Document document = new Document();
+    document.put("_id", "test-id");
+    document.put("currentDate", new Date());
+    document.put("pastDate", new Date(0L)); // 1970-01-01T00:00:00.000Z
+    document.put("futureDate", new Date(4102444800000L)); // 2100-01-01
+    document.put("nullDate", null);
+    document.put("stringField", "not a date");
+
+    String jsonString = document.toJson(MongoDbUtils.EXTENDED_JSON_WRITER_SETTINGS);
+
+    assertNotNull("JSON string should not be null", jsonString);
+    // Verify all date fields use Extended JSON format
+    int dateCount = jsonString.split("\"\\$date\"").length - 1;
+    assertEquals("Should have 3 $date entries", 3, dateCount);
+
+    // Verify round-trip conversion
+    Document parsedDocument = Document.parse(jsonString);
+    assertNotNull(parsedDocument.get("currentDate"));
+    assertNotNull(parsedDocument.get("pastDate"));
+    assertNotNull(parsedDocument.get("futureDate"));
+  }
 }