@clipin/convex-wearables 0.0.2 → 0.1.0

package/src/component/connections.test.ts

@@ -0,0 +1,297 @@
+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("connections", () => {
+  describe("createConnection", () => {
+    it("creates a new active connection", async () => {
+      const t = convexTest(schema, modules);
+
+      const id = await t.run(async (ctx) => {
+        return await ctx.db.insert("connections", {
+          userId: "user-1",
+          provider: "garmin",
+          accessToken: "access-token-123",
+          refreshToken: "refresh-token-456",
+          tokenExpiresAt: Date.now() + 3600000,
+          providerUserId: "garmin-user-789",
+          status: "active",
+        });
+      });
+
+      expect(id).toBeDefined();
+
+      const conn = await t.run(async (ctx) => {
+        return await ctx.db.get(id);
+      });
+      expect(conn).toMatchObject({
+        provider: "garmin",
+        status: "active",
+        providerUserId: "garmin-user-789",
+      });
+    });
+
+    it("re-activates existing connection with patch", async () => {
+      const t = convexTest(schema, modules);
+
+      const id = await t.run(async (ctx) => {
+        return await ctx.db.insert("connections", {
+          userId: "user-1",
+          provider: "strava",
+          accessToken: "old-token",
+          status: "active",
+        });
+      });
+
+      // Disconnect
+      await t.run(async (ctx) => {
+        await ctx.db.patch(id, {
+          status: "inactive",
+          accessToken: undefined,
+          refreshToken: undefined,
+        });
+      });
+
+      // Re-activate with new tokens
+      await t.run(async (ctx) => {
+        await ctx.db.patch(id, {
+          status: "active",
+          accessToken: "new-token",
+          refreshToken: "new-refresh",
+        });
+      });
+
+      const conn = await t.run(async (ctx) => {
+        return await ctx.db.get(id);
+      });
+      expect(conn?.status).toBe("active");
+      expect(conn?.accessToken).toBe("new-token");
+    });
+  });
+
+  describe("queries", () => {
+    it("finds connections by user via index", async () => {
+      const t = convexTest(schema, modules);
+
+      await t.run(async (ctx) => {
+        await ctx.db.insert("connections", {
+          userId: "user-1",
+          provider: "garmin",
+          accessToken: "t1",
+          status: "active",
+        });
+        await ctx.db.insert("connections", {
+          userId: "user-1",
+          provider: "strava",
+          accessToken: "t2",
+          status: "active",
+        });
+        await ctx.db.insert("connections", {
+          userId: "user-2",
+          provider: "whoop",
+          accessToken: "t3",
+          status: "active",
+        });
+      });
+
+      const user1 = await t.run(async (ctx) => {
+        return await ctx.db
+          .query("connections")
+          .withIndex("by_user", (idx) => idx.eq("userId", "user-1"))
+          .collect();
+      });
+
+      expect(user1).toHaveLength(2);
+      const providers = user1.map((c) => c.provider);
+      expect(providers).toContain("garmin");
+      expect(providers).toContain("strava");
+    });
+
+    it("finds connection by user + provider via index", async () => {
+      const t = convexTest(schema, modules);
+
+      await t.run(async (ctx) => {
+        await ctx.db.insert("connections", {
+          userId: "user-1",
+          provider: "garmin",
+          accessToken: "t1",
+          status: "active",
+        });
+        await ctx.db.insert("connections", {
+          userId: "user-1",
+          provider: "strava",
+          accessToken: "t2",
+          status: "active",
+        });
+      });
+
+      const conn = await t.run(async (ctx) => {
+        return await ctx.db
+          .query("connections")
+          .withIndex("by_user_provider", (idx) =>
+            idx.eq("userId", "user-1").eq("provider", "garmin"),
+          )
+          .first();
+      });
+
+      expect(conn).not.toBeNull();
+      expect(conn?.provider).toBe("garmin");
+    });
+
+    it("redacts token fields from getByUserProvider", async () => {
+      const t = convexTest(schema, modules);
+
+      await t.run(async (ctx) => {
+        await ctx.db.insert("connections", {
+          userId: "user-1",
+          provider: "garmin",
+          providerUserId: "garmin-user",
+          accessToken: "secret-access",
+          refreshToken: "secret-refresh",
+          tokenExpiresAt: Date.now() + 60_000,
+          status: "active",
+        });
+      });
+
+      const conn = await t.query(api.connections.getByUserProvider, {
+        userId: "user-1",
+        provider: "garmin",
+      });
+
+      expect(conn).toMatchObject({
+        userId: "user-1",
+        provider: "garmin",
+        providerUserId: "garmin-user",
+        status: "active",
+      });
+      expect(conn).not.toHaveProperty("accessToken");
+      expect(conn).not.toHaveProperty("refreshToken");
+      expect(conn).not.toHaveProperty("tokenExpiresAt");
+    });
+
+    it("finds active connections via index", async () => {
+      const t = convexTest(schema, modules);
+
+      await t.run(async (ctx) => {
+        await ctx.db.insert("connections", {
+          userId: "user-1",
+          provider: "garmin",
+          accessToken: "t1",
+          status: "active",
+        });
+        await ctx.db.insert("connections", {
+          userId: "user-2",
+          provider: "strava",
+          accessToken: "t2",
+          status: "inactive",
+        });
+      });
+
+      const active = await t.run(async (ctx) => {
+        return await ctx.db
+          .query("connections")
+          .withIndex("by_status", (idx) => idx.eq("status", "active"))
+          .collect();
+      });
+
+      expect(active).toHaveLength(1);
+      expect(active[0].userId).toBe("user-1");
+    });
+
+    it("returns the latest sync job per provider in getSyncStatus", async () => {
+      const t = convexTest(schema, modules);
+
+      await t.run(async (ctx) => {
+        const garminConnectionId = await ctx.db.insert("connections", {
+          userId: "user-1",
+          provider: "garmin",
+          accessToken: "garmin-token",
+          status: "active",
+          lastSyncedAt: 1_000,
+        });
+        const stravaConnectionId = await ctx.db.insert("connections", {
+          userId: "user-1",
+          provider: "strava",
+          accessToken: "strava-token",
+          status: "active",
+          lastSyncedAt: 2_000,
+        });
+
+        await ctx.db.insert("syncJobs", {
+          connectionId: garminConnectionId,
+          userId: "user-1",
+          provider: "garmin",
+          idempotencyKey: "garmin-1",
+          status: "completed",
+          startedAt: 100,
+        });
+        await ctx.db.insert("syncJobs", {
+          connectionId: stravaConnectionId,
+          userId: "user-1",
+          provider: "strava",
+          idempotencyKey: "strava-1",
+          status: "failed",
+          startedAt: 200,
+          error: "rate limited",
+        });
+      });
+
+      const statuses = await t.query(api.connections.getSyncStatus, {
+        userId: "user-1",
+      });
+
+      expect(statuses).toEqual(
+        expect.arrayContaining([
+          {
+            provider: "garmin",
+            connectionStatus: "active",
+            lastSyncedAt: 1_000,
+            syncJobStatus: "completed",
+            syncJobError: null,
+          },
+          {
+            provider: "strava",
+            connectionStatus: "active",
+            lastSyncedAt: 2_000,
+            syncJobStatus: "failed",
+            syncJobError: "rate limited",
+          },
+        ]),
+      );
+    });
+  });
+
+  describe("disconnect", () => {
+    it("sets status to inactive and clears tokens", async () => {
+      const t = convexTest(schema, modules);
+
+      const id = await t.run(async (ctx) => {
+        return await ctx.db.insert("connections", {
+          userId: "user-1",
+          provider: "whoop",
+          accessToken: "secret",
+          refreshToken: "secret-r",
+          status: "active",
+        });
+      });
+
+      await t.run(async (ctx) => {
+        await ctx.db.patch(id, {
+          status: "inactive",
+          accessToken: undefined,
+          refreshToken: undefined,
+          tokenExpiresAt: undefined,
+        });
+      });
+
+      const conn = await t.run(async (ctx) => {
+        return await ctx.db.get(id);
+      });
+      expect(conn?.status).toBe("inactive");
+      expect(conn?.accessToken).toBeUndefined();
+      expect(conn?.refreshToken).toBeUndefined();
+    });
+  });
+});

