jpmschweitzer/core-api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 5 Wiki Activity

feat(scribe): archive, trash and look up a mailbox entry by message number (T-13/T-9)

Browse Source 
The user wants a way to get rid of a message that is no longer useful. A
message is stored once and shared by every recipient; `history` is how
agents rebuild context (D-66), so deleting the message itself would take
it from every other reader. Deletion is therefore per mailbox entry
(D-70): `archive` (kept, out of the default view) and `trash` (out of the
mailbox, restorable). True erasure of content stays `redact` — not this
round.

Migration 009 (down_revision="008") adds
scribe_mailbox_entries.archived_at and trashed_at — independent nullable
timestamps, mirroring book_records.archived_at/trashed_at (migration
005). No data step: every existing entry is neither.

PATCH /scribe/mailbox/{entry_id} takes `archived` and `trashed` booleans
beside `read` (true sets the timestamp if not already set, false clears
it); the response carries both. GET /scribe/mailbox takes `view`: `inbox`
(default, neither archived nor trashed), `archive` (archived and not
trashed), `trash` (trashed, regardless of archived_at — trashing hides an
entry from the archive view too), `all` (no filter on either column).
`find` now excludes trashed entries (archived ones still match).

T-9: GET /scribe/mailbox?message_id=N is a direct lookup, not a filtered
list — the unique constraint on (address, message_id) guarantees zero or
one, in any view, ignoring unread/tag/before_id entirely. That is the
point: a client that already knows the message number never pages the
unread-first/id-descending listing to find it.

Judgement call: the listing's own cursor (`before_id`, a single `id`
comparison) still does not match its two-key sort (unread-first, then id
descending) — the pre-existing gap the dossier flagged as optional to
fix. Left unchanged: T-9's message_id lookup is the actual answer to "a
client pages to find one," and reworking the general cursor is a larger,
separate concern (which field(s) a keyset cursor needs) that risks the
already-passing test_mailbox_lists_unread_first for no requirement this
round asked for.

Judgement call: archived_at and trashed_at are independent timestamps,
never cross-clearing each other. Trashing an already-archived entry does
not clear archived_at, so restoring it (trashed=false) returns it to the
archive view, not the inbox — the view filter's own trash-takes-priority
rule is what keeps it out of view=archive while trashed, not a write-time
side effect.

Tests: 12 new (6 archive/trash flow + 4 message_id lookup + 2 migration
round-trip). Full suite 554 -> 566 passed.

Mutation checks (Edit, reverted after each):
- view=inbox dropped its trashed_at filter ->
  test_trash_hides_from_inbox_archive_and_find_shows_in_trash failed
  (assert 1 == 0).
- message_id lookup dropped the caller-address filter ->
  test_message_id_answers_nothing_for_a_message_not_in_their_mailbox
  failed (assert 1 == 0).
- trash updated every mailbox entry for the message instead of the
  caller's own row ->
  test_trashing_one_recipients_entry_leaves_the_others_untouched failed
  (assert 0 == 1).
All three reverted; full suite re-verified green (566 passed).

