mainsequence-metatable 0.1.2.dev3__tar.gz → 0.1.2.dev4__tar.gz

{mainsequence_metatable-0.1.2.dev3/mainsequence_metatable.egg-info → mainsequence_metatable-0.1.2.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.2.dev3
+Version: 0.1.2.dev4
 Summary: Main Sequence MetaTables Python client and standalone API
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence_metatable-0.1.2.dev3 → mainsequence_metatable-0.1.2.dev4}/api/backend/operations/import_relations.py

@@ -335,9 +335,7 @@ def replace_projection(session, row, value):
         session,
         table=row,
         contract=value,
-        foreign_key_targets=resolved_foreign_key_targets(
-            session, data_source_uid=row.data_source_uid, contract=value
-        ),
+        foreign_key_targets=None,
     )
 
 

{mainsequence_metatable-0.1.2.dev3 → mainsequence_metatable-0.1.2.dev4}/api/backend/persistence/projections.py

@@ -99,7 +99,7 @@ def resolved_foreign_key_targets(
 
 
 def materialize_contract_projection(
-    session: Session, *, table: MetaTable, contract: dict, foreign_key_targets: list[UUID]
+    session: Session, *, table: MetaTable, contract: dict, foreign_key_targets: list[UUID] | None
 ) -> None:
     """Insert projections with the table in its caller-owned transaction."""
     for column in contract["columns"]:
@@ -131,6 +131,13 @@ def materialize_contract_projection(
                 contract_fragment=index,
             )
         )
