feat: merge cartsnitch/api into api/ subdirectory

Consolidate API gateway service into monorepo.
Squashed from https://github.com/cartsnitch/api main (89bacb1).

Co-Authored-By: Paperclip <noreply@paperclip.ing>

tests/test_routes/test_alerts.py

@@ -0,0 +1,35 @@
+"""Integration tests for alert endpoints."""
+
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_list_alerts_empty(client, auth_headers):
+    """No purchases means no alerts."""
+    resp = await client.get("/alerts", headers=auth_headers)
+    assert resp.status_code == 200
+    assert resp.json() == []
+
+
+@pytest.mark.asyncio
+async def test_get_alert_settings(client, auth_headers):
+    resp = await client.get("/alerts/settings", headers=auth_headers)
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["price_increase_threshold_pct"] == 5.0
+    assert data["shrinkflation_enabled"] is True
+    assert data["email_notifications"] is False
+
+
+@pytest.mark.asyncio
+async def test_update_alert_settings_returns_501(client, auth_headers):
+    resp = await client.put(
+        "/alerts/settings",
+        headers=auth_headers,
+        json={
+            "price_increase_threshold_pct": 10.0,
+            "shrinkflation_enabled": False,
+            "email_notifications": True,
+        },
+    )
+    assert resp.status_code == 501

tests/test_routes/test_coupons.py

@@ -0,0 +1,58 @@
+"""Integration tests for coupon endpoints."""
+
+from datetime import date
+from decimal import Decimal
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from cartsnitch_api.models import Coupon, Store
+
+
+@pytest.fixture
+async def coupon_data(db_engine, auth_headers):
+    """Seed stores and coupons."""
+    factory = async_sessionmaker(db_engine, class_=AsyncSession, expire_on_commit=False)
+    async with factory() as session:
+        store = Store(name="Target", slug="target")
+        session.add(store)
+        await session.commit()
+        await session.refresh(store)
+
+        coupon = Coupon(
+            store_id=store.id,
+            title="$2 off laundry",
+            description="$2 off any laundry detergent",
+            discount_value=Decimal("2.00"),
+            discount_type="fixed",
+            valid_from=date(2026, 1, 1),
+            valid_to=date(2026, 12, 31),
+        )
+        session.add(coupon)
+        await session.commit()
+
+        return {"store": store, "coupon": coupon, "headers": auth_headers}
+
+
+@pytest.mark.asyncio
+async def test_list_coupons(client, coupon_data):
+    resp = await client.get("/coupons", headers=coupon_data["headers"])
+    assert resp.status_code == 200
+    data = resp.json()
+    assert len(data) >= 1
+
+
+@pytest.mark.asyncio
+async def test_list_coupons_by_store(client, coupon_data):
+    store_id = str(coupon_data["store"].id)
+    resp = await client.get(f"/coupons?store_id={store_id}", headers=coupon_data["headers"])
+    assert resp.status_code == 200
+    assert len(resp.json()) >= 1
+
+
+@pytest.mark.asyncio
+async def test_relevant_coupons_empty(client, auth_headers):
+    """No purchases means no relevant coupons."""
+    resp = await client.get("/coupons/relevant", headers=auth_headers)
+    assert resp.status_code == 200
+    assert resp.json() == []

tests/test_routes/test_prices.py

