user error when search on nonexistent table (#27246)

when we don't have a tablet index name, the index is missing and we have an index name to use in an error message. hence the unusual `Result` type

added regression test.

GitOrigin-RevId: 7127845a9895525fb9cd7d88bd87ab8a8725a1c1

Author: ldanilek

crates/common/src/types/index.rs

@@ -128,15 +128,23 @@ pub type TabletIndexName = GenericIndexName<TabletId>;
 pub enum StableIndexName {
     Physical(TabletIndexName),
     Virtual(IndexName, TabletIndexName),
-    Missing,
+    Missing(IndexName),
 }
 
 impl StableIndexName {
     pub fn tablet_index_name(&self) -> Option<&TabletIndexName> {
         match self {
             StableIndexName::Physical(tablet_index_name) => Some(tablet_index_name),
             StableIndexName::Virtual(_, tablet_index_name) => Some(tablet_index_name),
-            StableIndexName::Missing => None,
+            StableIndexName::Missing(_) => None,
+        }
+    }
+
+    pub fn tablet_index_name_or_missing(&self) -> Result<&TabletIndexName, &IndexName> {
+        match self {
+            StableIndexName::Physical(tablet_index_name) => Ok(tablet_index_name),
+            StableIndexName::Virtual(_, tablet_index_name) => Ok(tablet_index_name),
+            StableIndexName::Missing(index_name) => Err(index_name),
         }
     }
 
@@ -160,7 +168,7 @@ impl StableIndexName {
                         .tablet_number(*tablet_index_name.table())?,
                 }))
             },
-            StableIndexName::Missing => Ok(None),
+            StableIndexName::Missing(_) => Ok(None),
         }
     }
 }

crates/database/src/bootstrap_model/index.rs

@@ -680,7 +680,7 @@ impl<'a, RT: Runtime> IndexModel<'a, RT> {
                 )),
                 TableFilter::ExcludePrivateSystemTables => {
                     if index_name.table().is_system() {
-                        Ok(StableIndexName::Missing)
+                        Ok(StableIndexName::Missing(index_name.clone()))
                     } else {
                         Ok(StableIndexName::Physical(
                             self.resolve_index_name(namespace, index_name)?,
@@ -689,7 +689,7 @@ impl<'a, RT: Runtime> IndexModel<'a, RT> {
                 },
             }
         } else {
-            Ok(StableIndexName::Missing)
+            Ok(StableIndexName::Missing(index_name.clone()))
         }
     }
 

crates/database/src/bootstrap_model/user_facing.rs

@@ -340,7 +340,7 @@ fn start_index_range<RT: Runtime>(
                 max_size: max_rows,
             }))
         },
-        StableIndexName::Missing => Ok(Ok(DeveloperIndexRangeResponse {
+        StableIndexName::Missing(_) => Ok(Ok(DeveloperIndexRangeResponse {
             page: vec![],
             cursor: CursorPosition::End,
         })),

crates/database/src/query/search_query.rs

@@ -20,6 +20,7 @@ use common::{
     },
 };
 use errors::ErrorMetadata;
+use indexing::index_registry::index_not_found_error;
 use search::{
     CandidateRevision,
     MAX_CANDIDATE_REVISIONS,
@@ -97,15 +98,17 @@ impl SearchQuery {
             .into_iter()
             .filter(|(_, index_key)| self.cursor_interval.contains(index_key))
             .collect();
-        let namespace = match self.stable_index_name.tablet_index_name() {
-            Some(index_name) => tx.table_mapping().tablet_namespace(*index_name.table())?,
-            None => TableNamespace::Global,
+        let (namespace, table_number) = match self.stable_index_name.tablet_index_name_or_missing()
+        {
+            Ok(index_name) => {
+                let namespace = tx.table_mapping().tablet_namespace(*index_name.table())?;
+                let tablet_number = tx.table_mapping().tablet_number(*index_name.table())?;
+                (namespace, tablet_number)
+            },
+            Err(missing_index_name) => {
+                anyhow::bail!(index_not_found_error(missing_index_name));
+            },
         };
-        let table_number = tx
-            .table_mapping()
-            .namespace(namespace)
-            .id(&self.query.table)?
-            .table_number;
         Ok(SearchResultIterator::new(
             revisions_in_range,
             namespace,

crates/isolate/src/tests/user_error.rs

@@ -161,6 +161,16 @@ async fn test_nonexistent_table(rt: TestRuntime) -> anyhow::Result<()> {
     .await
 }
 
+#[convex_macro::test_runtime]
+async fn test_index_on_nonexistent_table(rt: TestRuntime) -> anyhow::Result<()> {
+    UdfTest::run_test_with_isolate2(rt, async move |t: UdfTestType| {
+        t.mutation("userError:indexOnNonexistentTable", assert_obj!())
+            .await?;
+        Ok(())
+    })
+    .await
+}
+
 #[convex_macro::test_runtime]
 async fn test_nonexistent_id(rt: TestRuntime) -> anyhow::Result<()> {
     UdfTest::run_test_with_isolate2(rt, async move |t: UdfTestType| {

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

@@ -124,21 +124,6 @@ export const nonexistentTable = mutation(
         "expected query filtering to fake ID to return 0 results",
       );
     }
-    // Querying a non-existent table is fine.
-    results = await db.query("missing" as any).collect();
-    if (results.length !== 0) {
-      throw new Error('expected db.query("missing") to return 0 results');
-    }
-
-    // Querying a non-existent table with filters is fine too
-    results = await db
-      .query("missing" as any)
-      .filter((q) => q.eq(q.field("foo"), "foo"))
-      .collect();
-    if (results.length !== 0) {
-      throw new Error('expected db.query("missing") to return 0 results');
-    }
-
     results = await db
       .query("boatVotes")
       .withIndex("by_boat", (q) => q.gt("boat", fakeId))
@@ -151,6 +136,54 @@ export const nonexistentTable = mutation(
   },
 );
 
+export const indexOnNonexistentTable = mutation(async ({ db }) => {
+  // Querying a non-existent table by_creation_time is fine.
+  let results = await db.query("missing" as any).collect();
+  if (results.length !== 0) {
+    throw new Error('expected db.query("missing") to return 0 results');
+  }
+
+  // Querying a non-existent table with filters is fine too
+  results = await db
+    .query("missing" as any)
+    .filter((q) => q.eq(q.field("foo"), "foo"))
+    .collect();
+  if (results.length !== 0) {
+    throw new Error('expected db.query("missing") to return 0 results');
+  }
+
+  // Querying a non-existent table with index throws error about the index
+  // missing (not the table missing).
+  const assertIndexNotFound = async (
+    thunk: () => Promise<void>,
+    indexName: string,
+  ) => {
+    try {
+      await thunk();
+    } catch (error: any) {
+      if (!error.toString().includes(`Index ${indexName} not found`)) {
+        throw error;
+      }
+      return;
+    }
+    throw new Error("expected TableNotFound error");
+  };
+  await assertIndexNotFound(async () => {
+    await db
+      .query("missing" as any)
+      .withIndex("by_foo")
+      .collect();
+  }, "missing.by_foo");
+
+  // Same error with search index
+  await assertIndexNotFound(async () => {
+    await db
+      .query("missing" as any)
+      .withSearchIndex("search_foo", (q) => q.search("foo", "foo"))
+      .collect();
+  }, "missing.search_foo");
+});
+
 export const nonexistentId = mutation({
   handler: async (
     { db },