package/src/component/connections.ts

@@ -0,0 +1,329 @@
+import { v } from "convex/values";
+import { internalMutation, internalQuery, mutation, query } from "./_generated/server";
+import { connectionStatus, providerName } from "./schema";
+
+// ---------------------------------------------------------------------------
+// Queries
+// ---------------------------------------------------------------------------
+
+/**
+ * Get all connections for a user.
+ */
+export const getConnections = query({
+  args: { userId: v.string() },
+  returns: v.array(v.any()),
+  handler: async (ctx, args) => {
+    const connections = await ctx.db
+      .query("connections")
+      .withIndex("by_user", (idx) => idx.eq("userId", args.userId))
+      .collect();
+
+    // Strip sensitive token fields before returning
+    return connections.map((conn) => ({
+      _id: conn._id,
+      _creationTime: conn._creationTime,
+      userId: conn.userId,
+      provider: conn.provider,
+      providerUserId: conn.providerUserId,
+      providerUsername: conn.providerUsername,
+      status: conn.status,
+      lastSyncedAt: conn.lastSyncedAt,
+    }));
+  },
+});
+
+/**
+ * Get a specific connection by user + provider.
+ */
+export const getByUserProvider = query({
+  args: {
+    userId: v.string(),
+    provider: providerName,
+  },
+  returns: v.union(v.any(), v.null()),
+  handler: async (ctx, args) => {
+    const conn = await ctx.db
+      .query("connections")
+      .withIndex("by_user_provider", (idx) =>
+        idx.eq("userId", args.userId).eq("provider", args.provider),
+      )
+      .first();
+
+    if (!conn) {
+      return null;
+    }
+
+    return {
+      _id: conn._id,
+      _creationTime: conn._creationTime,
+      userId: conn.userId,
+      provider: conn.provider,
+      providerUserId: conn.providerUserId,
+      providerUsername: conn.providerUsername,
+      status: conn.status,
+      lastSyncedAt: conn.lastSyncedAt,
+    };
+  },
+});
+
+/**
+ * Get all active connections (for periodic sync).
+ */
+export const getAllActive = internalQuery({
+  args: {},
+  returns: v.array(v.any()),
+  handler: async (ctx) => {
+    return await ctx.db
+      .query("connections")
+      .withIndex("by_status", (idx) => idx.eq("status", "active"))
+      .collect();
+  },
+});
+
+export const getById = internalQuery({
+  args: {
+    connectionId: v.id("connections"),
+  },
+  returns: v.union(v.any(), v.null()),
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.connectionId);
+  },
+});
+
+export const getByProviderUser = internalQuery({
+  args: {
+    provider: providerName,
+    providerUserId: v.string(),
+  },
+  returns: v.union(v.any(), v.null()),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("connections")
+      .withIndex("by_provider_user", (idx) =>
+        idx.eq("provider", args.provider).eq("providerUserId", args.providerUserId),
+      )
+      .first();
+  },
+});
+
+/**
+ * Get sync status for a user across all their connections.
+ */
+export const getSyncStatus = query({
+  args: { userId: v.string() },
+  returns: v.array(v.any()),
+  handler: async (ctx, args) => {
+    const connections = await ctx.db
+      .query("connections")
+      .withIndex("by_user", (idx) => idx.eq("userId", args.userId))
+      .collect();
+
+    const statuses = [];
+    for (const conn of connections) {
+      const latestJob = await ctx.db
+        .query("syncJobs")
+        .withIndex("by_connection", (idx) => idx.eq("connectionId", conn._id))
+        .order("desc")
+        .first();
+
+      statuses.push({
+        provider: conn.provider,
+        connectionStatus: conn.status,
+        lastSyncedAt: conn.lastSyncedAt,
+        syncJobStatus: latestJob?.status ?? null,
+        syncJobError: latestJob?.error ?? null,
+      });
+    }
+
+    return statuses;
+  },
+});
+
+// ---------------------------------------------------------------------------
+// Mutations
+// ---------------------------------------------------------------------------
+
+/**
+ * Create a new connection (after successful OAuth token exchange).
+ */
+export const createConnection = internalMutation({
+  args: {
+    userId: v.string(),
+    provider: providerName,
+    providerUserId: v.optional(v.string()),
+    providerUsername: v.optional(v.string()),
+    accessToken: v.string(),
+    refreshToken: v.optional(v.string()),
+    tokenExpiresAt: v.optional(v.number()),
+    scope: v.optional(v.string()),
+  },
+  returns: v.id("connections"),
+  handler: async (ctx, args) => {
+    // Check if connection already exists
+    const existing = await ctx.db
+      .query("connections")
+      .withIndex("by_user_provider", (idx) =>
+        idx.eq("userId", args.userId).eq("provider", args.provider),
+      )
+      .first();
+
+    if (existing) {
+      // Re-activate and update tokens
+      await ctx.db.patch(existing._id, {
+        ...args,
+        status: "active",
+      });
+      return existing._id;
+    }
+
+    return await ctx.db.insert("connections", {
+      ...args,
+      status: "active",
+    });
+  },
+});
+
+/**
+ * Ensure a push-based provider connection exists for SDK-ingested providers
+ * like Apple Health or Google Health Connect.
+ */
+export const ensurePushConnection = internalMutation({
+  args: {
+    userId: v.string(),
+    provider: providerName,
+    providerUserId: v.optional(v.string()),
+    providerUsername: v.optional(v.string()),
+  },
+  returns: v.id("connections"),
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query("connections")
+      .withIndex("by_user_provider", (idx) =>
+        idx.eq("userId", args.userId).eq("provider", args.provider),
+      )
+      .first();
+
+    if (existing) {
+      await ctx.db.patch(existing._id, {
+        providerUserId: args.providerUserId ?? existing.providerUserId,
+        providerUsername: args.providerUsername ?? existing.providerUsername,
+        status: "active",
+      });
+      return existing._id;
+    }
+
+    return await ctx.db.insert("connections", {
+      userId: args.userId,
+      provider: args.provider,
+      providerUserId: args.providerUserId,
+      providerUsername: args.providerUsername,
+      status: "active",
+    });
+  },
+});
+
+/**
+ * Update OAuth tokens (e.g., after refresh).
+ */
+export const updateTokens = internalMutation({
+  args: {
+    connectionId: v.id("connections"),
+    accessToken: v.string(),
+    refreshToken: v.optional(v.string()),
+    tokenExpiresAt: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const { connectionId, ...updates } = args;
+    await ctx.db.patch(connectionId, updates);
+  },
+});
+
+/**
+ * Mark a connection as synced (update lastSyncedAt).
+ */
+export const markSynced = internalMutation({
+  args: { connectionId: v.id("connections") },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.connectionId, {
+      lastSyncedAt: Date.now(),
+    });
+  },
+});
+
+/**
+ * Update connection status.
+ */
+export const updateStatus = internalMutation({
+  args: {
+    connectionId: v.id("connections"),
+    status: connectionStatus,
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.connectionId, { status: args.status });
+  },
+});
+
+/**
+ * Update the stored OAuth scope / permissions for a connection.
+ */
+export const updateScope = internalMutation({
+  args: {
+    connectionId: v.id("connections"),
+    scope: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.connectionId, {
+      scope: args.scope,
+    });
+  },
+});
+
+/**
+ * Disconnect a provider — sets status to inactive.
+ */
+export const disconnect = mutation({
+  args: {
+    userId: v.string(),
+    provider: providerName,
+  },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const conn = await ctx.db
+      .query("connections")
+      .withIndex("by_user_provider", (idx) =>
+        idx.eq("userId", args.userId).eq("provider", args.provider),
+      )
+      .first();
+
+    if (conn) {
+      await ctx.db.patch(conn._id, {
+        status: "inactive",
+        accessToken: undefined,
+        refreshToken: undefined,
+        tokenExpiresAt: undefined,
+      });
+    }
+
+    return null;
+  },
+});
+
+/**
+ * Delete a connection and all associated data sources.
+ */
+export const deleteConnection = internalMutation({
+  args: { connectionId: v.id("connections") },
+  handler: async (ctx, args) => {
+    // Delete associated data sources
+    const sources = await ctx.db
+      .query("dataSources")
+      .withIndex("by_connection", (idx) => idx.eq("connectionId", args.connectionId))
+      .collect();
+
+    for (const source of sources) {
+      await ctx.db.delete(source._id);
+    }
+
+    await ctx.db.delete(args.connectionId);
+  },
+});

package/src/component/convex.config.ts

@@ -0,0 +1,7 @@
+import workflow from "@convex-dev/workflow/convex.config";
+import { defineComponent } from "convex/server";
+
+const component = defineComponent("wearables");
+component.use(workflow, { name: "workflow" });
+
+export default component;