Build a Smart Cart with Sahha

import { createClient } from "@supabase/supabase-js";

const supabase = createClient(
  Deno.env.get("SUPABASE_URL")!,
  Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!
);

// Fetch recent score events
async function getRecentScores(externalId: string) {
  const yesterday = new Date(
    Date.now() - 24 * 60 * 60 * 1000
  ).toISOString();

  const { data: events, error } = await supabase
    .from("sahha_events")
    .select("*")
    .eq("external_id", externalId)
    .eq("event_type", "ScoreCreatedIntegrationEvent")
    .gte("created_at", yesterday)
    .order("created_at", { ascending: false })
    .limit(50);

  if (error) throw error;
  return events;
}

// Fetch archetypes — deduplicated by name
async function getRecentArchetypes(externalId: string) {
  const { data: events, error } = await supabase
    .from("sahha_events")
    .select("*")
    .eq("external_id", externalId)
    .eq("event_type", "ArchetypeCreatedIntegrationEvent")
    .order("created_at", { ascending: false })
    .limit(30);

  if (error) throw error;

  // Keep only the latest event per archetype name
  const seen = new Set<string>();
  return events.filter((e) => {
    const name = e.payload?.name;
    if (name && !seen.has(name)) {
      seen.add(name);
      return true;
    }
    return false;
  });
}

// ─── convex/queries.ts ──────────────────────────────────
import { internalQuery } from "./_generated/server";
import { v } from "convex/values";

// Fetch recent events for a user (scores, biomarkers, etc.)
export const getByExternalId = internalQuery({
  args: {
    externalId: v.string(),
    limit: v.optional(v.number()),
  },
  handler: async (ctx, args) => {
    const limit = args.limit ?? 50;
    const events = await ctx.db
      .query("healthEvents")
      .withIndex("by_user_type", (q) =>
        q.eq("externalId", args.externalId)
      )
      .order("desc")
      .take(limit);

    return events.map((e) => ({
      eventType: e.eventType,
      payload: e.payload,
      receivedAt: e.receivedAt,
    }));
  },
});

// Fetch archetypes — deduplicated by name
export const getArchetypesByExternalId = internalQuery({
  args: { externalId: v.string() },
  handler: async (ctx, args) => {
    const events = await ctx.db
      .query("healthEvents")
      .withIndex("by_user_type", (q) =>
        q
          .eq("externalId", args.externalId)
          .eq("eventType", "ArchetypeCreatedIntegrationEvent")
      )
      .order("desc")
      .take(30);

    // Keep only the latest per archetype name
    const seen = new Set<string>();
    const unique = [];
    for (const e of events) {
      const name = (e.payload as Record<string, unknown>)
        ?.name as string;
      if (name && !seen.has(name)) {
        seen.add(name);
        unique.push({
          eventType: e.eventType,
          payload: e.payload,
        });
      }
    }
    return unique;
  },
});

// Note: Both queries use internalQuery — they can only be called
// from other Convex server-side functions (like the HTTP action
// in the next step), not from the client.

import { getFirestore } from "firebase-admin/firestore";

const db = getFirestore();

// Fetch recent score events
async function getRecentScores(externalId: string) {
  const yesterday = new Date(
    Date.now() - 24 * 60 * 60 * 1000
  ).toISOString();

  const snapshot = await db
    .collection("sahha_events")
    .doc(externalId)
    .collection("ScoreCreatedIntegrationEvent")
    .where("createdAtUtc", ">=", yesterday)
    .orderBy("createdAtUtc", "desc")
    .limit(50)
    .get();

  return snapshot.docs.map((doc) => doc.data());
}

// Fetch archetypes — deduplicated by name
async function getRecentArchetypes(externalId: string) {
  const snapshot = await db
    .collection("sahha_events")
    .doc(externalId)
    .collection("ArchetypeCreatedIntegrationEvent")
    .orderBy("createdAtUtc", "desc")
    .limit(30)
    .get();

  const events = snapshot.docs.map((doc) => doc.data());

  // Keep only the latest event per archetype name
  const seen = new Set<string>();
  return events.filter((e) => {
    const name = e.payload?.name;
    if (name && !seen.has(name)) {
      seen.add(name);
      return true;
    }
    return false;
  });
}

// ─── supabase/functions/smart-cart/index.ts ─────────────
import { createClient } from "@supabase/supabase-js";

const supabase = createClient(
  Deno.env.get("SUPABASE_URL")!,
  Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!
);

