fix(gb-9103): fix aliases in queries/mutations

Author: pimeys

Cargo.lock

@@ -66,7 +66,7 @@ futures = "0.3"
 futures-util = "0.3.31"
 grafbase-database-definition = { version = "0.1.0", path = "crates/database-definition" }
 grafbase-postgres-introspection = { version = "0.1.0", path = "crates/postgres-introspection" }
-grafbase-sdk = "0.15.4"
+grafbase-sdk = "0.15.7"
 http = "1.3"
 indexmap = "2.9.0"
 indoc = "2.0.6"

Cargo.toml

@@ -24,6 +24,11 @@ impl<'a> TableColumnWalker<'a> {
         self.get_name(self.get().client_name())
     }
 
+    /// Returns the provided alias if present, otherwise falls back to the client name.
+    pub fn alias(self, alias: Option<&'a str>) -> &'a str {
+        alias.unwrap_or_else(|| self.client_name())
+    }
+
     /// The type of the column in the database.
     pub fn database_type(self) -> DatabaseType<'a> {
         match self.get().database_type() {

crates/database-definition/src/walkers/table_column.rs

@@ -1,6 +1,6 @@
 [extension]
 name = "postgres"
-version = "0.4.8"
+version = "0.4.9"
 description = """
 Integrate your Postgres database directly into Grafbase Gateway. This extension exposes your database schema and with the help of the introspection tool, automatically generates a fully-functional GraphQL subgraph, eliminating the need to build and maintain a separate service.
 """

extensions/postgres/extension.toml

@@ -12,25 +12,31 @@ use std::{borrow::Cow, collections::HashMap};
 use super::{Context, PageInfo};
 
 #[derive(Clone)]
-pub struct SelectColumn<'a>(TableColumnWalker<'a>);
+pub struct SelectColumn<'a> {
+    column: TableColumnWalker<'a>,
+    alias: Option<&'a str>,
+}
 
 impl<'a> SelectColumn<'a> {
-    pub fn into_expression(self, table_name: Option<Cow<'a, str>>) -> (TableColumnWalker<'a>, Expression<'a>) {
+    pub fn into_expression(
+        self,
+        table_name: Option<Cow<'a, str>>,
+    ) -> (TableColumnWalker<'a>, Expression<'a>, Option<&'a str>) {
         let table_name = match table_name {
             Some(name) => name,
-            None => Cow::Borrowed(self.0.table().database_name()),
+            None => Cow::Borrowed(self.column.table().database_name()),
         };
 
-        let sql_col = Column::new(self.0.database_name()).table(table_name);
+        let sql_col = Column::new(self.column.database_name()).table(table_name);
 
-        let r#enum = match self.0.database_type() {
+        let r#enum = match self.column.database_type() {
             DatabaseType::Scalar(scalar_type) => {
                 let expr = match scalar_type.from_db_to_client_cast() {
                     Some(cast) => Expression::from(ast::cast(sql_col, cast)),
                     None => Expression::from(sql_col),
                 };
 
-                return (self.0, expr);
+                return (self.column, expr, self.alias);
             }
             DatabaseType::Enum(walker) => walker,
         };
@@ -46,15 +52,15 @@ impl<'a> SelectColumn<'a> {
 
         let expr = builder.r#else(Expression::from(col)).into();
 
-        (self.0, expr)
+        (self.column, expr, self.alias)
     }
 }
 
 #[derive(Clone)]
-pub struct Unnest<'a>(TableColumnWalker<'a>, EnumWalker<'a>);
+pub struct Unnest<'a>(TableColumnWalker<'a>, EnumWalker<'a>, Option<&'a str>);
 
 impl<'a> Unnest<'a> {
-    pub fn into_select(self, table_name: Option<Cow<'a, str>>) -> (TableColumnWalker<'a>, Select<'a>) {
+    pub fn into_select(self, table_name: Option<Cow<'a, str>>) -> (TableColumnWalker<'a>, Select<'a>, Option<&'a str>) {
         let unnest_col = Column::new(format!("unnest_{}", self.0.database_name()));
         let unnest_col = ast::cast(unnest_col, "text");
 
@@ -79,7 +85,7 @@ impl<'a> Unnest<'a> {
         let mut select = Select::from_table(expr);
         select.value(aggregate);
 
-        (self.0, select)
+        (self.0, select, self.2)
     }
 }
 
@@ -91,9 +97,14 @@ pub enum TableSelection<'a> {
     /// GraphQL enum values, renamed.
     ColumnUnnest(Unnest<'a>),
     /// Joins a unique row with a nested selection.
-    JoinUnique(RelationWalker<'a>, SelectionIterator<'a>),
+    JoinUnique(RelationWalker<'a>, SelectionIterator<'a>, Option<&'a str>),
     /// Joins a collection of rows with a nested selection.
-    JoinMany(RelationWalker<'a>, SelectionIterator<'a>, CollectionArgs<'a>),
+    JoinMany(
+        RelationWalker<'a>,
+        SelectionIterator<'a>,
+        CollectionArgs<'a>,
+        Option<&'a str>,
+    ),
 }
 
 /// An iterator over a GraphQL selection. Returns either a column or a
@@ -251,7 +262,12 @@ impl<'a> Iterator for SelectionIterator<'a> {
             let extra = self.extra_columns.get(self.extra_column_index);
             self.extra_column_index += 1;
 
-            return extra.map(|column| Ok(TableSelection::Column(SelectColumn(*column))));
+            return extra.map(|column| {
+                Ok(TableSelection::Column(SelectColumn {
+                    column: *column,
+                    alias: None,
+                }))
+            });
         };
 
         self.index += 1;
@@ -264,10 +280,17 @@ impl<'a> Iterator for SelectionIterator<'a> {
         {
             match column.database_type() {
                 DatabaseType::Enum(r#enum) if column.is_array() => {
-                    return Some(Ok(TableSelection::ColumnUnnest(Unnest(column, r#enum))));
+                    return Some(Ok(TableSelection::ColumnUnnest(Unnest(
+                        column,
+                        r#enum,
+                        selection_field.alias(),
+                    ))));
                 }
                 _ => {
-                    return Some(Ok(TableSelection::Column(SelectColumn(column))));
+                    return Some(Ok(TableSelection::Column(SelectColumn {
+                        column,
+                        alias: selection_field.alias(),
+                    })));
                 }
             }
         }
@@ -299,7 +322,11 @@ impl<'a> Iterator for SelectionIterator<'a> {
                 Err(err) => return Some(Err(err)),
             };
 
-            Some(Ok(TableSelection::JoinUnique(relation, iterator)))
+            Some(Ok(TableSelection::JoinUnique(
+                relation,
+                iterator,
+                selection_field.alias(),
+            )))
         } else {
             let params = selection_field
                 .arguments::<CollectionParameters>(self.ctx.arguments)
@@ -327,7 +354,12 @@ impl<'a> Iterator for SelectionIterator<'a> {
             let args = CollectionArgs::new(self.ctx.database_definition, relation.referenced_table(), params);
 
             match args {
-                Ok(args) => Some(Ok(TableSelection::JoinMany(relation, iterator, args))),
+                Ok(args) => Some(Ok(TableSelection::JoinMany(
+                    relation,
+                    iterator,
+                    args,
+                    selection_field.alias(),
+                ))),
                 Err(error) => Some(Err(error)),
             }
         }

extensions/postgres/src/context/selection_iterator.rs

@@ -32,12 +32,16 @@ pub fn build<'a>(
         for selection in selection {
             match selection? {
                 TableSelection::Column(select) => {
-                    let (column, expr) = select.into_expression(None);
-                    returning.push((column.client_name(), expr));
+                    let (column, expr, alias) = select.into_expression(None);
+                    let alias = alias.unwrap_or_else(|| column.client_name());
+
+                    returning.push((alias, expr));
                 }
                 TableSelection::ColumnUnnest(unnest) => {
-                    let (column, nested) = unnest.into_select(None);
-                    returning.push((column.client_name(), Expression::from(nested)));
+                    let (column, nested, alias) = unnest.into_select(None);
+                    let alias = alias.unwrap_or_else(|| column.client_name());
+
+                    returning.push((alias, Expression::from(nested)));
                 }
                 // our output type doesn't have relations, so this is never reachable
                 TableSelection::JoinMany(..) | TableSelection::JoinUnique(..) => {

extensions/postgres/src/resolve/query/delete.rs

@@ -58,17 +58,17 @@ pub fn build<'a>(
         for selection in selection {
             match selection? {
                 TableSelection::Column(select) => {
-                    let (column, expr) = select.into_expression(Some(insert_name.clone().into()));
+                    let (column, expr, alias) = select.into_expression(Some(insert_name.clone().into()));
 
-                    selected_data.push((column.client_name(), expr));
+                    selected_data.push((alias.unwrap_or_else(|| column.client_name()), expr));
                     returning.push(column.database_name());
                 }
                 TableSelection::ColumnUnnest(unnest) => {
-                    let (column, nested) = unnest.into_select(Some(insert_name.clone().into()));
+                    let (column, nested, field_alias) = unnest.into_select(Some(insert_name.clone().into()));
                     let alias = format!("transformed_{}", column.database_name());
 
                     selected_data.push((
-                        column.client_name(),
+                        field_alias.unwrap_or_else(|| column.client_name()),
                         Column::new("json_array").table(alias.clone()).into(),
                     ));
 

extensions/postgres/src/resolve/query/insert.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use grafbase_database_definition::{RelationWalker, TableColumnWalker};
 use grafbase_sdk::{SdkError, host_io::postgres::types::DatabaseValue};
 use indexmap::{IndexMap, map::Entry};
@@ -93,35 +95,38 @@ pub fn build(builder: SelectBuilder<'_>) -> Result<Select<'_>, SdkError> {
         match selection? {
             // Base columns from the main table (e.g., User.id, User.name)
             TableSelection::Column(select) => {
-                let (column, _) = select.into_expression(None); // We only need column names here
+                let (column, _, _) = select.into_expression(None); // We only need column names here
                 // Reference the column from the aliased main table (e.g., "User"."name")
                 let col_expr = Column::from((builder.table().client_name(), column.database_name()));
                 columns_for_json.push((column.client_name().to_string(), col_expr.into()));
             }
             // Nested object/array fetched via LATERAL JOIN (e.g., blogs, author)
-            TableSelection::JoinUnique(relation, nested_selection) => {
+            TableSelection::JoinUnique(relation, nested_selection, alias) => {
                 inject_relation(
                     &mut main_select,
                     &mut columns_for_json,
                     relation,
                     nested_selection,
                     None,
+                    alias,
                 )?;
             }
-            TableSelection::JoinMany(relation, nested_selection, args) => {
+            TableSelection::JoinMany(relation, nested_selection, args, alias) => {
                 inject_relation(
                     &mut main_select,
                     &mut columns_for_json,
                     relation,
                     nested_selection,
                     Some(args),
+                    alias,
                 )?;
             }
             TableSelection::ColumnUnnest(unnest) => {
                 // Handle array unnesting if required in the final object structure.
                 // This might involve adding a subquery result similar to lateral joins.
-                let (column, nested_select) = unnest.into_select(None);
-                columns_for_json.push((column.client_name().to_string(), Expression::from(nested_select)));
+                let (column, nested_select, alias) = unnest.into_select(None);
+                let alias = alias.unwrap_or_else(|| column.database_name());
+                columns_for_json.push((alias.to_string(), Expression::from(nested_select)));
             }
         }
     }
@@ -189,11 +194,13 @@ fn inject_relation<'a>(
     relation: RelationWalker<'a>,
     nested_selection: SelectionIterator<'a>,
     args: Option<CollectionArgs<'a>>,
+    alias: Option<&'a str>,
 ) -> Result<(), SdkError> {
-    let client_field_name = relation.client_field_name();
-    let join_alias = client_field_name;
+    let join_alias = alias
+        .map(Cow::Borrowed)
+        .unwrap_or_else(|| Cow::Owned(relation.client_field_name()));
 
-    let mut join_builder = SelectBuilder::new(relation.referenced_table(), nested_selection, join_alias.clone());
+    let mut join_builder = SelectBuilder::new(relation.referenced_table(), nested_selection, join_alias.to_string());
     join_builder.set_relation(relation);
 
     let nested_select = match args {
@@ -211,7 +218,7 @@ fn inject_relation<'a>(
 
     columns_for_json.push((
         join_alias.to_string(), // Alias in the final JSON object (e.g., "blogs")
-        Column::from((join_alias.clone(), join_alias)).into(), // Column from lateral join result
+        Column::from((join_alias.to_string(), join_alias.to_string())).into(), // Column from lateral join result
     ));
 
     Ok(())