@@ -0,0 +1,90 @@
+"""Integration tests for price endpoints."""
+
+from datetime import date
+from decimal import Decimal
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from cartsnitch_api.models import NormalizedProduct, PriceHistory, Store
+
+
+@pytest.fixture
+async def price_data(db_engine, auth_headers):
+    """Seed products with price history showing an increase."""
+    factory = async_sessionmaker(db_engine, class_=AsyncSession, expire_on_commit=False)
+    async with factory() as session:
+        store = Store(name="Walmart", slug="walmart")
+        product = NormalizedProduct(
+            canonical_name="Tide Pods 42ct",
+            category="household",
+            brand="Tide",
+        )
+        session.add_all([store, product])
+        await session.commit()
+        await session.refresh(store)
+        await session.refresh(product)
+
+        # Two price points — second is higher (increase)
+        ph1 = PriceHistory(
+            normalized_product_id=product.id,
+            store_id=store.id,
+            observed_date=date(2026, 2, 1),
+            regular_price=Decimal("12.99"),
+            source="receipt",
+        )
+        ph2 = PriceHistory(
+            normalized_product_id=product.id,
+            store_id=store.id,
+            observed_date=date(2026, 3, 1),
+            regular_price=Decimal("14.49"),
+            source="receipt",
+        )
+        session.add_all([ph1, ph2])
+        await session.commit()
+
+        return {"product": product, "store": store, "headers": auth_headers}
+
+
+@pytest.mark.asyncio
+async def test_price_trends(client, price_data):
+    resp = await client.get("/prices/trends", headers=price_data["headers"])
+    assert resp.status_code == 200
+    data = resp.json()
+    assert len(data) >= 1
+    assert data[0]["product_name"] == "Tide Pods 42ct"
+    assert len(data[0]["data_points"]) == 2
+
+
+@pytest.mark.asyncio
+async def test_price_trends_by_category(client, price_data):
+    resp = await client.get("/prices/trends?category=household", headers=price_data["headers"])
+    assert resp.status_code == 200
+    assert len(resp.json()) == 1
+
+    resp = await client.get("/prices/trends?category=nonexistent", headers=price_data["headers"])
+    assert resp.status_code == 200
+    assert len(resp.json()) == 0
+
+
+@pytest.mark.asyncio
+async def test_price_increases(client, price_data):
+    resp = await client.get("/prices/increases", headers=price_data["headers"])
+    assert resp.status_code == 200
+    data = resp.json()
+    assert len(data) >= 1
+    increase = data[0]
+    assert increase["old_price"] == 12.99
+    assert increase["new_price"] == 14.49
+    assert increase["increase_pct"] > 0
+
+
+@pytest.mark.asyncio
+async def test_price_comparison(client, price_data):
+    pid = str(price_data["product"].id)
+    resp = await client.get(f"/prices/comparison?product_ids={pid}", headers=price_data["headers"])
+    assert resp.status_code == 200
+    data = resp.json()
+    assert len(data) >= 1
+    assert data[0]["product_name"] == "Tide Pods 42ct"
+    assert len(data[0]["prices"]) >= 1

tests/test_routes/test_products.py

@@ -0,0 +1,94 @@
+"""Integration tests for product endpoints."""
+
+import uuid
+from datetime import date
+from decimal import Decimal
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from cartsnitch_api.models import NormalizedProduct, PriceHistory, Store
+
+
+@pytest.fixture
+async def product_data(db_engine, auth_headers):
+    """Seed products and price history."""
+    factory = async_sessionmaker(db_engine, class_=AsyncSession, expire_on_commit=False)
+    async with factory() as session:
+        store = Store(name="Meijer", slug="meijer")
+        product = NormalizedProduct(
+            canonical_name="Cheerios 18oz",
+            category="pantry",
+            brand="General Mills",
+            upc_variants=["016000275263"],
+        )
+        session.add_all([store, product])
+        await session.commit()
+        await session.refresh(store)
+        await session.refresh(product)
+
+        ph1 = PriceHistory(
+            normalized_product_id=product.id,
+            store_id=store.id,
+            observed_date=date(2026, 3, 1),
+            regular_price=Decimal("4.99"),
+            source="receipt",
+        )
+        ph2 = PriceHistory(
+            normalized_product_id=product.id,
+            store_id=store.id,
+            observed_date=date(2026, 3, 10),
+            regular_price=Decimal("5.49"),
+            source="receipt",
+        )
+        session.add_all([ph1, ph2])
+        await session.commit()
+
+        return {"product": product, "store": store, "headers": auth_headers}
+
+
+@pytest.mark.asyncio
+async def test_list_products(client, product_data):
+    resp = await client.get("/products", headers=product_data["headers"])
+    assert resp.status_code == 200
+    data = resp.json()
+    assert len(data) >= 1
+    assert data[0]["name"] == "Cheerios 18oz"
+
+
+@pytest.mark.asyncio
+async def test_search_products(client, product_data):
+    resp = await client.get("/products?q=Cheerios", headers=product_data["headers"])
+    assert resp.status_code == 200
+    assert len(resp.json()) == 1
+
+    resp = await client.get("/products?q=nonexistent", headers=product_data["headers"])
+    assert resp.status_code == 200
+    assert len(resp.json()) == 0
+
+
+@pytest.mark.asyncio
+async def test_get_product_detail(client, product_data):
+    pid = str(product_data["product"].id)
+    resp = await client.get(f"/products/{pid}", headers=product_data["headers"])
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["name"] == "Cheerios 18oz"
+    assert data["brand"] == "General Mills"
+    assert len(data["prices_by_store"]) >= 1
+
+
+@pytest.mark.asyncio
+async def test_get_product_not_found(client, auth_headers):
+    resp = await client.get(f"/products/{uuid.uuid4()}", headers=auth_headers)
+    assert resp.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_get_product_prices(client, product_data):
+    pid = str(product_data["product"].id)
+    resp = await client.get(f"/products/{pid}/prices", headers=product_data["headers"])
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["product_name"] == "Cheerios 18oz"
+    assert len(data["data_points"]) == 2

