@clipin/convex-wearables 0.0.2 → 0.0.3

package/src/component/schema.ts

@@ -0,0 +1,339 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+/**
+ * Provider name union — all supported wearable providers.
+ */
+export const providerName = v.union(
+  v.literal("garmin"),
+  v.literal("suunto"),
+  v.literal("polar"),
+  v.literal("whoop"),
+  v.literal("strava"),
+  v.literal("apple"),
+  v.literal("samsung"),
+  v.literal("google"),
+);
+
+/**
+ * Connection status enum.
+ */
+export const connectionStatus = v.union(
+  v.literal("active"),
+  v.literal("inactive"),
+  v.literal("revoked"),
+  v.literal("expired"),
+  v.literal("error"),
+);
+
+/**
+ * Event category — top-level classification.
+ */
+export const eventCategory = v.union(v.literal("workout"), v.literal("sleep"));
+
+/**
+ * Sync job status.
+ */
+export const syncJobStatus = v.union(
+  v.literal("queued"),
+  v.literal("running"),
+  v.literal("completed"),
+  v.literal("failed"),
+  v.literal("canceled"),
+);
+
+/**
+ * Backfill job status.
+ */
+export const backfillStatus = v.union(
+  v.literal("queued"),
+  v.literal("running"),
+  v.literal("completed"),
+  v.literal("failed"),
+  v.literal("canceled"),
+);
+
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+
+export default defineSchema({
+  // -------------------------------------------------------------------------
+  // Connections — OAuth tokens + provider link per user
+  // -------------------------------------------------------------------------
+  connections: defineTable({
+    userId: v.string(), // app-provided user identifier
+    provider: providerName,
+    providerUserId: v.optional(v.string()),
+    providerUsername: v.optional(v.string()),
+    accessToken: v.optional(v.string()),
+    refreshToken: v.optional(v.string()),
+    tokenExpiresAt: v.optional(v.number()), // unix ms
+    scope: v.optional(v.string()),
+    status: connectionStatus,
+    lastSyncedAt: v.optional(v.number()), // unix ms
+  })
+    .index("by_user", ["userId"])
+    .index("by_user_provider", ["userId", "provider"])
+    .index("by_provider_user", ["provider", "providerUserId"])
+    .index("by_status", ["status"]),
+
+  // -------------------------------------------------------------------------
+  // Data Sources — user + provider + device combination
+  // -------------------------------------------------------------------------
+  dataSources: defineTable({
+    userId: v.string(),
+    provider: providerName,
+    connectionId: v.optional(v.id("connections")),
+    deviceModel: v.optional(v.string()),
+    softwareVersion: v.optional(v.string()),
+    source: v.optional(v.string()),
+    deviceType: v.optional(v.string()),
+    originalSourceName: v.optional(v.string()),
+  })
+    .index("by_user_provider", ["userId", "provider"])
+    .index("by_user_provider_device", ["userId", "provider", "deviceModel", "source"])
+    .index("by_connection", ["connectionId"]),
+
+  // -------------------------------------------------------------------------
+  // Data Points — time-series health metrics (heart rate, steps, SpO2, etc.)
+  // -------------------------------------------------------------------------
+  dataPoints: defineTable({
+    dataSourceId: v.id("dataSources"),
+    seriesType: v.string(), // "heart_rate", "steps", "spo2", etc.
+    recordedAt: v.number(), // unix ms
+    value: v.number(),
+    externalId: v.optional(v.string()),
+  })
+    .index("by_source_type_time", ["dataSourceId", "seriesType", "recordedAt"])
+    .index("by_type_time", ["seriesType", "recordedAt"]),
+
+  // -------------------------------------------------------------------------
+  // Events — workouts and sleep sessions
+  // -------------------------------------------------------------------------
+  events: defineTable({
+    dataSourceId: v.id("dataSources"),
+    userId: v.string(), // denormalized for direct user queries
+    category: eventCategory,
+    type: v.optional(v.string()), // "running", "cycling", "night_sleep", etc.
+    sourceName: v.optional(v.string()),
+    durationSeconds: v.optional(v.number()),
+    startDatetime: v.number(), // unix ms
+    endDatetime: v.optional(v.number()), // unix ms
+    externalId: v.optional(v.string()),
+
+    // Workout detail fields (present when category == "workout")
+    heartRateMin: v.optional(v.number()),
+    heartRateMax: v.optional(v.number()),
+    heartRateAvg: v.optional(v.number()),
+    energyBurned: v.optional(v.number()),
+    distance: v.optional(v.number()),
+    stepsCount: v.optional(v.number()),
+    maxSpeed: v.optional(v.number()),
+    maxWatts: v.optional(v.number()),
+    movingTimeSeconds: v.optional(v.number()),
+    totalElevationGain: v.optional(v.number()),
+    averageSpeed: v.optional(v.number()),
+    averageWatts: v.optional(v.number()),
+    elevHigh: v.optional(v.number()),
+    elevLow: v.optional(v.number()),
+
+    // Sleep detail fields (present when category == "sleep")
+    sleepTotalDurationMinutes: v.optional(v.number()),
+    sleepTimeInBedMinutes: v.optional(v.number()),
+    sleepEfficiencyScore: v.optional(v.number()),
+    sleepDeepMinutes: v.optional(v.number()),
+    sleepRemMinutes: v.optional(v.number()),
+    sleepLightMinutes: v.optional(v.number()),
+    sleepAwakeMinutes: v.optional(v.number()),
+    isNap: v.optional(v.boolean()),
+    sleepStages: v.optional(
+      v.array(
+        v.object({
+          stage: v.string(), // "deep", "rem", "light", "awake"
+          startTime: v.number(), // unix ms
+          endTime: v.number(), // unix ms
+        }),
+      ),
+    ),
+  })
+    .index("by_user_category_time", ["userId", "category", "startDatetime"])
+    .index("by_source_category_time", ["dataSourceId", "category", "startDatetime"])
+    .index("by_source_start_end", ["dataSourceId", "startDatetime", "endDatetime"])
+    .index("by_external_id", ["externalId"]),
+
+  // -------------------------------------------------------------------------
+  // Daily Summaries — precomputed daily aggregates
+  // -------------------------------------------------------------------------
+  dailySummaries: defineTable({
+    userId: v.string(),
+    date: v.string(), // "2026-03-15" (ISO date string)
+    category: v.string(), // "activity" | "sleep" | "recovery" | "body"
+
+    // Activity metrics
+    totalSteps: v.optional(v.number()),
+    totalCalories: v.optional(v.number()),
+    activeCalories: v.optional(v.number()),
+    activeMinutes: v.optional(v.number()),
+    totalDistance: v.optional(v.number()),
+    floorsClimbed: v.optional(v.number()),
+    avgHeartRate: v.optional(v.number()),
+    maxHeartRate: v.optional(v.number()),
+    minHeartRate: v.optional(v.number()),
+
+    // Sleep metrics
+    sleepDurationMinutes: v.optional(v.number()),
+    sleepEfficiency: v.optional(v.number()),
+    deepSleepMinutes: v.optional(v.number()),
+    remSleepMinutes: v.optional(v.number()),
+    lightSleepMinutes: v.optional(v.number()),
+    awakeDuringMinutes: v.optional(v.number()),
+    timeInBedMinutes: v.optional(v.number()),
+
+    // Recovery metrics
+    hrvAvg: v.optional(v.number()),
+    hrvRmssd: v.optional(v.number()),
+    restingHeartRate: v.optional(v.number()),
+    recoveryScore: v.optional(v.number()),
+
+    // Body metrics
+    weight: v.optional(v.number()),
+    bodyFatPercentage: v.optional(v.number()),
+    bodyMassIndex: v.optional(v.number()),
+    leanBodyMass: v.optional(v.number()),
+    bodyTemperature: v.optional(v.number()),
+
+    // Stress / other
+    avgStressLevel: v.optional(v.number()),
+    bodyBattery: v.optional(v.number()),
+    spo2Avg: v.optional(v.number()),
+  })
+    .index("by_user_category_date", ["userId", "category", "date"])
+    .index("by_user_date", ["userId", "date"]),
+
+  // -------------------------------------------------------------------------
+  // Sync Jobs — workflow tracking for data syncs
+  // -------------------------------------------------------------------------
+  syncJobs: defineTable({
+    connectionId: v.id("connections"),
+    userId: v.string(),
+    provider: providerName,
+    mode: v.optional(v.union(v.literal("manual"), v.literal("cron"), v.literal("webhook"))),
+    triggerSource: v.optional(v.string()),
+    idempotencyKey: v.string(),
+    status: syncJobStatus,
+    startedAt: v.number(), // unix ms
+    completedAt: v.optional(v.number()),
+    error: v.optional(v.string()),
+    recordsProcessed: v.optional(v.number()),
+    workflowId: v.optional(v.string()),
+    windowStart: v.optional(v.number()),
+    windowEnd: v.optional(v.number()),
+    attempt: v.optional(v.number()),
+    lastHeartbeatAt: v.optional(v.number()),
+    cursor: v.optional(v.string()),
+    currentPhase: v.optional(
+      v.union(v.literal("events"), v.literal("dataPoints"), v.literal("summaries")),
+    ),
+  })
+    .index("by_user", ["userId"])
+    .index("by_connection", ["connectionId"])
+    .index("by_user_provider", ["userId", "provider"])
+    .index("by_user_status", ["userId", "status"])
+    .index("by_status", ["status"])
+    .index("by_idempotency_key", ["idempotencyKey"])
+    .index("by_workflow", ["workflowId"]),
+
+  // -------------------------------------------------------------------------
+  // OAuth States — temporary state for OAuth PKCE flows
+  // -------------------------------------------------------------------------
+  oauthStates: defineTable({
+    state: v.string(), // random state token
+    userId: v.string(),
+    provider: providerName,
+    codeVerifier: v.optional(v.string()), // PKCE
+    redirectUri: v.optional(v.string()),
+    createdAt: v.number(), // unix ms
+  }).index("by_state", ["state"]),
+
+  // -------------------------------------------------------------------------
+  // Provider Settings — which providers are enabled + config
+  // -------------------------------------------------------------------------
+  providerSettings: defineTable({
+    provider: providerName,
+    isEnabled: v.boolean(),
+    clientId: v.optional(v.string()),
+    clientSecret: v.optional(v.string()),
+    subscriptionKey: v.optional(v.string()),
+    updatedAt: v.optional(v.number()),
+  }).index("by_provider", ["provider"]),
+
+  // -------------------------------------------------------------------------
+  // Provider Priorities — sync order when multiple providers have same data
+  // -------------------------------------------------------------------------
+  providerPriorities: defineTable({
+    provider: providerName,
+    priority: v.number(), // 1 = highest
+  })
+    .index("by_provider", ["provider"])
+    .index("by_priority", ["priority"]),
+
+  // -------------------------------------------------------------------------
+  // Menstrual Cycle Tracking (MCT) — Women's Health data
+  // -------------------------------------------------------------------------
+  menstrualCycles: defineTable({
+    userId: v.string(),
+    provider: providerName,
+    externalId: v.optional(v.string()), // summaryId from provider
+    periodStartDate: v.string(), // "2026-03-01" ISO date
+    dayInCycle: v.optional(v.number()),
+    cycleLength: v.optional(v.number()),
+    predictedCycleLength: v.optional(v.number()),
+    periodLength: v.optional(v.number()),
+    currentPhase: v.optional(v.number()), // numeric phase ID
+    currentPhaseType: v.optional(v.string()), // "MENSTRUAL", "FOLLICULAR", "OVULATION", "LUTEAL", "SECOND_TRIMESTER", etc.
+    lengthOfCurrentPhase: v.optional(v.number()),
+    daysUntilNextPhase: v.optional(v.number()),
+    isPredictedCycle: v.optional(v.boolean()),
+    fertileWindowStart: v.optional(v.number()), // day in cycle
+    lengthOfFertileWindow: v.optional(v.number()),
+    lastUpdatedAt: v.optional(v.number()), // unix ms
+
+    // Pregnancy data (present when in pregnant phase)
+    isPregnant: v.optional(v.boolean()),
+    pregnancyDueDate: v.optional(v.string()), // "2026-09-15" ISO date
+    pregnancyOriginalDueDate: v.optional(v.string()),
+    pregnancyCycleStartDate: v.optional(v.string()),
+    pregnancyTitle: v.optional(v.string()),
+    numberOfBabies: v.optional(v.string()), // "SINGLE", "TWINS", etc.
+  })
+    .index("by_user_date", ["userId", "periodStartDate"])
+    .index("by_user_provider", ["userId", "provider"])
+    .index("by_external_id", ["externalId"]),
+
+  // -------------------------------------------------------------------------
+  // Backfill Jobs — tracks long-running backfill operations (e.g. Garmin)
+  // -------------------------------------------------------------------------
+  backfillJobs: defineTable({
+    connectionId: v.id("connections"),
+    userId: v.string(),
+    provider: providerName,
+    dataType: v.string(), // "full" for a full run; current type tracked separately
+    status: backfillStatus,
+    startedAt: v.number(),
+    completedAt: v.optional(v.number()),
+    error: v.optional(v.string()),
+    workflowId: v.optional(v.string()),
+    windowStart: v.optional(v.number()),
+    windowEnd: v.optional(v.number()),
+    currentDataType: v.optional(v.string()),
+    currentAttempt: v.optional(v.number()),
+    currentEventId: v.optional(v.string()),
+    completedDataTypes: v.optional(v.array(v.string())),
+    lastHeartbeatAt: v.optional(v.number()),
+  })
+    .index("by_connection", ["connectionId"])
+    .index("by_connection_type", ["connectionId", "dataType"])
+    .index("by_status", ["status"])
+    .index("by_workflow", ["workflowId"]),
+});

