mainsequence-metatable 0.1.4.dev5__py3-none-any.whl → 0.1.5.dev6__py3-none-any.whl

api/app/configuration.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import Literal
 
 import yaml
-from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
 
 
 class LocalCredentialConfiguration(BaseModel):
@@ -16,7 +16,6 @@ class LocalCredentialConfiguration(BaseModel):
 class DeploymentConfiguration(BaseModel):
     model_config = ConfigDict(extra="forbid", frozen=True)
     local_mode_available: StrictBool = False
-    application_migration_providers: dict[StrictStr, StrictStr] = Field(default_factory=dict)
     local_credentials: LocalCredentialConfiguration = Field(default_factory=LocalCredentialConfiguration)
 
     @classmethod

api/app/main.py

@@ -10,7 +10,6 @@ from sqlalchemy.orm import Session
 
 from api.app.auth.boundary import trusted_actor_facts
 from api.app.auth.local_actor import catalog_session
-from api.app.routes.application_migrations import router as application_migrations_router
 from api.app.routes.column_search import router as column_search_router
 from api.app.routes.contract_validation import router as contract_validation_router
 from api.app.routes.data_sources import router as data_sources_router
@@ -189,7 +188,6 @@ def create_app(config: RuntimeConfig | None = None) -> FastAPI:
     service.include_router(managed_finalize_router)
     service.include_router(table_sql_router)
     service.include_router(migration_connection_router)
-    service.include_router(application_migrations_router)
     service.include_router(table_import_router)
     service.include_router(source_relations_router)
     service.include_router(table_registration_router)

api/app/routes/managed_finalize.py