tests/test_routes/test_public.py

@@ -0,0 +1,73 @@
+"""Integration tests for public endpoints (no auth)."""
+
+import uuid
+from datetime import date
+from decimal import Decimal
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from cartsnitch_api.models import NormalizedProduct, PriceHistory, Store
+
+
+@pytest.fixture
+async def public_data(db_engine):
+    """Seed data for public endpoints."""
+    factory = async_sessionmaker(db_engine, class_=AsyncSession, expire_on_commit=False)
+    async with factory() as session:
+        store = Store(name="Target", slug="target")
+        product = NormalizedProduct(
+            canonical_name="Skippy PB 16oz",
+            category="pantry",
+            brand="Skippy",
+        )
+        session.add_all([store, product])
+        await session.commit()
+        await session.refresh(store)
+        await session.refresh(product)
+
+        ph = PriceHistory(
+            normalized_product_id=product.id,
+            store_id=store.id,
+            observed_date=date(2026, 3, 5),
+            regular_price=Decimal("3.99"),
+            source="receipt",
+        )
+        session.add(ph)
+        await session.commit()
+
+        return {"product": product, "store": store}
+
+
+@pytest.mark.asyncio
+async def test_public_trend(client, public_data):
+    pid = str(public_data["product"].id)
+    resp = await client.get(f"/public/trends/{pid}")
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["product_name"] == "Skippy PB 16oz"
+    assert len(data["data_points"]) == 1
+
+
+@pytest.mark.asyncio
+async def test_public_trend_not_found(client):
+    resp = await client.get(f"/public/trends/{uuid.uuid4()}")
+    assert resp.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_public_store_comparison(client, public_data):
+    pid = str(public_data["product"].id)
+    resp = await client.get(f"/public/store-comparison?product_ids={pid}")
+    assert resp.status_code == 200
+    data = resp.json()
+    assert len(data["products"]) == 1
+
+
+@pytest.mark.asyncio
+async def test_public_inflation(client, public_data):
+    resp = await client.get("/public/inflation")
+    assert resp.status_code == 200
+    data = resp.json()
+    assert "categories" in data
+    assert "cartsnitch_index" in data

tests/test_routes/test_purchases.py

