velocity-python 0.1.102__tar.gz → 0.1.103__tar.gz

{velocity_python-0.1.102 → velocity_python-0.1.103}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.102
+Version: 0.1.103
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.102 → velocity_python-0.1.103}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.1.102"
+version = "0.1.103"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.1.102 → velocity_python-0.1.103}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.102"
+__version__ = version = "0.1.103"
 
 import importlib as _importlib
 

{velocity_python-0.1.102 → velocity_python-0.1.103}/src/velocity/aws/handlers/mixins/data_service.py

@@ -65,12 +65,59 @@ def _bump_sys_id_sequence(tx, table):
     )
 
 
+def _sys_id_fk_references(tx, table):
+    """Foreign keys pointing AT this table's sys_id, as
+    (referencing_table, referencing_column) pairs. A multi-column FK yields
+    referencing_column None (callers treat it conservatively)."""
+    return tx.execute(
+        """select con.conrelid::regclass::text as referencing_table,
+                  case when array_length(con.conkey, 1) = 1
+                       then (select att.attname from pg_attribute att
+                              where att.attrelid = con.conrelid
+                                and att.attnum = con.conkey[1])
+                  end as referencing_column
+           from pg_constraint con
+           join pg_class rel on rel.oid = con.confrelid
+           join pg_namespace nsp on nsp.oid = rel.relnamespace
+           where con.contype = 'f' and nsp.nspname = 'public'
+             and rel.relname = %s
+             and (select att.attname from pg_attribute att
+                   where att.attrelid = con.confrelid
+                     and att.attnum = con.confkey[1]) = 'sys_id'""",
+        (table,),
+    ).all()
+
+
+def _count_fk_rows(tx, references, sys_id):
+    """Rows that actually reference ``sys_id`` through the given FK pairs.
+    Returns human-readable "table (n row(s))" descriptions, or raises for an
+    FK shape too odd to check safely (multi-column, unquotable names)."""
+    blocked = []
+    for ref in references:
+        ref_table = ref.get("referencing_table") or ""
+        ref_column = ref.get("referencing_column") or ""
+        if not (_IDENTIFIER_RE.match(ref_table) and _IDENTIFIER_RE.match(ref_column)):
+            raise AlertError(
+                f"Renumbering is not allowed: {ref_table or 'a table'} references "
+                f"this table through a foreign key this tool cannot inspect."
+            )
+        count = tx.execute(
+            f'select count(*) as n from "{ref_table}" where "{ref_column}" = %s',
+            (sys_id,),
+        ).scalar()
+        if count:
+            blocked.append(f"{ref_table} ({count} row(s))")
+    return blocked
+
+
 def renumber_row(tx, table, old_sys_id, new_sys_id, overwrite=False):
     """Assign a CHOSEN sys_id to an existing row (admin surgery).
 
     Rules (deliberately simple):
-    - refused when any real foreign-key constraint references this table's
-      sys_id (renumbering under FKs is a cascade problem for another day);
+    - a foreign-key CONSTRAINT on this table's sys_id is fine; what refuses
+      the change is actual referencing ROWS — rows pointing at the old id
+      (reassigning references is not implemented), or, on overwrite, rows
+      pointing at the occupant that would be deleted;
     - when the target sys_id already exists: refused unless ``overwrite`` —
       which DELETES the occupying row first;
     - the table's sys_id sequence is bumped past MAX(sys_id) afterwards so
@@ -95,27 +142,24 @@ def renumber_row(tx, table, old_sys_id, new_sys_id, overwrite=False):
     if not tx.table(table).find(old_id):
         raise AlertError(f"Record {old_id} was not found in {table}.")
 
-    referencing = tx.execute(
-        """select con.conrelid::regclass::text as referencing_table
-           from pg_constraint con
-           join pg_class rel on rel.oid = con.confrelid
-           join pg_namespace nsp on nsp.oid = rel.relnamespace
-           where con.contype = 'f' and nsp.nspname = 'public'
-             and rel.relname = %s
-           limit 5""",
-        (table,),
-    ).all()
-    if referencing:
-        tables = ", ".join(sorted({r["referencing_table"] for r in referencing}))
+    references = _sys_id_fk_references(tx, table)
+    blocked = _count_fk_rows(tx, references, old_id)
+    if blocked:
         raise AlertError(
-            f"Renumbering is not allowed: {tables} reference(s) {table} "
-            "through a foreign key. (Denied for now — reassigning "
-            "references is not implemented.)"
+            f"Renumbering is not allowed: {', '.join(sorted(blocked))} still "
+            f"reference {table} {old_id}. (Reassigning references is not "
+            "implemented — repoint or remove those rows first.)"
         )
 
     if tx.table(table).find(new_id):
         if not overwrite:
             return "exists"
+        occupied = _count_fk_rows(tx, references, new_id)
+        if occupied:
+            raise AlertError(
+                f"Cannot overwrite {table} {new_id}: {', '.join(sorted(occupied))} "
+                "still reference it."
+            )
         tx.execute(f'DELETE FROM "{table}" WHERE sys_id = %s', (new_id,))
 
     tx.execute(

{velocity_python-0.1.102 → velocity_python-0.1.103}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.102
+Version: 0.1.103
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.102 → velocity_python-0.1.103}/tests/test_data_service_renumber.py

@@ -1,5 +1,6 @@
-"""renumber_row: chosen-sys_id assignment with FK denial, occupied-target
-confirmation, overwrite semantics, and the sequence bump."""
+"""renumber_row: chosen-sys_id assignment with row-level FK checking (a
+constraint alone no longer denies — actual referencing ROWS do), occupied-
+target confirmation, overwrite semantics, and the sequence bump."""
 
 import pytest
 from unittest.mock import MagicMock
@@ -9,9 +10,13 @@ from velocity.aws.handlers.mixins.data_service import renumber_row
 
 
 class FakeTx:
-    def __init__(self, existing_ids=(5,), fk_tables=()):
+    def __init__(self, existing_ids=(5,), fk=(), refs=None):
+        """``fk``: (referencing_table, referencing_column) pairs — the FK
+        constraints on this table's sys_id. ``refs``: {(table, column):
+        {sys_id: row_count}} — the rows actually referencing each id."""
         self.existing = set(existing_ids)
-        self.fk_tables = list(fk_tables)
+        self.fk = list(fk)
+        self.refs = refs or {}
         self.executed = []
         outer = self
 
@@ -29,8 +34,15 @@ class FakeTx:
         result = MagicMock()
         if "pg_constraint" in sql:
             result.all.return_value = [
-                {"referencing_table": t} for t in self.fk_tables
+                {"referencing_table": t, "referencing_column": c} for t, c in self.fk
             ]
+        elif sql.strip().lower().startswith("select count(*)"):
+            for (t, c), counts in self.refs.items():
+                if f'"{t}"' in sql and f'"{c}"' in sql:
+                    result.scalar.return_value = counts.get(params[0], 0)
+                    break
+            else:
+                result.scalar.return_value = 0
         else:
             result.all.return_value = []
         if sql.strip().upper().startswith("DELETE"):
@@ -54,6 +66,28 @@ def test_simple_renumber_updates_and_bumps_sequence():
     assert 42 in tx.existing and 5 not in tx.existing
 
 
+def test_fk_constraint_without_referencing_rows_is_allowed():
+    # Paul's studios case (2026-09-05): a legacy event.studio_id FK exists,
+    # but no event row points at this studio — the renumber must proceed.
+    tx = FakeTx(existing_ids=(5,), fk=(("event", "studio_id"),))
+    assert renumber_row(tx, "studio", 5, 42) == "renumbered"
+    assert any(s.startswith("select count(*)") for s in sqls(tx))
+    assert 42 in tx.existing
+
+
+def test_actual_referencing_rows_deny_with_counts():
+    tx = FakeTx(
+        existing_ids=(5,),
+        fk=(("event", "studio_id"),),
+        refs={("event", "studio_id"): {5: 3}},
+    )
+    with pytest.raises(AlertError) as err:
+        renumber_row(tx, "studio", 5, 42)
+    assert "event (3 row(s))" in str(err.value)
+    assert "still reference studio 5" in str(err.value)
+    assert not any(s.startswith(("DELETE", "UPDATE")) for s in sqls(tx))
+
+
 def test_occupied_target_reports_exists_without_touching_data():
     tx = FakeTx(existing_ids=(5, 42))
     assert renumber_row(tx, "studio", 5, 42) == "exists"
@@ -61,19 +95,32 @@ def test_occupied_target_reports_exists_without_touching_data():
 
 
 def test_overwrite_deletes_the_occupant_then_renumbers():
-    tx = FakeTx(existing_ids=(5, 42))
+    tx = FakeTx(existing_ids=(5, 42), fk=(("event", "studio_id"),))
     assert renumber_row(tx, "studio", 5, 42, overwrite=True) == "renumbered"
     ordered = [s.split()[0] for s in sqls(tx) if s.split()[0] in ("DELETE", "UPDATE")]
     assert ordered == ["DELETE", "UPDATE"]
     assert tx.existing == {42}
 
 
-def test_foreign_key_reference_denies_the_change():
-    tx = FakeTx(existing_ids=(5,), fk_tables=("event_link_student",))
+def test_overwrite_refused_when_the_occupant_is_referenced():
+    tx = FakeTx(
+        existing_ids=(5, 42),
+        fk=(("event", "studio_id"),),
+        refs={("event", "studio_id"): {42: 2}},
+    )
     with pytest.raises(AlertError) as err:
-        renumber_row(tx, "people", 5, 42)
-    assert "event_link_student" in str(err.value)
-    assert not any(s.startswith(("DELETE", "UPDATE")) for s in sqls(tx))
+        renumber_row(tx, "studio", 5, 42, overwrite=True)
+    assert "Cannot overwrite studio 42" in str(err.value)
+    assert "event (2 row(s))" in str(err.value)
+    assert 42 in tx.existing  # occupant untouched
+
+
+def test_uninspectable_fk_shape_stays_conservatively_denied():
+    # Multi-column FK surfaces referencing_column None — deny rather than guess.
+    tx = FakeTx(existing_ids=(5,), fk=(("event_link", None),))
+    with pytest.raises(AlertError) as err:
+        renumber_row(tx, "studio", 5, 42)
+    assert "cannot inspect" in str(err.value)
 
 
 @pytest.mark.parametrize(