@@ -203,7 +203,7 @@ def finalize_managed(
                 table.introspection_snapshot = snapshot
                 table.provisioning_status = "active"
                 table.protect_from_deletion = True
-                if payload.alembic_revision:
+                if "alembic_revision" in payload.model_fields_set:
                     table.alembic_revision = payload.alembic_revision
                 if version_root is not None and uid != version_root:
                     table.alembic_version_meta_table_uid = version_root

api/app/routes/migration_connection.py

@@ -1,41 +1,93 @@
-"""Direct database migration connections are disabled by the security boundary."""
+"""Resolve the selected environment connection for application-owned migrations."""
+
 from __future__ import annotations
 
 from typing import Any, Literal
 from uuid import UUID
 
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, Request, Response
 from pydantic import BaseModel, ConfigDict, Field
+from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from api.app.auth.boundary import trusted_actor_facts
 from api.app.auth.local_actor import catalog_session
+from api.app.routes.table_introspection import data_source_provider
 from api.app.routes.table_sql import authorized_table
+from api.backend.backends.migration_connection import migration_connection_description
+from api.backend.domain.data_source_rules import (
+    DataSourceAdmissionError,
+    require_data_source_access,
+)
 from api.backend.domain.permission_rules import TrustedActorFacts
+from api.backend.integrations.runtime_data_sources import DataSourceIntegrationError
+from api.backend.persistence.grants import GrantRepository
 from api.backend.persistence.locking import lock_catalog
+from api.backend.persistence.models import MetaTable
 
-router = APIRouter(prefix='/meta-tables', tags=['MetaTables'])
+router = APIRouter(prefix="/meta-tables", tags=["MetaTables"])
 
 
 class MigrationRequest(BaseModel):
-    model_config = ConfigDict(extra='forbid')
-    purpose: Literal['schema_migration'] = 'schema_migration'
-    package: str = ''
-    migration_namespace: str = ''
-    migration_provider_key: str = ''
+    model_config = ConfigDict(extra="forbid")
+    purpose: Literal["schema_migration"] = "schema_migration"
+    package: str = ""
+    migration_namespace: str = ""
+    migration_provider_key: str = ""
     ttl_seconds: int = Field(default=900, ge=60, le=3600)
     code_repository_context: dict[str, Any] | None = None
 
 
-@router.post('/{table_uid}/migration-connection/', responses={409: {
-    'description': 'Direct connections are disabled pending API-mediated migrations.'}})
-def migration_connection(table_uid: UUID, payload: MigrationRequest,
-                         actor: TrustedActorFacts = Depends(trusted_actor_facts),
-                         session: Session = Depends(catalog_session)):
+@router.post("/{table_uid}/migration-connection/")
+def migration_connection(
+    table_uid: UUID,
+    payload: MigrationRequest,
+    request: Request,
+    response: Response,
+    actor: TrustedActorFacts = Depends(trusted_actor_facts),
+    session: Session = Depends(catalog_session),
+    sources=Depends(data_source_provider),
+):
     lock_catalog(session)
-    authorized_table(session, actor, table_uid, edit=True, reserved_policy='reconcile')
-    # No role issuance, Secret lookup, SQLite path, DSN, or local-mode exception.
-    raise HTTPException(409, {
-        'code': 'direct_migration_connections_disabled',
-        'detail': 'Application-table migrations require API-mediated execution, which is not available yet. Direct database connections are disabled.',
-    })
+    table = authorized_table(session, actor, table_uid, edit=True, reserved_policy="reconcile")
+    if (
+        table.management_mode != "platform_managed"
+        or table.schema_management_mode != "alembic_managed"
+    ):
+        raise HTTPException(409, "MetaTable is not Alembic managed.")
+    for field, value in [
+        ("migration_package", payload.package),
+        ("migration_namespace", payload.migration_namespace),
+        ("migration_provider_key", payload.migration_provider_key),
+    ]:
+        if value and value != getattr(table, field):
+            raise HTTPException(409, "Migration provider identity does not match.")
+    root_uid = table.alembic_version_meta_table_uid or table.uid
+    tables = list(
+        session.scalars(
+            select(MetaTable).where(
+                (MetaTable.uid == root_uid) | (MetaTable.alembic_version_meta_table_uid == root_uid)
+            )
+        )
+    )
+    if any(
+        not GrantRepository(session).may_access_table(table_uid=item.uid, actor=actor, edit=True)
+        for item in tables
+    ):
+        raise HTTPException(403, "Writer access is required for every provider catalog table.")
+    try:
+        source = sources.get(table.data_source_uid)
+        require_data_source_access(source, access="write")
+        result = migration_connection_description(source)
+    except DataSourceAdmissionError as exc:
+        raise HTTPException(exc.status_code, exc.code) from exc
+    except DataSourceIntegrationError as exc:
+        raise HTTPException(503, "DataSource is unavailable.") from exc
+    # Include removed provider models so finalization reconciles dropped tables.
+    result["meta_table_uids"] = [str(item.uid) for item in tables if item.uid != root_uid]
+    control = getattr(request.app.state, "runtime_control", None)
+    if control is not None:
+        result.update(control.hold_migration(actor.user_uid))
+    response.headers["Cache-Control"] = "no-store"
+    response.headers["Pragma"] = "no-cache"
+    return result

api/app/routes/run_logs.py

@@ -14,7 +14,9 @@ from api.app.auth.local_actor import catalog_session
 from api.app.routes.update_crud import admitted_update
 from api.backend.domain.permission_rules import TrustedActorFacts
 from api.backend.integrations.run_logs import _query, read_logs
-from api.backend.persistence.models import UpdateRun
+from api.backend.persistence.grants import GrantRepository
+from api.backend.persistence.models import MetaTable, UpdateNode, UpdateRun
+from api.backend.persistence.run_graphs import MAX_NODES
 from metatables.log_contract import LogPage
 
 router = APIRouter(tags=["TimeIndexTableUpdates"])
@@ -49,6 +51,37 @@ def run_logs(
     return read_logs(state, state.log_snapshots, [run], request.query_params, scope=str(run_uid))
 
 
+@router.get("/table-update-runs/{run_uid}/invocation-logs/", response_model=LogPage)
+def invocation_logs(
+    run_uid: UUID,
+    request: Request,
+    query: Annotated[LogQuery, Query()],
+    actor: TrustedActorFacts = Depends(trusted_actor_facts),
+    session: Session = Depends(catalog_session),
+):
+    """One time-ordered page across the readable attempts of the selected run's invocation.
+
+    `run_uid` narrows the page to one attempt of that invocation. A run without a
+    saved graph is its own invocation.
+    """
+    run = session.get(UpdateRun, run_uid)
+    if run is None:
+        raise HTTPException(404, "Run not found.")
+    admitted_update(session, actor, run.update_uid)
+    member = UpdateRun.root_run_uid == run.root_run_uid if run.root_run_uid else UpdateRun.uid == run.uid
+    statement = select(UpdateRun).join(UpdateNode, UpdateNode.uid == UpdateRun.update_uid).join(
+        MetaTable, MetaTable.uid == UpdateNode.output_table_uid
+    ).where(member, GrantRepository.table_access_predicate(actor))
+    if query.run_uid is not None:
+        statement = statement.where(UpdateRun.uid == query.run_uid)
+    runs = list(session.scalars(statement.order_by(UpdateRun.started_at, UpdateRun.uid)))
+    if not runs:
+        raise HTTPException(422, "Run filter is not a readable attempt of this invocation.")
+    state = request.app.state.runtime
+    return read_logs(state, state.log_snapshots, runs, request.query_params,
+                     scope=f"invocation:{run.root_run_uid or run.uid}", max_runs=MAX_NODES)
+
+
 @router.get("/time-index-table-updates/{update_uid}/logs/", response_model=LogPage)
 def update_logs(
     update_uid: UUID,

api/app/routes/runtime_context.py

@@ -74,7 +74,6 @@ def runtime_context(
 
     result = {
         "credential_store": state.credential_store.descriptor(),
-        "application_migrations_available": bool(getattr(deployment, "application_migration_providers", {})),
         "is_admin": caller.is_admin,
         "user_uid": str(caller.user_uid),
         "local_mode": state.config.local_mode,

api/app/routes/update_crud.py

@@ -16,6 +16,7 @@ from api.app.auth.local_actor import catalog_session
 from api.app.routes.table_response import project_table_response
 from api.app.routes.update_runs import _run_payload
 from api.backend.domain.permission_rules import TrustedActorFacts
+from api.backend.persistence import run_graphs
 from api.backend.persistence.grants import GrantRepository
 from api.backend.persistence.labels import LabelRepository
 from api.backend.persistence.models import (
@@ -207,7 +208,7 @@ def list_runs(request: Request, actor: TrustedActorFacts = Depends(trusted_actor
             item = _run_payload(row)
             graph = session.get(UpdateRunGraph, row.root_run_uid) if row.root_run_uid else None
             saved = next((node for node in graph.snapshot['nodes'] if node['id'] == f'update:{row.update_uid}'), None) if graph else None
-            item['updater_label'] = saved['label'] if saved else session.get(UpdateNode, row.update_uid).update_hash
+            item['updater_label'] = saved['label'] if saved else run_graphs.updater_label(session.get(UpdateNode, row.update_uid))
             item['graph_availability'] = 'available' if graph else 'unavailable'
             if graph is None:
                 item['root_run_uid'] = None
@@ -220,9 +221,12 @@ def get_run(run_uid: UUID, actor: TrustedActorFacts = Depends(trusted_actor_fact
     run = session.get(UpdateRun, run_uid)
     if run is None:
         raise HTTPException(404, 'Run not found.')
-    admitted_update(session, actor, run.update_uid)
+    update = admitted_update(session, actor, run.update_uid)
     result = _run_payload(run)
-    if run.root_run_uid is None or session.get(UpdateRunGraph, run.root_run_uid) is None:
+    graph = session.get(UpdateRunGraph, run.root_run_uid) if run.root_run_uid else None
+    saved = next((node for node in graph.snapshot['nodes'] if node['id'] == f'update:{run.update_uid}'), None) if graph else None
+    result['updater_label'] = saved['label'] if saved else run_graphs.updater_label(update)
+    if graph is None:
         result.update(root_run_uid=None, graph_availability='unavailable')
     return result
 

api/backend/backends/catalog.py

@@ -167,24 +167,11 @@ class PostgreSQLCatalog:
                     "SELECT pg_advisory_unlock(hashtext('metatables:bootstrap'))"
                 )
 
-    @contextmanager
-    def migration_guard(self, connection):
-        from sqlalchemy.orm import Session
-
-        with Session(bind=connection.engine) as session:
-            yield session
-
     @contextmanager
     def migration_connection(self, engine):
         with engine.connect() as connection, connection.begin():
             yield connection
 
-    @contextmanager
-    def application_migration_connection(self, engine):
-        with self.migration_connection(engine) as connection:
-            connection.exec_driver_sql("SET LOCAL search_path TO public")
-            yield connection
-
 
 class SQLiteCatalog(PostgreSQLCatalog):
     default_schema = None
@@ -192,17 +179,6 @@ class SQLiteCatalog(PostgreSQLCatalog):
     def initialize_namespace(self, connection):
         pass
 
-    @contextmanager
-    def migration_guard(self, connection):
-        from sqlalchemy.orm import Session
-        with Session(bind=connection) as session:
-            yield session
-
-    @contextmanager
-    def application_migration_connection(self, engine):
-        with self.migration_connection(engine) as connection:
-            yield connection
-
     def create_engine(self, url, *, native_values=False):
         options = {"timeout": 30, "check_same_thread": False}
         if native_values:

api/backend/backends/contracts.py

@@ -173,8 +173,6 @@ class CatalogBackend(Protocol):
     def schema(self, name: str | None) -> str | None: ...
     def bootstrap_lock(self, engine: Engine) -> AbstractContextManager[None]: ...
     def migration_connection(self, engine: Engine) -> AbstractContextManager[Connection]: ...
-    def application_migration_connection(self, engine: Engine) -> AbstractContextManager[Connection]: ...
-    def migration_guard(self, connection: Connection) -> AbstractContextManager[Session]: ...
     def schema_object_state(self, connection: Connection, name: str) -> Any: ...
     def column_type_matches(self, expected: Any, actual: Any, dialect: Any) -> bool: ...
     def index_names(self, inspector: Any, table: str) -> set[str]: ...

api/backend/backends/hosted.py

@@ -21,11 +21,6 @@ class HostedCatalog(PostgreSQLCatalog):
     def initialize_namespace(self, connection):
         pass
 
-    @contextmanager
-    def application_migration_connection(self, engine):
-        with self.migration_connection(engine) as connection:
-            yield connection
-
     def registration_schema(self, source, name):
         return self.physical_schema(source, name)
 
@@ -126,14 +121,6 @@ class MySQLCatalog(HostedCatalog):
         ]:
             raise CatalogConfigurationError("catalog_index_definition_drift")
 
-    @contextmanager
-    def migration_guard(self, connection):
-        from sqlalchemy.orm import Session
-
-        # Hold catalog admission while implicit DDL commits use a separate connection.
-        with Session(connection.engine) as session:
-            yield session
-
     @contextmanager
     def migration_connection(self, engine):
         # DDL implicitly commits on MySQL. The shared bootstrap journal records

api/backend/backends/migration_connection.py

@@ -0,0 +1,62 @@
+"""Describe the configured runtime connection for application-owned Alembic.
+
+DDL authority belongs to the configured database login. This does not create a
+role or claim that a direct database connection enforces catalog table grants.
+"""
+
+from sqlalchemy.engine import URL
+
+from api.backend.backends.registry import engine_descriptor
+
+
+def migration_connection_description(source):
+    settings = source.connection
+    dialect = engine_descriptor(source.class_type).dialect
+    tls = {}
+    if dialect == "sqlite":
+        url = URL.create("sqlite", database=str(settings.path))
+    else:
+        query = {}
+        driver = {
+            "postgresql": "postgresql+psycopg2",
+            "mysql": "mysql+pymysql",
+            "mssql": "mssql+pyodbc",
+        }[dialect]
+        if dialect == "postgresql":
+            query = {"sslmode": settings.ssl_mode, "connect_timeout": "10"}
+        elif dialect == "mysql":
+            query = {"charset": settings.default_charset or "utf8mb4"}
+        else:
+            query = {
+                "driver": "ODBC Driver 18 for SQL Server",
+                "Encrypt": "yes" if settings.encrypt else "no",
+                "TrustServerCertificate": "yes" if settings.trust_server_certificate else "no",
+            }
+        if dialect in {"postgresql", "mysql"}:
+            tls = {
+                "ssl_mode": settings.ssl_mode,
+                "ca_certificate": settings.tls_ca_certificate,
+                "client_certificate": settings.tls_client_certificate,
+                "client_key": settings.tls_client_key,
+            }
+        url = URL.create(
+            driver,
+            username=settings.database_user,
+            password=settings.password,
+            host=settings.host,
+            port=settings.port,
+            database=settings.database_name,
+            query=query,
+        )
+    return {
+        "ok": True,
+        "data_source_uid": str(source.uid),
+        "dialect": dialect,
+        "credential_kind": "configured_runtime_connection",
+        "role_name": None,
+        "owner_role_name": None,
+        "expires_at": None,
+        "uri": url.render_as_string(hide_password=False),
+        "tls": tls,
+        "default_schema": settings.default_schema,
+    }

api/backend/integrations/run_logs.py

@@ -151,7 +151,7 @@ def _hosted(run, capture, query, start, end, budget, jobs):
         return rows, "error", bool(rows)
 
 
-def read_logs(state, cache, runs, params, *, scope):
+def read_logs(state, cache, runs, params, *, scope, max_runs=MAX_RUNS):
     query = _query(params)
     token = params.get("cursor")
     signature = (storage_key(state), scope, query)
@@ -192,9 +192,9 @@ def read_logs(state, cache, runs, params, *, scope):
             )
 
         rows, statuses, segments, captures = [], {}, [], []
-        budget, hosted_budget, truncated = [0], [0], len(runs) > MAX_RUNS
+        budget, hosted_budget, truncated = [0], [0], len(runs) > max_runs
         jobs = {}
-        for run in runs[:MAX_RUNS]:
+        for run in runs[:max_runs]:
             capture = LogCapture.model_validate(run.log_capture or {"mode": "unavailable"})
             status, found, more = "unavailable", [], False
             if state.config.local_mode and capture.mode == "local":

api/backend/persistence/run_graphs.py

@@ -32,6 +32,13 @@ def fingerprint(update_uid, actor, payload):
     return sha256(json.dumps(body, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
 
 
+def updater_label(update):
+    """The updater's class name, as graphs and run history label it; its hash otherwise."""
+    path = update.build_configuration.get("table_updater_class_import_path", {})
+    label = path.get("qualname") if isinstance(path, dict) else None
+    return label if isinstance(label, str) else update.update_hash
+
+
 def _require(condition, message):
     if not condition:
         raise CatalogInvariantError(message)
@@ -107,10 +114,7 @@ def build_snapshot(session, actor, root_uid, plan):
     for uid, update in sorted(updates.items()):
         _require(grants.may_access_table(table_uid=update.output_table_uid, actor=actor, edit=True),
                  "Run updater is unavailable")
-        path = update.build_configuration.get("table_updater_class_import_path", {})
-        label = path.get("qualname") if isinstance(path, dict) else None
-        nodes.append({"id": f"update:{uid}", "uid": uid, "kind": "update",
-                      "label": label if isinstance(label, str) else update.update_hash,
+        nodes.append({"id": f"update:{uid}", "uid": uid, "kind": "update", "label": updater_label(update),
                       "update_hash": update.update_hash, "output_table_uid": str(update.output_table_uid),
                       "namespace": tables[str(update.output_table_uid)][1]})
         edges.append({"source": f"update:{uid}", "target": f"table:{update.output_table_uid}", "kind": "writes"})
@@ -265,6 +269,10 @@ def read_graph(session, actor, selected):
     grants = GrantRepository(session)
     if root_node is None or not grants.may_access_table(table_uid=root_node.output_table_uid, actor=actor):
         return None
+    # Attempt records bound each node's timeline: admission to completion around the
+    # calculation window that node_states records.
+    attempts = {str(row.uid): row for row in session.scalars(select(UpdateRun).where(UpdateRun.uid.in_(
+        [UUID(state["run_uid"]) for state in graph.node_states.values() if state["run_uid"]])))}
     nodes = []
     for saved in graph.snapshot["nodes"]:
         table_uid = UUID(saved.get("output_table_uid") or saved["uid"])
@@ -276,6 +284,9 @@ def read_graph(session, actor, selected):
         if node["kind"] == "update":
             node.update(graph.node_states[node["id"]])
             node["status"] = node["state"]
+            attempt = attempts.get(node["run_uid"])
+            node["attempt_started_at"] = attempt.started_at if attempt else None
+            node["attempt_ended_at"] = attempt.ended_at if attempt else None
         nodes.append(node)
     ids = {node["id"] for node in nodes}
     return {"availability": "available", "run_uid": str(selected.uid), "root_run_uid": str(root.uid),

api/metatables/configuration.yaml

@@ -1,3 +1 @@
 local_mode_available: false
-application_migration_providers:
-  market-tutorial: examples.tutorial.migrations:migration

examples/README.md

@@ -8,7 +8,7 @@ For one connected walkthrough, start with the [market tutorial](tutorial/README.
 
 | Asset | What it demonstrates | Required environment |
 | --- | --- | --- |
-| [Local application](local_app/README.md) | Setup, API/Admin launch, explicit bootstrap, approved migrations and persistent write/read | Installed package, application Git checkout, SDK login; Node/npm for Admin. |
+| [Local application](local_app/README.md) | Setup, API/Admin launch, explicit bootstrap, application-owned migrations and persistent write/read | Installed package, application Git checkout, SDK login; Node/npm for Admin. |
 | [tables.py](tables.py) | Related account and time-index balance contracts | Import/contract checks are offline. |
 | [quickstart.py](quickstart.py) | Retrieve and validate a visible table | Configured API, SDK session, table grant. |
 | [external_table.py](external_table.py) | Register an existing physical relation | API, source access, pre-existing matching table. |

examples/local_app/README.md

@@ -7,7 +7,7 @@ needs a commit and an `origin` remote. Use Python 3.13+ on macOS or Linux.
 ```bash
 python -m pip install mainsequence-metatable
 mainsequence login
-metatables init --local --provider local-example=examples.local_app.migrations:migration
+metatables init --local
 metatables serve --local --admin
 ```
 
@@ -22,7 +22,7 @@ In another terminal in the same project and Python environment:
 ```bash
 metatables --local runtime status
 metatables --local runtime initialize
-metatables --local migrations upgrade --provider local-example
+metatables --local migrations upgrade --provider examples.local_app.migrations:migration
 python -m examples.local_app
 metatables --local meta-table list
 ```
@@ -33,10 +33,9 @@ Expected example output:
 [{"key": "hello", "message": "My local MetaTables application"}]
 ```
 
-The provider creates the table and finalizes its catalog binding through the API.
+The client runs the provider to create the table, then finalizes its catalog binding through the API.
 The example resolves that table by identifier, compiles bound SQL for the API's
-selected dialect, upserts one note, and reads it back. It never opens SQLite from
-the client. Repeating it keeps one row. Stop and restart the launcher, then inspect
+selected dialect, upserts one note, and reads it back. Ordinary reads and writes use the API; only migrations open the environment database. Repeating it keeps one row. Stop and restart the launcher, then inspect
 the existing row before any write:
 
 ```bash
@@ -49,5 +48,4 @@ Native keyring credentials are the default; for a headless machine, configure th
 file credential provider as described in the [local runtime guide](../../docs/operations/local-runtime.md#local-credentials).
 
 For your own application, define tables like [Note](tables.py), install the package
-containing your [migration provider](migrations/__init__.py), and explicitly approve
-its alias in `configuration.yaml`. See [migration authoring](../../docs/client/define-and-migrate-tables.md).
+containing your [migration provider](migrations/__init__.py) in the application process. See [migration authoring](../../docs/client/define-and-migrate-tables.md).

examples/local_app/migrations/__init__.py

@@ -1,4 +1,4 @@
-"""Only this application's note table belongs to this approved provider."""
+"""Only this application's note table belongs to this application-owned provider."""
 
 from examples.local_app.tables import Base, Note
 from metatables.migrations import (

examples/scripts/setup_metatables.py

@@ -5,22 +5,12 @@ from pathlib import Path
 
 
 def setup_metatables():
-    from mainsequence.client.exceptions import raise_for_response
-    from mainsequence.client.utils import make_request
-
     from metatables.endpoint import api_endpoint_scope, resolve_api_endpoint
-    from metatables.models import _MetaTablesBaseObjectOrm
-
-    class MigrationResource(_MetaTablesBaseObjectOrm):
-        ENDPOINT = "application-migrations/upgrade/"
+    from metatables.runtime import upgrade_application
 
     with api_endpoint_scope():
         print(f"Preparing tutorial on MetaTables API: {resolve_api_endpoint().url}", flush=True)
-        response = make_request(s=MigrationResource.build_session(), loaders=MigrationResource.LOADERS,
-            r_type="POST", url=MigrationResource.get_object_url(),
-            payload={"json": {"provider": "market-tutorial"}}, time_out=(5, 120))
-        raise_for_response(response)
-        result = response.json()
+        result = upgrade_application('examples.tutorial.migrations:migration', timeout=120)
         print(f"Tutorial DataSource: {result['data_source_uid']}; revision: {result['revision']} "
               f"({'migrated' if result['migrated'] else 'already current'})", flush=True)
         return result