snowflake-code-unit-registry 0.5.12__tar.gz → 0.7.2__tar.gz

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/Cargo.lock

@@ -499,9 +499,9 @@ dependencies = [
 
 [[package]]
 name = "fastrand"
-version = "2.3.0"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
 
 [[package]]
 name = "find-msvc-tools"
@@ -2095,7 +2095,7 @@ dependencies = [
 
 [[package]]
 name = "scai-error-derive"
-version = "0.5.12"
+version = "0.7.2"
 dependencies = [
  "err_code",
  "heck",
@@ -2109,7 +2109,7 @@ dependencies = [
 
 [[package]]
 name = "scai-state-core"
-version = "0.5.12"
+version = "0.7.2"
 dependencies = [
  "chrono",
  "err_code",
@@ -2134,7 +2134,7 @@ dependencies = [
 
 [[package]]
 name = "scai-state-csharp"
-version = "0.5.12"
+version = "0.7.2"
 dependencies = [
  "interoptopus",
  "interoptopus_backend_csharp",
@@ -2145,7 +2145,7 @@ dependencies = [
 
 [[package]]
 name = "scai-state-node"
-version = "0.5.12"
+version = "0.7.2"
 dependencies = [
  "napi",
  "napi-build",
@@ -2157,7 +2157,7 @@ dependencies = [
 
 [[package]]
 name = "scai-state-python"
-version = "0.5.12"
+version = "0.7.2"
 dependencies = [
  "pyo3",
  "pythonize",
@@ -2578,9 +2578,9 @@ dependencies = [
 
 [[package]]
 name = "tokio"
-version = "1.51.0"
+version = "1.51.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bd1c4c0fc4a7ab90fc15ef6daaa3ec3b893f004f915f2392557ed23237820cd"
+checksum = "f66bf9585cda4b724d3e78ab34b73fb2bbaba9011b9bfdf69dc836382ea13b8c"
 dependencies = [
  "bytes",
  "libc",

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/scai-error-derive", "crates/scai-state-core", "crates/scai-state-python"]
 
 [workspace.package]
-version = "0.5.12"
+version = "0.7.2"
 edition = "2021"
 license = "SEE LICENSE IN LICENSE"
 repository = "https://github.com/snowflake-eng/scai-state"

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-code-unit-registry
-Version: 0.5.12
+Version: 0.7.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/crates/scai-state-core/examples/code-unit.example.json

@@ -2,6 +2,7 @@
   "schemaVersion": 1,
   "isMissing": false,
   "inScope": true,
+  "containsCommit": true,
   "kind": "databaseObject",
   "id": "a3f1b2c4-5d6e-7f89-0a1b-2c3d4e5f6a7b",
   "updatedAt": "2025-01-15T10:30:00Z",
@@ -9,13 +10,15 @@
     "objectType": "procedure",
     "database": "AdventureWorks",
     "schema": "Sales",
-    "name": "usp_GetMonthlyRevenue"
+    "name": "usp_GetMonthlyRevenue",
+    "canonicalName": "AdventureWorks.Sales.usp_GetMonthlyRevenue(DATETIME,DATETIME,NVARCHAR)"
   },
   "target": {
     "objectType": "procedure",
     "database": "ADVENTUREWORKS",
     "schema": "SALES",
-    "name": "USP_GET_MONTHLY_REVENUE"
+    "name": "USP_GET_MONTHLY_REVENUE",
+    "canonicalName": "ADVENTUREWORKS.SALES.USP_GET_MONTHLY_REVENUE(TIMESTAMP_NTZ,TIMESTAMP_NTZ,VARCHAR)"
   },
   "files": {
     "source": {
@@ -130,6 +133,7 @@
         "name": "MonthYear",
         "type": "VARCHAR(7)",
         "nullable": false,
+        "isPrimaryKey": true,
         "targetName": "MONTH_YEAR",
         "targetType": "VARCHAR(7)"
       }

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/crates/scai-state-core/schemas/code-unit.schema.json

@@ -58,6 +58,10 @@
       "description": "true if CodeUnit is in the migration scope",
       "default": true
     },
+    "containsCommit": {
+      "type": "boolean",
+      "description": "True if the stored procedure contains a commit transaction"
+    },
     "kind": {
       "type": "string",
       "title": "Kind",
@@ -93,6 +97,10 @@
         "name": {
           "type": "string",
           "description": "Original object name preserving casing"
+        },
+        "canonicalName": {
+          "type": "string",
+          "description": "Computed canonical identifier: database.schema.name or database.schema.name(paramTypes) for procedures/functions"
         }
       }
     },
@@ -115,6 +123,10 @@
         "name": {
           "type": "string",
           "description": "Object name preserving casing"
+        },
+        "canonicalName": {
+          "type": "string",
+          "description": "Computed canonical identifier: database.schema.name or database.schema.name(paramTypes) for procedures/functions"
         }
       }
     },
@@ -366,6 +378,7 @@
               "name": { "type": "string", "description": "Column name" },
               "type": { "type": "string", "description": "Data type" },
               "nullable": { "type": "boolean", "default": true },
+              "isPrimaryKey": { "type": "boolean", "description": "True if this column is part of the table's primary key" },
               "targetName": { "type": "string" },
               "targetType": { "type": "string" }
             }

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/crates/scai-state-core/src/generated/query_reference.rs

@@ -55,6 +55,7 @@ QUERYABLE FIELDS
   codeStatus.registration.sourceId               string      Identifier for the source system
   codeStatus.registration.status                 enum        pending, inProgress, completed, failed, excluded (Latest status of this operation)
   codeStatus.registration.updatedAt              string      Timestamp of last registration status update
+  containsCommit                                 boolean     True if the stored procedure contains a commit transaction
   dependencies                                   object      Dependency relationships for a code unit
   dependencies.dependsOn                         array       Code units this unit depends on; items: {id, isMissing, relationTypes}
   dependencies.hasTransitiveMissingDependencies  boolean     True when this unit depends (directly or indirectly) on at least one missing dependency
@@ -69,11 +70,13 @@ QUERYABLE FIELDS
   planning.topologicalRank                       integer     Dependency rank hint used for sorting with dependencies. Valid ranks are >= 0. A value of -1 indicates a cycle or downstream dependency on a cycle.
   planning.wave                                  integer     1-based wave assignment
   source                                         object      Source database object metadata
+  source.canonicalName                           string      Computed canonical identifier: database.schema.name or database.schema.name(paramTypes) for procedures/functions
   source.database                                string      Source database name
   source.name                                    string      Original object name preserving casing
   source.objectType                              enum        database, schema, table, view, materializedView, function, procedure, stage, udfHelper, sequence, tableType, trigger, other (Type of database object)
   source.schema                                  string      Source schema name
   target                                         object      Target database object metadata
+  target.canonicalName                           string      Computed canonical identifier: database.schema.name or database.schema.name(paramTypes) for procedures/functions
   target.database                                string      Database name
   target.name                                    string      Object name preserving casing
   target.objectType                              enum        database, schema, table, view, materializedView, function, procedure, stage, udfHelper, sequence, tableType, trigger, other (Type of database object)

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/crates/scai-state-core/src/registry/tests.rs

@@ -30,12 +30,14 @@ fn make_code_unit(id: &str, name: &str, object_type: CodeUnitObjectType) -> Code
             database: Some("DB".to_string()),
             schema: Some("dbo".to_string()),
             name: Some(name.to_string()),
+            ..Default::default()
         }),
         target: Some(TargetMetadata {
             object_type: Some(object_type),
             database: Some("DB".to_string()),
             schema: Some("DBO".to_string()),
             name: Some(name.to_uppercase()),
+            ..Default::default()
         }),
         ..Default::default()
     }
@@ -351,6 +353,7 @@ fn test_create_generates_id_when_missing() {
             database: None,
             schema: None,
             name: None,
+            ..Default::default()
         }),
         ..Default::default()
     };
@@ -571,6 +574,7 @@ fn test_find_by_object_match_nested_fields() {
         database: Some("DB".to_string()),
         schema: Some("sales".to_string()),
         name: Some("Table2".to_string()),
+        ..Default::default()
     });
 
     registry.create(&mut cu1, None).unwrap();
@@ -604,6 +608,7 @@ fn test_find_by_object_multiple_fields() {
         database: Some("DB".to_string()),
         schema: Some("sales".to_string()),
         name: Some("Table2".to_string()),
+        ..Default::default()
     });
 
     registry.create(&mut cu1, None).unwrap();
@@ -743,6 +748,7 @@ fn test_find_by_object_match_by_source_database_and_name() {
         database: Some("OTHER_DB".to_string()),
         schema: Some("dbo".to_string()),
         name: Some("Table2".to_string()),
+        ..Default::default()
     });
 
     registry.create(&mut cu1, None).unwrap();
