mainsequence-metatable 0.1.4.dev5__tar.gz → 0.1.5.dev6__tar.gz

{mainsequence_metatable-0.1.4.dev5 → mainsequence_metatable-0.1.5.dev6}/.agents/skills/client/metatables-local-development/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: metatables-local-development
-description: "Develop and test applications using the installed MetaTables client against local SQLite before returning to the intended environment database. Covers project/API/Admin setup, runtime verification, isolated fixtures, approved migrations and switching back after verification. Excludes MetaTables client/API implementation and hosted frontend deployment."
+description: "Develop and test applications using the installed MetaTables client against local SQLite before returning to the intended environment database. Covers project/API/Admin setup, runtime verification, isolated fixtures, application-owned migrations and switching back after verification. Excludes MetaTables client/API implementation and hosted frontend deployment."
 ---
 
 # Local-first MetaTables application development
@@ -62,17 +62,16 @@ Do not retry against automatic hosted discovery when a local connection fails.
    `metatables --local runtime initialize`, then inspect status again.
    Starting the API does not initialize or migrate a database.
 4. Author and review application migrations using the
-   [migrations skill](../metatables-migrations/SKILL.md). Approve the installed
-   provider in configuration and apply its head to the verified local runtime:
+   [migrations skill](../metatables-migrations/SKILL.md). Run the application-local
+   provider against the verified local runtime:
 
    ```bash
-   metatables init --local --provider ledger=ledger.migrations:migration
-   metatables --local migrations upgrade --provider ledger
+   metatables --local migrations upgrade --provider ledger.migrations:migration
    ```
 
-   Substitute the application's own alias and module. Execution takes an approved
-   alias; authoring takes a Python reference. System initialization and application
-   migration history remain separate.
+   Substitute the application's own module. Provider code and revisions are
+   installed in the application process; the API requires no provider approval
+   or installation. System initialization and application histories remain separate.
 5. Build application contracts/queries with the
    [table skill](../metatables-meta-tables/SKILL.md), or producers/readers with the
    [updater skill](../metatables-time-index-table-updates/SKILL.md). Use small,

{mainsequence_metatable-0.1.4.dev5 → mainsequence_metatable-0.1.5.dev6}/.agents/skills/client/metatables-meta-tables/SKILL.md

@@ -85,11 +85,26 @@ revisions; do not recompute identity from columns or rewrite applied history.
 ## Queries and mutations
 
 Read `docs/client/query-and-mutate.md` and `examples/query.py`. Use
-`compile_sqlalchemy_statement` with bound parameters and explicit catalog table
-scope/access. Resolve registered physical names instead of guessing them from
-identifiers. Use the documented expression subset and scopes for actual read/write targets.
-Arbitrary DDL, system relations, multiple statements and indirect view/trigger
-writes are unsupported by the governed SQL API.
+`compile_sqlalchemy_statement` with bound parameters. The request sends SQL and
+selects one DataSource; the API executes as the authenticated user, and the
+selected database backend enforces Reader/Writer permissions on the tables
+actually touched. The API does not parse SQL for authorization. The compiler can
+resolve DataSource and dialect from the selected runtime; supply both explicitly
+for offline compilation. Preserve execution mode, row limits and timeouts.
+
+There is no declared table list: `MetaTableOperationScopeTable`,
+`MetaTableOperationScope` and `scope_tables` were intentionally removed. Do not
+recreate them, add per-query registration checks, or parse SQL to enforce a client
+scope. Use existing physical bindings in SQLAlchemy models. Registration and
+schema evolution belong to their lifecycle workflows. For older applications,
+use the [legacy upgrade skill](../metatables-upgrade-legacy-app/SKILL.md) and
+`docs/client/upgrade-legacy-app.md`.
+
+`operation="select"` selects read execution; the other labels select write
+execution. The label does not classify the SQL. Database permissions enforce
+access; row/time limits and transaction handling remain in the API. Refer to the
+query guide for engine-specific statement/batch behavior. Application DDL belongs
+to the separate migration-provider workflow.
 
 Column search is supported. Description search, search-index refresh, and
 legacy convenience sharing/label actions are not supported API workflows.