@@ -0,0 +1,95 @@
+"""Integration tests for purchase endpoints."""
+
+import uuid
+from datetime import date
+from decimal import Decimal
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from cartsnitch_api.auth.jwt import create_access_token
+from cartsnitch_api.models import Purchase, PurchaseItem, Store, User
+
+
+@pytest.fixture
+async def purchase_data(db_engine):
+    """Seed a user, store, purchase, and items."""
+    factory = async_sessionmaker(db_engine, class_=AsyncSession, expire_on_commit=False)
+    async with factory() as session:
+        from cartsnitch_api.auth.passwords import hash_password
+
+        user = User(
+            email="buyer@example.com",
+            hashed_password=hash_password("testpass123"),
+            display_name="Buyer",
+        )
+        store = Store(name="Kroger", slug="kroger")
+        session.add_all([user, store])
+        await session.commit()
+        await session.refresh(user)
+        await session.refresh(store)
+
+        purchase = Purchase(
+            user_id=user.id,
+            store_id=store.id,
+            receipt_id="receipt-001",
+            purchase_date=date(2026, 3, 10),
+            total=Decimal("42.50"),
+        )
+        session.add(purchase)
+        await session.commit()
+        await session.refresh(purchase)
+
+        item = PurchaseItem(
+            purchase_id=purchase.id,
+            product_name_raw="Organic Milk 1gal",
+            quantity=Decimal("1"),
+            unit_price=Decimal("5.99"),
+            extended_price=Decimal("5.99"),
+        )
+        session.add(item)
+        await session.commit()
+
+        token = create_access_token(user.id)
+        return {
+            "user": user,
+            "store": store,
+            "purchase": purchase,
+            "headers": {"Authorization": f"Bearer {token}"},
+        }
+
+
+@pytest.mark.asyncio
+async def test_list_purchases(client, purchase_data):
+    resp = await client.get("/purchases", headers=purchase_data["headers"])
+    assert resp.status_code == 200
+    data = resp.json()
+    assert len(data) == 1
+    assert data[0]["store_name"] == "Kroger"
+    assert data[0]["total"] == 42.50
+
+
+@pytest.mark.asyncio
+async def test_get_purchase_detail(client, purchase_data):
+    pid = str(purchase_data["purchase"].id)
+    resp = await client.get(f"/purchases/{pid}", headers=purchase_data["headers"])
+    assert resp.status_code == 200
+    data = resp.json()
+    assert len(data["line_items"]) == 1
+    assert data["line_items"][0]["name"] == "Organic Milk 1gal"
+
+
+@pytest.mark.asyncio
+async def test_get_purchase_not_found(client, auth_headers):
+    resp = await client.get(f"/purchases/{uuid.uuid4()}", headers=auth_headers)
+    assert resp.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_purchase_stats(client, purchase_data):
+    resp = await client.get("/purchases/stats", headers=purchase_data["headers"])
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["total_spent"] == 42.50
+    assert data["purchase_count"] == 1
+    assert "Kroger" in data["by_store"]

tests/test_routes/test_stores.py

@@ -0,0 +1,77 @@
+"""Integration tests for store endpoints."""
+
+import pytest
+
+from cartsnitch_api.models import Store
+
+
+@pytest.fixture
+async def seeded_store(db_engine):
+    """Insert a test store directly into the DB."""
+    from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+    factory = async_sessionmaker(db_engine, class_=AsyncSession, expire_on_commit=False)
+    async with factory() as session:
+        store = Store(name="Meijer", slug="meijer", logo_url=None, website_url=None)
+        session.add(store)
+        await session.commit()
+        await session.refresh(store)
+        return store
+
+
+@pytest.mark.asyncio
+async def test_list_stores(client, seeded_store):
+    resp = await client.get("/stores")
+    assert resp.status_code == 200
+    data = resp.json()
+    assert len(data) >= 1
+    assert data[0]["slug"] == "meijer"
+
+
+@pytest.mark.asyncio
+async def test_list_user_stores_empty(client, auth_headers):
+    resp = await client.get("/me/stores", headers=auth_headers)
+    assert resp.status_code == 200
+    assert resp.json() == []
+
+
+@pytest.mark.asyncio
+async def test_connect_and_disconnect_store(client, auth_headers, seeded_store):
+    # Connect
+    resp = await client.post(
+        "/me/stores/meijer/connect",
+        headers=auth_headers,
+        json={"credentials": None},
+    )
+    assert resp.status_code == 201
+    assert resp.json()["connected"] is True
+
+    # List should show connected
+    resp = await client.get("/me/stores", headers=auth_headers)
+    assert resp.status_code == 200
+    assert len(resp.json()) == 1
+
+    # Disconnect
+    resp = await client.delete("/me/stores/meijer", headers=auth_headers)
+    assert resp.status_code == 204
+
+    # List should be empty again
+    resp = await client.get("/me/stores", headers=auth_headers)
+    assert resp.json() == []
+
+
+@pytest.mark.asyncio
+async def test_connect_nonexistent_store(client, auth_headers):
+    resp = await client.post(
+        "/me/stores/nonexistent/connect",
+        headers=auth_headers,
+        json={},
+    )
+    assert resp.status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_connect_duplicate_store(client, auth_headers, seeded_store):
+    await client.post("/me/stores/meijer/connect", headers=auth_headers, json={})
+    resp = await client.post("/me/stores/meijer/connect", headers=auth_headers, json={})
+    assert resp.status_code == 409