Add persistent Postgres storage (dual SQLite/Postgres db.py + psycopg)

rmn-backend/README.md

@@ -78,7 +78,11 @@ Notes:
    an affiliate feed (Amazon Product Advertising API, Impact, CJ, Rakuten). Because the rest
    of the app reads from the catalog/DB, this is an isolated swap. Affiliate links here are
    also where the revenue model lives.
-6. **Deploy** — backend to Railway/Render/Fly, frontend as static hosting, DB managed Postgres.
+6. ~~**Deploy**~~ ✅ Done — live on Hugging Face Spaces (Docker) at
+   https://horoburger-rmn.hf.space. The FastAPI app serves both the API and the static
+   frontend from one service (see `/Dockerfile` and `/README.md` at the repo root). Storage
+   is ephemeral there, so the remaining production step is a managed Postgres (Neon/Supabase
+   free tier) for durable accounts/collections.
 
 ## Moving this into Claude Code
 This folder is the seed. In Claude Code, point it at this directory and ask, step by step:

rmn-backend/db.py

@@ -1,17 +1,26 @@
 """
-RMN persistence layer — SQLite, standard-library only.
+RMN persistence layer.
 
-Keeps things simple: one file (rmn.db), no ORM, no extra dependencies.
-Stores user accounts (email + salted/hashed password), login sessions
-(bearer tokens), and each user's saved products grouped into collections.
+Works with two backends, chosen at runtime:
+  * SQLite (default) — a local file (rmn.db); zero setup, used for dev.
+  * PostgreSQL — used automatically when the DATABASE_URL env var is set
+    (e.g. a free Neon/Supabase database), so accounts/collections/tracking
+    persist permanently in production.
 
-Swap SQLite for Postgres later by changing only the connection helper —
-the function signatures below are the contract the rest of the app uses.
+Same public function signatures either way — the rest of the app is unchanged.
 """
-import sqlite3, hashlib, hmac, secrets, json, os
+import hashlib, hmac, secrets, json, os
 from datetime import datetime, timezone
 
-DB_PATH = os.environ.get("RMN_DB", "rmn.db")   # override on hosts with a writable path
+DATABASE_URL = os.environ.get("DATABASE_URL")     # set this -> use Postgres
+PG = bool(DATABASE_URL)
+DB_PATH = os.environ.get("RMN_DB", "rmn.db")       # SQLite path (writable on hosts)
+
+if PG:
+    import psycopg
+    from psycopg.rows import dict_row
+else:
+    import sqlite3
 
 
 class DuplicateEmail(Exception):
@@ -19,67 +28,95 @@ class DuplicateEmail(Exception):
 
 
 def _conn():
+    if PG:
+        return psycopg.connect(DATABASE_URL, row_factory=dict_row)
     conn = sqlite3.connect(DB_PATH)
     conn.row_factory = sqlite3.Row
     conn.execute("PRAGMA foreign_keys = ON")
     return conn
 
 
+def _q(sql):
+    """SQLite uses ? placeholders; Postgres uses %s."""
+    return sql.replace("?", "%s") if PG else sql
+
+
+def _is_dupe(e):
+    return type(e).__name__ in ("IntegrityError", "UniqueViolation")
+
+
 def _now():
     return datetime.now(timezone.utc).isoformat()
 
 
 def init_db():
     with _conn() as c:
