@clipin/convex-wearables 0.0.2 → 0.0.3

package/src/component/dataPoints.ts

@@ -0,0 +1,305 @@
+import { v } from "convex/values";
+import { internalMutation, query } from "./_generated/server";
+
+// ---------------------------------------------------------------------------
+// Queries
+// ---------------------------------------------------------------------------
+
+/**
+ * Get time-series data points with cursor-based pagination.
+ * Uses the by_source_type_time index for efficient range queries.
+ */
+export const getTimeSeries = query({
+  args: {
+    dataSourceId: v.id("dataSources"),
+    seriesType: v.string(),
+    startDate: v.number(),
+    endDate: v.number(),
+    limit: v.optional(v.number()),
+    cursor: v.optional(v.string()),
+    order: v.optional(v.union(v.literal("asc"), v.literal("desc"))),
+  },
+  returns: v.object({
+    points: v.array(
+      v.object({
+        timestamp: v.number(),
+        value: v.number(),
+      }),
+    ),
+    nextCursor: v.union(v.string(), v.null()),
+    hasMore: v.boolean(),
+  }),
+  handler: async (ctx, args) => {
+    const limit = Math.min(args.limit ?? 500, 2000);
+    const order = args.order ?? "asc";
+
+    const startDate = args.cursor ? Number(args.cursor) : args.startDate;
+
+    const results = await ctx.db
+      .query("dataPoints")
+      .withIndex("by_source_type_time", (idx) =>
+        order === "asc"
+          ? idx
+              .eq("dataSourceId", args.dataSourceId)
+              .eq("seriesType", args.seriesType)
+              .gte("recordedAt", startDate)
+              .lte("recordedAt", args.endDate)
+          : idx
+              .eq("dataSourceId", args.dataSourceId)
+              .eq("seriesType", args.seriesType)
+              .gte("recordedAt", args.startDate)
+              .lte("recordedAt", startDate),
+      )
+      .order(order)
+      .take(limit + 1);
+
+    const hasMore = results.length > limit;
+    const items = hasMore ? results.slice(0, limit) : results;
+    const points = items.map((dp) => ({
+      timestamp: dp.recordedAt,
+      value: dp.value,
+    }));
+    const nextCursor =
+      hasMore && items.length > 0 ? String(items[items.length - 1].recordedAt) : null;
+
+    return { points, nextCursor, hasMore };
+  },
+});
+
+/**
+ * Get time-series data for a user across all their data sources for a given series type.
+ * This is a user-facing query that resolves data sources internally.
+ */
+export const getTimeSeriesForUser = query({
+  args: {
+    userId: v.string(),
+    seriesType: v.string(),
+    startDate: v.number(),
+    endDate: v.number(),
+    limit: v.optional(v.number()),
+  },
+  returns: v.array(
+    v.object({
+      timestamp: v.number(),
+      value: v.number(),
+    }),
+  ),
+  handler: async (ctx, args) => {
+    const limit = Math.min(args.limit ?? 500, 2000);
+
+    // Get all data sources for this user
+    const sources = await ctx.db
+      .query("dataSources")
+      .withIndex("by_user_provider", (idx) => idx.eq("userId", args.userId))
+      .collect();
+
+    // Collect data from all sources (merge and sort)
+    const allPoints: { timestamp: number; value: number }[] = [];
+    for (const source of sources) {
+      const points = await ctx.db
+        .query("dataPoints")
+        .withIndex("by_source_type_time", (idx) =>
+          idx
+            .eq("dataSourceId", source._id)
+            .eq("seriesType", args.seriesType)
+            .gte("recordedAt", args.startDate)
+            .lte("recordedAt", args.endDate),
+        )
+        .take(limit);
+
+      for (const dp of points) {
+        allPoints.push({ timestamp: dp.recordedAt, value: dp.value });
+      }
+    }
+
+    // Sort by timestamp and limit
+    allPoints.sort((a, b) => a.timestamp - b.timestamp);
+    return allPoints.slice(0, limit);
+  },
+});
+
+/**
+ * Get the latest data point for a user and series type.
+ */
+export const getLatestDataPoint = query({
+  args: {
+    userId: v.string(),
+    seriesType: v.string(),
+  },
+  returns: v.union(
+    v.object({
+      timestamp: v.number(),
+      value: v.number(),
+      provider: v.string(),
+    }),
+    v.null(),
+  ),
+  handler: async (ctx, args) => {
+    const sources = await ctx.db
+      .query("dataSources")
+      .withIndex("by_user_provider", (idx) => idx.eq("userId", args.userId))
+      .collect();
+
+    let latest: { timestamp: number; value: number; provider: string } | null = null;
+
+    for (const source of sources) {
+      const point = await ctx.db
+        .query("dataPoints")
+        .withIndex("by_source_type_time", (idx) =>
+          idx.eq("dataSourceId", source._id).eq("seriesType", args.seriesType),
+        )
+        .order("desc")
+        .first();
+
+      if (point && (latest === null || point.recordedAt > latest.timestamp)) {
+        latest = {
+          timestamp: point.recordedAt,
+          value: point.value,
+          provider: source.provider,
+        };
+      }
+    }
+
+    return latest;
+  },
+});
+
+/**
+ * Get all available series types for a user (i.e., types that have at least one data point).
+ */
+export const getAvailableSeriesTypes = query({
+  args: { userId: v.string() },
+  returns: v.array(v.string()),
+  handler: async (ctx, args) => {
+    const sources = await ctx.db
+      .query("dataSources")
+      .withIndex("by_user_provider", (idx) => idx.eq("userId", args.userId))
+      .collect();
+
+    const types = new Set<string>();
+
+    for (const source of sources) {
+      // Sample a few data points to discover types
+      // This is efficient because we only need one per type
+      const points = await ctx.db
+        .query("dataPoints")
+        .withIndex("by_source_type_time", (idx) => idx.eq("dataSourceId", source._id))
+        .take(200);
+
+      for (const point of points) {
+        types.add(point.seriesType);
+      }
+    }
+
+    return Array.from(types).sort();
+  },
+});
+
+// ---------------------------------------------------------------------------
+// Mutations
+// ---------------------------------------------------------------------------
+
+/**
+ * Store a single data point. Deduplicates by (source, type, time).
+ */
+export const storeDataPoint = internalMutation({
+  args: {
+    dataSourceId: v.id("dataSources"),
+    seriesType: v.string(),
+    recordedAt: v.number(),
+    value: v.number(),
+    externalId: v.optional(v.string()),
+  },
+  returns: v.id("dataPoints"),
+  handler: async (ctx, args) => {
+    // Deduplicate by (source, type, time)
+    const existing = await ctx.db
+      .query("dataPoints")
+      .withIndex("by_source_type_time", (idx) =>
+        idx
+          .eq("dataSourceId", args.dataSourceId)
+          .eq("seriesType", args.seriesType)
+          .eq("recordedAt", args.recordedAt),
+      )
+      .first();
+
+    if (existing) {
+      await ctx.db.patch(existing._id, { value: args.value });
+      return existing._id;
+    }
+
+    return await ctx.db.insert("dataPoints", args);
+  },
+});
+
+/**
+ * Store a batch of data points. Used by sync workflows.
+ * Must complete within 1 second — caller is responsible for batch sizing.
+ */
+export const storeBatch = internalMutation({
+  args: {
+    dataSourceId: v.id("dataSources"),
+    seriesType: v.string(),
+    points: v.array(
+      v.object({
+        recordedAt: v.number(),
+        value: v.number(),
+        externalId: v.optional(v.string()),
+      }),
+    ),
+  },
+  returns: v.number(),
+  handler: async (ctx, args) => {
+    let count = 0;
+    for (const point of args.points) {
+      // Deduplicate by (source, type, time)
+      const existing = await ctx.db
+        .query("dataPoints")
+        .withIndex("by_source_type_time", (idx) =>
+          idx
+            .eq("dataSourceId", args.dataSourceId)
+            .eq("seriesType", args.seriesType)
+            .eq("recordedAt", point.recordedAt),
+        )
+        .first();
+
+      if (existing) {
+        await ctx.db.patch(existing._id, { value: point.value });
+      } else {
+        await ctx.db.insert("dataPoints", {
+          dataSourceId: args.dataSourceId,
+          seriesType: args.seriesType,
+          recordedAt: point.recordedAt,
+          value: point.value,
+          externalId: point.externalId,
+        });
+      }
+      count++;
+    }
+    return count;
+  },
+});
+
+/**
+ * Delete all data points for a data source. Used during user/connection cleanup.
+ */
+export const deleteByDataSource = internalMutation({
+  args: { dataSourceId: v.id("dataSources") },
+  handler: async (ctx, args) => {
+    // Delete in batches to avoid hitting limits
+    let batch = await ctx.db
+      .query("dataPoints")
+      .withIndex("by_source_type_time", (idx) => idx.eq("dataSourceId", args.dataSourceId))
+      .take(1000);
+
+    while (batch.length > 0) {
+      for (const dp of batch) {
+        await ctx.db.delete(dp._id);
+      }
+      batch = await ctx.db
+        .query("dataPoints")
+        .withIndex("by_source_type_time", (idx) => idx.eq("dataSourceId", args.dataSourceId))
+        .take(1000);
+    }
+  },
+});

