@clipin/convex-wearables 0.0.2 → 0.0.3

package/src/component/_generated/server.ts

@@ -0,0 +1,48 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  ActionBuilder,
+  HttpActionBuilder,
+  MutationBuilder,
+  QueryBuilder,
+  GenericActionCtx,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  GenericDatabaseReader,
+  GenericDatabaseWriter,
+} from "convex/server";
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+} from "convex/server";
+import type { DataModel } from "./dataModel.js";
+
+export const query: QueryBuilder<DataModel, "public"> = queryGeneric;
+export const internalQuery: QueryBuilder<DataModel, "internal"> =
+  internalQueryGeneric;
+export const mutation: MutationBuilder<DataModel, "public"> = mutationGeneric;
+export const internalMutation: MutationBuilder<DataModel, "internal"> =
+  internalMutationGeneric;
+export const action: ActionBuilder<DataModel, "public"> = actionGeneric;
+export const internalAction: ActionBuilder<DataModel, "internal"> =
+  internalActionGeneric;
+export const httpAction: HttpActionBuilder = httpActionGeneric;
+
+export type QueryCtx = GenericQueryCtx<DataModel>;
+export type MutationCtx = GenericMutationCtx<DataModel>;
+export type ActionCtx = GenericActionCtx<DataModel>;
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/src/component/backfillJobs.test.ts

@@ -0,0 +1,47 @@
+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("backfillJobs", () => {
+  it("returns the latest backfill job for a connection", async () => {
+    const t = convexTest(schema, modules);
+
+    const connectionId = await t.run(async (ctx) => {
+      return await ctx.db.insert("connections", {
+        userId: "user-1",
+        provider: "garmin",
+        accessToken: "token",
+        status: "active",
+      });
+    });
+
+    await t.run(async (ctx) => {
+      await ctx.db.insert("backfillJobs", {
+        connectionId,
+        userId: "user-1",
+        provider: "garmin",
+        dataType: "full",
+        status: "failed",
+        startedAt: 1,
+        completedAt: 2,
+      });
+      await ctx.db.insert("backfillJobs", {
+        connectionId,
+        userId: "user-1",
+        provider: "garmin",
+        dataType: "full",
+        status: "running",
+        startedAt: 3,
+      });
+    });
+
+    const job = await t.query(api.backfillJobs.getLatestByConnection, {
+      connectionId,
+    });
+
+    expect(job?.status).toBe("running");
+    expect(job?.startedAt).toBe(3);
+  });
+});

package/src/component/backfillJobs.ts