Deno.serve(async (req) => {
  // CORS preflight
  if (req.method === "OPTIONS") {
    return new Response(null, {
      status: 204,
      headers: {
        "Access-Control-Allow-Origin": "*",
        "Access-Control-Allow-Methods": "POST, OPTIONS",
        "Access-Control-Allow-Headers": "Content-Type",
      },
    });
  }

  if (req.method !== "POST") {
    return new Response("Method not allowed", { status: 405 });
  }

  const corsHeaders = {
    "Access-Control-Allow-Origin": "*",
    "Access-Control-Allow-Methods": "POST, OPTIONS",
    "Access-Control-Allow-Headers": "Content-Type",
  };

  try {
    const { externalId } = await req.json();
    if (!externalId) {
      return new Response(
        JSON.stringify({ error: "externalId is required" }),
        {
          status: 400,
          headers: { "Content-Type": "application/json", ...corsHeaders },
        }
      );
    }

    // 1. Query scores
    const yesterday = new Date(
      Date.now() - 24 * 60 * 60 * 1000
    ).toISOString();

    const { data: scoreEvents } = await supabase
      .from("sahha_events")
      .select("*")
      .eq("external_id", externalId)
      .eq("event_type", "ScoreCreatedIntegrationEvent")
      .gte("created_at", yesterday)
      .order("created_at", { ascending: false })
      .limit(50);

    // 2. Query archetypes (deduplicated)
    const { data: allArchetypes } = await supabase
      .from("sahha_events")
      .select("*")
      .eq("external_id", externalId)
      .eq("event_type", "ArchetypeCreatedIntegrationEvent")
      .order("created_at", { ascending: false })
      .limit(30);

    const seen = new Set<string>();
    const archetypeEvents = (allArchetypes ?? []).filter((e: any) => {
      const name = e.payload?.name;
      if (name && !seen.has(name)) {
        seen.add(name);
        return true;
      }
      return false;
    });

    // 3. Extract scores
    const scores = (scoreEvents ?? [])
      .map((e: any) => {
        const p = e.payload;
        return {
          type: (p?.type as string) ?? "unknown",
          score: (p?.score as number) ?? 0,
          state: (p?.state as string) ?? "unknown",
          factors: Array.isArray(p?.factors)
            ? p.factors.map((f: any) => ({
                name: (f.name as string) ?? "",
                score: (f.score as number) ?? 0,
                state: (f.state as string) ?? "",
              }))
            : [],
        };
      });

    // 4. Extract archetypes
    const archetypes = archetypeEvents.map((e: any) => {
      const p = e.payload;
      return {
        name: (p?.name as string) ?? "",
        value: (p?.value as string) ?? "",
        periodicity: (p?.periodicity as string) ?? "",
      };
    });

    // 5. Categorize health state
    const healthState = categorizeHealthState(scores, archetypes);

    // 6. Query products for this health state
    const { data: products, error: productsError } = await supabase
      .from("products")
      .select("*")
      .eq("active", true)
      .contains("for_states", [healthState])
      .order("priority", { ascending: true })
      .limit(4);

    if (productsError) throw productsError;

    // 7. Respond with health state + products
    return new Response(
      JSON.stringify({
        externalId,
        healthState,
        scores: getLatestScores(scores),
        archetypes,
        products: (products ?? []).map((p: any) => ({
          productId: p.id,
          name: p.name,
          description: p.description,
          category: p.category,
          price: p.price,
          imageUrl: p.image_url,
          tags: p.tags,
        })),
      }),
      {
        status: 200,
        headers: { "Content-Type": "application/json", ...corsHeaders },
      }
    );
  } catch (err) {
    return new Response(
      JSON.stringify({ error: "Internal server error" }),
      {
        status: 500,
        headers: { "Content-Type": "application/json", ...corsHeaders },
      }
    );
  }
});

// --- Helper functions (types + categorization) go here —
//     same as the section above ---
//
// Deploy: npx supabase functions deploy smart-cart --no-verify-jwt

// ─── convex/smartCart.ts ────────────────────────────────
import { httpAction } from "./_generated/server";
import { internal } from "./_generated/api";

const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Methods": "POST, OPTIONS",
  "Access-Control-Allow-Headers": "Content-Type",
};

