Schema version 8: store the key setup, drop the fixed device column (section 23.2)

This commit is contained in:
ai-bot committed 2026-10-03 14:36:19 +00:00
1 parent 042044cf61
commit 69efe35d5d
1 file changed
+66 -32
+66 -32
View File
@@ -4,12 +4,9 @@ from pathlib import Path
import sqlite3 import sqlite3
SCHEMA_VERSION = 7 SCHEMA_VERSION = 8
FIXED_KEYS = ( # The app always supports exactly three key slots (section 23.2).
(1, "SeedSigner", "hardware", "SeedSigner"), KEY_COUNT = 3
(2, "Blockstream Jade", "hardware", "Blockstream Jade"),
(3, "Nunchuk", "cloud", "Nunchuk"),
)
# Table definitions use a {table} placeholder, so a migration can create the same # Table definitions use a {table} placeholder, so a migration can create the same
# table under a temporary name while it rebuilds it. # table under a temporary name while it rebuilds it.
KEYS_TABLE = """ KEYS_TABLE = """
@@ -18,7 +15,6 @@ KEYS_TABLE = """
key_number INTEGER NOT NULL UNIQUE CHECK (key_number BETWEEN 1 AND 3), key_number INTEGER NOT NULL UNIQUE CHECK (key_number BETWEEN 1 AND 3),
name TEXT NOT NULL, name TEXT NOT NULL,
type TEXT NOT NULL CHECK (type IN ('hardware', 'cloud')), type TEXT NOT NULL CHECK (type IN ('hardware', 'cloud')),
device TEXT NOT NULL CHECK (device IN ('SeedSigner', 'Blockstream Jade', 'Nunchuk')),
created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
) )
""" """
@@ -157,6 +153,7 @@ def initialize_database(database_path="data/helsesjekk.sqlite3"):
_create_table(connection, table, statement) _create_table(connection, table, statement)
for table, column, definition in OPTIONAL_COLUMNS: for table, column, definition in OPTIONAL_COLUMNS:
_ensure_column(connection, table, column, definition) _ensure_column(connection, table, column, definition)
_migrate_keys(connection)
_migrate_key_checks(connection) _migrate_key_checks(connection)
_migrate_ai_security_checks(connection) _migrate_ai_security_checks(connection)
_migrate_status_values(connection) _migrate_status_values(connection)
@@ -291,6 +288,26 @@ def _verify_foreign_keys(connection):
) )
def _migrate_keys(connection):
"""Rebuild keys when it still carries the removed device column.
The configured name is the product label everywhere, so the fixed device
value is gone (section 23.2). SQLite cannot drop a column from a table with
a CHECK constraint, so the table is rebuilt once.
"""
columns = _table_columns(connection, "keys")
if not columns or "device" not in columns:
return
temporary = _create_replacement(connection, "keys", KEYS_TABLE)
connection.execute(f"""
INSERT INTO {temporary} (id, key_number, name, type, created_at)
SELECT id, key_number, name, type, created_at
FROM keys
""")
_replace_table(connection, "keys", temporary)
def _migrate_key_checks(connection): def _migrate_key_checks(connection):
"""Rebuild key_checks when it still uses the pre-section-19 layout. """Rebuild key_checks when it still uses the pre-section-19 layout.
@@ -462,39 +479,56 @@ def _rebuild_tool_checks(connection):
_replace_table(connection, "tool_checks", temporary) _replace_table(connection, "tool_checks", temporary)
def seed_fixed_keys(database_path="data/helsesjekk.sqlite3"):
"""Ensure the three fixed key profiles exist without overwriting custom names."""
connection = sqlite3.connect(database_path, timeout=5)
try:
with connection:
for key_number, name, key_type, device in FIXED_KEYS:
connection.execute(
"""
INSERT INTO keys (key_number, name, type, device)
VALUES (?, ?, ?, ?)
ON CONFLICT(key_number) DO UPDATE SET
type = excluded.type,
device = excluded.device
""",
(key_number, name, key_type, device),
)
finally:
connection.close()
def list_keys(database_path="data/helsesjekk.sqlite3"): def list_keys(database_path="data/helsesjekk.sqlite3"):
"""Return the configured key profiles in display order.""" """Return the stored key profiles in key order.
An empty list means a new database, which the app answers with the first-run
setup step. A database that holds only part of the setup raises an error, so
an unreadable database is never treated as a new installation
(section 23.2).
"""
connection = sqlite3.connect(database_path, timeout=5) connection = sqlite3.connect(database_path, timeout=5)
connection.row_factory = sqlite3.Row connection.row_factory = sqlite3.Row
try: try:
rows = connection.execute( rows = connection.execute(
""" """
SELECT id, key_number, name, type, device, created_at SELECT id, key_number, name, type, created_at
FROM keys FROM keys
ORDER BY key_number ORDER BY key_number
""" """
).fetchall() ).fetchall()
return [dict(row) for row in rows] finally:
connection.close()
keys = [dict(row) for row in rows]
if keys and len(keys) != KEY_COUNT:
raise RuntimeError(
f"The stored key setup has {len(keys)} of {KEY_COUNT} keys"
)
return keys
def save_key_setup(entries, database_path="data/helsesjekk.sqlite3"):
"""Store the key setup for the three key slots.
The setup is written once, because the names and the types are locked after
they are saved (section 23.2). A database that already holds a setup is left
untouched.
"""
if list_keys(database_path):
raise RuntimeError("The key setup is already stored")
connection = sqlite3.connect(database_path, timeout=5)
connection.execute("PRAGMA foreign_keys = ON")
try:
with connection:
connection.executemany(
"INSERT INTO keys (key_number, name, type) VALUES (?, ?, ?)",
[
(entry["key_number"], entry["name"], entry["type"])
for entry in entries
],
)
finally: finally:
connection.close() connection.close()
@@ -630,7 +664,7 @@ def list_key_status(database_path="data/helsesjekk.sqlite3"):
try: try:
rows = connection.execute( rows = connection.execute(
f""" f"""
SELECT k.id AS key_id, k.key_number, k.name, k.type, k.device, SELECT k.id AS key_id, k.key_number, k.name, k.type,
({_LATEST_CHECK_QUERY.format(expression="hc.checked_at")}) AS last_checked_at, ({_LATEST_CHECK_QUERY.format(expression="hc.checked_at")}) AS last_checked_at,
({_LATEST_CHECK_QUERY.format(expression="hc.next_check_due")}) AS next_check_due ({_LATEST_CHECK_QUERY.format(expression="hc.next_check_due")}) AS next_check_due
FROM keys AS k FROM keys AS k
@@ -757,7 +791,7 @@ def get_health_check(health_check_id, database_path="data/helsesjekk.sqlite3"):
dict(row) dict(row)
for row in connection.execute( for row in connection.execute(
""" """
SELECT kc.id, kc.key_id, k.key_number, k.name, k.type, k.device, SELECT kc.id, kc.key_id, k.key_number, k.name, k.type,
kc.available, kc.hardware_works, kc.firmware_version, kc.available, kc.hardware_works, kc.firmware_version,
kc.seed_backup_verified, kc.cloud_health_status, kc.seed_backup_verified, kc.cloud_health_status,
kc.cloud_provider_operational, kc.address_path_verified, kc.cloud_provider_operational, kc.address_path_verified,