[CX-6011] support empty string as object FieldName (#24179)

lift restriction on ConvexObject keys being nonempty. Note this PR does not affect IdentifierFieldName at all, just FieldName.

as discussed in Slack, the main blocker for this change is making sure it works in the dashboard.
This unblocks customers from importing objects with empty string fields.

I don't think we can easily make this safe to push in any order, because npm-packages/convex/src/value is shared by dashboard client-side and system udfs, and crates/convex/sync_types is shared by backend, funrun, and rust client. worst case scenario seems fine to me though, since it involves dashboard throwing clear errors ("Field name cannot be empty") just from a different layer -- from the system udf instead of from typechecking. And errors only happen if the developer tries to use empty string as a key.

@atrakh pls check dashboard
@sujayakar to make sure the backend changes make sense

I tested that you can Add Documents in the dashboard and the field shows up.

![Screenshot 2024-04-02 at 1 33 48 PM](https://github.com/get-convex/convex/assets/4319355/0c23ad32-f269-46d5-9b84-590f748a0b6c)

GitOrigin-RevId: 921bdd9281d040a8960d9d891e0e2eb8284cd130

Author: ldanilek

crates/convex/sync_types/src/identifier.rs

@@ -82,24 +82,12 @@ pub fn is_valid_field_name(s: &str) -> bool {
 }
 
 fn check_valid_field_name_inner(s: &str) -> Result<(), String> {
-    let mut chars = s.chars();
-    match chars.next() {
-        Some('$') => {
-            return Err(format!(
-                "Field name {s} starts with '$', which is reserved."
-            ))
-        },
-        Some(c) => {
-            if !c.is_ascii() || c.is_ascii_control() {
-                return Err(format!(
-                    "Field name {s} has invalid character '{c}': Field names can only contain \
-                     non-control ASCII characters"
-                ));
-            }
-        },
-        None => return Err(format!("Field name cannot be empty")),
-    };
-    for c in chars {
+    if s.starts_with('$') {
+        return Err(format!(
+            "Field name {s} starts with '$', which is reserved."
+        ));
+    }
+    for c in s.chars() {
         if !c.is_ascii() || c.is_ascii_control() {
             return Err(format!(
                 "Field name {s} has invalid character '{c}': Field names can only contain \

crates/isolate/src/tests/mod.rs

@@ -31,6 +31,7 @@ mod source_maps;
 mod system_udfs;
 mod unicode;
 mod user_error;
+mod values;
 mod vector_search;
 
 pub fn assert_contains(error: &impl Display, expected: &str) {

crates/isolate/src/tests/values.rs

@@ -0,0 +1,33 @@
+use common::{
+    assert_obj,
+    value::ConvexValue,
+};
+use must_let::must_let;
+use runtime::testing::TestRuntime;
+use value::assert_val;
+
+use crate::test_helpers::UdfTest;
+
+#[convex_macro::test_runtime]
+async fn test_bigint(rt: TestRuntime) -> anyhow::Result<()> {
+    let t = UdfTest::default(rt).await?;
+    let value = t.query("values:intQuery", assert_obj!()).await?;
+    must_let!(let ConvexValue::Int64(v) = value);
+    assert_eq!(v, 1);
+    Ok(())
+}
+
+#[convex_macro::test_runtime]
+async fn test_empty_key(rt: TestRuntime) -> anyhow::Result<()> {
+    // Check that an object with an empty key round trips through mutation and
+    // query.
+    let t = UdfTest::default(rt).await?;
+    let id = t
+        .mutation("values:insertObject", assert_obj!("obj" => {"" => "hi"}))
+        .await?;
+    let value = t.query("values:getObject", assert_obj!("id" => id)).await?;
+    must_let!(let ConvexValue::Object(o) = value);
+    assert_eq!(o.len(), 3);
+    assert_eq!(o.get("").unwrap().clone(), assert_val!("hi"));
+    Ok(())
+}

crates/local_backend/src/public_api.rs

@@ -471,7 +471,7 @@ mod tests {
         http_format_tester(
             rt,
             "/api/query",
-            "bigint:intQuery",
+            "values:intQuery",
             json!({}),
             None,
             Err("RequiresFormatParam"),
@@ -484,7 +484,7 @@ mod tests {
         http_format_tester(
             rt,
             "/api/query",
-            "bigint:intQuery",
+            "values:intQuery",
             json!({}),
             Some("json"),
             Ok(json!("1")),
@@ -497,7 +497,7 @@ mod tests {
         http_format_tester(
             rt,
             "/api/mutation",
-            "bigint:intMutation",
+            "values:intMutation",
             json!({}),
             None,
             Err("RequiresFormatParam"),
@@ -510,7 +510,7 @@ mod tests {
         http_format_tester(
             rt,
             "/api/mutation",
-            "bigint:intMutation",
+            "values:intMutation",
             json!({}),
             Some("json"),
             Ok(json!("1")),
@@ -523,7 +523,7 @@ mod tests {
         http_format_tester(
             rt,
             "/api/action",
-            "bigint:intAction",
+            "values:intAction",
             json!({}),
             None,
             Err("RequiresFormatParam"),
@@ -536,7 +536,7 @@ mod tests {
         http_format_tester(
             rt,
             "/api/action",
-            "bigint:intAction",
+            "values:intAction",
             json!({}),
             Some("json"),
             Ok(json!("1")),

crates/value/src/tests.rs

@@ -1,7 +1,11 @@
-use std::mem;
+use std::{
+    mem,
+    ops::Deref,
+};
 
 use crate::{
     assert_obj,
+    obj,
     ConvexObject,
     ConvexValue,
     InternalId,
@@ -130,3 +134,35 @@ fn test_shallow_merge() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn test_object_keys() -> anyhow::Result<()> {
+    let obj = assert_obj!(
+        "name" => "me",
+    );
+    assert_eq!(
+        obj.keys().map(Deref::deref).collect::<Vec<_>>(),
+        vec!["name"]
+    );
+    let empty_string_key = assert_obj!(
+        "" => "empty",
+    );
+    assert_eq!(
+        empty_string_key
+            .keys()
+            .map(Deref::deref)
+            .collect::<Vec<_>>(),
+        vec![""]
+    );
+    let control_char_key: anyhow::Result<_> = try { obj!("\t" => "tab")? };
+    assert!(control_char_key
+        .unwrap_err()
+        .to_string()
+        .contains("Field names can only contain non-control ASCII characters"));
+    let dollar_sign_key: anyhow::Result<_> = try { obj!("$id" => "tab")? };
+    assert!(dollar_sign_key
+        .unwrap_err()
+        .to_string()
+        .contains("Field name $id starts with '$', which is reserved"));
+    Ok(())
+}

npm-packages/convex/src/values/value.ts

@@ -153,9 +153,6 @@ export const base64ToBigInt = (DataView.prototype as any).getBigInt64
 const MAX_IDENTIFIER_LEN = 1024;
 
 function validateObjectField(k: string) {
-  if (k.length === 0) {
-    throw new Error("Empty field names are disallowed.");
-  }
   if (k.length > MAX_IDENTIFIER_LEN) {
     throw new Error(
       `Field name ${k} exceeds maximum field name length ${MAX_IDENTIFIER_LEN}.`,

npm-packages/udf-tests/convex/_generated/api.d.ts

@@ -22,7 +22,6 @@ import type * as asyncTests from "../asyncTests.js";
 import type * as auth from "../auth.js";
 import type * as basic from "../basic.js";
 import type * as benches from "../benches.js";
-import type * as bigint from "../bigint.js";
 import type * as creationTime from "../creationTime.js";
 import type * as crons from "../crons.js";
 import type * as crons_error from "../crons_error.js";
@@ -74,6 +73,7 @@ import type * as sourceMaps from "../sourceMaps.js";
 import type * as sync from "../sync.js";
 import type * as unicode from "../unicode.js";
 import type * as userError from "../userError.js";
+import type * as values from "../values.js";
 import type * as vector_search from "../vector_search.js";
 
 /**
@@ -93,7 +93,6 @@ declare const fullApi: ApiFromModules<{
   auth: typeof auth;
   basic: typeof basic;
   benches: typeof benches;
-  bigint: typeof bigint;
   creationTime: typeof creationTime;
   crons: typeof crons;
   crons_error: typeof crons_error;
@@ -145,6 +144,7 @@ declare const fullApi: ApiFromModules<{
   sync: typeof sync;
   unicode: typeof unicode;
   userError: typeof userError;
+  values: typeof values;
   vector_search: typeof vector_search;
 }>;
 export declare const api: FilterApi<

npm-packages/udf-tests/convex/bigint.ts

@@ -0,0 +1,28 @@
+import { mutation, query, action } from "./_generated/server";
+import { v } from "convex/values";
+
+export const intQuery = query(async () => {
+  return 1n;
+});
+
+export const intMutation = mutation(async () => {
+  return 1n;
+});
+
+export const intAction = action(async () => {
+  return 1n;
+});
+
+export const insertObject = mutation({
+  args: { obj: v.any() },
+  handler: async (ctx, { obj }) => {
+    return ctx.db.insert("test", obj);
+  },
+});
+
+export const getObject = query({
+  args: { id: v.id("test") },
+  handler: async (ctx, { id }) => {
+    return ctx.db.get(id);
+  },
+});