export const generateCart = httpAction(async (ctx, request) => {
  if (request.method === "OPTIONS") {
    return new Response(null, { status: 204, headers: corsHeaders });
  }

  try {
    const { externalId } = await request.json();
    if (!externalId) {
      return new Response(
        JSON.stringify({ error: "externalId is required" }),
        { status: 400, headers: { "Content-Type": "application/json", ...corsHeaders } }
      );
    }

    // 1. Query health data (both in parallel)
    const [events, archetypeEvents] = await Promise.all([
      ctx.runQuery(internal.queries.getByExternalId, { externalId, limit: 50 }),
      ctx.runQuery(internal.queries.getArchetypesByExternalId, { externalId }),
    ]);

    if (!events?.length && !archetypeEvents?.length) {
      return new Response(
        JSON.stringify({ error: "No health data found for this profile" }),
        { status: 404, headers: { "Content-Type": "application/json", ...corsHeaders } }
      );
    }

    // 2. Extract scores from ScoreCreatedIntegrationEvent payloads
    const scores = (events ?? [])
      .filter((e: { eventType: string }) =>
        e.eventType === "ScoreCreatedIntegrationEvent"
      )
      .map((e: { payload: unknown }) => {
        const p = e.payload as Record<string, unknown>;
        return {
          type: (p?.type as string) ?? "unknown",
          score: (p?.score as number) ?? 0,
          state: (p?.state as string) ?? "unknown",
          factors: Array.isArray(p?.factors)
            ? (p.factors as Array<Record<string, unknown>>).map((f) => ({
                name: (f.name as string) ?? "",
                score: (f.score as number) ?? 0,
                state: (f.state as string) ?? "",
              }))
            : [],
        };
      });

    // 3. Extract archetypes
    const archetypes = (archetypeEvents ?? []).map(
      (e: { payload: unknown }) => {
        const p = e.payload as Record<string, unknown>;
        return {
          name: (p?.name as string) ?? "",
          value: (p?.value as string) ?? "",
          periodicity: (p?.periodicity as string) ?? "",
        };
      }
    );

    // 4. Categorize health state
    const healthState = categorizeHealthState(scores, archetypes);

    // 5. Query products for this health state
    const products = await ctx.runQuery(
      internal.queries.getProductsForState,
      { stateId: healthState }
    );

    // 6. Return structured data
    return new Response(
      JSON.stringify({
        externalId,
        healthState,
        scores: getLatestScores(scores),
        archetypes,
        products: products.map((p) => ({
          productId: p.productId,
          name: p.name,
          description: p.description,
          category: p.category,
          price: p.price,
          imageUrl: p.imageUrl,
          tags: p.tags,
        })),
      }),
      {
        status: 200,
        headers: { "Content-Type": "application/json", ...corsHeaders },
      }
    );
  } catch (err: unknown) {
    const message = err instanceof Error ? err.message : String(err);
    console.error("Smart cart error:", message);
    return new Response(
      JSON.stringify({ error: "Internal server error" }),
      { status: 500, headers: { "Content-Type": "application/json", ...corsHeaders } }
    );
  }
});

// --- Helper functions (types + categorization) go here —
//     same as the section above ---

// ─── convex/http.ts — register the route ────────────────
// Important: Never return HTTP status 502 from a Convex
// httpAction — Convex intercepts 502 responses and strips
// CORS headers. Use 500 for server errors instead.
import { httpRouter } from "convex/server";
import { handleWebhook } from "./sahhaWebhook";
import { generateCart } from "./smartCart";

const http = httpRouter();

// Sahha Webhook (from the data streaming guide)
http.route({ path: "/sahha-webhook", method: "POST", handler: handleWebhook });
http.route({ path: "/sahha-webhook", method: "OPTIONS", handler: handleWebhook });

// Smart Cart endpoint
http.route({ path: "/smart-cart", method: "POST", handler: generateCart });
http.route({ path: "/smart-cart", method: "OPTIONS", handler: generateCart });

export default http;
//
// Deploy: npx convex dev

// ─── functions/src/smartCart.ts ──────────────────────────
import { onRequest } from "firebase-functions/v2/https";
import { getFirestore } from "firebase-admin/firestore";

const db = getFirestore();