+    # A replacement must expose its new keys inside this transaction before
+    # validating references to itself, including newly reflected composite keys.
+    session.flush()
+    if foreign_key_targets is None:
+        foreign_key_targets = resolved_foreign_key_targets(
+            session, data_source_uid=table.data_source_uid, contract=contract
+        )
     for foreign_key, target_uid in zip(contract["foreign_keys"], foreign_key_targets, strict=True):
         session.add(
             MetaTableForeignKey(

{mainsequence_metatable-0.1.2.dev3 → mainsequence_metatable-0.1.2.dev4/mainsequence_metatable.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.2.dev3
+Version: 0.1.2.dev4
 Summary: Main Sequence MetaTables Python client and standalone API
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence_metatable-0.1.2.dev3 → mainsequence_metatable-0.1.2.dev4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence-metatable"
-version = "0.1.2.dev3"
+version = "0.1.2.dev4"
 description = "Main Sequence MetaTables Python client and standalone API"
 readme = "README.md"
 requires-python = ">=3.13"

{mainsequence_metatable-0.1.2.dev3 → mainsequence_metatable-0.1.2.dev4}/tests/catalog/test_contract_projection.py

@@ -8,7 +8,7 @@ import pytest
 from sqlalchemy import create_engine, event, select
 from sqlalchemy.orm import Session
 
-from api.backend.contracts.table_contracts import ContractValidationError
+from api.backend.contracts.table_contracts import ContractValidationError, normalize_table_contract
 from api.backend.domain.catalog_rules import TableRegistration
 from api.backend.persistence.catalog import CatalogRepository
 from api.backend.persistence.models import (
@@ -106,6 +106,48 @@ def test_registration_persists_normalized_contract_and_projections(session):
     assert foreign_key.on_delete == "set null"
 
 
+@pytest.mark.parametrize("unique", [True, False])
+def test_refresh_self_reference_uses_new_composite_key_projection(session, unique):
+    from api.backend.operations.import_relations import replace_projection
+
+    row = CatalogRepository(session).register_table(_registration(
+        data_source_uid=uuid4(), name="hierarchy", contract=_contract("hierarchy"),
+    ))
+    session.commit()
+    value = normalize_table_contract({
+        "physical": {"table_name": "hierarchy"},
+        "columns": [{"name": name, "data_type": "int"} for name in (
+            "code", "version", "parent_code", "parent_version",
+        )],
+        "indexes": [{"name": "hierarchy_key", "columns": ["code", "version"], "unique": unique}],
+        "foreign_keys": [{
+            "source_columns": ["parent_code", "parent_version"],
+            "target_meta_table_uid": str(row.uid), "target_columns": ["code", "version"],
+        }],
+    }, management_mode="external_registered")
+    row.table_contract = value
+    if not unique:
+        with pytest.raises(ContractValidationError) as failure:
+            replace_projection(session, row, value)
+        assert failure.value.code == "foreign_key_target_columns_not_unique"
+        session.rollback()
+        assert {c.name for c in session.scalars(select(MetaTableColumn).where(
+            MetaTableColumn.meta_table_uid == row.uid,
+        ))} == {"uid", "target_uid"}
+        assert [c["name"] for c in row.table_contract["columns"]] == ["uid", "target_uid"]
+        return
+    replace_projection(session, row, value)
+    session.commit()
+    edge = session.scalar(select(MetaTableForeignKey).where(
+        MetaTableForeignKey.source_table_uid == row.uid,
+    ))
+    assert edge.target_table_uid == row.uid
+    assert edge.target_columns == ["code", "version"]
+    assert {c.name for c in session.scalars(select(MetaTableColumn).where(
+        MetaTableColumn.meta_table_uid == row.uid,
+    ))} == {"code", "version", "parent_code", "parent_version"}
+
+
 @pytest.mark.parametrize(
     ("target_mode", "expected_code"),
     [

{mainsequence_metatable-0.1.2.dev3 → mainsequence_metatable-0.1.2.dev4}/tests/database_backend/test_relation_import.py

@@ -25,11 +25,17 @@ from api.backend.persistence.database import (
     create_catalog_engine,
     upgrade_catalog,
 )
-from api.backend.persistence.models import DataSource, MetaTable, MetaTableGrant, SQLSecurityState
+from api.backend.persistence.models import (
+    DataSource,
+    MetaTable,
+    MetaTableForeignKey,
+    MetaTableGrant,
+    SQLSecurityState,
+)
 
 
 @pytest.fixture
-def relations(engine, source):
+def relations(request, engine, source):
     schema = None if source.class_type == "sqlite" else source.connection.default_schema
     metadata = sa.MetaData()
     customers = sa.Table(
@@ -47,6 +53,18 @@ def relations(engine, source):
         sa.Column("amount", sa.Numeric(12, 2)),
         schema=schema,
     )
+    hierarchy = None
+    if getattr(request, "param", None) == "self_referencing":
+        hierarchy = sa.Table(
+            "hierarchy", metadata,
+            sa.Column("id", sa.Integer, primary_key=True),
+            sa.Column("code", sa.String(20), unique=True),
+            sa.Column("parent_code", sa.String(20)),
+            schema=schema,
+        )
+        hierarchy.append_constraint(sa.ForeignKeyConstraint(
+            [hierarchy.c.parent_code], [hierarchy.c.code], name="hierarchy_parent_fk",
+        ))
     with engine.begin() as conn:
         metadata.create_all(conn)
         conn.execute(customers.insert(), [dict(id=1, name="Alice"), dict(id=2, name="Bob")])
@@ -54,6 +72,8 @@ def relations(engine, source):
             orders.insert(),
             [dict(id=1, customer_id=1, amount=12.5), dict(id=2, customer_id=2, amount=20)],
         )
+        if hierarchy is not None:
+            conn.execute(hierarchy.insert(), dict(id=1, code="root"))
         preparer = conn.dialect.identifier_preparer
         qualified = preparer.format_table(customers)
         view = (preparer.quote(schema) + "." if schema else "") + "customer_view"
@@ -190,6 +210,39 @@ def external_api(engine, source, relations, external_credentials, tmp_path):
         catalog_engine.dispose()
 
 
+@pytest.mark.parametrize("relations", ["self_referencing"], indirect=True)
+def test_self_referencing_import_reimport_and_writer_refresh(external_api, engine, source, relations):
+    api = external_api
+    hierarchy = next(table for table in relations.tables.values() if table.name == "hierarchy")
+    body = dict(data_source_uid=str(source.uid), relation_names=["hierarchy"],
+                follow_foreign_keys=False)
+    preview = api.http.post("/meta-tables/import-from-data-source/", json=body)
+    assert preview.status_code == 200 and preview.json()["counts"]["would_create"] == 1
+    imported = api.http.post("/meta-tables/import-from-data-source/", json={**body, "dry_run": False})
+    assert imported.status_code == 200, imported.text
+    assert imported.json()["committed"] and imported.json()["counts"]["created"] == 1
+    uid = imported.json()["relations"][0]["meta_table_uid"]
+    repeated = api.http.post("/meta-tables/import-from-data-source/", json={**body, "dry_run": False})
+    assert repeated.status_code == 200, repeated.text
+    assert repeated.json()["counts"]["unchanged"] == 1
+    assert repeated.json()["relations"][0]["meta_table_uid"] == uid
+    with engine.begin() as connection:
+        name = connection.dialect.identifier_preparer.format_table(hierarchy)
+        connection.exec_driver_sql(f"ALTER TABLE {name} ADD note VARCHAR(20)")
+    refreshed = api.http.post(f"/meta-tables/{uid}/introspect/")
+    assert refreshed.status_code == 200, refreshed.text
+    assert "note" in api.http.post(f"/meta-tables/{uid}/read/", json={}).json()["columns"]
+    with api.factory() as session:
+        edges = list(session.scalars(sa.select(MetaTableForeignKey).where(
+            MetaTableForeignKey.source_table_uid == UUID(uid),
+        )))
+        assert len(edges) == 1
+        assert edges[0].target_table_uid == UUID(uid)
+        assert edges[0].source_columns == ["parent_code"]
+        assert edges[0].target_columns == ["code"]
+        assert not session.get(SQLSecurityState, 1).ready
+
+
 def test_discovery_lists_tables_and_views_before_import(external_api, source, monkeypatch):
     from api.backend.backends.relation_tables import RelationTables