{mainsequence_metatable-0.1.4.dev5 → mainsequence_metatable-0.1.5.dev6}/.agents/skills/client/metatables-migrations/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: metatables-migrations
-description: "Create and evolve managed application tables through Alembic migration providers with the installed MetaTables Python client. Covers provider scope, scaffolding, offline revisions, approved API-side execution, and reservation or finalization failures. Excludes API catalog migrations, client-library implementation, API/server changes and repository tooling."
+description: "Create and evolve managed application tables through Alembic migration providers with the installed MetaTables Python client. Covers provider scope, scaffolding, revision authoring, client-side execution, and reservation or finalization failures. Excludes API catalog migrations, client-library implementation, API/server changes and repository tooling."
 ---
 
 # MetaTables client application migrations
@@ -12,6 +12,10 @@ client. It covers application-facing models and workflows. Client-library
 implementation, this repository's development/release tooling, and API internals
 have separate ownership.
 
+For upgrading older client imports, SQL scopes or provider integration, use the
+[legacy upgrade skill](../metatables-upgrade-legacy-app/SKILL.md). This skill
+covers authoring and running application schema revisions.
+
 In a copied skill, resolve the `docs/` and `examples/` paths below relative to
 this skill's `references/` directory. The client CLI bundles the matching version's
 guides and examples there, including their linked documents. In the MetaTables
@@ -25,8 +29,8 @@ verification within the requested scope.
 Read `docs/client/define-and-migrate-tables.md`,
 `docs/concepts/table-contracts-and-lifecycle.md`, and the tested
 `examples/tables.py`. Managed authoring is migration-first: define SQLAlchemy
-models, select a provider, author a revision, then let the API apply it and
-finalize the catalog bindings. Use the
+models, select a provider, author and apply a revision with the client, then
+finalize catalog bindings through the API. Use the
 [table skill](../metatables-meta-tables/SKILL.md) for contract design.
 
 Check `docs/reference/capabilities.md` and `metatables migrations --help` before
@@ -36,14 +40,15 @@ are not application-provider revisions.
 
 ## Source and runtime context
 
-- The API selects its active runtime DataSource. Do not accept a caller-supplied
-  DataSource, database URL, revision path, or branch override.
+- The API selects its active runtime DataSource. Upgrade and downgrade use that
+  environment connection. An explicit `--sqlalchemy-url` is available for revision
+  authoring; use it only when that authoring target is intended.
 - Git source facts come from the current checkout through the SDK. Do not ask the
   user to choose a branch or environment for a migration.
 - An explicit `METATABLES_API_URL` selects an API endpoint, not a branch or a
   storage binding. See `docs/client/installation-and-connection.md`.
-- Provider aliases are API deployment configuration, not Python import paths
-  supplied by a request.
+- Provider references resolve in the application process, for example
+  `ledger.migrations:migration`. The API needs no provider code or allowlist.
 
 ## Author the migration
 
@@ -66,12 +71,11 @@ are not application-provider revisions.
 5. Edit the generated `registry.py` so it returns exactly the models owned by
    that migration stream. Scaffolding alone selects no models and creates no
    tables.
-6. Create and review an offline Alembic revision:
+6. Create and review an Alembic revision (defaults to autogeneration):
 
    ```bash
    metatables migrations revision \
      --provider ledger.migrations:migration \
-     --no-autogenerate \
      --message "create ledger"
    ```
 
@@ -79,33 +83,32 @@ Use `--source-root` and `--code-repository-root` when the application does not
 use the default `src/` layout. Keep applied revisions immutable; add a new
 revision for every later schema change.
 
-## Execute through the approved runtime
+## Execute with the environment connection
 
-Direct client-side Alembic execution, `current`, `downgrade`, migration
-connections and database autogeneration are unsupported. `--sqlalchemy-url` does
-not bypass that boundary. The supported upgrade command executes inside the API.
-After verifying Local mode and the selected DataSource, use:
+After verifying the intended runtime, use the application's provider reference:
 
 ```bash
-metatables --local migrations upgrade --provider ledger
+metatables --local migrations upgrade --provider ledger.migrations:migration
+metatables --local migrations current --provider ledger.migrations:migration
+metatables --local migrations downgrade 0001 --provider ledger.migrations:migration
 ```
 