package/src/component/dataSources.test.ts

@@ -0,0 +1,247 @@
+import { convexTest } from "convex-test";
+import { describe, expect, it } from "vitest";
+import schema from "./schema";
+import { modules } from "./test.setup";
+
+describe("dataSources", () => {
+  it("creates a new data source", async () => {
+    const t = convexTest(schema, modules);
+
+    const id = await t.run(async (ctx) => {
+      return await ctx.db.insert("dataSources", {
+        userId: "user-1",
+        provider: "strava",
+        source: "strava",
+      });
+    });
+
+    const ds = await t.run(async (ctx) => {
+      return await ctx.db.get(id);
+    });
+
+    expect(ds?.userId).toBe("user-1");
+    expect(ds?.provider).toBe("strava");
+  });
+
+  it("finds data sources by user via index", async () => {
+    const t = convexTest(schema, modules);
+
+    await t.run(async (ctx) => {
+      await ctx.db.insert("dataSources", {
+        userId: "user-1",
+        provider: "strava",
+        source: "strava",
+      });
+      await ctx.db.insert("dataSources", {
+        userId: "user-1",
+        provider: "garmin",
+        deviceModel: "Forerunner 965",
+        source: "garmin-connect",
+      });
+      await ctx.db.insert("dataSources", {
+        userId: "user-2",
+        provider: "whoop",
+        source: "whoop",
+      });
+    });
+
+    const user1Sources = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataSources")
+        .withIndex("by_user_provider", (idx) => idx.eq("userId", "user-1"))
+        .collect();
+    });
+
+    expect(user1Sources).toHaveLength(2);
+  });
+
+  it("finds data sources by user + provider via index", async () => {
+    const t = convexTest(schema, modules);
+
+    await t.run(async (ctx) => {
+      await ctx.db.insert("dataSources", {
+        userId: "user-1",
+        provider: "strava",
+        source: "strava",
+      });
+      await ctx.db.insert("dataSources", {
+        userId: "user-1",
+        provider: "garmin",
+        source: "garmin-connect",
+      });
+    });
+
+    const stravaSources = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataSources")
+        .withIndex("by_user_provider", (idx) => idx.eq("userId", "user-1").eq("provider", "strava"))
+        .collect();
+    });
+
+    expect(stravaSources).toHaveLength(1);
+    expect(stravaSources[0].provider).toBe("strava");
+  });
+
+  it("upserts by user/provider/device/source (getOrCreate pattern)", async () => {
+    const t = convexTest(schema, modules);
+
+    // Create initial data source
+    const id1 = await t.run(async (ctx) => {
+      return await ctx.db.insert("dataSources", {
+        userId: "user-1",
+        provider: "garmin",
+        deviceModel: "Forerunner 965",
+        source: "garmin-connect",
+        softwareVersion: "1.0",
+      });
+    });
+
+    // Simulate getOrCreate — same user/provider/device/source should find existing
+    const found = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataSources")
+        .withIndex("by_user_provider_device", (idx) =>
+          idx
+            .eq("userId", "user-1")
+            .eq("provider", "garmin")
+            .eq("deviceModel", "Forerunner 965")
+            .eq("source", "garmin-connect"),
+        )
+        .first();
+    });
+
+    expect(found?._id).toBe(id1);
+
+    // Update the software version (simulating upsert update)
+    await t.run(async (ctx) => {
+      if (found) {
+        await ctx.db.patch(found._id, { softwareVersion: "2.0" });
+      }
+    });
+
+    const updated = await t.run(async (ctx) => {
+      return await ctx.db.get(id1);
+    });
+
+    expect(updated?.softwareVersion).toBe("2.0");
+  });
+
+  it("creates separate entries for different devices", async () => {
+    const t = convexTest(schema, modules);
+
+    await t.run(async (ctx) => {
+      await ctx.db.insert("dataSources", {
+        userId: "user-1",
+        provider: "garmin",
+        deviceModel: "Forerunner 965",
+        source: "garmin-connect",
+      });
+      await ctx.db.insert("dataSources", {
+        userId: "user-1",
+        provider: "garmin",
+        deviceModel: "Venu 3",
+        source: "garmin-connect",
+      });
+    });
+
+    const sources = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataSources")
+        .withIndex("by_user_provider", (idx) => idx.eq("userId", "user-1").eq("provider", "garmin"))
+        .collect();
+    });
+
+    expect(sources).toHaveLength(2);
+    const devices = sources.map((s) => s.deviceModel);
+    expect(devices).toContain("Forerunner 965");
+    expect(devices).toContain("Venu 3");
+  });
+
+  it("finds data sources by connectionId", async () => {
+    const t = convexTest(schema, modules);
+
+    const connId = await t.run(async (ctx) => {
+      return await ctx.db.insert("connections", {
+        userId: "user-1",
+        provider: "strava",
+        accessToken: "tok",
+        status: "active",
+      });
+    });
+
+    await t.run(async (ctx) => {
+      await ctx.db.insert("dataSources", {
+        userId: "user-1",
+        provider: "strava",
+        connectionId: connId,
+        source: "strava",
+      });
+      // Unrelated data source
+      await ctx.db.insert("dataSources", {
+        userId: "user-2",
+        provider: "garmin",
+        source: "garmin",
+      });
+    });
+
+    const byConn = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataSources")
+        .withIndex("by_connection", (idx) => idx.eq("connectionId", connId))
+        .collect();
+    });
+
+    expect(byConn).toHaveLength(1);
+    expect(byConn[0].provider).toBe("strava");
+  });
+
+  it("deletes all data sources for a user", async () => {
+    const t = convexTest(schema, modules);
+
+    await t.run(async (ctx) => {
+      await ctx.db.insert("dataSources", {
+        userId: "user-1",
+        provider: "strava",
+        source: "strava",
+      });
+      await ctx.db.insert("dataSources", {
+        userId: "user-1",
+        provider: "garmin",
+        source: "garmin",
+      });
+      await ctx.db.insert("dataSources", {
+        userId: "user-2",
+        provider: "whoop",
+        source: "whoop",
+      });
+    });
+
+    // Delete user-1 sources
+    await t.run(async (ctx) => {
+      const sources = await ctx.db
+        .query("dataSources")
+        .withIndex("by_user_provider", (idx) => idx.eq("userId", "user-1"))
+        .collect();
+      for (const s of sources) {
+        await ctx.db.delete(s._id);
+      }
+    });
+
+    const user1 = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataSources")
+        .withIndex("by_user_provider", (idx) => idx.eq("userId", "user-1"))
+        .collect();
+    });
+    expect(user1).toHaveLength(0);
+
+    // user-2 unaffected
+    const user2 = await t.run(async (ctx) => {
+      return await ctx.db
+        .query("dataSources")
+        .withIndex("by_user_provider", (idx) => idx.eq("userId", "user-2"))
+        .collect();
+    });
+    expect(user2).toHaveLength(1);
+  });
+});

