trellis-datamodel 0.3.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

trellis_datamodel/static/_app/version.json

@@ -1 +1 @@
-{"version":"1766080526003"}
+{"version":"1767080961734"}

trellis_datamodel/static/index.html

@@ -7,11 +7,11 @@
 		<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
 		<link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500&family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
 		
-		<link rel="modulepreload" href="/_app/immutable/entry/start.B7CjH6Z7.js">
-		<link rel="modulepreload" href="/_app/immutable/chunks/CXDUumOQ.js">
+		<link rel="modulepreload" href="/_app/immutable/entry/start.Cq8bDFFs.js">
+		<link rel="modulepreload" href="/_app/immutable/chunks/COKQndWa.js">
 		<link rel="modulepreload" href="/_app/immutable/chunks/zXDdy2c_.js">
 		<link rel="modulepreload" href="/_app/immutable/chunks/8ZaN1sxc.js">
-		<link rel="modulepreload" href="/_app/immutable/entry/app.abCkWeAJ.js">
+		<link rel="modulepreload" href="/_app/immutable/entry/app.BA1wC-Z2.js">
 		<link rel="modulepreload" href="/_app/immutable/chunks/QRltG_J6.js">
 		<link rel="modulepreload" href="/_app/immutable/chunks/DDNfEvut.js">
 		<link rel="modulepreload" href="/_app/immutable/chunks/BfBfOTnK.js">
@@ -21,15 +21,15 @@
 		<div style="display: contents">
 			<script>
 				{
-					__sveltekit_nmm995 = {
+					__sveltekit_vj8yr8 = {
 						base: ""
 					};
 
 					const element = document.currentScript.parentElement;
 
 					Promise.all([
-						import("/_app/immutable/entry/start.B7CjH6Z7.js"),
-						import("/_app/immutable/entry/app.abCkWeAJ.js")
+						import("/_app/immutable/entry/start.Cq8bDFFs.js"),
+						import("/_app/immutable/entry/app.BA1wC-Z2.js")
 					]).then(([kit, app]) => {
 						kit.start(app, element);
 					});

trellis_datamodel/tests/test_dbt_schema.py

@@ -244,6 +244,260 @@ class TestSyncDbtTests:
             }
         ]
 