export const smartCart = onRequest(async (req, res) => {
  // CORS
  res.set("Access-Control-Allow-Origin", "*");
  res.set("Access-Control-Allow-Methods", "POST, OPTIONS");
  res.set("Access-Control-Allow-Headers", "Content-Type");

  if (req.method === "OPTIONS") {
    res.status(204).send("");
    return;
  }

  if (req.method !== "POST") {
    res.status(405).send("Method not allowed");
    return;
  }

  try {
    const { externalId } = req.body;
    if (!externalId) {
      res.status(400).json({ error: "externalId is required" });
      return;
    }

    // 1. Query scores
    const yesterday = new Date(
      Date.now() - 24 * 60 * 60 * 1000
    ).toISOString();

    const scoreSnapshot = await db
      .collection("sahha_events")
      .doc(externalId)
      .collection("ScoreCreatedIntegrationEvent")
      .where("createdAtUtc", ">=", yesterday)
      .orderBy("createdAtUtc", "desc")
      .limit(50)
      .get();

    const scoreEvents = scoreSnapshot.docs.map((doc) =>
      doc.data()
    );

    // 2. Query archetypes (deduplicated)
    const archSnapshot = await db
      .collection("sahha_events")
      .doc(externalId)
      .collection("ArchetypeCreatedIntegrationEvent")
      .orderBy("createdAtUtc", "desc")
      .limit(30)
      .get();

    const allArchetypes = archSnapshot.docs.map((doc) =>
      doc.data()
    );

    const seen = new Set<string>();
    const archetypeEvents = allArchetypes.filter((e) => {
      const name = e.payload?.name;
      if (name && !seen.has(name)) {
        seen.add(name);
        return true;
      }
      return false;
    });

    // 3. Extract scores
    const scores = scoreEvents.map((e: any) => {
      const p = e.payload ?? e;
      return {
        type: (p?.type as string) ?? "unknown",
        score: (p?.score as number) ?? 0,
        state: (p?.state as string) ?? "unknown",
        factors: Array.isArray(p?.factors)
          ? p.factors.map((f: any) => ({
              name: (f.name as string) ?? "",
              score: (f.score as number) ?? 0,
              state: (f.state as string) ?? "",
            }))
          : [],
      };
    });

    // 4. Extract archetypes
    const archetypes = archetypeEvents.map((e: any) => {
      const p = e.payload ?? e;
      return {
        name: (p?.name as string) ?? "",
        value: (p?.value as string) ?? "",
        periodicity: (p?.periodicity as string) ?? "",
      };
    });

    // 5. Categorize health state
    const healthState = categorizeHealthState(scores, archetypes);

    // 6. Query products for this health state
    const productsSnapshot = await db
      .collection("products")
      .where("active", "==", true)
      .where("forStates", "array-contains", healthState)
      .orderBy("priority", "asc")
      .limit(4)
      .get();

    const products = productsSnapshot.docs.map((doc) => {
      const d = doc.data();
      return {
        productId: doc.id,
        name: d.name,
        description: d.description,
        category: d.category,
        price: d.price,
        imageUrl: d.imageUrl,
        tags: d.tags,
      };
    });

    // 7. Respond with health state + products
    res.status(200).json({
      externalId,
      healthState,
      scores: getLatestScores(scores),
      archetypes,
      products,
    });
  } catch (err) {
    console.error("Smart cart error:", err);
    res.status(500).json({ error: "Internal server error" });
  }
});

// --- Helper functions (types + categorization) go here —
//     same as the section above ---
//
// Deploy: firebase deploy --only functions

create table products (
  id text primary key,
  name text not null,
  description text not null,
  category text not null
    check (category in ('SUPPLEMENT', 'SNACK', 'MEAL', 'DRINK')),
  price integer not null,
  tags text[] default '{}',
  for_states text[] not null,
  priority integer not null default 10,
  score_mapping jsonb,
  archetype_match jsonb,
  image_url text,
  active boolean not null default true
);

-- Seed (3 of 15 shown — full seed in starter project)
insert into products
  (id, name, description, category, price,
   tags, for_states, priority, image_url, active)
values
  ('bone-broth', 'Bone Broth (Pack of 6)',
   'Collagen-rich. Slow-simmered 24hrs.',
   'MEAL', 3299,
   '{"collagen","anti-inflammatory","recovery"}',
   '{"recovery"}', 1,
   'https://images.unsplash.com/photo-1547592166-23ac45744acd?w=200&h=200&fit=crop',
   true);

insert into products
  (id, name, description, category, price,
   tags, for_states, priority, image_url, active)
values
  ('electrolyte-mix', 'Electrolyte Mix (30 sticks)',
   'Zero sugar. Rapid rehydration.',
   'DRINK', 2499,
   '{"hydration","electrolytes","performance"}',
   '{"high-training"}', 1,
   'https://images.unsplash.com/photo-1622597467836-f3285f2131b8?w=200&h=200&fit=crop',
   true);

insert into products
  (id, name, description, category, price,
   tags, for_states, priority, image_url, active)
