mainsequence-metatable 0.1.17.dev29__tar.gz → 0.1.18.dev30__tar.gz

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/.agents/skills/client/metatables-meta-tables/SKILL.md

@@ -143,8 +143,8 @@ Before a destructive action, or to show impact in an application UI, call
 The API returns whether the caller may run it, every blocker, and a graph of
 affected tables, foreign-key effects and reading updates; render that result
 rather than re-deriving foreign-key or permission rules in the client. Cascading
-foreign keys are allowed, but write on a table requires write on every table its
-cascades modify; a cascade into an unregistered table makes the parent read-only.
+foreign keys are allowed. Write on a table depends only on its own grants; the
+cascade effects in the result are information, never a reason the action is blocked.
 
 On a TimescaleDB DataSource, time-index tables are hypertables. Their compression
 and retention policies are set only through `TimeIndexMetaTable.set_timescale_policies`

{mainsequence_metatable-0.1.17.dev29/src/mainsequence_metatable.egg-info → mainsequence_metatable-0.1.18.dev30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.17.dev29
+Version: 0.1.18.dev30
 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.17.dev29 → mainsequence_metatable-0.1.18.dev30}/docs/adr/api/0002-application-administration-and-table-ownership.md

@@ -6,6 +6,14 @@
 > conflicting application-migration execution and credential restrictions;
 > governed API operations and MetaTables system migrations remain separate.
 
+> Amendment (2026-10-03): "Cascades" below means the confirmed cascade delete,
+> which drops referencing tables and so needs Writer access to every table it
+> drops. Foreign-key row actions (`CASCADE`, `SET NULL`, `SET DEFAULT`) are
+> different: the referencing table's own foreign key authorizes them, so a caller
+> who changes a referenced row needs no access to the referencing tables, and
+> tables that reference a table never change who may write it
+> ([ADR 0007](0007-database-enforced-table-access.md), amended 2026-10-03).
+
 
 Date: 2026-09-29
 

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/docs/adr/api/0007-database-enforced-table-access.md

@@ -14,14 +14,23 @@
 > `metatables` schema and tables in the DataSource's default schema; it need not
 > own the database.
 
-> Amendment (2026-10-03): Cascading foreign keys are allowed. The database runs
-> `CASCADE`, `SET NULL` and `SET DEFAULT` actions as the table owner, so a role
-> keeps write on a table only while every login reaching it can also write each
-> table those actions modify, following chains of cascades. A cascade into an
-> unregistered table leaves the parent read-only. Registration and reconciliation
-> record each table's cascade targets; nothing inspects submitted queries. This
-> replaces the rule that foreign keys must use `restrict` or `no action`, which the
-> implementation applied on every engine, not only where the explorer is enabled.
+> Amendment (2026-10-03): Cascading foreign keys are allowed, and write on a table
+> depends only on that table's own grants. A foreign key's `CASCADE`, `SET NULL` or
+> `SET DEFAULT` action belongs to the referencing table: whoever controls that
+> table's schema decided what happens to its rows when the referenced row changes.
+> A caller who deletes or re-keys a referenced row therefore needs no access to
+> the referencing tables, however long the chain, and no table that references
+> another ever changes who may write it. This withdraws three rules:
+>
+> - foreign keys must use `restrict` or `no action`, which the implementation
+>   applied on every engine, not only where the explorer is enabled;
+> - the MySQL and SQL Server check that refused writes whose cascades reached
+>   other tables (`unscoped_cascade_denied`);
+> - an interim development change that removed write on a table from callers who
+>   could not write every table referencing it.
+>
+> Reconciliation still records each table's cascade targets, but only so the
+> [impact pre-flight](0016-impact-preflight.md) can show their effects.
 
 
 Date: 2026-09-29
@@ -159,8 +168,8 @@ The API removes every check of what the SQL means:
   statement the role lacks privileges for.
 - No declared table scope. A request names only its DataSource.
 - No checks for views, triggers or cascades before query execution. Registration
-  and schema management establish and preserve the safeguards and foreign-key
-  rule below, without inspecting each submitted query.
+  and schema management establish and preserve the safeguards below, without
+  inspecting each submitted query.
 - One statement per request comes from the extended query protocol, and row limits
   from fetching at most `max_rows` rows, not from rewriting the query.
 