package/src/component/sdkPush.test.ts

@@ -0,0 +1,367 @@
+import { convexTest } from "convex-test";
+import { describe, expect, it } from "vitest";
+import { api } from "./_generated/api";
+import schema from "./schema";
+import { modules } from "./test.setup";
+
+describe("sdkPush", () => {
+  it("ingests normalized Google Health Connect data into connections, sources, events, points, and summaries", async () => {
+    const t = convexTest(schema, modules);
+
+    const result = await t.action(api.sdkPush.ingestNormalizedPayload, {
+      userId: "user-1",
+      provider: "google",
+      providerUserId: "hc-user-1",
+      providerUsername: "denis@example.com",
+      sourceMetadata: {
+        deviceModel: "Pixel Watch 3",
+        source: "health-connect",
+      },
+      events: [
+        {
+          category: "sleep",
+          type: "sleep_session",
+          startDatetime: Date.parse("2026-03-17T22:30:00Z"),
+          endDatetime: Date.parse("2026-03-18T06:30:00Z"),
+          durationSeconds: 8 * 60 * 60,
+          externalId: "hc-sleep-1",
+          sleepTotalDurationMinutes: 440,
+          sleepTimeInBedMinutes: 480,
+          sleepDeepMinutes: 90,
+          sleepLightMinutes: 240,
+          sleepRemMinutes: 110,
+          sleepAwakeMinutes: 40,
+          sleepEfficiencyScore: 91,
+        },
+      ],
+      dataPoints: [
+        {
+          seriesType: "heart_rate",
+          recordedAt: Date.parse("2026-03-18T07:00:00Z"),
+          value: 58,
+          externalId: "hc-hr-1",
+        },
+        {
+          seriesType: "steps",
+          recordedAt: Date.parse("2026-03-18T12:00:00Z"),
+          value: 4200,
+          externalId: "hc-steps-1",
+        },
+        {
+          seriesType: "resting_heart_rate",
+          recordedAt: Date.parse("2026-03-18T07:00:00Z"),
+          value: 49,
+          externalId: "hc-rhr-1",
+        },
+      ],
+      summaries: [
+        {
+          date: "2026-03-18",
+          category: "activity",
+          totalSteps: 10000,
+          totalCalories: 650,
+        },
+        {
+          date: "2026-03-18",
+          category: "recovery",
+          restingHeartRate: 49,
+        },
+      ],
+    });
+
+    expect(result.eventsStored).toBe(1);
+    expect(result.dataPointsStored).toBe(3);
+    expect(result.summariesStored).toBe(2);
+
+    const connection = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("connections")
+        .withIndex("by_user_provider", (idx) => idx.eq("userId", "user-1").eq("provider", "google"))
+        .first();
+    });
+    expect(connection).toMatchObject({
+      userId: "user-1",
+      provider: "google",
+      providerUserId: "hc-user-1",
+      providerUsername: "denis@example.com",
+      status: "active",
+    });
+    expect(connection?.lastSyncedAt).toBeTypeOf("number");
+
+    const dataSources = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataSources")
+        .withIndex("by_user_provider", (idx) => idx.eq("userId", "user-1").eq("provider", "google"))
+        .collect();
+    });
+    expect(dataSources).toHaveLength(1);
+    expect(dataSources[0]).toMatchObject({
+      deviceModel: "Pixel Watch 3",
+      source: "health-connect",
+    });
+
+    const events = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("events")
+        .withIndex("by_user_category_time", (idx) =>
+          idx.eq("userId", "user-1").eq("category", "sleep"),
+        )
+        .collect();
+    });
+    expect(events).toHaveLength(1);
+    expect(events[0]).toMatchObject({
+      externalId: "hc-sleep-1",
+      sleepTotalDurationMinutes: 440,
+      sourceName: "Google Health Connect",
+    });
+
+    const dataPoints = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataPoints")
+        .withIndex("by_source_type_time", (idx) => idx.eq("dataSourceId", dataSources[0]._id))
+        .collect();
+    });
+    expect(dataPoints).toHaveLength(3);
+
+    const summaries = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dailySummaries")
+        .withIndex("by_user_date", (idx) => idx.eq("userId", "user-1").eq("date", "2026-03-18"))
+        .collect();
+    });
+    expect(summaries).toHaveLength(2);
+  });
+
+  it("deduplicates SDK pushes by external id and source-time keys", async () => {
+    const t = convexTest(schema, modules);
+
+    await t.action(api.sdkPush.ingestNormalizedPayload, {
+      userId: "user-2",
+      provider: "apple",
+      sourceMetadata: {
+        deviceModel: "Apple Watch Ultra 2",
+        source: "healthkit",
+      },
+      events: [
+        {
+          category: "workout",
+          type: "running",
+          startDatetime: Date.parse("2026-03-18T10:00:00Z"),
+          endDatetime: Date.parse("2026-03-18T10:30:00Z"),
+          externalId: "apple-workout-1",
+          distance: 5000,
+        },
+      ],
+      dataPoints: [
+        {
+          seriesType: "heart_rate",
+          recordedAt: Date.parse("2026-03-18T10:15:00Z"),
+          value: 148,
+        },
+      ],
+    });
+
+    await t.action(api.sdkPush.ingestNormalizedPayload, {
+      userId: "user-2",
+      provider: "apple",
+      sourceMetadata: {
+        deviceModel: "Apple Watch Ultra 2",
+        source: "healthkit",
+      },
+      events: [
+        {
+          category: "workout",
+          type: "running",
+          startDatetime: Date.parse("2026-03-18T10:00:00Z"),
+          endDatetime: Date.parse("2026-03-18T10:30:00Z"),
+          externalId: "apple-workout-1",
+          distance: 5200,
+        },
+      ],
+      dataPoints: [
+        {
+          seriesType: "heart_rate",
+          recordedAt: Date.parse("2026-03-18T10:15:00Z"),
+          value: 150,
+        },
+      ],
+    });
+
+    const sources = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataSources")
+        .withIndex("by_user_provider", (idx) => idx.eq("userId", "user-2").eq("provider", "apple"))
+        .collect();
+    });
+
+    const events = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("events")
+        .withIndex("by_user_category_time", (idx) =>
+          idx.eq("userId", "user-2").eq("category", "workout"),
+        )
+        .collect();
+    });
+    expect(events).toHaveLength(1);
+    expect(events[0].distance).toBe(5200);
+
+    const dataPoints = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataPoints")
+        .withIndex("by_source_type_time", (idx) =>
+          idx
+            .eq("dataSourceId", sources[0]._id)
+            .eq("seriesType", "heart_rate")
+            .eq("recordedAt", Date.parse("2026-03-18T10:15:00Z")),
+        )
+        .collect();
+    });
+    expect(dataPoints).toHaveLength(1);
+    expect(dataPoints[0].value).toBe(150);
+  });
+
+  it("accepts plan-compatible payload aliases and normalizes series types", async () => {
+    const t = convexTest(schema, modules);
+
+    await t.action(api.sdkPush.ingestNormalizedPayload, {
+      userId: "user-3",
+      provider: "google",
+      syncTimestamp: Date.parse("2026-03-18T18:00:00Z"),
+      device: {
+        model: "Pixel 9 Pro",
+        softwareVersion: "Android 16",
+        source: "health-connect",
+      },
+      dataPoints: [
+        {
+          seriesType: "hrv_rmssd",
+          recordedAt: Date.parse("2026-03-18T07:00:00Z"),
+          value: 42,
+          externalId: "hc-hrv-1",
+        },
+        {
+          seriesType: "floors_climbed",
+          recordedAt: Date.parse("2026-03-18T12:00:00Z"),
+          value: 12,
+          externalId: "hc-floors-1",
+        },
+        {
+          seriesType: "distance",
+          recordedAt: Date.parse("2026-03-18T12:01:00Z"),
+          value: 1500,
+          externalId: "hc-distance-1",
+        },
+        {
+          seriesType: "active_calories",
+          recordedAt: Date.parse("2026-03-18T12:02:00Z"),
+          value: 340,
+          externalId: "hc-active-calories-1",
+        },
+      ],
+      dailySummaries: [
+        {
+          date: "2026-03-18",
+          category: "activity",
+          totalSteps: 12345,
+          totalCalories: 780,
+        },
+      ],
+    });
+
+    const source = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataSources")
+        .withIndex("by_user_provider", (idx) => idx.eq("userId", "user-3").eq("provider", "google"))
+        .first();
+    });
+
+    expect(source).toMatchObject({
+      deviceModel: "Pixel 9 Pro",
+      softwareVersion: "Android 16",
+      source: "health-connect",
+    });
+
+    const points = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataPoints")
+        .withIndex("by_source_type_time", (idx) => idx.eq("dataSourceId", source!._id))
+        .collect();
+    });
+
+    expect(points.map((point) => point.seriesType).sort()).toEqual([
+      "active_calories",
+      "distance",
+      "floors_climbed",
+      "heart_rate_variability_rmssd",
+    ]);
+
+    const summaries = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dailySummaries")
+        .withIndex("by_user_date", (idx) => idx.eq("userId", "user-3").eq("date", "2026-03-18"))
+        .collect();
+    });
+
+    expect(summaries).toHaveLength(1);
+    expect(summaries[0]).toMatchObject({
+      category: "activity",
+      totalSteps: 12345,
+      totalCalories: 780,
+    });
+  });
+
+  it("batches large data-point payloads across multiple writes", async () => {
+    const t = convexTest(schema, modules);
+
+    await t.action(api.sdkPush.ingestNormalizedPayload, {
+      userId: "user-4",
+      provider: "google",
+      sourceMetadata: {
+        deviceModel: "Pixel Watch 3",
+        source: "health-connect",
+      },
+      dataPoints: Array.from({ length: 205 }, (_, index) => ({
+        seriesType: "heart_rate",
+        recordedAt: Date.parse("2026-03-18T10:00:00Z") + index * 60_000,
+        value: 120 + (index % 5),
+        externalId: `hc-batch-${index}`,
+      })),
+    });
+
+    const source = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataSources")
+        .withIndex("by_user_provider", (idx) => idx.eq("userId", "user-4").eq("provider", "google"))
+        .first();
+    });
+
+    const points = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataPoints")
+        .withIndex("by_source_type_time", (idx) =>
+          idx.eq("dataSourceId", source!._id).eq("seriesType", "heart_rate"),
+        )
+        .collect();
+    });
+
+    expect(points).toHaveLength(205);
+  });
+
+  it("rejects unsupported series types", async () => {
+    const t = convexTest(schema, modules);
+
+    await expect(
+      t.action(api.sdkPush.ingestNormalizedPayload, {
+        userId: "user-5",
+        provider: "google",
+        dataPoints: [
+          {
+            seriesType: "totally_unknown_metric",
+            recordedAt: Date.parse("2026-03-18T10:00:00Z"),
+            value: 1,
+          },
+        ],
+      }),
+    ).rejects.toThrow('Unsupported series type "totally_unknown_metric"');
+  });
+});