- Make sure primary keys are supported types

- Fix TODO nodeId check, move out of transpile into builder
- Create SupportedPrimaryKeyType enum for PK type matching

Author: spitfire55

src/builder.rs

@@ -989,6 +989,16 @@ pub struct NodeIdInstance {
     pub values: Vec<serde_json::Value>,
 }
 
+impl NodeIdInstance {
+    pub fn validate(&self, table: &Table) -> Result<(), String> {
+        // Validate that nodeId belongs to the table being queried
+        if self.schema_name != table.schema || self.table_name != table.name {
+            return Err("nodeId belongs to a different collection".to_string());
+        }
+        Ok(())
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct NodeIdBuilder {
     pub alias: String,

src/graphql.rs

@@ -1233,55 +1233,58 @@ impl ___Type for QueryType {
                 f.push(collection_entrypoint);
 
                 // Add single record query by primary key if the table has a primary key
+                // and the primary key types are supported (int, bigint, uuid, string)
                 if let Some(primary_key) = table.primary_key() {
-                    let node_type = NodeType {
-                        table: Arc::clone(table),
-                        fkey: None,
-                        reverse_reference: None,
-                        schema: Arc::clone(&self.schema),
-                    };
-
-                    // Create arguments for each primary key column
-                    let mut pk_args = Vec::new();
-                    for col_name in &primary_key.column_names {
-                        if let Some(col) = table.columns.iter().find(|c| &c.name == col_name) {
-                            let col_type = sql_column_to_graphql_type(col, &self.schema)
-                                .ok_or_else(|| {
-                                    format!(
-                                        "Could not determine GraphQL type for column {}",
-                                        col_name
-                                    )
-                                })
-                                .unwrap_or_else(|_| __Type::Scalar(Scalar::String(None)));
-
-                            // Use graphql_column_field_name to convert snake_case to camelCase if needed
-                            let arg_name = self.schema.graphql_column_field_name(col);
-
-                            pk_args.push(__InputValue {
-                                name_: arg_name,
-                                type_: __Type::NonNull(NonNullType {
-                                    type_: Box::new(col_type),
-                                }),
-                                description: Some(format!("The record's `{}` value", col_name)),
-                                default_value: None,
-                                sql_type: Some(NodeSQLType::Column(Arc::clone(col))),
-                            });
+                    if table.has_supported_pk_types_for_by_pk() {
+                        let node_type = NodeType {
+                            table: Arc::clone(table),
+                            fkey: None,
+                            reverse_reference: None,
+                            schema: Arc::clone(&self.schema),
+                        };
+
+                        // Create arguments for each primary key column
+                        let mut pk_args = Vec::new();
+                        for col_name in &primary_key.column_names {
+                            if let Some(col) = table.columns.iter().find(|c| &c.name == col_name) {
+                                let col_type = sql_column_to_graphql_type(col, &self.schema)
+                                    .ok_or_else(|| {
+                                        format!(
+                                            "Could not determine GraphQL type for column {}",
+                                            col_name
+                                        )
+                                    })
+                                    .unwrap_or_else(|_| __Type::Scalar(Scalar::String(None)));
+
+                                // Use graphql_column_field_name to convert snake_case to camelCase if needed
+                                let arg_name = self.schema.graphql_column_field_name(col);
+
+                                pk_args.push(__InputValue {
+                                    name_: arg_name,
+                                    type_: __Type::NonNull(NonNullType {
+                                        type_: Box::new(col_type),
+                                    }),
+                                    description: Some(format!("The record's `{}` value", col_name)),
+                                    default_value: None,
+                                    sql_type: Some(NodeSQLType::Column(Arc::clone(col))),
+                                });
+                            }
                         }
-                    }
 
-                    let pk_entrypoint = __Field {
-                        name_: format!("{}ByPk", lowercase_first_letter(table_base_type_name)),
-                        type_: __Type::Node(node_type),
-                        args: pk_args,
-                        description: Some(format!(
-                            "Retrieve a record of type `{}` by its primary key",
-                            table_base_type_name
-                        )),
-                        deprecation_reason: None,
-                        sql_type: None,
-                    };
+                        let pk_entrypoint = __Field {
+                            name_: format!("{}ByPk", lowercase_first_letter(table_base_type_name)),
+                            type_: __Type::Node(node_type),
+                            args: pk_args,
+                            description: Some(format!(
+                                "Retrieve a record of type `{}` by its primary key",
+                                table_base_type_name
+                            )),
+                            deprecation_reason: None,
+                            sql_type: None,
+                        };
 
-                    f.push(pk_entrypoint);
+                        f.push(pk_entrypoint);
+                    }
                 }
             }
         }
@@ -3443,7 +3446,7 @@ impl FromStr for FilterOp {
             "contains" => Ok(Self::Contains),
             "containedBy" => Ok(Self::ContainedBy),
             "overlaps" => Ok(Self::Overlap),
-            _ => Err("Invalid filter operation".to_string()),
+            other => Err(format!("Invalid filter operation: {}", other)),
         }
     }
 }

src/sql_types.rs

@@ -565,6 +565,18 @@ impl Table {
             .collect::<Vec<&Arc<Column>>>()
     }
 
+    pub fn has_supported_pk_types_for_by_pk(&self) -> bool {
+        let pk_columns = self.primary_key_columns();
+        if pk_columns.is_empty() {
+            return false;
+        }
+
+        // Check that all primary key columns have supported types
+        pk_columns.iter().all(|col| {
+            SupportedPrimaryKeyType::from_type_name(&col.type_name).is_some()
+        })
+    }
+
     pub fn is_any_column_selectable(&self) -> bool {
         self.columns.iter().any(|x| x.permissions.is_selectable)
     }
@@ -577,6 +589,41 @@ impl Table {
     }
 }
 
+#[derive(Debug, PartialEq)]
+pub enum SupportedPrimaryKeyType {
+    // Integer types
+    Int,      // int, int4, integer
+    BigInt,   // bigint, int8
+    SmallInt, // smallint, int2
+    // String types
+    Text,     // text
+    VarChar,  // varchar
+    Char,     // char, bpchar
+    CiText,   // citext
+    // UUID
+    UUID,     // uuid
+}
+
+impl SupportedPrimaryKeyType {
+    fn from_type_name(type_name: &str) -> Option<Self> {
+        match type_name {
+            // Integer types
+            "int" | "int4" | "integer" => Some(Self::Int),
+            "bigint" | "int8" => Some(Self::BigInt),
+            "smallint" | "int2" => Some(Self::SmallInt),
+            // String types
+            "text" => Some(Self::Text),
+            "varchar" => Some(Self::VarChar),
+            "char" | "bpchar" => Some(Self::Char),
+            "citext" => Some(Self::CiText),
+            // UUID
+            "uuid" => Some(Self::UUID),
+            // Any other type is not supported
+            _ => None,
+        }
+    }
+}
+
 #[derive(Deserialize, Clone, Debug, Eq, PartialEq, Hash)]
 pub struct SchemaDirectives {
     // @graphql({"inflect_names": true})

src/transpile.rs

@@ -1424,9 +1424,7 @@ impl NodeIdInstance {
         param_context: &mut ParamContext,
     ) -> Result<String, String> {
         // Validate that nodeId belongs to the table being queried
-        if self.schema_name != table.schema || self.table_name != table.name {
-            return Err("nodeId belongs to a different collection".to_string());
-        }
+        self.validate(table)?;
 
         let pkey = table
             .primary_key()