@@ -202,8 +211,9 @@ client.
 - Any role can see the names, columns and row counts of every table in PostgreSQL's
   system catalogs, but not their data. MetaTables accepts this where the explorer
   is enabled. Role names are opaque, because table permissions are visible too.
-- Databases run foreign-key cascades as the table owner. Write on a table
-  requires write on every table its cascades modify (amendment 2026-10-03).
+- Databases run foreign-key cascades as the table owner. The referencing table's
+  own foreign key authorizes them, so they need no access from the caller
+  (amendment 2026-10-03). SQLite is the exception described below.
 - Heavy queries still consume resources. Per-role connection limits, time limits
   and, optionally, a read replica bound them.
 
@@ -214,6 +224,10 @@ runtimes: reads on the caller's Reader and Writer tables, writes on Writer table
 only, and nothing else, including catalog tables, schema changes, transaction
 control and `PRAGMA`. The callback responds to SQLite's own authorization events
 inside the backend adapter; the API does not parse the query to infer its access.
+SQLite also asks it about the reads and writes of foreign-key actions, which it
+cannot tell apart from the caller's own. A local delete or key update on a
+referenced table therefore fails unless the caller can access every referencing
+table.
 
 ### Engine-specific enforcement
 
@@ -283,8 +297,8 @@ and [MySQL implicit commits](https://dev.mysql.com/doc/refman/8.4/en/implicit-co
 - The DataSource login needs `CREATEROLE` and the right to create the `metatables`
   schema; it does not need to own the database.
 - Physical table names become visible to explorer users.
-- Cascading foreign keys narrow write access to callers who can write the whole
-  cascade; a cascade into an unregistered table makes its parent read-only.
+- Cascading foreign keys are allowed. Tables that reference a table never change
+  who may write it.
 - Team membership reaches the database at the pace of the existing one-hour
   platform-fact cache.
 

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/docs/adr/api/0016-impact-preflight.md

@@ -1,5 +1,11 @@
 # ADR 0016: Impact pre-flight for cascades and deletes
 
+> Amendment (2026-10-03): Cascade effects are information, never blockers. An
+> earlier version of this ADR reported a cascade into an unregistered table or a
+> table the caller could not write as a blocker, and computed `can_write` after
+> removing write from such callers. Both are withdrawn with that rule
+> ([ADR 0007](0007-database-enforced-table-access.md), amended 2026-10-03).
+
 Date: 2026-10-03
 
 Status: Accepted.
@@ -14,17 +20,18 @@ own their UIs.
 
 Related decisions: [ADR 0001](0001-unified-api-storage-and-local-sqlite.md) (the SDK
 makes no access decisions of its own), [ADR 0002](0002-application-administration-and-table-ownership.md)
-(cascades need access to every affected table) and [ADR 0007](0007-database-enforced-table-access.md)
-(amended 2026-10-03: write requires write on every cascade target).
+(the confirmed cascade delete needs access to every table it drops) and
+[ADR 0007](0007-database-enforced-table-access.md) (amended 2026-10-03: tables that
+reference a table never change who may write it).
 
 ## Context
 
-Cascading foreign keys are now allowed. A caller keeps write on a table only while
-they can write every table its `CASCADE`, `SET NULL` and `SET DEFAULT` actions
-modify. A project that builds its own UI needs to show, before acting, which
-tables a delete or key update reaches, what happens to each, and why a write is
-or is not available. Before this decision, a caller could only try the action
-and read the error.
+Cascading foreign keys are now allowed, and write on a table depends only on its
+own grants. A delete or key update can still reach many tables through their
+`CASCADE`, `SET NULL` and `SET DEFAULT` actions. A project that builds its own UI
+needs to show, before acting, which tables an action reaches, what happens to
+each, and whether the action is available. Before this decision, a caller could
+only try the action and read the error.
 
 ## Decision
 
@@ -59,23 +66,21 @@ The response is a graph rooted at the table:
     with no names.
 
   Each node lists its `effects` (`drop`, `delete`, `update`, `input_changed`) and
-  the caller's `can_write`. For row actions, `can_write` is the database
-  privilege after cascade narrowing, computed by the same function the
-  reconciler uses. For `drop_table`, it is the edit grant the drop requires.
+  the caller's `can_write`. For row actions, `can_write` is the caller's write on
+  that table: its grants, and whether the table and DataSource accept writes.
+  Tables that reference it never change it. For `drop_table`, it is the edit
+  grant the drop requires.
 - **Edges**: each edge points from the dependent to what it depends on, as in
   the schema graph. Edges are classified by effect: `cascade_delete`,
   `cascade_update`, `set_null`, `set_default`, `restrict` (fails while
   referencing rows exist), `drop`, and `reads`.
 - **Verdict**: `allowed` and every blocker, each with a code and the node it
-  concerns:
-  - `cascade_target_unregistered`
-  - `cascade_target_not_writable`
-  - `table_not_writable`
-  - `writes_unsupported`
-  - `data_source_read_only`
-  - `retained_referencing_table`
-  - `alembic_protection`
-  - `deletion_protected`
+  concerns. A row action is blocked only by the table itself:
+  `table_not_writable`, `writes_unsupported` or `data_source_read_only`. Cascade
+  effects are information, never blockers, because the referencing table's own
+  foreign key authorizes them. `drop_table` keeps the confirmed delete's
+  blockers: `table_not_writable` (for every table it drops),
+  `retained_referencing_table`, `alembic_protection` and `deletion_protected`.
 
 `delete-with-cascade` runs the same planner (`persistence/impact.py`) and refuses
 with its first blocker's status and message, so a preview and the confirmed
@@ -91,7 +96,7 @@ every rule at execution time.
 | Need | Today |
 | --- | --- |
 | `on_update` in the catalog | `MetaTableForeignKey` and contracts carry only `on_delete`; contracts reject `set default`. Row-action edges use the physical actions, which are complete. |
-| Effective write in table responses | `permissions.write` reflects catalog grants and can say yes when cascade narrowing says no. Callers should use the pre-flight. |
+| SQLite runtimes | MetaTables' authorizer also checks the reads and writes of foreign-key actions, so a local delete or key update on a referenced table fails unless the caller can access every referencing table ([ADR 0007](0007-database-enforced-table-access.md)). The pre-flight does not report this. |
 | Plain delete | `DELETE /meta-tables/{uid}/` still answers 409 without listing references. |
 | Contract changes | No `change_contract` action; a PATCH that would invalidate an incoming key fails with a text message. |
 | Schema and update graphs | `get_schema_graph` returns an untyped dict; `update-graph` has no client method. |

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/docs/adr/index.md

@@ -36,4 +36,4 @@ decisions belong in the SDK repository and are linked as dependencies.
 | [0013: Application-owned migrations](api/0013-application-owned-migrations.md) | Accepted and implemented | Application-side Alembic, environment database authority, API catalog integration and separate system migrations. |
 | [0014: System migrations in the deployment workflow](api/0014-main-sequence-release-jobs-and-production-migrations.md) | Accepted; implemented on development; hosted verification pending | A Main Sequence Job verifies, migrates and registers the declared runtime database from the candidate image before each API rollout, including the first. |
 | [0015: TimescaleDB compression and retention policies](api/0015-timescale-compression-and-retention-policies.md) | Accepted; implemented on branch; TimescaleDB verification pending | Time-index tables on TimescaleDB become hypertables; Writers set compression and retention through the API/Admin; Timescale keeps the jobs, and the Admin shows their status. |
-| [0016: Impact pre-flight for cascades and deletes](api/0016-impact-preflight.md) | Accepted; implemented; container engine verification pending | `get_impact` returns what a row delete, key update or table drop reaches, every blocker and the caller's effective write, from the planner the confirmed delete runs; projects render it in their own UIs. |
+| [0016: Impact pre-flight for cascades and deletes](api/0016-impact-preflight.md) | Accepted; implemented; container engine verification pending | `get_impact` returns what a row delete, key update or table drop reaches, every blocker and whether the caller may write each table, from the planner the confirmed delete runs; cascade effects never block. Projects render it in their own UIs. |

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/docs/security/index.md

@@ -23,6 +23,7 @@ deployment's migration Job does so for its declared runtime database.
 | Application Settings and global Security admission | MetaTables, using the trusted platform admin fact |
 | Sharing, lifecycle and schema admission | The MetaTables API |
 | Data access during SQL execution | Database roles and privileges; SQLite engine authorizer locally |
+| What happens to rows that reference a changed row | The referencing table's foreign key, chosen by whoever controls its schema |
 | Showing permitted actions and access explanations | The Admin UI and Python client, using API decisions |
 
 MetaTables does not maintain another Organization or Environment policy model.
@@ -128,9 +129,10 @@ statement classification or function allowlist. The database enforces access in
 joins, CTEs, subqueries and permitted invoker routines. Database permissions are
 established during setup and schema changes. Catalog tables remain inaccessible,
 views cannot be registered, elevated routines cannot confer owner access, and
-triggered writes are restricted by the engine's policy. A table with cascading
-foreign keys is writable only by callers who can write every table the cascade
-modifies.
+triggered writes are restricted by the engine's policy. Cascading foreign keys are
+allowed: a referencing table's own foreign key decides what happens to its rows, so
+tables that reference a table never change who may write it. See
+[foreign keys and cascades](permissions.md#foreign-keys-and-cascades).
 
 PostgreSQL stores the catalog in `metatables` and owns managed tables through a
 non-login owner role. User, Team and namespace grants become database privileges

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/docs/security/permissions.md

@@ -60,7 +60,10 @@ Permissions follow the resources actually affected:
 - A query needs Reader access to every table it reads and Writer access to every
   table it changes. Supplying an authorized table UID does not authorize arbitrary
   SQL against other tables.
-- A cascade needs Writer access to every affected table. Migration connection
+- A confirmed cascade delete needs Writer access to every table it drops. A
+  foreign-key action (`CASCADE`, `SET NULL`, `SET DEFAULT`) needs no access to the
+  referencing tables: their own foreign keys authorize it (see
+  [Foreign keys and cascades](#foreign-keys-and-cascades)). Migration connection
   admission checks all provider catalog tables, including their registry. The
   resulting direct connection is governed by database privileges, not table grants.
 - An updater needs Writer access to its output and Reader access to its inputs.
@@ -81,6 +84,57 @@ drop the externally owned physical relation. Application system tables and grant
 records cannot be edited as ordinary API table data. Direct migration access uses
 the environment login's privileges; its restrictions are the environment operator's responsibility.
 
+## Foreign keys and cascades
+
+**Write on a table depends only on that table's own grants.** Tables that
+reference it, directly or through any chain of foreign keys, never add or remove
+access to it.
+
+A foreign key belongs to the referencing table. Whoever controls that table's
+schema chooses its action, and so decides what happens to their own rows when a
+referenced row is deleted or its key changes:
+
+| Action on the referencing table | What happens to its rows |
+| --- | --- |
+| `CASCADE` | Deleted with the referenced row, or re-keyed with it |
+| `SET NULL` / `SET DEFAULT` | Their reference is cleared or reset |
+| `RESTRICT` / `NO ACTION` | The database refuses the change while they exist |
+
+A caller who changes a referenced row therefore needs no access to the
+referencing tables. The database applies each referencing table's action as part
+of that write; MetaTables adds no check of its own. PostgreSQL runs these actions
+as the referencing table's owner.
+
+| Operation on a referenced table | Access required |
+| --- | --- |
+| Insert rows, or update columns no foreign key references | Writer on the table |
+| Delete rows, or update referenced key columns | Writer on the table; each referencing table's action then applies |
+| Drop the table with the confirmed cascade delete | Writer on the table and on every referencing table it drops |
+
+For example, Alice owns `assets`. Carol's `details` table references `assets`
+with `ON DELETE CASCADE`. Alice's Writers can still insert, update and delete
+assets without any access to `details`. When they delete an asset, the database
+deletes Carol's rows for it, because Carol's foreign key says so. If Carol wants
+her rows kept, she uses `RESTRICT` or `NO ACTION`, and the database then refuses
+to delete assets her rows still reference. Dropping `assets` with the confirmed
+cascade delete would drop `details` too, so it needs Writer access to both.
+
+Referencing another owner's table is a commitment: its Writers' deletes and key
+updates apply your foreign key's action to your rows.
+
+**Seeing the effects first.** `table.get_impact(action=...)` (or
+`GET /meta-tables/{uid}/impact/`) lists every table a row delete, key update or
+table drop reaches and what happens to each. Cascade effects are information,
+never a reason the action is blocked. Tables you cannot view appear as opaque
+nodes. See [ADR 0016](../adr/api/0016-impact-preflight.md).
+
+**SQLite limitation.** In a local SQLite runtime, MetaTables' authorizer is also
+asked about the reads and writes that foreign-key actions make, and it cannot
+tell them apart from the caller's own. A delete or key update on a referenced
+table therefore fails unless the caller can access every referencing table.
+PostgreSQL does not have this limitation; MySQL and SQL Server are pending
+verification against their containers.
+
 ## Choosing the right page
 
 A Writer uses the table page for data, schema, updater, deletion, and sharing

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/pyproject.toml

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

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30/src/mainsequence_metatable.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.17.dev29
+Version: 0.1.18.dev30
 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.17.dev29 → mainsequence_metatable-0.1.18.dev30}/src/mainsequence_metatable.egg-info/SOURCES.txt

@@ -526,7 +526,6 @@ tests/packaging/test_dev_release_version.py
 tests/packaging/test_distribution_sources.py
 tests/packaging/test_editable_build.py
 tests/packaging/test_installed_distribution.py
-tests/permissions/test_cascade_writes.py
 tests/permissions/test_governed_sql_scope.py
 tests/permissions/test_local_actor_membership.py
 tests/permissions/test_migration_boundary.py

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/src/metatables/api/backend/backends/access.py

@@ -87,9 +87,6 @@ class DatabaseAccess:
         deleted or their keys updated, as (schema, table, on_delete, on_update)."""
         raise NotImplementedError
 
-    def relation_key(self, schema, table):
-        return schema, table
-
     def refresh_policies(self, session):
         tables = list(
             session.scalars(
@@ -191,15 +188,6 @@ class DatabaseAccess:
                 memberships.add((login, role("user", principal.user_uid, write)))
                 for team in principal.teams:
                     memberships.add((login, role("team", team, write)))
-        cascades = {
-            self.relation_key(p.schema_name or "main", p.table_name): {
-                self.relation_key(t["schema"], t["table"]) for t in p.cascade_targets or ()
-            }
-            for p in policies.values()
-        }
-        privileges = restrict_cascading_writes(
-            roles, memberships, privileges, cascades, key=self.relation_key
-        )
         return dict(roles=roles, memberships=sorted(memberships), privileges=sorted(privileges))
 
     def reconcile(self, session, *, inspect_objects=False):
@@ -310,51 +298,6 @@ def referential_action(value):
     return str(value).strip().lower().replace("_", " ")
 
 
-def restrict_cascading_writes(roles, memberships, privileges, cascades, key=lambda *r: r):
-    """Keep a write grant only while every login reaching it may write what its cascades modify.
-
-    Databases run foreign-key actions as the table owner, so a cascade into a
-    table the caller cannot write would bypass that table's grants (ADR 0007).
-    Unregistered targets are writable by nobody. Revocations repeat until stable
-    because a withdrawn grant can invalidate another table's cascade.
-    """
-    parents = {}
-    for member, parent in memberships:
-        parents.setdefault(member, set()).add(parent)
-    reach = {}
-    for login in (name for name, definition in roles.items() if definition["login"]):
-        reached, frontier = {login}, [login]
-        while frontier:
-            for parent in parents.get(frontier.pop(), ()):
-                if parent not in reached:
-                    reached.add(parent)
-                    frontier.append(parent)
-        reach[login] = reached
-    privileges = set(privileges)
-    while True:
-        writes = {}
-        for name, schema, table, allowed in privileges:
-            if allowed:
-                writes.setdefault(name, set()).add(key(schema, table))
-        effective = {
-            login: set().union(*(writes.get(name, ()) for name in reached))
-            for login, reached in reach.items()
-        }
-        denied = {
-            entry
-            for entry in privileges
-            if entry[3]
-            and any(
-                entry[0] in reached
-                and not cascades.get(key(*entry[1:3]), set()) <= effective[login]
-                for login, reached in reach.items()
-            )
-        }
-        if not denied:
-            return privileges
-        privileges = (privileges - denied) | {(*entry[:3], False) for entry in denied}
-
-
 def install_session_security(session, resolver):
     """Attach the runtime resolver to a catalog unit of work, not to global auth."""
     session.info["sql_security_resolver"] = resolver

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/src/metatables/api/backend/backends/hosted.py

@@ -319,17 +319,6 @@ class MySQLCatalog(HostedCatalog):
                 ).scalar()
                 if trigger:
                     raise SQLExecutionError(code="triggered_sql_write_unsupported")
-                affected = connection.execute(
-                    sa.text(
-                        "SELECT CONSTRAINT_SCHEMA, TABLE_NAME "
-                        "FROM information_schema.REFERENTIAL_CONSTRAINTS WHERE UNIQUE_CONSTRAINT_SCHEMA=:schema "
-                        "AND REFERENCED_TABLE_NAME=:table AND (DELETE_RULE IN ('CASCADE','SET NULL') "
-                        "OR UPDATE_RULE IN ('CASCADE','SET NULL'))"
-                    ),
-                    {"schema": schema, "table": table},
-                ).all()
-                if any((s, n) not in writable for s, n in affected):
-                    raise SQLExecutionError(code="unscoped_cascade_denied")
 
 
 class MSSQLCatalog(HostedCatalog):
@@ -492,15 +481,3 @@ class MSSQLCatalog(HostedCatalog):
                     {"uid": row.object_id},
                 ).scalar():
                     raise SQLExecutionError(code="triggered_sql_write_unsupported")
-                affected = connection.execute(
-                    sa.text(
-                        "SELECT s.name, t.name FROM sys.foreign_keys f "
-                        "JOIN sys.tables t ON t.object_id=f.parent_object_id JOIN sys.schemas s ON s.schema_id=t.schema_id "
-                        "WHERE f.referenced_object_id=:uid AND (f.delete_referential_action>0 OR f.update_referential_action>0)"
-                    ),
-                    {"uid": row.object_id},
-                ).all()
-                if any(
-                    (s, n) not in writable and ("public", n) not in writable for s, n in affected
-                ):
-                    raise SQLExecutionError(code="unscoped_cascade_denied")

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/src/metatables/api/backend/backends/hosted_access.py

@@ -57,13 +57,11 @@ class HostedAccess(DatabaseAccess):
             self.backend.tables.relations.validate_runtime_view(connection, schema, table.physical_table_name)
             return False
         # Existing adapter inspection runs once here, never during caller SQL.
-        # Cascade targets are in scope: plan() narrows write to callers who can write them.
-        relation = (schema, table.physical_table_name)
         try:
             self.backend.catalog.validate_relations(
                 connection,
-                {relation},
-                {relation} | {target[:2] for target in self.cascade_targets(connection, table)},
+                {(schema, table.physical_table_name)},
+                {(schema, table.physical_table_name)},
             )
         except SQLExecutionError as exc:
             if exc.code == "triggered_sql_write_unsupported":

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/src/metatables/api/backend/backends/sqlite_access.py

@@ -75,10 +75,6 @@ class SQLiteAccess(DatabaseAccess):
                     )
         return targets
 
-    def relation_key(self, schema, table):
-        # One database; the authorizer matches table names only.
-        return table
-
     def apply(self, session, desired, previous):
         # The immutable grant snapshot is installed on each dedicated connection.
         return None

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/src/metatables/api/backend/migrations/versions/0010_cascade_targets.py

@@ -1,4 +1,4 @@
-"""Record cascade targets so write grants follow foreign-key actions (ADR 0007)."""
+"""Record each table's cascade targets for the impact pre-flight (ADR 0016)."""
 
 import sqlalchemy as sa
 from alembic import op

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/src/metatables/api/backend/persistence/impact.py

@@ -13,7 +13,6 @@ from uuid import UUID
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
-from metatables.api.backend.backends.access import restrict_cascading_writes
 from metatables.api.backend.domain.catalog_rules import CatalogInvariantError
 from metatables.api.backend.domain.permission_rules import TrustedActorFacts
 from metatables.api.backend.persistence.grants import GrantRepository
@@ -178,29 +177,13 @@ class _Graph:
                 .where(MetaTable.data_source_uid == root.data_source_uid)
             )
         }
-        self.database_writable = self._database_writable()
-
-    def _database_writable(self):
-        """The caller's write after cascade narrowing; same rule as plan() (ADR 0007)."""
-        uids = {policy.table_uid for policy in self.policies.values()}
-        editable = self.planner._uids(uids, edit=True)
-        privileges = {
-            ("caller", key, None, True)
-            for key, policy in self.policies.items()
+        # A table's write is its own grant; foreign keys that reference it never change it.
+        editable = self.planner._uids({policy.table_uid for policy in self.policies.values()}, edit=True)
+        self.writable = {
+            policy.table_uid
+            for policy in self.policies.values()
             if self.read_write and policy.writable and policy.table_uid in editable
         }
-        cascades = {
-            key: {self.key(t["schema"], t["table"]) for t in policy.cascade_targets or ()}
-            for key, policy in self.policies.items()
-        }
-        kept = restrict_cascading_writes(
-            {"caller": {"login": "caller"}},
-            [],
-            privileges,
-            cascades,
-            key=lambda key, _: key,
-        )
-        return {self.policies[key].table_uid for _, key, _, allowed in kept if allowed}
 
     def load(self, uids) -> None:
         missing = set(uids) - set(self.tables)
@@ -238,7 +221,7 @@ class _Graph:
             "physical_schema": table.physical_schema,
             "physical_table_name": table.physical_table_name,
             "effects": [],
-            "can_write": table.uid in self.database_writable,
+            "can_write": table.uid in self.writable,
         }
 
     def relation(self, schema: str, table: str, effect: str) -> str:
@@ -310,16 +293,10 @@ class _Graph:
                     continue
                 child_key = self.key(target["schema"], target["table"])
                 row_effect = "delete" if effect == "cascade_delete" else "update"
+                # The referencing table's own foreign key authorizes these effects.
                 child = self.policies.get(child_key)
                 if child is None:
                     child_id = self.relation(target["schema"], target["table"], row_effect)
-                    self.blockers.append(
-                        Blocker(
-                            "cascade_target_unregistered",
-                            "A foreign-key action modifies a table MetaTables does not manage.",
-                            child_id,
-                        )
-                    )
                 else:
                     affected.add(child.table_uid)
                     child_id = self.table(child.table_uid, row_effect)
@@ -346,27 +323,13 @@ class _Graph:
                 edge = self._edge(key.source_table_uid, key.target_table_uid, "foreign_key", "restrict")
                 edge.update(name=key.name, on_delete=key.on_delete)
                 self.edges.append(edge)
-        editable = self.planner._uids(affected, edit=True)
-        for uid in sorted(affected, key=str):
-            node_id = self.table(uid)
-            policy = policies.get(uid)
-            if uid not in editable:
-                code, message = "table_not_writable", "You cannot write an affected table."
-            elif policy is None or not policy.writable:
-                code, message = "writes_unsupported", "An affected table does not accept writes."
-            elif uid not in self.database_writable and uid != self.root.uid:
-                code, message = "cascade_target_not_writable", "A cascade reaches a table you cannot write."
-            else:
-                continue
-            self.blockers.append(Blocker(code, message, node_id))
-        if self.root.uid not in self.database_writable and not self.blockers:
-            # Write is all-or-nothing: another action of this table's keys may reach further.
+        if not self.planner._uids({self.root.uid}, edit=True):
             self.blockers.append(
-                Blocker(
-                    "cascade_target_not_writable",
-                    "Another foreign-key action on this table reaches a table you cannot write.",
-                    root_id,
-                )
+                Blocker("table_not_writable", "You cannot write this table.", root_id)
+            )
+        elif root_policy is None or not root_policy.writable:
+            self.blockers.append(
+                Blocker("writes_unsupported", "This table does not accept writes.", root_id)
             )
 
     def readers(self) -> None:

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/src/metatables/api/backend/persistence/models.py

@@ -105,7 +105,7 @@ class SQLTablePolicy(Base):
     table_name: Mapped[str] = mapped_column(String(255), nullable=False)
     writable: Mapped[bool] = mapped_column(Boolean, nullable=False)
     # {schema, table, on_delete, on_update} per foreign key whose actions modify
-    # another table; see restrict_cascading_writes and the impact pre-flight.
+    # another table; read by the impact pre-flight (ADR 0016).
     cascade_targets: Mapped[list | None] = mapped_column(JSON, default=list)
 
 

{mainsequence_metatable-0.1.17.dev29 → mainsequence_metatable-0.1.18.dev30}/src/metatables/models.py

@@ -1138,7 +1138,7 @@ class MetaTableImpactNode(BasePydanticModel):
     )
     can_write: bool | None = Field(
         default=None,
-        description="The caller's effective write, after cascade narrowing; None for updates.",
+        description="Whether the caller may write this table; None for updates.",
     )