Migration 008 -> 009 -> 008 -> 009 round-tripped against core_api_test,
both manually (alembic CLI) and in
TestMigration009RoundTrip. Production stays at 008 — every alembic
invocation derived POSTGRES_* from TEST_DATABASE_URL.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
jpmschweitzer
2026-10-19 22:54:35 +02:00
co-authored by Claude Sonnet 5
parent 0bba3baf32
commit 7c67a4a46b
7 changed files with 501 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_scribe.py
+297
View File
@@ -618,3 +618,300 @@ class TestTenantRegistryEnforcement:
"/scribe/addresses", headers=office_headers("jeroen", "office-claude", tenant=TENANT)
)
assert response.status_code == 200
# =============================================================================
# Archive and trash a mailbox entry (core-api T-13 / D-66, D-70): deletion
# is per mailbox entry, never per message — the message stays in `history`
# and another recipient's entry is untouched throughout.
# =============================================================================
def _send_and_get_entry_id(client, body: str, to: str = "tower-control") -> tuple:
"""Register the usual pair if needed by the caller, send one message,
and return (message, entry_id) for the recipient's own mailbox entry."""
sent = client.post(
"/scribe/messages",
json={"to": [to], "body": body},
headers=office_headers("jeroen", "office-claude"),
).json()
entry_id = client.get(
"/scribe/mailbox", headers=office_headers("tower-control", "office-gemini")
).json()["entries"][0]["id"]
return sent, entry_id
class TestArchiveAndTrash:
def test_archive_hides_from_inbox_and_shows_in_archive_view(self, client):
register(client, "jeroen", "office-claude")
register(client, "tower-control", "office-gemini")
_, entry_id = _send_and_get_entry_id(client, "archive me")
archived = client.patch(
f"/scribe/mailbox/{entry_id}",
json={"archived": True},
headers=office_headers("tower-control", "office-gemini"),
)
assert archived.status_code == 200
assert archived.json()["archived_at"] is not None
assert archived.json()["trashed_at"] is None
inbox = client.get(
"/scribe/mailbox", headers=office_headers("tower-control", "office-gemini")
).json()
assert inbox["total"] == 0
archive_view = client.get(
"/scribe/mailbox",
params={"view": "archive"},
headers=office_headers("tower-control", "office-gemini"),
).json()
assert archive_view["total"] == 1
assert archive_view["entries"][0]["id"] == entry_id
def test_unarchive_brings_it_back_to_inbox(self, client):
register(client, "jeroen", "office-claude")
register(client, "tower-control", "office-gemini")
_, entry_id = _send_and_get_entry_id(client, "archive then unarchive")
client.patch(
f"/scribe/mailbox/{entry_id}",
json={"archived": True},
headers=office_headers("tower-control", "office-gemini"),
)
unarchived = client.patch(
f"/scribe/mailbox/{entry_id}",
json={"archived": False},
headers=office_headers("tower-control", "office-gemini"),
)
assert unarchived.json()["archived_at"] is None
inbox = client.get(
"/scribe/mailbox", headers=office_headers("tower-control", "office-gemini")
).json()
assert inbox["total"] == 1
assert inbox["entries"][0]["id"] == entry_id
def test_trash_hides_from_inbox_archive_and_find_shows_in_trash(self, client):
register(client, "jeroen", "office-claude")
register(client, "tower-control", "office-gemini")
_, entry_id = _send_and_get_entry_id(client, "trash-findable-term")
trashed = client.patch(
f"/scribe/mailbox/{entry_id}",
json={"trashed": True},
headers=office_headers("tower-control", "office-gemini"),
)
assert trashed.status_code == 200
assert trashed.json()["trashed_at"] is not None
inbox = client.get(
"/scribe/mailbox", headers=office_headers("tower-control", "office-gemini")
).json()
assert inbox["total"] == 0
archive_view = client.get(
"/scribe/mailbox",
params={"view": "archive"},
headers=office_headers("tower-control", "office-gemini"),
).json()
assert archive_view["total"] == 0
found = client.get(
"/scribe/messages",
params={"q": "trash-findable-term"},
headers=office_headers("tower-control", "office-gemini"),
).json()
assert found["total"] == 0
trash_view = client.get(
"/scribe/mailbox",
params={"view": "trash"},
headers=office_headers("tower-control", "office-gemini"),
).json()
assert trash_view["total"] == 1
assert trash_view["entries"][0]["id"] == entry_id
def test_restore_brings_it_back_to_inbox(self, client):
register(client, "jeroen", "office-claude")
register(client, "tower-control", "office-gemini")
_, entry_id = _send_and_get_entry_id(client, "trash then restore")
client.patch(
f"/scribe/mailbox/{entry_id}",
json={"trashed": True},
headers=office_headers("tower-control", "office-gemini"),
)
restored = client.patch(
f"/scribe/mailbox/{entry_id}",
json={"trashed": False},
headers=office_headers("tower-control", "office-gemini"),
)
assert restored.json()["trashed_at"] is None
inbox = client.get(
"/scribe/mailbox", headers=office_headers("tower-control", "office-gemini")
).json()
assert inbox["total"] == 1
assert inbox["entries"][0]["id"] == entry_id
def test_message_stays_in_history_throughout_archive_and_trash(self, client):
register(client, "jeroen", "office-claude")
register(client, "tower-control", "office-gemini")
message, entry_id = _send_and_get_entry_id(client, "history survives")
for payload in ({"archived": True}, {"trashed": True}):
client.patch(
f"/scribe/mailbox/{entry_id}",
json=payload,
headers=office_headers("tower-control", "office-gemini"),
)
history = client.get(
"/scribe/addresses/tower-control/history",
headers=office_headers("tower-control", "office-gemini"),
).json()
assert [m["id"] for m in history["messages"]] == [message["id"]]
def test_trashing_one_recipients_entry_leaves_the_others_untouched(self, client):
register(client, "jeroen", "office-claude")
register(client, "tower-control", "office-gemini")
register(client, "jeroen-2", "office-claude")
client.post(
"/scribe/messages",
json={"to": ["tower-control", "jeroen-2"], "body": "broadcast"},
headers=office_headers("jeroen", "office-claude"),
)
tower_entry_id = client.get(
"/scribe/mailbox", headers=office_headers("tower-control", "office-gemini")
).json()["entries"][0]["id"]
client.patch(
f"/scribe/mailbox/{tower_entry_id}",
json={"trashed": True},
headers=office_headers("tower-control", "office-gemini"),
)
other_inbox = client.get(
"/scribe/mailbox", headers=office_headers("jeroen-2", "office-claude")
).json()
assert other_inbox["total"] == 1
assert other_inbox["entries"][0]["trashed_at"] is None
# =============================================================================
# Look an entry up by message number (core-api T-9): zero or one, in any
# view, no paging required.
# =============================================================================
class TestMailboxMessageIdLookup:
def test_message_id_finds_the_entry_in_any_view(self, client):
register(client, "jeroen", "office-claude")
register(client, "tower-control", "office-gemini")
message, entry_id = _send_and_get_entry_id(client, "locate me")
client.patch(
f"/scribe/mailbox/{entry_id}",
json={"trashed": True},
headers=office_headers("tower-control", "office-gemini"),
)
found = client.get(
"/scribe/mailbox",
params={"message_id": message["id"]},
headers=office_headers("tower-control", "office-gemini"),
).json()
assert found["total"] == 1
assert found["entries"][0]["id"] == entry_id
assert found["entries"][0]["trashed_at"] is not None
def test_message_id_answers_nothing_for_a_message_not_in_their_mailbox(self, client):
register(client, "jeroen", "office-claude")
register(client, "tower-control", "office-gemini")
sent = client.post(
"/scribe/messages",
json={"to": ["tower-control"], "body": "not jeroen's"},
headers=office_headers("jeroen", "office-claude"),
).json()
found = client.get(
"/scribe/mailbox",
params={"message_id": sent["id"]},
headers=office_headers("jeroen", "office-claude"),
).json()
assert found["total"] == 0
assert found["entries"] == []
def test_message_id_answers_nothing_across_tenants(self, client):
register(client, "jeroen", "office-claude", tenant=TENANT)
register(client, "tower-control", "office-gemini", tenant=TENANT)
sent = client.post(
"/scribe/messages",
json={"to": ["tower-control"], "body": "tenant-scoped"},
headers=office_headers("jeroen", "office-claude", tenant=TENANT),
).json()
register(client, "tower-control", "office-gemini", tenant=OTHER_TENANT)
found = client.get(
"/scribe/mailbox",
params={"message_id": sent["id"]},
headers=office_headers("tower-control", "office-gemini", OTHER_TENANT),
).json()
assert found["total"] == 0
def test_message_id_finds_a_read_entry_past_the_first_page_in_one_call(self, client):
"""dossier verification #4: today's listing sorts unread-first,
then by id descending, behind a single before_id cursor. Seed one
old entry that stays unread (so it sorts first regardless of its
low id) ahead of 51 read ones (one more than the default page size
of 50) — the oldest read entry (lowest id among them) sorts last,
past the first page. `message_id` answers it in one call, with no
`before_id` paging."""
register(client, "jeroen", "office-claude")
register(client, "tower-control", "office-gemini")
old_unread = client.post(
"/scribe/messages",
json={"to": ["tower-control"], "body": "old and unread"},
headers=office_headers("jeroen", "office-claude"),
).json()
read_message_ids = []
for i in range(51):
sent = client.post(
"/scribe/messages",
json={"to": ["tower-control"], "body": f"read {i}"},
headers=office_headers("jeroen", "office-claude"),
).json()
read_message_ids.append(sent["id"])
all_entries = client.get(
"/scribe/mailbox",
params={"view": "all", "limit": 200},
headers=office_headers("tower-control", "office-gemini"),
).json()["entries"]
for entry in all_entries:
if entry["message"]["id"] != old_unread["id"]:
client.patch(
f"/scribe/mailbox/{entry['id']}",
json={"read": True},
headers=office_headers("tower-control", "office-gemini"),
)
# The oldest (lowest-id) read message: last among the reads when
# sorted id-descending, so page 1 (the default limit of 50) never
# reaches it — plain listing would need a second before_id call.
target_message_id = read_message_ids[0]
page_one = client.get(
"/scribe/mailbox", headers=office_headers("tower-control", "office-gemini")
).json()
assert target_message_id not in {e["message"]["id"] for e in page_one["entries"]}
found = client.get(
"/scribe/mailbox",
params={"message_id": target_message_id},
headers=office_headers("tower-control", "office-gemini"),
).json()
assert found["total"] == 1
assert found["entries"][0]["message"]["id"] == target_message_id
tests/test_scribe_migration.py
+51 -1
View File
@@ -1,5 +1,5 @@
"""
Tests for Scribe migration 006.
Tests for Scribe migrations 006 and 009.
Runs against `core_api_test` only (see conftest.py — skip when
TEST_DATABASE_URL is unset, hard failure if it resolves to `core_api`).
@@ -27,6 +27,23 @@ async def _table_exists(url: str, table: str) -> bool:
await engine.dispose()
async def _columns(url: str, table: str) -> set:
asyncpg_url = url.replace("postgresql://", "postgresql+asyncpg://", 1)
engine = create_async_engine(asyncpg_url, poolclass=NullPool)
try:
async with engine.connect() as conn:
result = await conn.execute(
text(
"SELECT column_name FROM information_schema.columns "
"WHERE table_name = :table"
),
{"table": table},
)
return {row[0] for row in result.all()}
finally:
await engine.dispose()
class TestMigration006RoundTrip:
"""Migration 006 must upgrade and downgrade cleanly (dossier verification #1)."""
@@ -58,3 +75,36 @@ class TestMigration006RoundTrip:
assert await _table_exists(test_database_url, "scribe_addresses")
assert await _table_exists(test_database_url, "scribe_messages")
assert await _table_exists(test_database_url, "scribe_mailbox_entries")
class TestMigration009RoundTrip:
"""Migration 009 (core-api T-13) must upgrade and downgrade cleanly —
dossier verification #2: 008 -> 009 -> 008 -> 009."""
@pytest.mark.asyncio
async def test_upgrade_adds_archived_and_trashed_at(self, test_database_url):
result = run_alembic(test_database_url, "upgrade", "head")
assert result.returncode == 0, result.stderr
columns = await _columns(test_database_url, "scribe_mailbox_entries")
assert {"archived_at", "trashed_at"} <= columns
@pytest.mark.asyncio
async def test_downgrade_then_upgrade_round_trips_cleanly(self, test_database_url):
baseline = run_alembic(test_database_url, "upgrade", "head")
assert baseline.returncode == 0, baseline.stderr
down = run_alembic(test_database_url, "downgrade", "008")
assert down.returncode == 0, down.stderr
columns_at_008 = await _columns(test_database_url, "scribe_mailbox_entries")
assert "archived_at" not in columns_at_008
assert "trashed_at" not in columns_at_008
# The table itself, created by 006, must survive a downgrade of
# 009 — proves 009 only adds/drops its own two columns.
assert await _table_exists(test_database_url, "scribe_mailbox_entries")
# Leave the schema at head (009 is head) for the rest of the suite.
up = run_alembic(test_database_url, "upgrade", "head")
assert up.returncode == 0, up.stderr
columns_at_head = await _columns(test_database_url, "scribe_mailbox_entries")
assert {"archived_at", "trashed_at"} <= columns_at_head