-        c.executescript("""
-        CREATE TABLE IF NOT EXISTS users(
-            id         INTEGER PRIMARY KEY AUTOINCREMENT,
-            email      TEXT UNIQUE NOT NULL,
-            pw_hash    TEXT NOT NULL,
-            created_at TEXT NOT NULL
-        );
-        CREATE TABLE IF NOT EXISTS sessions(
-            token      TEXT PRIMARY KEY,
-            user_id    INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-            created_at TEXT NOT NULL
-        );
-        CREATE TABLE IF NOT EXISTS saved_items(
-            user_id    INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-            collection TEXT NOT NULL,
-            product_id INTEGER NOT NULL,
-            created_at TEXT NOT NULL,
-            PRIMARY KEY(user_id, collection, product_id)
-        );
-        CREATE TABLE IF NOT EXISTS products(
-            id          INTEGER PRIMARY KEY,
-            name        TEXT, brand TEXT, category TEXT, subcategory TEXT, color TEXT,
-            price       REAL, prev_price REAL, on_sale INTEGER,
-            rating      REAL, reviews INTEGER, seller TEXT, in_stock INTEGER,
-            emoji       TEXT, specs TEXT, description TEXT, text TEXT
-        );
-        CREATE INDEX IF NOT EXISTS idx_products_sub ON products(subcategory);
-        CREATE TABLE IF NOT EXISTS price_history(
-            product_id INTEGER NOT NULL,
-            price      REAL NOT NULL,
-            ts         TEXT NOT NULL
-        );
-        CREATE TABLE IF NOT EXISTS price_watches(
-            user_id      INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-            product_id   INTEGER NOT NULL,
-            target_price REAL,
-            created_at   TEXT NOT NULL,
-            PRIMARY KEY(user_id, product_id)
-        );
-        CREATE TABLE IF NOT EXISTS alerts(
-            id         INTEGER PRIMARY KEY AUTOINCREMENT,
-            user_id    INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-            product_id INTEGER NOT NULL,
-            old_price  REAL NOT NULL,
-            new_price  REAL NOT NULL,
-            ts         TEXT NOT NULL,
-            seen       INTEGER NOT NULL DEFAULT 0
-        );
-        """)
+        if PG:
+            stmts = [
+                """CREATE TABLE IF NOT EXISTS users(
+                    id SERIAL PRIMARY KEY, email TEXT UNIQUE NOT NULL,
+                    pw_hash TEXT NOT NULL, created_at TEXT NOT NULL)""",
+                """CREATE TABLE IF NOT EXISTS sessions(
+                    token TEXT PRIMARY KEY,
+                    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                    created_at TEXT NOT NULL)""",
+                """CREATE TABLE IF NOT EXISTS saved_items(
+                    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                    collection TEXT NOT NULL, product_id INTEGER NOT NULL,
+                    created_at TEXT NOT NULL,
+                    PRIMARY KEY(user_id, collection, product_id))""",
+                """CREATE TABLE IF NOT EXISTS products(
+                    id INTEGER PRIMARY KEY, name TEXT, brand TEXT, category TEXT,
+                    subcategory TEXT, color TEXT, price DOUBLE PRECISION,
+                    prev_price DOUBLE PRECISION, on_sale INTEGER, rating DOUBLE PRECISION,
+                    reviews INTEGER, seller TEXT, in_stock INTEGER, emoji TEXT,
+                    specs TEXT, description TEXT, text TEXT)""",
+                """CREATE TABLE IF NOT EXISTS price_history(
+                    product_id INTEGER NOT NULL, price DOUBLE PRECISION NOT NULL, ts TEXT NOT NULL)""",
+                """CREATE TABLE IF NOT EXISTS price_watches(
+                    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                    product_id INTEGER NOT NULL, target_price DOUBLE PRECISION,
+                    created_at TEXT NOT NULL, PRIMARY KEY(user_id, product_id))""",
+                """CREATE TABLE IF NOT EXISTS alerts(
+                    id SERIAL PRIMARY KEY,
+                    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                    product_id INTEGER NOT NULL, old_price DOUBLE PRECISION NOT NULL,
+                    new_price DOUBLE PRECISION NOT NULL, ts TEXT NOT NULL,
+                    seen INTEGER NOT NULL DEFAULT 0)""",
+            ]
+            for s in stmts:
+                c.execute(s)
+        else:
+            c.executescript("""
+            CREATE TABLE IF NOT EXISTS users(
+                id INTEGER PRIMARY KEY AUTOINCREMENT, email TEXT UNIQUE NOT NULL,
+                pw_hash TEXT NOT NULL, created_at TEXT NOT NULL);
+            CREATE TABLE IF NOT EXISTS sessions(
+                token TEXT PRIMARY KEY,
+                user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                created_at TEXT NOT NULL);
+            CREATE TABLE IF NOT EXISTS saved_items(
+                user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                collection TEXT NOT NULL, product_id INTEGER NOT NULL,
+                created_at TEXT NOT NULL, PRIMARY KEY(user_id, collection, product_id));
+            CREATE TABLE IF NOT EXISTS products(
+                id INTEGER PRIMARY KEY, name TEXT, brand TEXT, category TEXT,
+                subcategory TEXT, color TEXT, price REAL, prev_price REAL, on_sale INTEGER,
+                rating REAL, reviews INTEGER, seller TEXT, in_stock INTEGER,
+                emoji TEXT, specs TEXT, description TEXT, text TEXT);
+            CREATE INDEX IF NOT EXISTS idx_products_sub ON products(subcategory);
+            CREATE TABLE IF NOT EXISTS price_history(
+                product_id INTEGER NOT NULL, price REAL NOT NULL, ts TEXT NOT NULL);
+            CREATE TABLE IF NOT EXISTS price_watches(
+                user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                product_id INTEGER NOT NULL, target_price REAL, created_at TEXT NOT NULL,
+                PRIMARY KEY(user_id, product_id));
+            CREATE TABLE IF NOT EXISTS alerts(
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                product_id INTEGER NOT NULL, old_price REAL NOT NULL, new_price REAL NOT NULL,
+                ts TEXT NOT NULL, seen INTEGER NOT NULL DEFAULT 0);
+            """)
 
 
 # ---------- passwords ----------