-`ledger` is the approved alias, not a Python provider reference. Only `head` is
-supported. The global `--local` selects the running project's API connection;
-inspect runtime status because Admin can switch that API to Hosted.
+The global `--local` selects the running project's API connection; inspect runtime
+status because Admin can switch that API to Hosted. Upgrade/downgrade accept
+Alembic targets. Use `--no-autogenerate` for offline revision authoring.
 
-The API applies a provider through `POST /application-migrations/upgrade/`, which
-accepts only an alias listed in its `application_migration_providers`. The
-deployment must already install the reviewed provider code. The API reserves the
-provider's catalog rows, runs Alembic to the provider head, and finalizes the
-physical bindings. The caller needs Writer access to every existing provider
-table and cannot upload revisions, choose a database or target revision, or
-downgrade. See `docs/api/tables-and-migrations.md`.
+The client imports and executes application revisions, using the connection
+resolved for the selected environment. Environment operators supply the database
+login's DDL privileges. MetaTables does not mint migration roles or sandbox DDL.
+API Writer checks govern connection admission and provider catalog operations.
+The client reserves catalog entries, runs Alembic, closes its physical connection,
+and finalizes contracts through the API. Treat connection material as private.
 
-Use the application's tested setup entry point when one exists;
-`examples/scripts/setup_metatables.py` and `docs/client/tutorial.md` show the
-pattern. Do not replace it with direct model registration or an undocumented
-request body.
+Use the application's setup entry point when available. Python code can call
+`metatables.upgrade_application("ledger.migrations:migration")`;
+`examples/scripts/setup_metatables.py` shows the pattern. Remove the retired
+`application_migration_providers` setting and use Python references instead of aliases.
+Application migration histories remain separate from API system migrations.
 
 ## Lifecycle invariants
 
@@ -134,13 +137,14 @@ Read `docs/operations/recovery-and-observability.md`.
 - If Alembic succeeds but finalization fails, physical DDL may already be
   committed. Inspect every per-table result and the actual schema before
   retrying.
-- Treat an uncertain journal outcome as reconciliation work. Do not blindly
-  retry, stamp, downgrade, cascade-delete, or register around it.
+- Inspect partial DDL before retrying, especially on engines without transactional
+  DDL. A finalization-only failure can be retried without reapplying committed
+  revisions. Client DDL has no API executor journal.
 - Destructive catalog deletion is not migration recovery and never bypasses
   schema-management protection.
 
 ## Validation
 
-Verify provider scope, revision content, the approved-provider configuration,
+Verify provider scope, revision content, the selected environment connection,
 repeat execution, and final active bindings. Report separately what was checked
 offline and what was exercised against a configured API.