+    def test_syncs_many_to_one_relationship(self, test_client, temp_dir, temp_data_model_path):
+        """
+        Ensure many_to_one relationships write FK test to source entity (the "many" side).
+        """
+        data_model = {
+            "version": 0.1,
+            "entities": [
+                {
+                    "id": "customer_entity",
+                    "label": "Customers",
+                    "dbt_model": "model.project.customers",
+                    "position": {"x": 0, "y": 0},
+                },
+                {
+                    "id": "order_entity",
+                    "label": "Orders",
+                    "dbt_model": "model.project.orders",
+                    "drafted_fields": [{"name": "customer_id", "datatype": "int"}],
+                    "position": {"x": 100, "y": 0},
+                },
+            ],
+            "relationships": [
+                {
+                    "source": "order_entity",  # Source is "many" side, so FK should be here
+                    "target": "customer_entity",  # Target is "one" side (PK)
+                    "type": "many_to_one",
+                    "source_field": "customer_id",  # FK field
+                    "target_field": "id",  # PK field
+                }
+            ],
+        }
+
+        # Persist data model
+        with open(temp_data_model_path, "w") as f:
+            yaml.dump(data_model, f)
+
+        response = test_client.post("/api/sync-dbt-tests")
+        assert response.status_code == 200
+
+        # orders.yml should contain a relationship test (FK is on source/orders)
+        orders_yml = os.path.join(temp_dir, "models", "3_core", "orders.yml")
+        assert os.path.exists(orders_yml)
+        with open(orders_yml, "r") as f:
+            schema = yaml.safe_load(f)
+
+        rel_tests = schema["models"][0]["columns"][0]["data_tests"]
+        assert rel_tests == [
+            {
+                "relationships": {
+                    "arguments": {"to": "ref('customers')", "field": "id"},
+                }
+            }
+        ]
+
+        # customers.yml should NOT have a relationship test (PK is on target/customers)
+        customers_yml = os.path.join(temp_dir, "models", "3_core", "customers.yml")
+        if os.path.exists(customers_yml):
+            with open(customers_yml, "r") as f:
+                customer_schema = yaml.safe_load(f)
+            # If customers.yml exists, it shouldn't have relationship tests for this relationship
+            if "models" in customer_schema and len(customer_schema["models"]) > 0:
+                if "columns" in customer_schema["models"][0]:
+                    for col in customer_schema["models"][0]["columns"]:
+                        if col.get("name") == "id":
+                            # PK field shouldn't have relationship test pointing back
+                            tests = col.get("data_tests", [])
+                            for test in tests:
+                                if "relationships" in test:
+                                    rel = test["relationships"]
+                                    ref = rel.get("arguments", {}).get("to", "") or rel.get("to", "")
+                                    assert "ref('orders')" not in ref
+
+    def test_removes_stale_relationship_tests_when_type_changes(
+        self, test_client, temp_dir, temp_data_model_path
+    ):
+        """
+        When relationship type changes (e.g., one_to_many -> many_to_one),
+        stale relationship tests should be removed from old FK location and
+        added to new FK location.
+        """
+        # Start with one_to_many relationship (FK on target/orders)
+        data_model = {
+            "version": 0.1,
+            "entities": [
+                {
+                    "id": "customers",
+                    "label": "Customers",
+                    "dbt_model": "model.project.customers",
+                    "position": {"x": 0, "y": 0},
+                },
+                {
+                    "id": "orders",
+                    "label": "Orders",
+                    "dbt_model": "model.project.orders",
+                    "drafted_fields": [{"name": "customer_id", "datatype": "int"}],
+                    "position": {"x": 100, "y": 0},
+                },
+            ],
+            "relationships": [
+                {
+                    "source": "customers",
+                    "target": "orders",
+                    "type": "one_to_many",  # FK on target (orders)
+                    "source_field": "id",
+                    "target_field": "customer_id",
+                }
+            ],
+        }
+        with open(temp_data_model_path, "w") as f:
+            yaml.dump(data_model, f)
+
+        # First sync: FK should be on orders
+        response = test_client.post("/api/sync-dbt-tests")
+        assert response.status_code == 200
+
+        orders_yml = os.path.join(temp_dir, "models", "3_core", "orders.yml")
+        assert os.path.exists(orders_yml)
+        with open(orders_yml, "r") as f:
+            schema = yaml.safe_load(f)
+        
+        # Verify FK test is on orders.customer_id
+        rel_tests = schema["models"][0]["columns"][0]["data_tests"]
+        assert len(rel_tests) == 1
+        assert "relationships" in rel_tests[0]
+        assert rel_tests[0]["relationships"]["arguments"]["to"] == "ref('customers')"
+
+        # Now change relationship type to many_to_one (FK should move to source/customers)
+        data_model["relationships"][0]["type"] = "many_to_one"
+        # Swap fields: FK now on source (customers), PK on target (orders)
+        data_model["relationships"][0]["source_field"] = "customer_id"
+        data_model["relationships"][0]["target_field"] = "id"
+        # Swap source/target to reflect new direction
+        data_model["relationships"][0]["source"] = "orders"
+        data_model["relationships"][0]["target"] = "customers"
+
+        with open(temp_data_model_path, "w") as f:
+            yaml.dump(data_model, f)
+
+        # Second sync: FK should move to orders, old FK on customers should be removed
+        response = test_client.post("/api/sync-dbt-tests")
+        assert response.status_code == 200
+
+        # Verify orders.yml still has the test (FK is still on orders, just different semantics)
+        with open(orders_yml, "r") as f:
+            schema = yaml.safe_load(f)
+        
+        rel_tests = schema["models"][0]["columns"][0]["data_tests"]
+        assert len(rel_tests) == 1
+        assert "relationships" in rel_tests[0]
+        assert rel_tests[0]["relationships"]["arguments"]["to"] == "ref('customers')"
+
+        # Verify customers.yml does NOT have a relationship test
+        # (even if it exists, it shouldn't have a test pointing back to orders)
+        customers_yml = os.path.join(temp_dir, "models", "3_core", "customers.yml")
+        if os.path.exists(customers_yml):
+            with open(customers_yml, "r") as f:
+                customer_schema = yaml.safe_load(f)
+            if "models" in customer_schema and len(customer_schema["models"]) > 0:
+                if "columns" in customer_schema["models"][0]:
+                    for col in customer_schema["models"][0]["columns"]:
+                        if col.get("name") == "id":
+                            tests = col.get("data_tests", [])
+                            for test in tests:
+                                if "relationships" in test:
+                                    rel = test["relationships"]
+                                    ref = rel.get("arguments", {}).get("to", "") or rel.get("to", "")
+                                    assert "ref('orders')" not in ref
+
+    def test_removes_stale_tests_when_swapping_one_to_many_to_many_to_one(
+        self, test_client, temp_dir, temp_data_model_path
+    ):
+        """
+        Test the specific bug scenario: swapping one_to_many to many_to_one
+        should move FK from target to source and remove stale test from target.
+        """
+        # Create initial state: one_to_many with FK on target
+        data_model = {
+            "version": 0.1,
+            "entities": [
+                {
+                    "id": "department",
+                    "label": "Department",
+                    "dbt_model": "model.project.department",
+                    "drafted_fields": [{"name": "department_id", "datatype": "text"}],
+                },
+                {
+                    "id": "cool_stuff",
+                    "label": "Cool Stuff",
+                    "dbt_model": "model.project.cool_stuff",
+                    "drafted_fields": [{"name": "department_id", "datatype": "text"}],
+                },
+            ],
+            "relationships": [
+                {
+                    "source": "department",
+                    "target": "cool_stuff",
+                    "type": "one_to_many",  # FK on target (cool_stuff)
+                    "source_field": "department_id",
+                    "target_field": "department_id",
+                }
+            ],
+        }
+        with open(temp_data_model_path, "w") as f:
+            yaml.dump(data_model, f)
+
+        # Initial sync: FK should be on cool_stuff
+        response = test_client.post("/api/sync-dbt-tests")
+        assert response.status_code == 200
+
+        cool_stuff_yml = os.path.join(temp_dir, "models", "3_core", "cool_stuff.yml")
+        assert os.path.exists(cool_stuff_yml)
+        with open(cool_stuff_yml, "r") as f:
+            schema = yaml.safe_load(f)
+        
+        # Verify FK test exists on cool_stuff.department_id
+        rel_tests = schema["models"][0]["columns"][0]["data_tests"]
+        assert len(rel_tests) == 1
+        assert "relationships" in rel_tests[0]
+
+        # Now swap to many_to_one (FK should move to department)
+        data_model["relationships"][0]["type"] = "many_to_one"
+        # Note: source/target stay the same, only type changes (as per fixed swap logic)
+        with open(temp_data_model_path, "w") as f:
+            yaml.dump(data_model, f)
+
+        # Second sync: FK should move to department, stale test removed from cool_stuff
+        response = test_client.post("/api/sync-dbt-tests")
+        assert response.status_code == 200
+
+        # Verify cool_stuff.yml no longer has the relationship test
+        with open(cool_stuff_yml, "r") as f:
+            schema = yaml.safe_load(f)
+        
+        # cool_stuff.department_id should NOT have relationship test anymore
+        if "columns" in schema["models"][0]:
+            for col in schema["models"][0]["columns"]:
+                if col.get("name") == "department_id":
+                    tests = col.get("data_tests", [])
+                    # Should have no relationship tests (or no tests at all)
+                    for test in tests:
+                        assert "relationships" not in test
+
+        # Verify department.yml now has the relationship test
+        department_yml = os.path.join(temp_dir, "models", "3_core", "department.yml")
+        assert os.path.exists(department_yml)
+        with open(department_yml, "r") as f:
+            dept_schema = yaml.safe_load(f)
+        
+        # department.department_id should have relationship test pointing to cool_stuff
+        rel_tests = dept_schema["models"][0]["columns"][0]["data_tests"]
+        assert len(rel_tests) == 1
+        assert "relationships" in rel_tests[0]
+        assert rel_tests[0]["relationships"]["arguments"]["to"] == "ref('cool_stuff')"
+
 
 class TestGetModelSchema:
     """Tests for GET /api/models/{model_name}/schema endpoint."""