@@ -100,20 +137,26 @@ def _check_password(password, stored):
 
 # ---------- users & sessions ----------
 def create_user(email, password):
-    with _conn() as c:
-        try:
+    pw, now = _hash_password(password), _now()
+    try:
+        with _conn() as c:
+            if PG:
+                row = c.execute(
+                    "INSERT INTO users(email, pw_hash, created_at) VALUES(%s,%s,%s) RETURNING id",
+                    (email, pw, now)).fetchone()
+                return row["id"]
             cur = c.execute(
-                "INSERT INTO users(email, pw_hash, created_at) VALUES(?,?,?)",
-                (email, _hash_password(password), _now()),
-            )
-        except sqlite3.IntegrityError:
+                "INSERT INTO users(email, pw_hash, created_at) VALUES(?,?,?)", (email, pw, now))
+            return cur.lastrowid
+    except Exception as e:
+        if _is_dupe(e):
             raise DuplicateEmail(email)
-        return cur.lastrowid
+        raise
 
 
 def verify_user(email, password):
     with _conn() as c:
-        row = c.execute("SELECT id, pw_hash FROM users WHERE email=?", (email,)).fetchone()
+        row = c.execute(_q("SELECT id, pw_hash FROM users WHERE email=?"), (email,)).fetchone()
     if not row or not _check_password(password, row["pw_hash"]):
         return None
     return row["id"]
@@ -122,7 +165,7 @@ def verify_user(email, password):
 def create_session(user_id):
     token = secrets.token_urlsafe(32)
     with _conn() as c:
-        c.execute("INSERT INTO sessions(token, user_id, created_at) VALUES(?,?,?)",
+        c.execute(_q("INSERT INTO sessions(token, user_id, created_at) VALUES(?,?,?)"),
                   (token, user_id, _now()))
     return token
 
@@ -131,43 +174,41 @@ def user_for_token(token):
     if not token:
         return None
     with _conn() as c:
-        row = c.execute("SELECT user_id FROM sessions WHERE token=?", (token,)).fetchone()
+        row = c.execute(_q("SELECT user_id FROM sessions WHERE token=?"), (token,)).fetchone()
     return row["user_id"] if row else None
 
 
 def delete_session(token):
     with _conn() as c:
-        c.execute("DELETE FROM sessions WHERE token=?", (token,))
+        c.execute(_q("DELETE FROM sessions WHERE token=?"), (token,))
 
 
 # ---------- collections ----------
 def add_saved(user_id, collection, product_id):
     with _conn() as c:
-        c.execute(
-            "INSERT OR IGNORE INTO saved_items(user_id, collection, product_id, created_at) "
-            "VALUES(?,?,?,?)", (user_id, collection, product_id, _now()))
+        c.execute(_q("INSERT INTO saved_items(user_id, collection, product_id, created_at) "
+                     "VALUES(?,?,?,?) ON CONFLICT DO NOTHING"),
+                  (user_id, collection, product_id, _now()))
 
 
 def remove_saved(user_id, collection, product_id):
     with _conn() as c:
-        c.execute(
-            "DELETE FROM saved_items WHERE user_id=? AND collection=? AND product_id=?",
-            (user_id, collection, product_id))
+        c.execute(_q("DELETE FROM saved_items WHERE user_id=? AND collection=? AND product_id=?"),
+                  (user_id, collection, product_id))
 
 
 def get_collections(user_id):
     """Return {collection_name: [product_id, ...]} ordered by when saved."""
     with _conn() as c:
-        rows = c.execute(
-            "SELECT collection, product_id FROM saved_items "
-            "WHERE user_id=? ORDER BY created_at", (user_id,)).fetchall()
+        rows = c.execute(_q("SELECT collection, product_id FROM saved_items "
+                            "WHERE user_id=? ORDER BY created_at"), (user_id,)).fetchall()
     out = {}
     for r in rows:
         out.setdefault(r["collection"], []).append(r["product_id"])
     return out
 
 
-# ---------- product catalog (now the source of truth) ----------
+# ---------- product catalog (SQLite-only; in prod the catalog lives in catalog.json) ----------
 _PRODUCT_COLS = ["id", "name", "brand", "category", "subcategory", "color",
                  "price", "prev_price", "on_sale", "rating", "reviews", "seller",
                  "in_stock", "emoji", "specs", "description", "text"]
@@ -188,7 +229,8 @@ def catalog_count():
 
 
 def import_products(products):
-    """Insert/replace a list of product dicts (as produced by generate_catalog)."""
+    if PG:
+        return  # catalog is served from catalog.json, not stored in Postgres
     now = _now()
     with _conn() as c:
         c.executemany(
@@ -200,24 +242,22 @@ def import_products(products):
               p["price"], p["prev_price"], int(p["on_sale"]), p["rating"], p["reviews"],
               p["seller"], int(p["in_stock"]), p["emoji"], json.dumps(p["specs"]),
               p["description"], p["_text"]) for p in products])
-        # seed one price-history point per product so tracking has a baseline
         c.executemany("INSERT INTO price_history(product_id, price, ts) VALUES(?,?,?)",
                       [(p["id"], p["price"], now) for p in products])
 
 
 def ensure_catalog(json_path="catalog.json"):
-    """Seed the products table from catalog.json the first time only."""
-    if catalog_count() > 0:
+    if PG or catalog_count() > 0:
         return
     if not os.path.exists(json_path):
-        raise FileNotFoundError(
-            f"{json_path} not found — run `python generate_catalog.py` first.")
+        raise FileNotFoundError(f"{json_path} not found — run `python generate_catalog.py` first.")
     with open(json_path) as f:
         import_products(json.load(f))
 
 
 def reseed_catalog_from_json(json_path="catalog.json"):
-    """Wipe and reload products from catalog.json (used by generate_catalog.py)."""
+    if PG:
+        return
     with _conn() as c:
         c.execute("DELETE FROM products")
         c.execute("DELETE FROM price_history")
@@ -226,13 +266,14 @@ def reseed_catalog_from_json(json_path="catalog.json"):
 
 
 def load_catalog():
+    if PG:
+        return []
     with _conn() as c:
         rows = c.execute("SELECT * FROM products").fetchall()
     return [_row_to_product(r) for r in rows]
 
 
 def category_breakdown():
