feat(torii-sqlite): primitive upgrades towards bigger types

crates/dojo/types/src/primitive.rs

@@ -403,6 +403,44 @@
             }
         }
     }
+
+    pub fn can_upgrade_to(&self, other: &Primitive) -> bool {
+        use Primitive::*;
+        match (self, other) {
+            // USize is not allowed to upgrade
+            (USize(_), _) => false,
+
+            // Boolean (no upgrades)
+            (Bool(_), Bool(_)) => true,
+
+            // Unsigned integer upgrades
+            (U8(_), U16(_) | U32(_) | USize(_) | U64(_) | U128(_) | Felt252(_)) => true,
+            (U16(_), U32(_) | USize(_) | U64(_) | U128(_) | Felt252(_)) => true,
+            (U32(_), USize(_) | U64(_) | U128(_) | Felt252(_)) => true,
+            (U64(_), U128(_) | Felt252(_)) => true,
+            (U128(_), Felt252(_)) => true,
+
+            // U256 can only upgrade to itself
+            (U256(_), U256(_)) => true,
+
+            // Signed integer upgrades
+            (I8(_), I16(_) | I32(_) | I64(_) | I128(_) | Felt252(_)) => true,
+            (I16(_), I32(_) | I64(_) | I128(_) | Felt252(_)) => true,
+            (I32(_), I64(_) | I128(_) | Felt252(_)) => true,
+            (I64(_), I128(_) | Felt252(_)) => true,
+            (I128(_), Felt252(_)) => true,
+
+            // Felt252 and address types
+            (Felt252(_), ClassHash(_) | ContractAddress(_)) => true,
+            (ClassHash(_), Felt252(_) | ContractAddress(_)) => true,
+            (ContractAddress(_), Felt252(_) | ClassHash(_)) => true,
+
+            // Same type is considered an upgrade (no-op)
+            (a, b) if std::mem::discriminant(a) == std::mem::discriminant(b) => true,
+
+            _ => false,
+        }
+    }
 }
 
 #[cfg(test)]

crates/torii/indexer/src/processors/upgrade_event.rs

@@ -94,7 +94,7 @@
             world.model_reader(&namespace, &name).await?
         };
         let new_schema = model.schema().await?;
-        let schema_diff = new_schema.diff(&prev_schema);
+        let schema_diff = prev_schema.diff(&new_schema);
         // No changes to the schema. This can happen if torii is re-run with a fresh database.
         // As the register model fetches the latest schema from the chain.
         if schema_diff.is_none() {

crates/torii/indexer/src/processors/upgrade_model.rs

@@ -92,7 +92,7 @@
             world.model_reader(&namespace, &name).await?
         };
         let new_schema = model.schema().await?;
-        let schema_diff = new_schema.diff(&prev_schema);
+        let schema_diff = prev_schema.diff(&new_schema);
         // No changes to the schema. This can happen if torii is re-run with a fresh database.
         // As the register model fetches the latest schema from the chain.
         if schema_diff.is_none() {

crates/torii/sqlite/src/lib.rs

@@ -5,6 +5,7 @@
 
 use anyhow::{anyhow, Context, Result};
 use dojo_types::naming::get_tag;
+use dojo_types::primitive::SqlType;
 use dojo_types::schema::{Struct, Ty};
 use dojo_world::config::WorldMetadata;
 use dojo_world::contracts::abigen::model::Layout;
@@ -887,7 +888,10 @@
             alter_table_queries.push(format!("ALTER TABLE [{table_id}] DROP COLUMN [{name}]"));
             alter_table_queries
                 .push(format!("ALTER TABLE [{table_id}] ADD COLUMN [{name}] {sql_type}"));
-            alter_table_queries.push(format!("UPDATE [{table_id}] SET [{name}] = {sql_value}"));
+            alter_table_queries.push(format!(
+                "UPDATE [{table_id}] SET [{name}] = (SELECT {sql_value} FROM tmp_values_{name} \
+                 WHERE tmp_values_{name}.internal_id = [{table_id}].internal_id)"
+            ));
             alter_table_queries.push(format!("DROP TABLE tmp_values_{name}"));
             alter_table_queries.push(format!(
                 "CREATE INDEX IF NOT EXISTS [idx_{table_id}_{name}] ON [{table_id}] ([{name}]);"
@@ -1032,7 +1036,38 @@
             let column_name =
                 if column_prefix.is_empty() { "value".to_string() } else { column_prefix };
 
-            add_column(&column_name, p.to_sql_type().as_ref());
+            if let Some(upgrade_diff) = upgrade_diff {
+                if let Some(old_primitive) = upgrade_diff.as_primitive() {
+                    if old_primitive.can_upgrade_to(p) {
+                        // For upgrades to larger numeric types, convert to hex string padded to 64
+                        // chars
+                        let sql_value = if old_primitive.to_sql_type() == SqlType::Integer
+                            && p.to_sql_type() == SqlType::Text
+                        {
+                            // Convert integer to hex string with '0x' prefix and proper padding
+                            format!("printf('%064x', [{column_name}])")
+                        } else {
+                            format!("[{column_name}]")
+                        };
+
+                        modify_column(
+                            alter_table_queries,
+                            &column_name,
+                            p.to_sql_type().as_ref(),
+                            &sql_value,
+                        );
+                    } else {
+                        return Err(anyhow::anyhow!(
+                            "Invalid primitive type upgrade from {:?} to {:?}",
+                            old_primitive,
+                            p
+                        ));
+                    }
+                }
+            } else {
+                // New column
+                add_column(&column_name, p.to_sql_type().as_ref());
+            }
         }
     }