@@ -0,0 +1,245 @@
+import { v } from "convex/values";
+import { internal } from "./_generated/api";
+import { internalMutation, internalQuery, query } from "./_generated/server";
+import { backfillStatus, providerName } from "./schema";
+import { durableWorkflow } from "./workflowManager";
+
+export const backfillSignal = v.object({
+  kind: v.union(v.literal("webhook"), v.literal("timeout")),
+  dataType: v.string(),
+  itemCount: v.optional(v.number()),
+});
+
+export const getActiveByConnection = internalQuery({
+  args: {
+    connectionId: v.id("connections"),
+  },
+  returns: v.union(v.any(), v.null()),
+  handler: async (ctx, args) => {
+    const jobs = await ctx.db
+      .query("backfillJobs")
+      .withIndex("by_connection", (idx) => idx.eq("connectionId", args.connectionId))
+      .order("desc")
+      .take(10);
+
+    return jobs.find((job) => job.status === "queued" || job.status === "running") ?? null;
+  },
+});
+
+export const getById = internalQuery({
+  args: {
+    backfillJobId: v.id("backfillJobs"),
+  },
+  returns: v.union(v.any(), v.null()),
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.backfillJobId);
+  },
+});
+
+export const getLatestByConnection = query({
+  args: {
+    connectionId: v.id("connections"),
+  },
+  returns: v.union(v.any(), v.null()),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("backfillJobs")
+      .withIndex("by_connection", (idx) => idx.eq("connectionId", args.connectionId))
+      .order("desc")
+      .first();
+  },
+});
+
+export const create = internalMutation({
+  args: {
+    connectionId: v.id("connections"),
+    userId: v.string(),
+    provider: providerName,
+    dataType: v.string(),
+    windowStart: v.number(),
+    windowEnd: v.number(),
+  },
+  returns: v.id("backfillJobs"),
+  handler: async (ctx, args) => {
+    return await ctx.db.insert("backfillJobs", {
+      connectionId: args.connectionId,
+      userId: args.userId,
+      provider: args.provider,
+      dataType: args.dataType,
+      status: "queued",
+      startedAt: Date.now(),
+      windowStart: args.windowStart,
+      windowEnd: args.windowEnd,
+      completedDataTypes: [],
+      currentAttempt: 0,
+    });
+  },
+});
+
+export const updateStatus = internalMutation({
+  args: {
+    backfillJobId: v.id("backfillJobs"),
+    status: backfillStatus,
+    workflowId: v.optional(v.string()),
+    error: v.optional(v.string()),
+    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()),
+  },
+  handler: async (ctx, args) => {
+    const updates: Record<string, unknown> = {
+      status: args.status,
+    };
+    if (args.workflowId !== undefined) updates.workflowId = args.workflowId;
+    if (args.error !== undefined) updates.error = args.error;
+    if (args.currentDataType !== undefined) updates.currentDataType = args.currentDataType;
+    if (args.currentAttempt !== undefined) updates.currentAttempt = args.currentAttempt;
+    if (args.currentEventId !== undefined) updates.currentEventId = args.currentEventId;
+    if (args.completedDataTypes !== undefined) updates.completedDataTypes = args.completedDataTypes;
+    if (args.lastHeartbeatAt !== undefined) updates.lastHeartbeatAt = args.lastHeartbeatAt;
+    if (args.status === "completed" || args.status === "failed" || args.status === "canceled") {
+      updates.completedAt = Date.now();
+      updates.currentEventId = undefined;
+    }
+    await ctx.db.patch(args.backfillJobId, updates);
+  },
+});
+
+export const beginAwaitingType = internalMutation({
+  args: {
+    backfillJobId: v.id("backfillJobs"),
+    workflowId: v.string(),
+    dataType: v.string(),
+    attempt: v.number(),
+  },
+  returns: v.string(),
+  handler: async (ctx, args) => {
+    const eventId = await durableWorkflow.createEvent(ctx, {
+      workflowId: args.workflowId as never,
+      name: `garmin-backfill:${args.dataType}:${args.attempt}`,
+    });
+
+    await ctx.db.patch(args.backfillJobId, {
+      status: "running",
+      currentDataType: args.dataType,
+      currentAttempt: args.attempt,
+      currentEventId: eventId,
+      lastHeartbeatAt: Date.now(),
+    });
+
+    return eventId;
+  },
+});
+
+export const markTypeCompleted = internalMutation({
+  args: {
+    backfillJobId: v.id("backfillJobs"),
+    dataType: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const job = await ctx.db.get(args.backfillJobId);
+    if (!job) return;
+
+    const completed = new Set(job.completedDataTypes ?? []);
+    completed.add(args.dataType);
+
+    await ctx.db.patch(args.backfillJobId, {
+      completedDataTypes: Array.from(completed),
+      currentDataType: undefined,
+      currentAttempt: undefined,
+      currentEventId: undefined,
+      lastHeartbeatAt: Date.now(),
+    });
+  },
+});
+
+export const scheduleTimeout = internalMutation({
+  args: {
+    backfillJobId: v.id("backfillJobs"),
+    eventId: v.string(),
+    dataType: v.string(),
+    delayMs: v.number(),
+  },
+  handler: async (ctx, args) => {
+    await ctx.scheduler.runAfter(args.delayMs, internal.backfillJobs.emitTimeout, {
+      backfillJobId: args.backfillJobId,
+      eventId: args.eventId,
+      dataType: args.dataType,
+    });
+  },
+});
+
+export const emitTimeout = internalMutation({
+  args: {
+    backfillJobId: v.id("backfillJobs"),
+    eventId: v.string(),
+    dataType: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const job = await ctx.db.get(args.backfillJobId);
+    if (
+      !job ||
+      job.status !== "running" ||
+      job.currentEventId !== args.eventId ||
+      job.currentDataType !== args.dataType
+    ) {
+      return;
+    }
+
+    try {
+      await durableWorkflow.sendEvent(ctx, {
+        id: args.eventId as never,
+        value: {
+          kind: "timeout",
+          dataType: args.dataType,
+        },
+      });
+    } catch {
+      // Timeout events are best-effort. If the workflow already moved on,
+      // duplicate or stale sends should not fail the scheduler.
+    }
+  },
+});
+
+export const signalWebhookData = internalMutation({
+  args: {
+    connectionId: v.id("connections"),
+    dataType: v.string(),
+    itemCount: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const activeJob = await ctx.db
+      .query("backfillJobs")
+      .withIndex("by_connection", (idx) => idx.eq("connectionId", args.connectionId))
+      .order("desc")
+      .first();
+
+    if (
+      !activeJob ||
+      activeJob.status !== "running" ||
+      activeJob.currentDataType !== args.dataType ||
+      !activeJob.currentEventId
+    ) {
+      return;
+    }
+
+    try {
+      await durableWorkflow.sendEvent(ctx, {
+        id: activeJob.currentEventId as never,
+        value: {
+          kind: "webhook",
+          dataType: args.dataType,
+          itemCount: args.itemCount,
+        },
+      });
+      await ctx.db.patch(activeJob._id, {
+        currentEventId: undefined,
+        lastHeartbeatAt: Date.now(),
+      });
+    } catch {
+      // Duplicate Garmin webhook pushes should not fail ingestion.
+    }
+  },
+});

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();
+    });
+  });
+});