-    """Counts per product type (subcategory), with its parent category."""
     with _conn() as c:
         rows = c.execute(
             "SELECT category, subcategory, COUNT(*) AS n FROM products "
@@ -243,56 +284,52 @@ def category_breakdown():
 
 def update_price(product_id, new_price, prev_price):
     with _conn() as c:
-        c.execute("UPDATE products SET price=?, prev_price=?, on_sale=? WHERE id=?",
+        c.execute(_q("UPDATE products SET price=?, prev_price=?, on_sale=? WHERE id=?"),
                   (new_price, prev_price, int(new_price < prev_price), product_id))
-        c.execute("INSERT INTO price_history(product_id, price, ts) VALUES(?,?,?)",
+        c.execute(_q("INSERT INTO price_history(product_id, price, ts) VALUES(?,?,?)"),
                   (product_id, new_price, _now()))
 
 
 def price_history(product_id, limit=30):
     with _conn() as c:
-        rows = c.execute(
-            "SELECT price, ts FROM price_history WHERE product_id=? "
-            "ORDER BY ts DESC LIMIT ?", (product_id, limit)).fetchall()
+        rows = c.execute(_q("SELECT price, ts FROM price_history WHERE product_id=? "
+                            "ORDER BY ts DESC LIMIT ?"), (product_id, limit)).fetchall()
     return [{"price": r["price"], "ts": r["ts"]} for r in reversed(rows)]
 
 
 # ---------- price tracking ----------
 def add_watch(user_id, product_id, target_price=None):
     with _conn() as c:
-        c.execute(
-            "INSERT INTO price_watches(user_id, product_id, target_price, created_at) "
-            "VALUES(?,?,?,?) "
-            "ON CONFLICT(user_id, product_id) DO UPDATE SET target_price=excluded.target_price",
-            (user_id, product_id, target_price, _now()))
+        c.execute(_q("INSERT INTO price_watches(user_id, product_id, target_price, created_at) "
+                     "VALUES(?,?,?,?) "
+                     "ON CONFLICT(user_id, product_id) DO UPDATE SET target_price=excluded.target_price"),
+                  (user_id, product_id, target_price, _now()))
 
 
 def remove_watch(user_id, product_id):
     with _conn() as c:
-        c.execute("DELETE FROM price_watches WHERE user_id=? AND product_id=?",
+        c.execute(_q("DELETE FROM price_watches WHERE user_id=? AND product_id=?"),
                   (user_id, product_id))
 
 
 def get_watches(user_id):
     with _conn() as c:
-        rows = c.execute(
-            "SELECT product_id, target_price, created_at FROM price_watches "
-            "WHERE user_id=? ORDER BY created_at DESC", (user_id,)).fetchall()
+        rows = c.execute(_q("SELECT product_id, target_price, created_at FROM price_watches "
+                            "WHERE user_id=? ORDER BY created_at DESC"), (user_id,)).fetchall()
     return [{"product_id": r["product_id"], "target_price": r["target_price"],
              "created_at": r["created_at"]} for r in rows]
 
 
 def watchers_for(product_id):
     with _conn() as c:
-        rows = c.execute(
-            "SELECT user_id, target_price FROM price_watches WHERE product_id=?",
-            (product_id,)).fetchall()
+        rows = c.execute(_q("SELECT user_id, target_price FROM price_watches WHERE product_id=?"),
+                         (product_id,)).fetchall()
     return [(r["user_id"], r["target_price"]) for r in rows]
 
 
 def watched_product_ids(user_id):
     with _conn() as c:
-        rows = c.execute("SELECT product_id FROM price_watches WHERE user_id=?",
+        rows = c.execute(_q("SELECT product_id FROM price_watches WHERE user_id=?"),
                          (user_id,)).fetchall()
     return [r["product_id"] for r in rows]
 
@@ -300,9 +337,8 @@ def watched_product_ids(user_id):
 # ---------- alerts ----------
 def add_alert(user_id, product_id, old_price, new_price):
     with _conn() as c:
-        c.execute(
-            "INSERT INTO alerts(user_id, product_id, old_price, new_price, ts) "
-            "VALUES(?,?,?,?,?)", (user_id, product_id, old_price, new_price, _now()))
+        c.execute(_q("INSERT INTO alerts(user_id, product_id, old_price, new_price, ts) "
+                     "VALUES(?,?,?,?,?)"), (user_id, product_id, old_price, new_price, _now()))
 
 
 def get_alerts(user_id, unseen_only=False):
@@ -311,10 +347,10 @@ def get_alerts(user_id, unseen_only=False):
         q += " AND seen=0"
     q += " ORDER BY ts DESC LIMIT 50"
     with _conn() as c:
-        rows = c.execute(q, (user_id,)).fetchall()
+        rows = c.execute(_q(q), (user_id,)).fetchall()
     return [dict(r) for r in rows]
 
 
 def mark_alerts_seen(user_id):
     with _conn() as c:
-        c.execute("UPDATE alerts SET seen=1 WHERE user_id=?", (user_id,))
+        c.execute(_q("UPDATE alerts SET seen=1 WHERE user_id=?"), (user_id,))

rmn-backend/requirements.txt

@@ -3,3 +3,5 @@ uvicorn[standard]
 # semantic search (level 2) — small static embeddings, no torch
 model2vec
 numpy
+# persistent storage in production (used only when DATABASE_URL is set)
+psycopg[binary]