dlin-cli 0.2.1__tar.gz → 0.2.2__tar.gz

{dlin_cli-0.2.1 → dlin_cli-0.2.2}/Cargo.lock

@@ -230,7 +230,7 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "dlin"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "anyhow",
  "clap",
@@ -247,7 +247,7 @@ dependencies = [
 
 [[package]]
 name = "dlin-core"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "anyhow",
  "clap",
@@ -398,9 +398,9 @@ dependencies = [
 
 [[package]]
 name = "granit-parser"
-version = "0.0.2"
+version = "0.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7e736dfe3881c53a7dce0685eb18202d0d9fe6911782f9870946eb9ee89d778"
+checksum = "f50ba32164f9e098d5da618776a32afbb32270adcbe3d3d006107dae11e37c91"
 dependencies = [
  "arraydeque",
  "smallvec",
@@ -597,9 +597,9 @@ checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
 [[package]]
 name = "polyglot-sql"
-version = "0.4.2"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e264f8907f3a2050232cd06503afb637525038ddd388a2c9e03424e336cd9c8"
+checksum = "b0d5ea9283f03d3b6c32a230e60e7c6bc854e5bec83c399c75cad02bf46e9622"
 dependencies = [
  "serde",
  "serde_json",
@@ -750,9 +750,9 @@ dependencies = [
 
 [[package]]
 name = "serde-saphyr"
-version = "0.0.26"
+version = "0.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcc7fe48e34d02a97bc8e6253b8b91e5a47fe2c47eaacb5149cefbb69922eaf0"
+checksum = "5897b4c3faadadd35fdb6689f015641f3bc481d5adaaac56231ea15aeb243db3"
 dependencies = [
  "ahash",
  "annotate-snippets",

{dlin_cli-0.2.1 → dlin_cli-0.2.2}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "3"
 
 [workspace.package]
-version = "0.2.1"
+version = "0.2.2"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/eitsupi/dlin"
@@ -13,7 +13,7 @@ homepage = "https://github.com/eitsupi/dlin"
 petgraph = { version = "0.8", features = ["serde-1"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-serde-saphyr = "0.0.26"
+serde-saphyr = "0.0.27"
 regex = "1"
 walkdir = "2"
 colored = "3"
@@ -23,7 +23,7 @@ indexmap = "2"
 minijinja = "2"
 rayon = "1"
 globset = "0.4"
-polyglot-sql = { version = "0.4.2", default-features = false, features = ["all-dialects", "semantic"] }
+polyglot-sql = { version = "0.4.4", default-features = false, features = ["all-dialects", "semantic"] }
 path-slash = "0.2.1"
 clap = { version = "4", features = ["derive", "env"] }
 libc = "0.2"
@@ -34,7 +34,7 @@ insta = "1"
 serial_test = "3.4.0"
 
 # internal
-dlin-core = { version = "0.2.1", path = "crates/dlin-core" }
+dlin-core = { version = "0.2.2", path = "crates/dlin-core" }
 
 [workspace.lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tarpaulin_include)'] }

{dlin_cli-0.2.1 → dlin_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dlin-cli
-Version: 0.2.1
+Version: 0.2.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{dlin_cli-0.2.1 → dlin_cli-0.2.2}/crates/dlin/src/cli.rs

@@ -264,7 +264,7 @@ All selectors support glob patterns (*, **, ?, []):
         value_delimiter = ',',
         long_help = "\
 Filter output by node type (comma-separated). Default: all types.
-Available types: model, source, seed, snapshot, test, exposure.
+Available types: model, source, seed, snapshot, test, exposure, semantic_model, metric, saved_query.
 
 NOTE: In sql mode, generic tests are inferred from YAML declarations
 with dlin-specific IDs. Use --source manifest for exact dependency resolution."
@@ -953,8 +953,10 @@ pub struct ColumnGraphArgs {
     #[arg(short = 'o', long, default_value = "json")]
     pub output: ColumnOutputFormat,
 
-    /// SQL dialect for parsing (default: generic).
-    /// [possible values: bigquery, snowflake, postgres, redshift, databricks, spark, trino, duckdb, mysql, clickhouse, oracle, hive, sqlite, presto, athena, teradata, doris, starrocks, materialize, risingwave, singlestore, cockroachdb, tidb, tsql, druid, solr, tableau, dune, fabric, drill, dremio, exasol, datafusion]
+    /// SQL dialect for parsing compiled SQL.
+    /// Auto-detected from manifest.metadata.adapter_type when omitted; required if the manifest
+    /// does not declare an adapter_type.
+    /// [possible values: generic, bigquery, snowflake, postgres, duckdb, redshift, databricks, spark, trino, mysql, clickhouse, oracle, hive, sqlite, presto, athena, teradata, doris, starrocks, materialize, risingwave, singlestore, cockroachdb, tidb, tsql, druid, solr, tableau, dune, fabric, drill, dremio, exasol, datafusion]
     #[arg(long)]
     pub dialect: Option<DialectType>,
 
@@ -996,8 +998,10 @@ pub struct ColumnImpactArgs {
     #[arg(short = 'o', long, default_value = "json")]
     pub output: ColumnOutputFormat,
 
-    /// SQL dialect for parsing (default: generic).
-    /// [possible values: bigquery, snowflake, postgres, redshift, databricks, spark, trino, duckdb, mysql, clickhouse, oracle, hive, sqlite, presto, athena, teradata, doris, starrocks, materialize, risingwave, singlestore, cockroachdb, tidb, tsql, druid, solr, tableau, dune, fabric, drill, dremio, exasol, datafusion]
+    /// SQL dialect for parsing compiled SQL.
+    /// Auto-detected from manifest.metadata.adapter_type when omitted; required if the manifest
+    /// does not declare an adapter_type.
+    /// [possible values: generic, bigquery, snowflake, postgres, duckdb, redshift, databricks, spark, trino, mysql, clickhouse, oracle, hive, sqlite, presto, athena, teradata, doris, starrocks, materialize, risingwave, singlestore, cockroachdb, tidb, tsql, druid, solr, tableau, dune, fabric, drill, dremio, exasol, datafusion]
     #[arg(long)]
     pub dialect: Option<DialectType>,
 
@@ -1218,7 +1222,7 @@ Examples:
         value_delimiter = ',',
         long_help = "\
 Filter output by node type (comma-separated). Default: all types.
-Available types: model, source, seed, snapshot, test, exposure.
+Available types: model, source, seed, snapshot, test, exposure, semantic_model, metric, saved_query.
 
 NOTE: In sql mode, generic tests are inferred from YAML declarations
 with dlin-specific IDs. Use --source manifest for exact dependency resolution."

{dlin_cli-0.2.1 → dlin_cli-0.2.2}/crates/dlin/src/main.rs

@@ -810,6 +810,39 @@ fn resolve_manifest_path(manifest_arg: &Path) -> Result<PathBuf> {
     }
 }
 
+/// Resolve the SQL dialect to use for column lineage.
+///
+/// Precedence: CLI flag > manifest adapter_type > error.
+/// Avoids silent fallback to Generic, which produces incorrect results for
+/// warehouse-specific SQL (e.g. BigQuery backtick quoting, Snowflake QUALIFY).
+fn resolve_dialect(
+    cli_dialect: Option<DialectType>,
+    manifest: &parser::manifest::Manifest,
+) -> Result<DialectType> {
+    if let Some(d) = cli_dialect {
+        return Ok(d);
+    }
+    match manifest.metadata.adapter_type.as_deref() {
+        Some(adapter) if !adapter.trim().is_empty() => {
+            adapter.trim().parse::<DialectType>().map_err(|_| {
+                anyhow::anyhow!(
+                    "manifest adapter_type '{}' has no matching SQL dialect; \
+                     use --dialect to specify one explicitly (e.g. --dialect postgres)",
+                    adapter.trim()
+                )
+            })
+        }
+        Some(_) => anyhow::bail!(
+            "manifest adapter_type is empty; \
+             use --dialect to specify the SQL dialect (e.g. --dialect bigquery)"
+        ),
+        None => anyhow::bail!(
+            "manifest does not specify an adapter_type; \
+             use --dialect to specify the SQL dialect (e.g. --dialect bigquery)"
+        ),
+    }
+}
+
 /// Run the `column-lineage` subcommand
 #[cfg(not(tarpaulin_include))]
 #[allow(clippy::too_many_arguments)]
@@ -824,8 +857,6 @@ fn run_column_lineage_command(
     no_cache: bool,
     refresh_cache: bool,
 ) -> Result<()> {
-    let dialect = dialect.unwrap_or(DialectType::Generic);
-
     let project_dir = project_dir
         .canonicalize()
         .unwrap_or_else(|_| project_dir.to_path_buf());
@@ -847,6 +878,8 @@ fn run_column_lineage_command(
     let resolved_manifest_path = resolve_manifest_path_or_default(manifest_path, &project_dir)?;
     let manifest = parser::manifest::load_manifest(&resolved_manifest_path)?;
 
+    let dialect = resolve_dialect(dialect, &manifest)?;
+
     let models = if input::has_path_like_input(&raw_inputs) {
         let dag = parser::manifest::build_graph_from_parsed_manifest(&manifest)?;
         let cwd = std::env::current_dir()
@@ -1038,8 +1071,6 @@ fn run_column_impact_command(
     no_cache: bool,
     refresh_cache: bool,
 ) -> Result<()> {
-    let dialect = dialect.unwrap_or(DialectType::Generic);
-
     if columns.is_empty() {
         anyhow::bail!("no columns specified (use --column)");
     }
@@ -1051,6 +1082,8 @@ fn run_column_impact_command(
     let resolved = resolve_manifest_path_or_default(manifest_path, &project_dir)?;
     let manifest = parser::manifest::load_manifest(&resolved)?;
 
+    let dialect = resolve_dialect(dialect, &manifest)?;
+
     let mut cache = if no_cache {
         graph::column_lineage::ColumnLineageCache::disabled()
     } else if refresh_cache {

{dlin_cli-0.2.1 → dlin_cli-0.2.2}/crates/dlin/src/mcp.rs

@@ -231,7 +231,7 @@ fn tools() -> Vec<Value> {
                     "query": { "type": "string", "description": "Case-insensitive substring filter applied to node name, description, tags, and file path. Returns all nodes when omitted." },
                     "node_types": {
                         "type": "array",
-                        "items": { "type": "string", "enum": ["model", "source", "seed", "snapshot", "test", "exposure"] },
+                        "items": { "type": "string", "enum": ["model", "source", "seed", "snapshot", "test", "exposure", "semantic_model", "metric", "saved_query"] },
                         "description": "Node types to include. Defaults to all types when omitted."
                     }
                 },
@@ -247,7 +247,7 @@ fn tools() -> Vec<Value> {
                     "names": { "type": "array", "items": { "type": "string" }, "minItems": 1, "description": "Node names (e.g. 'orders') or dbt unique IDs (e.g. 'model.my_project.orders', 'source.my_project.raw.orders') to look up." },
                     "node_types": {
                         "type": "array",
-                        "items": { "type": "string", "enum": ["model", "source", "seed", "snapshot", "test", "exposure"] },
+                        "items": { "type": "string", "enum": ["model", "source", "seed", "snapshot", "test", "exposure", "semantic_model", "metric", "saved_query"] },
                         "description": "Restrict results to these node types. Nodes whose type does not match are reported in not_found."
                     }
                 },
@@ -451,6 +451,9 @@ fn node_type_from_str(s: &str) -> Option<NodeType> {
         "snapshot" => Some(NodeType::Snapshot),
         "test" => Some(NodeType::Test),
         "exposure" => Some(NodeType::Exposure),
+        "semantic_model" => Some(NodeType::SemanticModel),
+        "metric" => Some(NodeType::Metric),
+        "saved_query" => Some(NodeType::SavedQuery),
         _ => None,
     }
 }
@@ -770,7 +773,8 @@ fn normalize_manifest_unique_id(name: &str) -> Option<String> {
                 None
             }
         }
-        "model" | "seed" | "snapshot" | "exposure" => {
+        "model" | "seed" | "snapshot" | "exposure" | "semantic_model" | "metric"
+        | "saved_query" => {
             parts.remove(1);
             Some(parts.join("."))
         }
@@ -1268,6 +1272,87 @@ mod tests {
         assert_eq!(normalized, Some("test.my_test_name".to_string()));
     }
 
+    #[test]
+    fn normalize_manifest_unique_id_supports_semantic_layer_types() {
+        assert_eq!(
+            normalize_manifest_unique_id("semantic_model.my_project.orders"),
+            Some("semantic_model.orders".to_string())
+        );
+        assert_eq!(
+            normalize_manifest_unique_id("metric.my_project.revenue"),
+            Some("metric.revenue".to_string())
+        );
+        assert_eq!(
+            normalize_manifest_unique_id("saved_query.my_project.revenue_metrics"),
+            Some("saved_query.revenue_metrics".to_string())
+        );
+    }
+
+    #[test]
+    fn find_nodes_resolves_semantic_layer_full_unique_ids() {
+        let manifest_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("..")
+            .join("..")
+            .join("refs")
+            .join("jaffle-shop")
+            .join("target")
+            .join("manifest.json");
+        if !manifest_path.exists() {
+            eprintln!(
+                "SKIP: jaffle-shop fixture not found at {manifest_path:?}; run `make fixtures` to enable this test"
+            );
+            return;
+        }
+        let state = McpState::load(McpArgs {
+            project_dir: manifest_path
+                .parent()
+                .unwrap()
+                .parent()
+                .unwrap()
+                .to_path_buf(),
+            manifest_path: Some(manifest_path),
+            dialect: DialectType::Generic,
+        })
+        .unwrap();
+
+        let result = find_nodes(
+            &json!({
+                "names": [
+                    "semantic_model.jaffle_shop.supplies",
+                    "metric.jaffle_shop.revenue",
+                    "saved_query.jaffle_shop.revenue_metrics"
+                ]
+            }),
+            &state,
+        )
+        .unwrap();
+
+        assert_eq!(
+            result["not_found"],
+            json!([]),
+            "all full unique IDs should resolve"
+        );
+        assert_eq!(result["count"], 3);
+        let unique_ids: Vec<&str> = result["nodes"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|n| n["unique_id"].as_str().unwrap())
+            .collect();
+        assert!(
+            unique_ids.contains(&"semantic_model.supplies"),
+            "semantic_model node should resolve to correct type"
+        );
+        assert!(
+            unique_ids.contains(&"metric.revenue"),
+            "metric node should resolve to correct type"
+        );
+        assert!(
+            unique_ids.contains(&"saved_query.revenue_metrics"),
+            "saved_query node should resolve to correct type"
+        );
+    }
+
     #[test]
     fn extract_column_not_found_name_parses_column_prefix() {
         assert_eq!(

{dlin_cli-0.2.1 → dlin_cli-0.2.2}/crates/dlin/tests/integration_test.rs

@@ -2401,7 +2401,7 @@ mod manifest_only_mode {
         fs::create_dir_all(tmp.path().join("target")).unwrap();
 
         let manifest_json = r#"{
-  "metadata": {},
+  "metadata": {"adapter_type": "postgres"},
   "nodes": {
     "model.test_project.stg_orders": {
       "unique_id": "model.test_project.stg_orders",
@@ -2471,4 +2471,248 @@ mod manifest_only_mode {
             stdout
         );
     }
+
+    /// Build a manifest JSON string with the given adapter_type value (or none).
+    fn manifest_json_with_adapter(adapter_type: Option<&str>) -> String {
+        let metadata = match adapter_type {
+            Some(a) => format!(r#"{{"adapter_type": "{}"}}"#, a),
+            None => "{}".to_string(),
+        };
+        format!(
+            r#"{{
+  "metadata": {},
+  "nodes": {{
+    "model.test_project.stg_orders": {{
+      "unique_id": "model.test_project.stg_orders",
+      "name": "stg_orders",
+      "original_file_path": "models/stg_orders.sql",
+      "resource_type": "model",
+      "depends_on": {{"nodes": []}},
+      "config": {{"materialized": "view", "tags": []}},
+      "description": "",
+      "compiled_code": "SELECT order_id FROM raw.orders",
+      "columns": {{"order_id": {{"name": "order_id", "description": ""}}}}
+    }}
+  }},
+  "sources": {{}},
+  "exposures": {{}}
+}}"#,
+            metadata
+        )
+    }
+
+    fn write_manifest(dir: &std::path::Path, json: &str) {
+        fs::create_dir_all(dir.join("target")).unwrap();
+        fs::write(dir.join("target/manifest.json"), json).unwrap();
+    }
+
+    #[test]
+    fn test_column_upstream_auto_detects_dialect_from_manifest_adapter_type() {
+        // When --dialect is omitted but manifest has adapter_type, dialect is auto-detected.
+        let tmp = tempfile::tempdir().unwrap();
+        write_manifest(tmp.path(), &manifest_json_with_adapter(Some("postgres")));
+
+        let output = Command::new(binary_path())
+            .args([
+                "column",
+                "upstream",
+                "stg_orders",
+                "--project-dir",
+                tmp.path().to_str().unwrap(),
+                "--no-cache",
+            ])
+            .output()
+            .expect("Failed to run binary");
+
+        assert!(
+            output.status.success(),
+            "should succeed with auto-detected dialect from adapter_type; stderr: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    #[test]
+    fn test_column_upstream_errors_when_no_adapter_type_and_no_dialect_flag() {
+        // When both --dialect and manifest adapter_type are absent, the command must fail
+        // with an actionable error rather than silently using Generic.
+        let tmp = tempfile::tempdir().unwrap();
+        write_manifest(tmp.path(), &manifest_json_with_adapter(None));
+
+        let output = Command::new(binary_path())
+            .args([
+                "column",
+                "upstream",
+                "stg_orders",
+                "--project-dir",
+                tmp.path().to_str().unwrap(),
+                "--no-cache",
+            ])
+            .output()
+            .expect("Failed to run binary");
+
+        assert!(
+            !output.status.success(),
+            "should fail when adapter_type is absent and --dialect is not given"
+        );
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        assert!(
+            stderr.contains("does not specify an adapter_type"),
+            "error message should say 'does not specify an adapter_type': {}",
+            stderr
+        );
+    }
+
+    #[test]
+    fn test_column_upstream_errors_on_unknown_adapter_type() {
+        // An unrecognised adapter_type in the manifest must produce a clear error
+        // telling the user to pass --dialect explicitly.
+        let tmp = tempfile::tempdir().unwrap();
+        write_manifest(
+            tmp.path(),
+            &manifest_json_with_adapter(Some("unknown_warehouse")),
+        );
+
+        let output = Command::new(binary_path())
+            .args([
+                "column",
+                "upstream",
+                "stg_orders",
+                "--project-dir",
+                tmp.path().to_str().unwrap(),
+                "--no-cache",
+            ])
+            .output()
+            .expect("Failed to run binary");
+
+        assert!(
+            !output.status.success(),
+            "should fail when adapter_type is not a known dialect"
+        );
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        assert!(
+            stderr.contains("unknown_warehouse") && stderr.contains("--dialect"),
+            "error should name the unknown adapter and suggest --dialect: {}",
+            stderr
+        );
+    }
+
+    #[test]
+    fn test_column_upstream_dialect_flag_overrides_manifest_adapter_type() {
+        // --dialect takes precedence over whatever adapter_type the manifest declares.
+        let tmp = tempfile::tempdir().unwrap();
+        // adapter_type is deliberately wrong (trino); --dialect postgres should win.
+        write_manifest(tmp.path(), &manifest_json_with_adapter(Some("trino")));
+
+        let output = Command::new(binary_path())
+            .args([
+                "column",
+                "upstream",
+                "stg_orders",
+                "--project-dir",
+                tmp.path().to_str().unwrap(),
+                "--dialect",
+                "postgres",
+                "--no-cache",
+            ])
+            .output()
+            .expect("Failed to run binary");
+
+        assert!(
+            output.status.success(),
+            "--dialect flag should override adapter_type in manifest; stderr: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    #[test]
+    fn test_column_downstream_errors_when_no_adapter_type_and_no_dialect_flag() {
+        // Same error behaviour for the impact (downstream) subcommand.
+        let tmp = tempfile::tempdir().unwrap();
+        write_manifest(tmp.path(), &manifest_json_with_adapter(None));
+
+        let output = Command::new(binary_path())
+            .args([
+                "column",
+                "downstream",
+                "stg_orders",
+                "--column",
+                "order_id",
+                "--project-dir",
+                tmp.path().to_str().unwrap(),
+                "--no-cache",
+            ])
+            .output()
+            .expect("Failed to run binary");
+
+        assert!(
+            !output.status.success(),
+            "column downstream should also fail without adapter_type and --dialect"
+        );
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        assert!(
+            stderr.contains("does not specify an adapter_type"),
+            "error message should say 'does not specify an adapter_type': {}",
+            stderr
+        );
+    }
+
+    #[test]
+    fn test_column_upstream_errors_on_empty_adapter_type() {
+        // An empty string adapter_type must not silently fall back to Generic.
+        let tmp = tempfile::tempdir().unwrap();
+        write_manifest(tmp.path(), &manifest_json_with_adapter(Some("")));
+
+        let output = Command::new(binary_path())
+            .args([
+                "column",
+                "upstream",
+                "stg_orders",
+                "--project-dir",
+                tmp.path().to_str().unwrap(),
+                "--no-cache",
+            ])
+            .output()
+            .expect("Failed to run binary");
+
+        assert!(
+            !output.status.success(),
+            "empty adapter_type should fail rather than silently using Generic"
+        );
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        assert!(
+            stderr.contains("adapter_type is empty"),
+            "error message should say 'adapter_type is empty': {}",
+            stderr
+        );
+    }
+
+    #[test]
+    fn test_column_upstream_errors_on_whitespace_only_adapter_type() {
+        // A whitespace-only adapter_type must not silently fall back to Generic.
+        let tmp = tempfile::tempdir().unwrap();
+        write_manifest(tmp.path(), &manifest_json_with_adapter(Some("   ")));
+
+        let output = Command::new(binary_path())
+            .args([
+                "column",
+                "upstream",
+                "stg_orders",
+                "--project-dir",
+                tmp.path().to_str().unwrap(),
+                "--no-cache",
+            ])
+            .output()
+            .expect("Failed to run binary");
+
+        assert!(
+            !output.status.success(),
+            "whitespace-only adapter_type should fail rather than silently using Generic"
+        );
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        assert!(
+            stderr.contains("adapter_type is empty"),
+            "error message should say 'adapter_type is empty': {}",
+            stderr
+        );
+    }
 }