mainsequence_metatable-0.1.5.dev6/.agents/skills/client/metatables-upgrade-legacy-app/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: metatables-upgrade-legacy-app
+description: "Upgrade consuming applications from MainSequence 8.x MetaTables or older extracted clients to the installed metatables package. Use for legacy imports, removed SQL scopes, repository compilers and application migration-provider integration. Excludes MetaTables client/API implementation and ordinary schema revision authoring."
+---
+
+# Upgrade a legacy MetaTables application
+
+## Scope and references
+
+Update the consuming application to the installed client's current contract.
+Removed scope APIs are intentional; do not restore them in the client or create
+application compatibility shims. Keep identity/login and Git source integration
+in the MainSequence SDK.
+
+Read `docs/client/upgrade-legacy-app.md` for the conversion table and before/after
+repository compiler examples. In a copied skill, resolve the `docs/` and
+`examples/` paths here relative to this skill's `references/` directory. In the
+MetaTables source checkout, resolve them from the repository root.
+
+Use `docs/client/installation-and-connection.md` to establish the target package
+and compatible SDK versions. Refresh copied skills after a client upgrade with
+`metatables copy-metatables-skills`. Inspect the installed public exports and CLI
+help before mapping an unfamiliar old interface; avoid broad import rewrites.
+
+## Find and replace legacy usage
+
+Inspect dependency pins, table imports, shared repository compilers and their
+callers, runtime setup, and existing Alembic provider integration. Useful search
+terms are `mainsequence.client.metatables`, `mainsequence.meta_tables`,
+`MetaTableOperationScopeTable`, `MetaTableOperationScope`, `scope_tables`, and
+`application_migration_providers`.
+
+For SQL operations:
+
+- Import public table resources from `metatables` and the compiler from
+  `metatables.compiled_sql.v1`.
+- Send SQL and a DataSource. The API executes as the authenticated user, and the
+  selected engine enforces that user's table permissions on actual SQL access.
+  Removing the declared table list does not remove table permissions.
+- Delete scope classes, `scope_tables`, and scope-only wrappers or parameters,
+  including `models`, `access`, aliases or `reserved_policy` when they serve only
+  scope construction. Update callers and old nested wire payloads together.
+- Do not substitute per-query catalog lookups, registration/binding preflights,
+  local permission checks or SQL parsing for the removed scope machinery.
+  Registration/finalization remain table lifecycle operations. Preserve separate
+  application business rules.
+- Let the compiler obtain DataSource and dialect from the selected API runtime,
+  or supply both explicitly for offline compilation. Never use a MetaTable UID as
+  a DataSource UID or infer a new database from the retired table list.
+- Preserve the query's physical bindings, bound parameters, result behavior,
+  execution mode, offsets, row limits, statement deadlines and HTTP timeouts.
+  `select` selects read execution; the other operation labels select write
+  execution. These labels do not classify the SQL statement.
+
+Read `docs/client/query-and-mutate.md` for current query behavior and
+`docs/adr/api/0007-database-enforced-table-access.md` for the decision. The retained
+`compiled-sql.v1` label does not make the old scoped payload compatible.
+
+## Upgrade application migration integration
+
+Keep the existing provider package, namespace, model registry, version-table
+binding and applied revision history. Update bootstrap/import wiring to the
+installed client's public migration interfaces. Do not scaffold a replacement
+provider, rewrite applied history or stamp the database to bypass an upgrade issue.
+
+Providers load in the application process from Python references such as
+`ledger.migrations:migration`. The client executes Alembic with the environment
+connection; the API handles authorization, reservations and finalization. The
+environment operator supplies database DDL privileges. Remove retired API provider
+allowlists and aliases; the API needs no application provider code installed.
+MetaTables' internal catalog migrations remain a separate history.
+
+Use the [application migrations skill](../metatables-migrations/SKILL.md),
+`docs/client/define-and-migrate-tables.md`, and
+`docs/adr/api/0013-application-owned-migrations.md` for that workflow. Ordinary
+SQL continues through the governed API, independently of the migration connection.
+
+## Verify the upgrade
+
+Run imports and offline compilation first. The guide includes an example that
+needs no registration, credentials or running API. Check actual query parameters,
+mode and limits; use existing tests for application business behavior. Review
+provider loading and unchanged Alembic history. Remove obsolete tests that assert
+scope construction rather than recreating that behavior to make them pass.
+
+For application execution checks, follow the
+[local development skill](../metatables-local-development/SKILL.md), verify the
+actual local runtime, and exercise the smallest relevant workflow. Respect the
+requested scope for database mutations; a client upgrade alone does not authorize
+hosted migrations. Distinguish offline verification from API execution and from
+hosted-engine verification in the result.

{mainsequence_metatable-0.1.4.dev5 → mainsequence_metatable-0.1.5.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.4.dev5
+Version: 0.1.5.dev6
 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.4.dev5 → mainsequence_metatable-0.1.5.dev6}/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

{mainsequence_metatable-0.1.4.dev5 → mainsequence_metatable-0.1.5.dev6}/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)

{mainsequence_metatable-0.1.4.dev5 → mainsequence_metatable-0.1.5.dev6}/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

mainsequence_metatable-0.1.5.dev6/api/app/routes/migration_connection.py

@@ -0,0 +1,93 @@
+"""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, 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"])
+
+
+class MigrationRequest(BaseModel):
+    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/")
+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)
+    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

{mainsequence_metatable-0.1.4.dev5 → mainsequence_metatable-0.1.5.dev6}/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,

{mainsequence_metatable-0.1.4.dev5 → mainsequence_metatable-0.1.5.dev6}/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,

{mainsequence_metatable-0.1.4.dev5 → mainsequence_metatable-0.1.5.dev6}/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
 

{mainsequence_metatable-0.1.4.dev5 → mainsequence_metatable-0.1.5.dev6}/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:

{mainsequence_metatable-0.1.4.dev5 → mainsequence_metatable-0.1.5.dev6}/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]: ...

{mainsequence_metatable-0.1.4.dev5 → mainsequence_metatable-0.1.5.dev6}/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