package/src/component/dataSources.ts

@@ -0,0 +1,109 @@
+import { v } from "convex/values";
+import { internalMutation, mutation, query } from "./_generated/server";
+import { providerName } from "./schema";
+
+// ---------------------------------------------------------------------------
+// Queries
+// ---------------------------------------------------------------------------
+
+/**
+ * Get all data sources for a user.
+ */
+export const getByUser = query({
+  args: { userId: v.string() },
+  returns: v.array(v.any()),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("dataSources")
+      .withIndex("by_user_provider", (idx) => idx.eq("userId", args.userId))
+      .collect();
+  },
+});
+
+/**
+ * Get data sources for a user + provider combination.
+ */
+export const getByUserProvider = query({
+  args: {
+    userId: v.string(),
+    provider: providerName,
+  },
+  returns: v.array(v.any()),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("dataSources")
+      .withIndex("by_user_provider", (idx) =>
+        idx.eq("userId", args.userId).eq("provider", args.provider),
+      )
+      .collect();
+  },
+});
+
+// ---------------------------------------------------------------------------
+// Mutations
+// ---------------------------------------------------------------------------
+
+/**
+ * Get or create a data source. Used during data ingestion to ensure
+ * a data source exists for a given user/provider/device combination.
+ */
+export const getOrCreate = mutation({
+  args: {
+    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()),
+  },
+  returns: v.id("dataSources"),
+  handler: async (ctx, args) => {
+    // Look for existing data source matching this user/provider/device/source
+    const existing = await ctx.db
+      .query("dataSources")
+      .withIndex("by_user_provider_device", (idx) =>
+        idx
+          .eq("userId", args.userId)
+          .eq("provider", args.provider)
+          .eq("deviceModel", args.deviceModel ?? undefined)
+          .eq("source", args.source ?? undefined),
+      )
+      .first();
+
+    if (existing) {
+      // Update fields that may have changed
+      if (
+        args.softwareVersion !== existing.softwareVersion ||
+        args.deviceType !== existing.deviceType
+      ) {
+        await ctx.db.patch(existing._id, {
+          softwareVersion: args.softwareVersion,
+          deviceType: args.deviceType,
+          connectionId: args.connectionId ?? existing.connectionId,
+        });
+      }
+      return existing._id;
+    }
+
+    return await ctx.db.insert("dataSources", args);
+  },
+});
+
+/**
+ * Delete all data sources for a user. Used during account deletion.
+ */
+export const deleteByUser = internalMutation({
+  args: { userId: v.string() },
+  handler: async (ctx, args) => {
+    const sources = await ctx.db
+      .query("dataSources")
+      .withIndex("by_user_provider", (idx) => idx.eq("userId", args.userId))
+      .collect();
+
+    for (const source of sources) {
+      await ctx.db.delete(source._id);
+    }
+  },
+});