values
  ('chamomile-sleep-blend',
   'Chamomile Sleep Blend (20 bags)',
   'Chamomile, valerian, passionflower.',
   'DRINK', 1499,
   '{"sleep","calming","herbal"}',
   '{"sleep-support"}', 1,
   'https://images.unsplash.com/photo-1563911892437-1feda0179e1b?w=200&h=200&fit=crop',
   true);

// ─── Query products for a health state ──────────────────
async function buildCartForState(
  stateId: HealthStateId,
  maxItems = 4
) {
  const { data: products, error } = await supabase
    .from("products")
    .select("*")
    .eq("active", true)
    .contains("for_states", [stateId])
    .order("priority", { ascending: true })
    .limit(maxItems);

  if (error) throw error;
  return products;
}

// ─── convex/schema.ts — products table ──────────────────
products: defineTable({
  productId: v.string(),
  name: v.string(),
  description: v.string(),
  category: v.union(
    v.literal("SUPPLEMENT"),
    v.literal("SNACK"),
    v.literal("MEAL"),
    v.literal("DRINK")
  ),
  price: v.number(),
  tags: v.array(v.string()),
  forStates: v.array(v.string()),
  priority: v.number(),
  scoreMapping: v.optional(
    v.object({ scoreType: v.string(), minValue: v.number() })
  ),
  archetypeMatch: v.optional(
    v.object({ name: v.string(), values: v.array(v.string()) })
  ),
  imageUrl: v.optional(v.string()),
  active: v.boolean(),
}).index("by_active", ["active"]),

// ─── convex/seedProducts.ts (3 of 15 — full seed in starter) ─
import { internalMutation } from "./_generated/server";

export const seed = internalMutation(async (ctx) => {
  const products = [
    {
      productId: "bone-broth",
      name: "Bone Broth (Pack of 6)",
      description: "Collagen-rich. Slow-simmered 24hrs.",
      category: "MEAL" as const, price: 3299,
      tags: ["collagen", "anti-inflammatory", "recovery"],
      forStates: ["recovery"], priority: 1,
      imageUrl: "https://images.unsplash.com/photo-1547592166-23ac45744acd?w=200&h=200&fit=crop",
      active: true,
    },
    {
      productId: "electrolyte-mix",
      name: "Electrolyte Mix (30 sticks)",
      description: "Zero sugar. Rapid rehydration.",
      category: "DRINK" as const, price: 2499,
      tags: ["hydration", "electrolytes", "performance"],
      forStates: ["high-training"], priority: 1,
      imageUrl: "https://images.unsplash.com/photo-1622597467836-f3285f2131b8?w=200&h=200&fit=crop",
      active: true,
    },
    {
      productId: "chamomile-sleep-blend",
      name: "Chamomile Sleep Blend (20 bags)",
      description: "Chamomile, valerian, passionflower.",
      category: "DRINK" as const, price: 1499,
      tags: ["sleep", "calming", "herbal"],
      forStates: ["sleep-support"], priority: 1,
      imageUrl: "https://images.unsplash.com/photo-1563911892437-1feda0179e1b?w=200&h=200&fit=crop",
      active: true,
    },
    // ... 12 more across all states and categories
  ];

  for (const p of products) {
    await ctx.db.insert("products", p);
  }
});

// ─── convex/queries.ts — query products for a health state ──
export const getProductsForState = internalQuery({
  args: {
    stateId: v.string(),
    maxItems: v.optional(v.number()),
  },
  handler: async (ctx, args) => {
    const limit = args.maxItems ?? 4;
    const all = await ctx.db
      .query("products")
      .withIndex("by_active", (q) => q.eq("active", true))
      .collect();

    return all
      .filter((p) => p.forStates.includes(args.stateId))
      .sort((a, b) => a.priority - b.priority)
      .slice(0, limit);
  },
});

// ─── products collection (3 of 15 — full seed in starter) ──
import { getFirestore } from "firebase-admin/firestore";

const db = getFirestore();

