mainsequence 6.0.51__tar.gz → 6.0.52__tar.gz

{mainsequence-6.0.51 → mainsequence-6.0.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 6.0.51
+Version: 6.0.52
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: LicenseRef-MainSequence-Proprietary

{mainsequence-6.0.51 → mainsequence-6.0.52}/agent_scaffold/skills/data_publishing/meta_table_migrations/SKILL.md

@@ -108,6 +108,13 @@ platform-managed, Alembic-managed reservations and are validated before HTTP.
 - Do not create SDK reset/reconcile commands for stale reserved state. If stale
   reserved state exists, fail clearly and require an explicit backend/admin
   repair path.
+- Ordinary `MetaTable.delete()` must not bypass Alembic schema-management
+  protection. For a deliberate organization-admin teardown/reset only, use
+  `MetaTable.delete_with_cascade(confirm_cascade_delete=True, ...)` and set
+  `override_schema_management_protection=True` when deleting Alembic-managed
+  tables. Decide explicitly whether referencing MetaTables and time-indexed Data
+  Nodes are also deleted. This permanently deletes catalog rows and physical
+  tables; never use it as migration reconciliation or an Alembic downgrade.
 - Do not write direct backend migration request bodies in examples. Use the CLI
   and SDK provider APIs.
 - Do not call platform-managed model `.register()` in normal application code.

{mainsequence-6.0.51 → mainsequence-6.0.52}/mainsequence/client/metatables/core.py

@@ -1030,6 +1030,67 @@ class ManagedMetaTableFinalizeResponse(BasePydanticModel):
     model_config = ConfigDict(extra="allow")
 
 
+class MetaTableCascadeDeleteRequest(BasePydanticModel):
+    confirm_cascade_delete: Literal[True] = Field(
+        ...,
+        description="Explicit confirmation required for destructive cascade deletion.",
+    )
+    delete_referencing_meta_tables: bool = Field(
+        default=True,
+        description="Delete MetaTables that reference the selected MetaTable.",
+    )
+    delete_referencing_dynamic_tables: bool = Field(
+        default=True,
+        description="Delete time-indexed Data Nodes that reference the selected MetaTable.",
+    )
+    override_schema_management_protection: bool = Field(
+        default=False,
+        description=(
+            "Explicitly allow deletion of Alembic-managed MetaTables. The backend "
+            "still requires organization-admin permission."
+        ),
+    )
+
+    @field_validator("confirm_cascade_delete", mode="before")
+    @classmethod
+    def _require_explicit_confirmation(cls, value: Any) -> Any:
+        if value is not True:
+            raise ValueError("confirm_cascade_delete must be explicitly set to true.")
+        return value
+
+
+class MetaTableCascadeDeletedMetaTable(BasePydanticModel):
+    meta_table_uid: str
+    physical_schema: str | None = None
+    physical_table_name: str | None = None
+    management_mode: MetaTableManagementMode
+    physical_table_drop_scheduled: bool
+    physical_table_drop_cascade: bool
+    schema_management_protection_overridden: bool
+
+
+class MetaTableCascadeDeletedDynamicTable(BasePydanticModel):
+    type: Literal["meta_table"]
+    table_kind: Literal["time_indexed"]
+    time_indexed: Literal[True]
+    uid: str
+    identifier: str | None = None
+    namespace: str | None = None
+    physical_schema: str | None = None
+    physical_table_name: str | None = None
+
+
+class MetaTableCascadeDeleteResponse(BasePydanticModel):
+    ok: Literal[True]
+    action: Literal["delete_with_cascade"]
+    root_meta_table_uid: str
+    deleted_meta_tables: list[MetaTableCascadeDeletedMetaTable]
+    deleted_dynamic_tables: list[MetaTableCascadeDeletedDynamicTable]
+    deleted_meta_table_count: int = Field(..., ge=0)
+    deleted_dynamic_table_count: int = Field(..., ge=0)
+    blocking_edges: list[dict[str, Any]]
+
+
 class DataSource(BasePydanticModel, BaseObjectOrm):
     model_config = ConfigDict(extra="allow")
 
@@ -1558,6 +1619,60 @@ class MetaTable(
             override_protection=override_protection,
         )
 
+    @classmethod
+    def delete_with_cascade_by_uid(
+        cls,
+        uid: str,
+        *,
+        confirm_cascade_delete: bool | None = None,
+        delete_referencing_meta_tables: bool = True,
+        delete_referencing_dynamic_tables: bool = True,
+        override_schema_management_protection: bool = False,
+        timeout: int | float | tuple[float, float] | None = None,
+    ) -> MetaTableCascadeDeleteResponse:
+        if uid in (None, ""):
+            raise ValueError(f"{cls.__name__} uid is required for cascade deletion.")
+        request = MetaTableCascadeDeleteRequest(
+            confirm_cascade_delete=confirm_cascade_delete,
+            delete_referencing_meta_tables=delete_referencing_meta_tables,
+            delete_referencing_dynamic_tables=delete_referencing_dynamic_tables,
+            override_schema_management_protection=override_schema_management_protection,
+        )
+        operation = f"{cls.__name__}.delete_with_cascade"
+        request_payload: dict[str, Any] = {"json": _payload_json(request)}
+        query_context = cls._sdk_owned_query_context(operation)
+        if query_context:
+            request_payload["params"] = query_context
+        response = make_request(
+            s=cls.build_session(),
+            loaders=cls.LOADERS,
+            r_type="POST",
+            url=(f"{cls.get_object_url().rstrip('/')}/{uid}/delete-with-cascade/"),
+            payload=request_payload,
+            time_out=timeout,
+        )
+        if response.status_code != 200:
+            raise_for_response(response, payload=request_payload)
+        return MetaTableCascadeDeleteResponse.model_validate(response.json())
+
+    def delete_with_cascade(
+        self,
+        *,
+        confirm_cascade_delete: bool | None = None,
+        delete_referencing_meta_tables: bool = True,
+        delete_referencing_dynamic_tables: bool = True,
+        override_schema_management_protection: bool = False,
+        timeout: int | float | tuple[float, float] | None = None,
+    ) -> MetaTableCascadeDeleteResponse:
+        return type(self).delete_with_cascade_by_uid(
+            self._public_uid(),
+            confirm_cascade_delete=confirm_cascade_delete,
+            delete_referencing_meta_tables=delete_referencing_meta_tables,
+            delete_referencing_dynamic_tables=delete_referencing_dynamic_tables,
+            override_schema_management_protection=override_schema_management_protection,
+            timeout=timeout,
+        )
+
     @classmethod
     def register(
         cls,
@@ -4967,6 +5082,10 @@ __all__ = [
     "ManagedMetaTableCollectionCreateRow",
     "ManagedTimeIndexMetaTableCollectionCreateRow",
     "MetaTable",
+    "MetaTableCascadeDeleteRequest",
+    "MetaTableCascadeDeleteResponse",
+    "MetaTableCascadeDeletedDynamicTable",
+    "MetaTableCascadeDeletedMetaTable",
     "MetaTableMigrationConnection",
     "MetaTableMigrationConnectionRequest",
     "MetaTableColumnContract",

{mainsequence-6.0.51 → mainsequence-6.0.52}/mainsequence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 6.0.51
+Version: 6.0.52
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: LicenseRef-MainSequence-Proprietary

{mainsequence-6.0.51 → mainsequence-6.0.52}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence"
-version = "6.0.51"
+version = "6.0.52"
 description = "Main Sequence SDK "
 readme = "README.md"
 requires-python = ">=3.13"

{mainsequence-6.0.51 → mainsequence-6.0.52}/tests/test_meta_tables_client_models.py

@@ -8,6 +8,7 @@ from pydantic import ValidationError
 
 import mainsequence.client.metatables as meta_table_models
 import mainsequence.project_context as project_context
+from mainsequence.client.exceptions import ConflictError, PermissionDeniedError
 from mainsequence.meta_tables.compiled_sql.v1 import build_operation, compile_sqlalchemy_statement
 
 ENVIRONMENT_UID = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb"
@@ -88,6 +89,162 @@ def _project_context():
     )
 
 
+def _cascade_delete_response():
+    return {
+        "ok": True,
+        "action": "delete_with_cascade",
+        "root_meta_table_uid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+        "deleted_meta_tables": [
+            {
+                "meta_table_uid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+                "physical_schema": "public",
+                "physical_table_name": "example_assets__asset",
+                "management_mode": "platform_managed",
+                "physical_table_drop_scheduled": True,
+                "physical_table_drop_cascade": True,
+                "schema_management_protection_overridden": True,
+            }
+        ],
+        "deleted_dynamic_tables": [
+            {
+                "type": "meta_table",
+                "table_kind": "time_indexed",
+                "time_indexed": True,
+                "uid": "cccccccc-cccc-4ccc-8ccc-cccccccccccc",
+                "identifier": "AssetPrices",
+                "namespace": "example.assets",
+                "physical_schema": "public",
+                "physical_table_name": "example_assets__asset_prices",
+            }
+        ],
+        "deleted_meta_table_count": 1,
+        "deleted_dynamic_table_count": 1,
+        "blocking_edges": [
+            {
+                "relationship_type": "meta_table_to_meta_table",
+                "source_table_kind": "time_indexed",
+            }
+        ],
+    }
+
+
+def test_meta_table_confirmed_cascade_delete_posts_typed_contract(monkeypatch):
+    captured = {}
+
+    def fake_make_request(**kwargs):
+        captured.update(kwargs)
+        return _Response(_cascade_delete_response())
+
+    monkeypatch.setattr(meta_table_models, "make_request", fake_make_request)
+    monkeypatch.setattr(
+        meta_table_models.MetaTable,
+        "build_session",
+        classmethod(lambda cls: SimpleNamespace(headers={})),
+    )
+    meta_table = meta_table_models.MetaTable(
+        **_meta_table_response(
+            schema_management_mode="alembic_managed",
+            migration_provider_key="example:assets",
+        )
+    )
+
+    result = meta_table.delete_with_cascade(
+        confirm_cascade_delete=True,
+        delete_referencing_meta_tables=False,
+        delete_referencing_dynamic_tables=True,
+        override_schema_management_protection=True,
+        timeout=19,
+    )
+
+    assert isinstance(result, meta_table_models.MetaTableCascadeDeleteResponse)
+    assert result.root_meta_table_uid == meta_table.uid
+    assert result.deleted_meta_table_count == 1
+    assert result.deleted_dynamic_tables[0].table_kind == "time_indexed"
+    assert captured["r_type"] == "POST"
+    assert captured["url"].endswith(f"/meta-tables/{meta_table.uid}/delete-with-cascade/")
+    assert captured["payload"] == {
+        "json": {
+            "confirm_cascade_delete": True,
+            "delete_referencing_meta_tables": False,
+            "delete_referencing_dynamic_tables": True,
+            "override_schema_management_protection": True,
+        },
+        "params": {"organization_environment_uid": ENVIRONMENT_UID},
+    }
+    assert captured["time_out"] == 19
+
+
+@pytest.mark.parametrize("confirmation", [None, False, 1, "true"])
+def test_meta_table_cascade_delete_requires_explicit_true_confirmation(
+    monkeypatch,
+    confirmation,
+):
+    monkeypatch.setattr(
+        meta_table_models,
+        "make_request",
+        lambda **kwargs: pytest.fail("missing confirmation must fail before HTTP"),
+    )
+
+    with pytest.raises(ValidationError, match="confirm_cascade_delete"):
+        meta_table_models.MetaTable.delete_with_cascade_by_uid(
+            "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+            confirm_cascade_delete=confirmation,
+        )
+
+
+@pytest.mark.parametrize(
+    ("status_code", "error_type", "detail"),
+    [
+        (
+            403,
+            PermissionDeniedError,
+            "Only organization admins can perform this destructive MetaTable action.",
+        ),
+        (
+            409,
+            ConflictError,
+            "Alembic-managed MetaTables require schema-management override.",
+        ),
+    ],
+)
+def test_meta_table_cascade_delete_preserves_typed_backend_errors(
+    monkeypatch,
+    status_code,
+    error_type,
+    detail,
+):
+    captured = {}
+
+    def fake_make_request(**kwargs):
+        captured.update(kwargs)
+        return _Response(
+            {
+                "ok": False,
+                "code": "permission_denied"
+                if status_code == 403
+                else "alembic_managed_delete_blocked",
+                "detail": detail,
+            },
+            status_code=status_code,
+        )
+
+    monkeypatch.setattr(meta_table_models, "make_request", fake_make_request)
+
+    with pytest.raises(error_type, match=detail) as error:
+        meta_table_models.MetaTable.delete_with_cascade_by_uid(
+            "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+            confirm_cascade_delete=True,
+            override_schema_management_protection=True,
+        )
+
+    assert error.value.status_code == status_code
+    assert error.value.payload["code"] in {
+        "permission_denied",
+        "alembic_managed_delete_blocked",
+    }
+    assert captured["payload"]["params"] == {"organization_environment_uid": ENVIRONMENT_UID}
+
+
 @pytest.mark.parametrize(
     "legacy_field",
     ["organization_environment_uid", "project_uid", "repository_branch"],