@@ -653,7 +907,11 @@ class TestInferRelationships:
                     "label": "Customers",
                     "additional_models": ["model.project.customers_alt"],
                 },
-                {"id": "orders", "label": "Orders", "dbt_model": "model.project.orders"},
+                {
+                    "id": "orders",
+                    "label": "Orders",
+                    "dbt_model": "model.project.orders",
+                },
             ],
         }
         with open(temp_data_model_path, "w") as f:
@@ -847,9 +1105,7 @@ class TestModelSchemaVersionHandling:
         self._write_versioned_manifest(temp_dir)
         self._write_versioned_schema(temp_dir)
 
-        response = test_client.get(
-            "/api/models/player/schema", params={"version": 2}
-        )
+        response = test_client.get("/api/models/player/schema", params={"version": 2})
         assert response.status_code == 200
 
         schema = response.json()

trellis_datamodel/tests/test_yaml_handler.py

@@ -226,3 +226,231 @@ class TestYamlHandlerRelationshipTests:
         assert len(col["data_tests"]) == 2
         rel_test = next(t for t in col["data_tests"] if "relationships" in t)
         assert rel_test["relationships"]["arguments"]["to"] == "ref('new_model')"
+
+
+class TestYamlIndentation:
+    """Test YAML indentation formatting (regression test for issue #19)."""
+
+    def test_models_list_indentation(self, temp_dir):
+        """Test that models list items are properly indented under the models key."""
+        handler = YamlHandler()
+        file_path = os.path.join(temp_dir, "test_indentation.yml")
+
+        # Create data with a plain Python list (simulates real usage in dbt_core.py)
+        data = {"version": 2, "models": [{"name": "test_model", "description": "Test"}]}
+        handler.save_file(file_path, data)
+
+        # Read the raw file text
+        with open(file_path, "r") as f:
+            content = f.read()
+
+        # Assert proper indentation: models list items should be indented 2 spaces
+        # Expected format:
+        # models:
+        #   - name: test_model
+        assert (
+            "models:\n  - name:" in content
+        ), f"Expected proper indentation, got:\n{content}"
+
+    def test_ensure_model_normalizes_plain_list(self, temp_dir):
+        """Test that ensure_model normalizes plain Python lists to CommentedSeq."""
+        handler = YamlHandler()
+        file_path = os.path.join(temp_dir, "test_normalize.yml")
+
+        # Start with a plain Python list
+        data = {"version": 2, "models": []}
+
+        # Call ensure_model which should normalize the list
+        handler.ensure_model(data, "new_model")
+
+        # Verify it's now a CommentedSeq
+        assert isinstance(data["models"], CommentedSeq)
+
+        # Save and verify indentation
+        handler.save_file(file_path, data)
+
+        with open(file_path, "r") as f:
+            content = f.read()
+
+        assert (
+            "models:\n  - name:" in content
+        ), f"Expected proper indentation after normalization, got:\n{content}"
+
+
+class TestTagHandling:
+    """Test tag handling improvements (issue #20)."""
+
+    def test_update_model_tags_skips_empty_tags(self):
+        """Test that empty tags arrays are not written to YAML (Point 1)."""
+        handler = YamlHandler()
+        model = CommentedMap({"name": "test"})
+
+        # Update with empty tags - should not create tags key
+        handler.update_model_tags(model, [])
+
+        assert "tags" not in model
+        assert "config" not in model
+
+    def test_update_model_tags_removes_existing_empty_tags(self):
+        """Test that existing tags are removed when updated to empty (Point 1)."""
+        handler = YamlHandler()
+        model = CommentedMap({"name": "test", "tags": ["old_tag"]})
+
+        # Update with empty tags - should remove existing tags
+        handler.update_model_tags(model, [])
+
+        assert "tags" not in model
+
+    def test_update_model_tags_removes_config_tags_when_empty(self):
+        """Test that config.tags are removed when updated to empty (Point 1)."""
+        handler = YamlHandler()
+        model = CommentedMap(
+            {
+                "name": "test",
+                "config": CommentedMap({"tags": ["old_tag"], "materialized": "table"}),
+            }
+        )
+
+        # Update with empty tags - should remove config.tags but keep config
+        handler.update_model_tags(model, [])
+
+        assert "tags" not in model["config"]
+        assert model["config"]["materialized"] == "table"
+
+    def test_update_version_tags_skips_empty_tags(self):
+        """Test that empty tags arrays are not written for versions (Point 1)."""
+        handler = YamlHandler()
+        version = CommentedMap({"v": 2})
+
+        # Update with empty tags - should not create config
+        handler.update_version_tags(version, [])
+
+        assert "config" not in version
+
+    def test_update_version_tags_removes_existing_empty_tags(self):
+        """Test that existing version tags are removed when updated to empty (Point 1)."""
+        handler = YamlHandler()
+        version = CommentedMap({"v": 2, "config": CommentedMap({"tags": ["old_tag"]})})
+
+        # Update with empty tags - should remove config.tags
+        handler.update_version_tags(version, [])
+
+        assert "tags" not in version["config"]
+
+    def test_config_placement_after_description(self, temp_dir):
+        """Test that config block is placed after description (Point 2)."""
+        handler = YamlHandler()
+        file_path = os.path.join(temp_dir, "test_config_placement.yml")
+
+        # Create model with name and description, then add tags
+        model = CommentedMap()
+        model["name"] = "test_model"
+        model["description"] = "A test model"
+
+        handler.update_model_tags(model, ["core"])
+
+        # Save and check order
+        data = {"version": 2, "models": [model]}
+        handler.save_file(file_path, data)
+
+        with open(file_path, "r") as f:
+            content = f.read()
+
+        # Config should appear after description
+        desc_pos = content.find("description:")
+        config_pos = content.find("config:")
+
+        assert desc_pos > 0, "Description should be present"
+        assert config_pos > 0, "Config should be present"
+        assert config_pos > desc_pos, "Config should appear after description"
+
+    def test_config_placement_before_columns(self, temp_dir):
+        """Test that config block is placed before columns (Point 2)."""
+        handler = YamlHandler()
+        file_path = os.path.join(temp_dir, "test_config_before_columns.yml")
+
+        # Create model with name, description, and columns
+        model = CommentedMap()
+        model["name"] = "test_model"
+        model["description"] = "A test model"
+        model["columns"] = CommentedSeq([CommentedMap({"name": "id"})])
+
+        # Add tags - should insert config before columns
+        handler.update_model_tags(model, ["core"])
+
+        # Save and check order
+        data = {"version": 2, "models": [model]}
+        handler.save_file(file_path, data)
+
+        with open(file_path, "r") as f:
+            content = f.read()
+
+        # Config should appear before columns
+        config_pos = content.find("config:")
+        columns_pos = content.find("columns:")
+
+        assert config_pos > 0, "Config should be present"
+        assert columns_pos > 0, "Columns should be present"
+        assert config_pos < columns_pos, "Config should appear before columns"
+
+    def test_config_placement_after_name_when_no_description(self, temp_dir):
+        """Test that config is placed after name when description is missing (Point 2)."""
+        handler = YamlHandler()
+        file_path = os.path.join(temp_dir, "test_config_after_name.yml")
+
+        # Create model with only name
+        model = CommentedMap()
+        model["name"] = "test_model"
+
+        handler.update_model_tags(model, ["core"])
+
+        # Save and check order
+        data = {"version": 2, "models": [model]}
+        handler.save_file(file_path, data)
+
+        with open(file_path, "r") as f:
+            content = f.read()
+
+        # Config should appear after name
+        name_pos = content.find("name:")
+        config_pos = content.find("config:")
+
+        assert name_pos > 0, "Name should be present"
+        assert config_pos > 0, "Config should be present"
+        assert config_pos > name_pos, "Config should appear after name"
+
+    def test_version_config_placement(self, temp_dir):
+        """Test that config block in versions is placed correctly (Point 2)."""
+        handler = YamlHandler()
+        file_path = os.path.join(temp_dir, "test_version_config.yml")
+
+        # Create version with description
+        version = CommentedMap()
+        version["v"] = 2
+        version["description"] = "Version 2"
+
+        handler.update_version_tags(version, ["core"])
+
+        # Save and check order
+        model = CommentedMap()
+        model["name"] = "test_model"
+        model["versions"] = CommentedSeq([version])
+        data = {"version": 2, "models": [model]}
+        handler.save_file(file_path, data)
+
+        with open(file_path, "r") as f:
+            content = f.read()
+
+        # In the version block, config should appear after description
+        lines = content.split("\n")
+        v_line = next(i for i, line in enumerate(lines) if "v:" in line)
+        desc_line = next(
+            i for i, line in enumerate(lines) if i > v_line and "description:" in line
+        )
+        config_line = next(
+            i for i, line in enumerate(lines) if i > v_line and "config:" in line
+        )
+
+        assert (
+            config_line > desc_line
+        ), "Config should appear after description in version block"