async function seedProducts() {
  const products = [
    {
      id: "bone-broth",
      name: "Bone Broth (Pack of 6)",
      description: "Collagen-rich. Slow-simmered 24hrs.",
      category: "MEAL", price: 3299,
      tags: ["collagen", "anti-inflammatory", "recovery"],
      forStates: ["recovery"], priority: 1,
      imageUrl: "https://images.unsplash.com/photo-1547592166-23ac45744acd?w=200&h=200&fit=crop",
      active: true,
    },
    {
      id: "electrolyte-mix",
      name: "Electrolyte Mix (30 sticks)",
      description: "Zero sugar. Rapid rehydration.",
      category: "DRINK", price: 2499,
      tags: ["hydration", "electrolytes", "performance"],
      forStates: ["high-training"], priority: 1,
      imageUrl: "https://images.unsplash.com/photo-1622597467836-f3285f2131b8?w=200&h=200&fit=crop",
      active: true,
    },
    {
      id: "chamomile-sleep-blend",
      name: "Chamomile Sleep Blend (20 bags)",
      description: "Chamomile, valerian, passionflower.",
      category: "DRINK", price: 1499,
      tags: ["sleep", "calming", "herbal"],
      forStates: ["sleep-support"], priority: 1,
      imageUrl: "https://images.unsplash.com/photo-1563911892437-1feda0179e1b?w=200&h=200&fit=crop",
      active: true,
    },
    // ... 12 more across all states and categories
  ];

  const batch = db.batch();
  for (const product of products) {
    const { id, ...data } = product;
    batch.set(db.collection("products").doc(id), data);
  }
  await batch.commit();
}

// ─── Query products for a health state ──────────────────
async function buildCartForState(
  stateId: HealthStateId,
  maxItems = 4
) {
  const snapshot = await db
    .collection("products")
    .where("active", "==", true)
    .where("forStates", "array-contains", stateId)
    .orderBy("priority", "asc")
    .limit(maxItems)
    .get();

  return snapshot.docs.map((doc) => ({
    id: doc.id,
    ...doc.data(),
  }));
}

-- ─── Supabase: carts table ─────────────────────────────
create table carts (
  cart_id uuid primary key default gen_random_uuid(),
  external_id text not null,
  health_state text not null,
  generated_at timestamptz not null default now(),
  items jsonb not null,
  total_price integer not null,
  status text not null default 'draft'
    check (status in ('draft', 'accepted', 'modified', 'purchased')),

  constraint fk_external_id_exists check (external_id <> '')
);

create index idx_carts_external_id on carts (external_id, generated_at desc);

// ─── convex/schema.ts — carts table ────────────────────
carts: defineTable({
  externalId: v.string(),
  healthState: v.string(),
  generatedAt: v.number(),
  items: v.array(
    v.object({
      productId: v.string(),
      name: v.string(),
      price: v.number(),
      quantity: v.number(),
    })
  ),
  totalPrice: v.number(),
  status: v.union(
    v.literal("draft"),
    v.literal("accepted"),
    v.literal("modified"),
    v.literal("purchased")
  ),
})
  .index("by_external_id", ["externalId", "generatedAt"]),

// ─── Firestore: carts/{cartId} ─────────────────────────
interface CartDocument {
  externalId: string;
  healthState: string;
  generatedAt: FirebaseFirestore.Timestamp;
  items: Array<{
    productId: string;
    name: string;
    price: number;
    quantity: number;
  }>;
  totalPrice: number;
  status: "draft" | "accepted" | "modified" | "purchased";
}

-- ─── Supabase: cart_events table ───────────────────────
create table cart_events (
  event_id uuid primary key default gen_random_uuid(),
  cart_id uuid not null references carts(cart_id),
  external_id text not null,
  action text not null
    check (action in ('accepted', 'removed', 'swapped', 'repurchased', 'quantity_changed')),
  product_id text,
  swapped_for_product_id text,
  created_at timestamptz not null default now(),
  metadata jsonb
);

create index idx_cart_events_cart on cart_events (cart_id, created_at);
create index idx_cart_events_user on cart_events (external_id, created_at desc);

// ─── convex/schema.ts — cartEvents table ───────────────
cartEvents: defineTable({
  cartId: v.id("carts"),
  externalId: v.string(),
  action: v.union(
    v.literal("accepted"),
    v.literal("removed"),
    v.literal("swapped"),
    v.literal("repurchased"),
    v.literal("quantity_changed")
  ),
  productId: v.optional(v.string()),
  swappedForProductId: v.optional(v.string()),
  createdAt: v.number(),
  metadata: v.optional(v.any()),
})
  .index("by_cart", ["cartId", "createdAt"])
  .index("by_user", ["externalId", "createdAt"]),

// ─── Firestore: cart_events/{eventId} ──────────────────
interface CartEventDocument {
  cartId: string;
  externalId: string;
  action: "accepted" | "removed" | "swapped" | "repurchased" | "quantity_changed";
  productId?: string;
  swappedForProductId?: string;
  createdAt: FirebaseFirestore.Timestamp;
  metadata?: Record<string, unknown>;
}