@@ -963,6 +969,7 @@ fn make_code_unit_with_files(
             database: None,
             schema: None,
             name: None,
+            ..Default::default()
         }),
         target: Some(TargetMetadata {
             object_type: Some(crate::generated::types::ObjectType::Table),
@@ -3743,3 +3750,345 @@ fn test_empty_vec_fields_not_skipped_during_serialization() {
         "empty requiredBy must be serialized"
     );
 }
+
+// ── CanonicalNameHook tests ──────────────────────────────────────────
+
+#[test]
+fn canonical_name_set_on_create_table() {
+    let dir = temp_dir();
+    let registry = CodeUnitRegistry::init(dir.path()).unwrap();
+
+    let mut cu = make_code_unit("cn1", "MyTable", CodeUnitObjectType::Table);
+    registry.create(&mut cu, None).unwrap();
+
+    let stored = registry.get_by_id("cn1", None).unwrap();
+    assert_eq!(
+        stored.source.as_ref().unwrap().canonical_name.as_deref(),
+        Some("DB.dbo.MyTable"),
+    );
+    assert_eq!(
+        stored.target.as_ref().unwrap().canonical_name.as_deref(),
+        Some("DB.DBO.MYTABLE"),
+    );
+}
+
+#[test]
+fn canonical_name_includes_params_for_procedure() {
+    use crate::generated::types::{ParameterDef, Parameters, Signature};
+
+    let dir = temp_dir();
+    let registry = CodeUnitRegistry::init(dir.path()).unwrap();
+
+    let mut cu = make_code_unit("cn2", "MyProc", CodeUnitObjectType::Procedure);
+    cu.signature = Some(Signature {
+        parameters: Some(Parameters {
+            arguments: vec![
+                ParameterDef {
+                    name: Some("@StartDate".to_string()),
+                    type_: Some("DATETIME".to_string()),
+                    target_type: Some("TIMESTAMP_NTZ".to_string()),
+                    ..Default::default()
+                },
+                ParameterDef {
+                    name: Some("@Region".to_string()),
+                    type_: Some("NVARCHAR(50)".to_string()),
+                    target_type: Some("VARCHAR(50)".to_string()),
+                    ..Default::default()
+                },
+            ],
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+    registry.create(&mut cu, None).unwrap();
+
+    let stored = registry.get_by_id("cn2", None).unwrap();
+    assert_eq!(
+        stored.source.as_ref().unwrap().canonical_name.as_deref(),
+        Some("DB.dbo.MyProc(DATETIME,NVARCHAR)"),
+    );
+    assert_eq!(
+        stored.target.as_ref().unwrap().canonical_name.as_deref(),
+        Some("DB.DBO.MYPROC(TIMESTAMP_NTZ,VARCHAR)"),
+    );
+}
+
+#[test]
+fn canonical_name_includes_params_for_function() {
+    use crate::generated::types::{ParameterDef, Parameters, Signature};
+
+    let dir = temp_dir();
+    let registry = CodeUnitRegistry::init(dir.path()).unwrap();
+
+    let mut cu = make_code_unit("cn3", "MyFunc", CodeUnitObjectType::Function);
+    cu.signature = Some(Signature {
+        parameters: Some(Parameters {
+            arguments: vec![ParameterDef {
+                name: Some("@X".to_string()),
+                type_: Some("INT".to_string()),
+                target_type: Some("NUMBER".to_string()),
+                ..Default::default()
+            }],
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+    registry.create(&mut cu, None).unwrap();
+
+    let stored = registry.get_by_id("cn3", None).unwrap();
+    assert_eq!(
+        stored.source.as_ref().unwrap().canonical_name.as_deref(),
+        Some("DB.dbo.MyFunc(INT)"),
+    );
+    assert_eq!(
+        stored.target.as_ref().unwrap().canonical_name.as_deref(),
+        Some("DB.DBO.MYFUNC(NUMBER)"),
+    );
+}
+
+#[test]
+fn canonical_name_no_params_for_view() {
+    use crate::generated::types::{ParameterDef, Parameters, Signature};
+
+    let dir = temp_dir();
+    let registry = CodeUnitRegistry::init(dir.path()).unwrap();
+
+    let mut cu = make_code_unit("cn4", "MyView", CodeUnitObjectType::View);
+    cu.signature = Some(Signature {
+        parameters: Some(Parameters {
+            arguments: vec![ParameterDef {
+                type_: Some("INT".to_string()),
+                ..Default::default()
+            }],
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+    registry.create(&mut cu, None).unwrap();
+
+    let stored = registry.get_by_id("cn4", None).unwrap();
+    assert_eq!(
+        stored.source.as_ref().unwrap().canonical_name.as_deref(),
+        Some("DB.dbo.MyView"),
+        "views should not include parameter signature"
+    );
+}
+
+#[test]
+fn canonical_name_schema_and_name_only() {
+    let dir = temp_dir();
+    let registry = CodeUnitRegistry::init(dir.path()).unwrap();
+
+    let mut cu = CodeUnit {
+        id: Some("cn5".to_string()),
+        kind: Some(CodeUnitKind::DatabaseObject),
+        source: Some(SourceMetadata {
+            object_type: Some(CodeUnitObjectType::Table),
+            database: None,
+            schema: Some("dbo".to_string()),
+            name: Some("Orphan".to_string()),
+            ..Default::default()
+        }),
+        ..Default::default()
+    };
+    registry.create(&mut cu, None).unwrap();
+
+    let stored = registry.get_by_id("cn5", None).unwrap();
+    assert_eq!(
+        stored.source.as_ref().unwrap().canonical_name.as_deref(),
+        Some("dbo.Orphan"),
+        "canonicalName should be schema.name when database is missing"
+    );
+}
+
+#[test]
+fn canonical_name_name_only() {
+    let dir = temp_dir();
+    let registry = CodeUnitRegistry::init(dir.path()).unwrap();
+
+    let mut cu = CodeUnit {
+        id: Some("cn5b".to_string()),
+        kind: Some(CodeUnitKind::DatabaseObject),
+        source: Some(SourceMetadata {
+            object_type: Some(CodeUnitObjectType::Table),
+            database: None,
+            schema: None,
+            name: Some("Lonely".to_string()),
+            ..Default::default()
+        }),
+        ..Default::default()
+    };
+    registry.create(&mut cu, None).unwrap();
+
+    let stored = registry.get_by_id("cn5b", None).unwrap();
+    assert_eq!(
+        stored.source.as_ref().unwrap().canonical_name.as_deref(),
+        Some("Lonely"),
+        "canonicalName should be just name when database and schema are missing"
+    );
+}
+
+#[test]
+fn canonical_name_unknown_schema_fallback() {
+    let dir = temp_dir();
+    let registry = CodeUnitRegistry::init(dir.path()).unwrap();
+
+    let mut cu = CodeUnit {
+        id: Some("cn5c".to_string()),
+        kind: Some(CodeUnitKind::DatabaseObject),
+        source: Some(SourceMetadata {
+            object_type: Some(CodeUnitObjectType::Table),
+            database: Some("MyDB".to_string()),
+            schema: None,
+            name: Some("Widget".to_string()),
+            ..Default::default()
+        }),
+        ..Default::default()
+    };
+    registry.create(&mut cu, None).unwrap();
+
+    let stored = registry.get_by_id("cn5c", None).unwrap();
+    assert_eq!(
+        stored.source.as_ref().unwrap().canonical_name.as_deref(),
+        Some("MyDB.UNKNOWN_SCHEMA.Widget"),
+        "canonicalName should use UNKNOWN_SCHEMA when database is present but schema is missing"
+    );
+}
+
+#[test]
+fn canonical_name_none_when_name_missing() {
+    let dir = temp_dir();
+    let registry = CodeUnitRegistry::init(dir.path()).unwrap();
+
+    let mut cu = CodeUnit {
+        id: Some("cn5d".to_string()),
+        kind: Some(CodeUnitKind::DatabaseObject),
+        source: Some(SourceMetadata {
+            object_type: Some(CodeUnitObjectType::Table),
+            database: Some("DB".to_string()),
+            schema: Some("dbo".to_string()),
+            name: None,
+            ..Default::default()
+        }),
+        ..Default::default()
+    };
+    registry.create(&mut cu, None).unwrap();
+
+    let stored = registry.get_by_id("cn5d", None).unwrap();
+    assert_eq!(
+        stored.source.as_ref().unwrap().canonical_name,
+        None,
+        "canonicalName should be None when name is missing for non-container types"
+    );
+}
+
+#[test]
+fn canonical_name_database_object_type() {
+    let dir = temp_dir();
+    let registry = CodeUnitRegistry::init(dir.path()).unwrap();
+
+    let mut cu = CodeUnit {
+        id: Some("cn5e".to_string()),
+        kind: Some(CodeUnitKind::DatabaseObject),
+        source: Some(SourceMetadata {
+            object_type: Some(CodeUnitObjectType::Database),
+            database: Some("MyDB".to_string()),
+            schema: None,
+            name: None,
+            ..Default::default()
+        }),
+        ..Default::default()
+    };
+    registry.create(&mut cu, None).unwrap();
+
+    let stored = registry.get_by_id("cn5e", None).unwrap();
+    assert_eq!(
+        stored.source.as_ref().unwrap().canonical_name.as_deref(),
+        Some("MyDB"),
+        "database objectType should use just the database name, no schema"
+    );
+}
+
+#[test]
+fn canonical_name_schema_object_type_with_database() {
+    let dir = temp_dir();
+    let registry = CodeUnitRegistry::init(dir.path()).unwrap();
+
+    let mut cu = CodeUnit {
+        id: Some("cn5f".to_string()),
+        kind: Some(CodeUnitKind::DatabaseObject),
+        source: Some(SourceMetadata {
+            object_type: Some(CodeUnitObjectType::Schema),
+            database: Some("MyDB".to_string()),
+            schema: Some("Sales".to_string()),
+            name: None,
+            ..Default::default()
+        }),
+        ..Default::default()
+    };
+    registry.create(&mut cu, None).unwrap();
+
+    let stored = registry.get_by_id("cn5f", None).unwrap();
+    assert_eq!(
+        stored.source.as_ref().unwrap().canonical_name.as_deref(),
+        Some("MyDB.Sales"),
+        "schema objectType with database should be database.schema"
+    );
+}
+
+#[test]
+fn canonical_name_schema_object_type_without_database() {
+    let dir = temp_dir();
+    let registry = CodeUnitRegistry::init(dir.path()).unwrap();
+
+    let mut cu = CodeUnit {
+        id: Some("cn5g".to_string()),
+        kind: Some(CodeUnitKind::DatabaseObject),
+        source: Some(SourceMetadata {
+            object_type: Some(CodeUnitObjectType::Schema),
+            database: None,
+            schema: Some("Sales".to_string()),
+            name: None,
+            ..Default::default()
+        }),
+        ..Default::default()
+    };
+    registry.create(&mut cu, None).unwrap();
+
+    let stored = registry.get_by_id("cn5g", None).unwrap();
+    assert_eq!(
+        stored.source.as_ref().unwrap().canonical_name.as_deref(),
+        Some("Sales"),
+        "schema objectType without database should be just the schema name"
+    );
+}
+
+#[test]
+fn canonical_name_updated_on_update() {
+    let dir = temp_dir();
+    let registry = CodeUnitRegistry::init(dir.path()).unwrap();
+
+    let mut cu = make_code_unit("cn6", "OldName", CodeUnitObjectType::Table);
+    registry.create(&mut cu, None).unwrap();
+
+    let stored = registry.get_by_id("cn6", None).unwrap();
+    assert_eq!(
+        stored.source.as_ref().unwrap().canonical_name.as_deref(),
+        Some("DB.dbo.OldName"),
+    );
+
+    registry
+        .update(
+            "cn6",
+            &[("source.name", serde_json::json!("NewName"))],
+            None,
+        )
+        .unwrap();
+
+    let updated = registry.get_by_id("cn6", None).unwrap();
+    assert_eq!(
+        updated.source.as_ref().unwrap().canonical_name.as_deref(),
+        Some("DB.dbo.NewName"),
+        "canonicalName should reflect the updated name"
+    );
+}

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/crates/scai-state-core/src/registry.rs

@@ -504,16 +504,142 @@ impl Drop for HookGuard<'_> {
     }
 }
 
+/// Built-in hook that computes `canonicalName` on both `source` and `target`
+/// metadata before persisting. Format:
+/// - `database.schema.name` for most object types
+/// - `database.schema.name(TYPE,TYPE,...)` for procedures and functions,
+///   using base parameter types with length/precision stripped
+pub(crate) struct CanonicalNameHook;
+
+impl CanonicalNameHook {
+    /// Strip length/precision from a SQL type: `NVARCHAR(50)` -> `NVARCHAR`.
+    fn base_type(ty: &str) -> &str {
+        match ty.find('(') {
+            Some(pos) => &ty[..pos],
+            None => ty,
+        }
+    }
+
+    /// Build the canonical name from metadata fields and optional signature.
+    ///
+    /// Rules:
+    /// - `name` is always required unless objectType is `database` or `schema`
+    /// - `database` and `schema` are optional: result can be `name`, `schema.name`,
+    ///   or `database.schema.name`
+    /// - If `database` is present but `schema` is missing, substitute `UNKNOWN_SCHEMA`
+    ///   (except for objectType `database`, which has no schema)
+    fn compute(metadata: &Value, signature: Option<&Value>, type_field: &str) -> Option<String> {
+        let obj = metadata.as_object()?;
+        let database = obj.get("database").and_then(|v| v.as_str());
+        let schema = obj.get("schema").and_then(|v| v.as_str());
+        let name = obj.get("name").and_then(|v| v.as_str());
+        let object_type = obj.get("objectType").and_then(|v| v.as_str());
+
+        let is_container = matches!(object_type, Some("database" | "schema"));
+
+        if name.is_none() && !is_container {
+            return None;
+        }
+
+        let mut parts: Vec<&str> = Vec::new();
+
+        if let Some(db) = database {
+            parts.push(db);
+            if !matches!(object_type, Some("database")) {
+                parts.push(schema.unwrap_or("UNKNOWN_SCHEMA"));
+            }
+        } else if let Some(sch) = schema {
+            parts.push(sch);
+        }
+
+        if let Some(n) = name {
+            parts.push(n);
+        }
+
+        let mut canonical = parts.join(".");
+
+        let needs_signature = matches!(object_type, Some("procedure" | "function"));
+        if needs_signature {
+            if let Some(args) = signature
+                .and_then(|s| s.get("parameters"))
+                .and_then(|p| p.get("arguments"))
+                .and_then(|a| a.as_array())
+            {
+                let types: Vec<&str> = args
+                    .iter()
+                    .filter_map(|arg| arg.get(type_field).and_then(|v| v.as_str()))
+                    .map(Self::base_type)
+                    .collect();
+                if !types.is_empty() {
+                    canonical.push('(');
+                    canonical.push_str(&types.join(","));
+                    canonical.push(')');
+                }
+            }
+        }
+
+        Some(canonical)
+    }
+}
+
+impl RegistryHook for CanonicalNameHook {
+    fn before_persist(
+        &self,
+        _kind: ChangeType,
+        changes: Vec<CodeUnitChange>,
+        _registry: &CodeUnitRegistry,
+        _options: &WriteOptions,
+    ) -> Result<Vec<CodeUnitChange>> {
+        let mut result = changes;
+        for change in &mut result {
+            let Some(unit) = &mut change.after else {
+                continue;
+            };
+            let mut json = serde_json::to_value(&*unit)?;
+            let signature = json.get("signature").cloned();
+
+            if let Some(source) = json.get("source") {
+                if let Some(cn) = Self::compute(source, signature.as_ref(), "type") {
+                    json.as_object_mut()
+                        .unwrap()
+                        .get_mut("source")
+                        .unwrap()
+                        .as_object_mut()
+                        .unwrap()
+                        .insert("canonicalName".to_string(), Value::String(cn));
+                }
+            }
+
+            if let Some(target) = json.get("target") {
+                if let Some(cn) = Self::compute(target, signature.as_ref(), "targetType") {
+                    json.as_object_mut()
+                        .unwrap()
+                        .get_mut("target")
+                        .unwrap()
+                        .as_object_mut()
+                        .unwrap()
+                        .insert("canonicalName".to_string(), Value::String(cn));
+                }
+            }
+
+            *unit = serde_json::from_value(json)?;
+        }
+        Ok(result)
+    }
+}
+
 /// The ordered set of built-in hooks that run on every write operation.
 ///
 /// Order matters: PathNormalizationHook first (so downstream hooks see
 /// canonical paths), ChecksumHook second (so checksums are based on
-/// resolved paths), then DependencyRefreshHook, then UpdatedAtHook last.
+/// resolved paths), then DependencyRefreshHook, CanonicalNameHook,
+/// then UpdatedAtHook last.
 fn builtin_hooks() -> Vec<Box<dyn RegistryHook + Send + Sync>> {
     vec![
         Box::new(PathNormalizationHook),
         Box::new(ChecksumHook),
         Box::new(DependencyRefreshHook),
+        Box::new(CanonicalNameHook),
         Box::new(UpdatedAtHook),
     ]
 }

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/crates/scai-state-python/tests/test_crud.py

@@ -58,6 +58,11 @@ def test_crud_lifecycle(registry_dir: str):
     created_id = registry.create(cu)
     assert created_id == "lifecycle-001"
 
+    # Verify canonicalName computed by hook
+    created = registry.get_by_id("lifecycle-001")
+    assert created.source.canonicalName == "DB.dbo.Orders"
+    assert created.target.canonicalName == "DB.DBO.ORDERS"
+
     # Find with filter
     results = registry.find_all(
         FindOptions(filter="source.objectType = 'table'")
@@ -71,6 +76,7 @@ def test_crud_lifecycle(registry_dir: str):
     # Verify update
     loaded = registry.get_by_id("lifecycle-001")
     assert loaded.source.name == "UpdatedOrders"
+    assert loaded.source.canonicalName == "DB.dbo.UpdatedOrders"
 
     # Delete
     registry.delete("lifecycle-001")

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/crates/scai-state-python/tests/test_serialization.py

@@ -50,6 +50,7 @@ def test_roundtrip_full_document(registry_dir: str):
     original = CodeUnit(
         id="roundtrip-001",
         kind=Kind.databaseObject,
+        containsCommit=True,
         source=SourceMetadata.model_validate(
             {
                 "objectType": ObjectType.procedure,
@@ -111,6 +112,7 @@ def test_roundtrip_full_document(registry_dir: str):
                     name="Revenue",
                     type="DECIMAL(18,2)",
                     nullable=False,
+                    isPrimaryKey=True,
                     targetName="REVENUE",
                     targetType="NUMBER(18,2)",
                 )
@@ -150,6 +152,7 @@ def test_roundtrip_full_document(registry_dir: str):
     assert loaded.schemaVersion == 1
     assert loaded.isMissing is False
     assert loaded.inScope is True
+    assert loaded.containsCommit is True
 
     # Source / Target
     assert loaded.source.database == "AdventureWorks"
@@ -201,6 +204,7 @@ def test_roundtrip_full_document(registry_dir: str):
     # Signature
     assert len(loaded.signature.columns) == 1
     assert loaded.signature.columns[0].name == "Revenue"
+    assert loaded.signature.columns[0].isPrimaryKey is True
     assert len(loaded.signature.parameters.arguments) == 1
     assert loaded.signature.parameters.arguments[0].name == "@StartDate"
     assert len(loaded.signature.parameters.returns) == 1

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "snowflake-code-unit-registry"
-version = "0.5.12"
+version = "0.7.2"
 description = "SCAI state management library for database migrations"
 readme = "README.md"
 requires-python = ">=3.9"

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/python/snowflake_code_unit_registry/__init__.py

@@ -41,7 +41,7 @@ from snowflake_code_unit_registry.types import CodeUnit
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
-__version__ = "0.5.12"
+__version__ = "0.7.2"
 __all__ = [
     "CodeUnitRegistry",
     "generate_id",

{snowflake_code_unit_registry-0.5.12 → snowflake_code_unit_registry-0.7.2}/python/snowflake_code_unit_registry/types.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  code-unit.schema.json
-#   timestamp: 2026-03-27T15:48:24+00:00
+#   timestamp: 2026-04-08T04:47:25+00:00
 
 from __future__ import annotations
 
@@ -58,9 +58,10 @@ class Issue(BaseModel):
 
 class Issues(RootModel[list[Issue]]):
     root: list[Issue] = Field(
-        default_factory=list,
+        [],
         description='Derived issues from converted code scanning',
         title='Issues',
+        validate_default=True,
     )
 
 
@@ -109,8 +110,8 @@ class Parameters(BaseModel):
     model_config = ConfigDict(
         extra='allow',
     )
-    arguments: list[ParameterDef] | None = Field(default_factory=list)
-    returns: list[ReturnDef] | None = Field(default_factory=list)
+    arguments: list[ParameterDef] | None = Field([], validate_default=True)
+    returns: list[ReturnDef] | None = Field([], validate_default=True)
 
 
 class Signature(BaseModel):
@@ -122,7 +123,7 @@ class Signature(BaseModel):
         extra='allow',
     )
     columns: list[ColumnDef] | None = Field(
-        default_factory=list, description='Column definitions'
+        [], description='Column definitions', validate_default=True
     )
     parameters: Parameters | None = Field(None, title='Parameters')
 
@@ -194,6 +195,10 @@ class SourceMetadata(BaseModel):
     database: str | None = Field(None, description='Source database name')
     schema_: str | None = Field(None, alias='schema', description='Source schema name')
     name: str | None = Field(None, description='Original object name preserving casing')
+    canonicalName: str | None = Field(
+        None,
+        description='Computed canonical identifier: database.schema.name or database.schema.name(paramTypes) for procedures/functions',
+    )
 
 
 class TargetMetadata(BaseModel):
@@ -208,6 +213,10 @@ class TargetMetadata(BaseModel):
     database: str | None = Field(None, description='Database name')
     schema_: str | None = Field(None, alias='schema', description='Schema name')
     name: str | None = Field(None, description='Object name preserving casing')
+    canonicalName: str | None = Field(
+        None,
+        description='Computed canonical identifier: database.schema.name or database.schema.name(paramTypes) for procedures/functions',
+    )
 
 
 class Files(BaseModel):
@@ -363,7 +372,7 @@ class Dependencies(BaseModel):
         extra='allow',
     )
     dependsOn: list[Dependency] | None = Field(
-        default_factory=list, description='Code units this unit depends on'
+        [], description='Code units this unit depends on', validate_default=True
     )
     requiredBy: list[str] | None = Field(
         [], description='Code units that depend on this unit'
@@ -424,9 +433,10 @@ class CodeUnit(BaseModel):
         None, description='Wave assignment and dependency rank hints', title='Planning'
     )
     issues: Issues | None = Field(
-        default_factory=lambda: Issues([]),
+        [],
         description='Derived issues from converted code scanning',
         title='Issues',
+        validate_default=True,
     )
     signature: Signature | None = Field(
         None,