@nativesquare/soma 0.9.3 → 0.10.0

package/src/component/strava/public.ts

@@ -7,48 +7,100 @@ import { v } from "convex/values";
 import { action } from "../_generated/server";
 import { api, internal } from "../_generated/api";
 import type { Doc, Id } from "../_generated/dataModel";
-import { StravaClient } from "../../strava/client";
+import { createStravaClient } from "./client.js";
+import { listAllActivities } from "./utils.js";
 import {
+  getLoggedInAthlete,
+  getActivityById,
+  getActivityStreams,
+} from "./types/stravaApi/sdk.gen.js";
+import { generateState } from "../utils.js";
+import {
+  buildAuthUrl,
   exchangeCode,
   refreshToken as refreshStravaToken,
-} from "../../strava/auth";
-import { transformActivity } from "../../strava/activity";
-import { transformAthlete } from "../../strava/athlete";
+} from "./auth.js";
+import { transformActivity } from "./transform/activity.js";
+import { transformAthlete } from "./transform/athlete.js";
 
 // ─── Public Actions ──────────────────────────────────────────────────────────
 
 /**
- * Full Strava OAuth callback handler.
+ * Generate a Strava OAuth authorization URL.
+ *
+ * If `userId` is provided, the state parameter is stored in the component's
+ * `pendingOAuth` table so that `completeStravaOAuth` can look it up
+ * automatically when the callback fires. This is the recommended flow
+ * when using `registerRoutes`.
+ *
+ * If `userId` is omitted, the host app must store the returned `state`
+ * itself and pass the userId to `connectStrava` manually.
+ */
+export const getStravaAuthUrl = action({
+  args: {
+    clientId: v.string(),
+    redirectUri: v.string(),
+    scope: v.optional(v.string()),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const state = generateState();
+
+    const authUrl = buildAuthUrl({
+      clientId: args.clientId,
+      redirectUri: args.redirectUri,
+      scope: args.scope,
+      state,
+    });
+
+    if (args.userId) {
+      await ctx.runMutation(internal.strava.private.storePendingOAuth, {
+        provider: "STRAVA",
+        state,
+        userId: args.userId,
+      });
+    }
+
+    return { authUrl, state };
+  },
+});
+
+/**
+ * Full Strava OAuth callback handler (manual flow).
  *
  * Exchanges the authorization code for tokens, creates/reactivates the
  * Soma connection, stores tokens securely, syncs the athlete profile,
  * and syncs all activities.
  *
+ * Used when the host app handles the callback itself and passes the
+ * userId directly (analogous to `connectGarmin`).
+ *
  * Returns `{ connectionId, synced, errors }`.
  */
 export const connectStrava = action({
   args: {
     userId: v.string(),
-    code: v.string(),
     clientId: v.string(),
     clientSecret: v.string(),
-    baseUrl: v.optional(v.string()),
-    includeStreams: v.optional(v.boolean()),
+    code: v.string(),
   },
   returns: v.object({
     connectionId: v.string(),
-    synced: v.number(),
+    synced: v.object({ athletes: v.number(), activities: v.number() }),
     errors: v.array(
-      v.object({ activityId: v.number(), error: v.string() }),
+      v.object({ type: v.string(), id: v.string(), error: v.string() }),
     ),
   }),
-  handler: async (ctx, args) => {
+  handler: async (ctx, args): Promise<{
+    connectionId: Id<"connections">;
+    synced: { athletes: number; activities: number };
+    errors: Array<{ type: string; id: string; error: string }>;
+  }> => {
     // 1. Exchange authorization code for tokens
     const tokens = await exchangeCode({
       clientId: args.clientId,
       clientSecret: args.clientSecret,
       code: args.code,
-      baseUrl: args.baseUrl,
     });
 
     // 2. Create/reactivate the Soma connection
@@ -61,7 +113,7 @@ export const connectStrava = action({
     );
 
     // 3. Store OAuth tokens in providerTokens table
-    const _stored: null = await ctx.runMutation(
+    await ctx.runMutation(
       internal.strava.private.storeTokens,
       {
         connectionId,
@@ -71,54 +123,109 @@ export const connectStrava = action({
       },
     );
 
-    // 4. Sync athlete profile
-    const client = new StravaClient({
+    // 4. Sync all data types
+    const result = await ctx.runAction(api.strava.public.syncAllTypes, {
       accessToken: tokens.access_token,
-      baseUrl: args.baseUrl,
+      connectionId,
+      userId: args.userId,
     });
 
-    const athlete = await client.getAthlete();
-    const athleteData = transformAthlete(athlete);
-    const _athleteId: Id<"athletes"> = await ctx.runMutation(
-      api.public.ingestAthlete,
+    // 5. Update lastDataUpdate timestamp
+    await ctx.runMutation(
+      api.public.updateConnection,
       {
         connectionId,
-        userId: args.userId,
-        ...athleteData,
-      } as never,
+        lastDataUpdate: new Date().toISOString(),
+      },
     );
 
-    // 5. Sync all activities
-    const summaries = await client.listAllActivities();
-    let synced = 0;
-    const errors: Array<{ activityId: number; error: string }> = [];
+    return { connectionId, synced: result.synced, errors: result.errors };
+  },
+});
 
-    for (const summary of summaries) {
-      try {
-        const detailed = await client.getActivity(summary.id);
-        const streams = args.includeStreams
-          ? await client.getActivityStreams(summary.id)
-          : undefined;
-        const data = transformActivity(detailed, { streams });
-        const _activityId: Id<"activities"> = await ctx.runMutation(
-          api.public.ingestActivity,
-          {
-            connectionId,
-            userId: args.userId,
-            ...data,
-          } as never,
-        );
-        synced++;
-      } catch (err) {
-        errors.push({
-          activityId: summary.id,
-          error: err instanceof Error ? err.message : String(err),
-        });
-      }
+/**
+ * Complete a Strava OAuth flow using stored pending state.
+ *
+ * Used by `registerRoutes` — the callback handler calls this with the
+ * `code` and `state` from the redirect. The action looks up the pending
+ * state (userId) stored during `getStravaAuthUrl`, exchanges for tokens,
+ * creates the connection, syncs data, and cleans up the pending entry.
+ */
+export const completeStravaOAuth = action({
+  args: {
+    code: v.string(),
+    state: v.string(),
+    clientId: v.string(),
+    clientSecret: v.string(),
+  },
+  returns: v.object({
+    connectionId: v.string(),
+    userId: v.string(),
+    synced: v.object({ athletes: v.number(), activities: v.number() }),
+    errors: v.array(
+      v.object({ type: v.string(), id: v.string(), error: v.string() }),
+    ),
+  }),
+  handler: async (ctx, args): Promise<{
+    connectionId: Id<"connections">;
+    userId: string;
+    synced: { athletes: number; activities: number };
+    errors: Array<{ type: string; id: string; error: string }>;
+  }> => {
+    // 1. Look up pending state
+    const pending: Doc<"pendingOAuth"> | null = await ctx.runQuery(
+      internal.strava.private.getPendingOAuth,
+      { state: args.state },
+    );
+    if (!pending) {
+      throw new Error(
+        "No pending Strava OAuth state found for this state parameter. " +
+        "The authorization may have expired or was already used.",
+      );
     }
 
-    // 6. Update lastDataUpdate timestamp
-    const _updated: null = await ctx.runMutation(
+    // 2. Exchange authorization code for tokens
+    const tokens = await exchangeCode({
+      clientId: args.clientId,
+      clientSecret: args.clientSecret,
+      code: args.code,
+    });
+
+    // 3. Clean up pending entry
+    await ctx.runMutation(
+      internal.strava.private.deletePendingOAuth,
+      { state: args.state },
+    );
+
+    // 4. Create/reactivate the Soma connection
+    const connectionId: Id<"connections"> = await ctx.runMutation(
+      api.public.connect,
+      {
+        userId: pending.userId,
+        provider: "STRAVA",
+      },
+    );
+
+    // 5. Store OAuth tokens
+    await ctx.runMutation(
+      internal.strava.private.storeTokens,
+      {
+        connectionId,
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresAt: tokens.expires_at,
+      },
+    );
+
+    // 6. Sync all data types
+    const result = await ctx.runAction(api.strava.public.syncAllTypes, {
+      accessToken: tokens.access_token,
+      connectionId,
+      userId: pending.userId,
+    });
+
+    // 7. Update lastDataUpdate timestamp
+    await ctx.runMutation(
       api.public.updateConnection,
       {
         connectionId,
@@ -126,7 +233,12 @@ export const connectStrava = action({
       },
     );
 
-    return { connectionId, synced, errors };
+    return {
+      connectionId,
+      userId: pending.userId,
+      synced: result.synced,
+      errors: result.errors,
+    };
   },
 });
 
@@ -143,17 +255,18 @@ export const syncStrava = action({
     userId: v.string(),
     clientId: v.string(),
     clientSecret: v.string(),
-    baseUrl: v.optional(v.string()),
-    includeStreams: v.optional(v.boolean()),
     after: v.optional(v.number()),
   },
   returns: v.object({
-    synced: v.number(),
+    synced: v.object({ athletes: v.number(), activities: v.number() }),
     errors: v.array(
-      v.object({ activityId: v.number(), error: v.string() }),
+      v.object({ type: v.string(), id: v.string(), error: v.string() }),
     ),
   }),
-  handler: async (ctx, args) => {
+  handler: async (ctx, args): Promise<{
+    synced: { athletes: number; activities: number };
+    errors: Array<{ type: string; id: string; error: string }>;
+  }> => {
     // 1. Look up connection
     const connection: Doc<"connections"> | null = await ctx.runQuery(
       internal.private.getConnectionByProvider,
@@ -199,10 +312,9 @@ export const syncStrava = action({
         clientId: args.clientId,
         clientSecret: args.clientSecret,
         refreshToken: tokenDoc.refreshToken,
-        baseUrl: args.baseUrl,
       });
       accessToken = refreshed.access_token;
-      const _refreshed: null = await ctx.runMutation(
+      await ctx.runMutation(
         internal.strava.private.storeTokens,
         {
           connectionId,
@@ -213,68 +325,119 @@ export const syncStrava = action({
       );
     }
 
-    // 4. Create client and sync
-    const client = new StravaClient({
+    // 4. Sync all data types
+    const result = await ctx.runAction(api.strava.public.syncAllTypes, {
       accessToken,
-      baseUrl: args.baseUrl,
+      connectionId,
+      userId: args.userId,
+      after: args.after,
     });
 
-    // Sync athlete profile
-    const athlete = await client.getAthlete();
-    const athleteData = transformAthlete(athlete);
-    const _athleteId: Id<"athletes"> = await ctx.runMutation(
-      api.public.ingestAthlete,
+    // 5. Update lastDataUpdate timestamp
+    await ctx.runMutation(
+      api.public.updateConnection,
       {
         connectionId,
-        userId: args.userId,
-        ...athleteData,
-      } as never,
+        lastDataUpdate: new Date().toISOString(),
+      },
     );
 
-    // Sync activities (optionally incremental via `after`)
-    const summaries = await client.listAllActivities({
-      after: args.after,
-    });
-    let synced = 0;
-    const errors: Array<{ activityId: number; error: string }> = [];
+    return { synced: result.synced, errors: result.errors };
+  },
+});
 
-    for (const summary of summaries) {
-      try {
-        const detailed = await client.getActivity(summary.id);
-        const streams = args.includeStreams
-          ? await client.getActivityStreams(summary.id)
-          : undefined;
-        const data = transformActivity(detailed, { streams });
-        const _activityId: Id<"activities"> = await ctx.runMutation(
-          api.public.ingestActivity,
-          {
+// ─── Sync Engine ────────────────────────────────────────────────────────────
+
+/**
+ * Fetch and ingest all Strava data types for a connected user.
+ *
+ * Called by the public actions (connectStrava, completeStravaOAuth, syncStrava)
+ * after obtaining a valid access token.
+ */
+export const syncAllTypes = action({
+  args: {
+    accessToken: v.string(),
+    connectionId: v.id("connections"),
+    userId: v.string(),
+    after: v.optional(v.number()),
+    before: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const { accessToken, connectionId, userId } = args;
+    const client = createStravaClient(accessToken);
+
+    const synced = { athletes: 0, activities: 0 };
+    const errors: Array<{ type: string; id: string; error: string }> = [];
+
+    // ── Athlete ──────────────────────────────────────────────────────────
+    try {
+      const { data: athlete, error } = await getLoggedInAthlete({ client });
+      if (error || !athlete) throw new Error(error ? JSON.stringify(error) : "No athlete data");
+      const data = transformAthlete(athlete);
+      await ctx.runMutation(api.public.ingestAthlete, {
+        connectionId,
+        userId,
+        ...data,
+      } as never);
+      synced.athletes++;
+    } catch (err) {
+      errors.push({
+        type: "athlete",
+        id: "fetch",
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+
+    // ── Activities ───────────────────────────────────────────────────────
+    try {
+      const summaries = await listAllActivities(client, {
+        after: args.after,
+        before: args.before,
+      });
+      for (const summary of summaries) {
+        if (summary.id == null) continue;
+        try {
+          const { data: detailed, error: detailError } = await getActivityById({ client, path: { id: summary.id } });
+          if (detailError || !detailed) throw new Error(detailError ? JSON.stringify(detailError) : "No activity data");
+
+          const { data: streams } = await getActivityStreams({
+            client,
+            path: { id: summary.id },
+            query: {
+              keys: ["time", "heartrate", "watts", "cadence", "latlng", "altitude", "velocity_smooth", "grade_smooth", "distance", "temp"],
+              key_by_type: true,
+            },
+          });
+
+          const data = transformActivity(detailed, { streams: streams ?? undefined });
+          await ctx.runMutation(api.public.ingestActivity, {
             connectionId,
-            userId: args.userId,
+            userId,
             ...data,
-          } as never,
-        );
-        synced++;
-      } catch (err) {
-        errors.push({
-          activityId: summary.id,
-          error: err instanceof Error ? err.message : String(err),
-        });
+          } as never);
+          synced.activities++;
+        } catch (err) {
+          errors.push({
+            type: "activity",
+            id: String(summary.id),
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
       }
+    } catch (err) {
+      errors.push({
+        type: "activity",
+        id: "fetch",
+        error: err instanceof Error ? err.message : String(err),
+      });
     }
 
-    // 5. Update lastDataUpdate timestamp
-    const _updated: null = await ctx.runMutation(
-      api.public.updateConnection,
-      {
-        connectionId,
-        lastDataUpdate: new Date().toISOString(),
-      },
-    );
-
     return { synced, errors };
   },
 });
 
+// ─── Disconnect ─────────────────────────────────────────────────────────────
+
 /**
  * Disconnect a user from Strava.
  *
@@ -286,7 +449,6 @@ export const disconnectStrava = action({
     userId: v.string(),
     clientId: v.string(),
     clientSecret: v.string(),
-    baseUrl: v.optional(v.string()),
   },
   returns: v.null(),
   handler: async (ctx, args) => {
@@ -310,11 +472,7 @@ export const disconnectStrava = action({
     );
     if (tokenDoc) {
       try {
-        const base = (args.baseUrl ?? "https://www.strava.com").replace(
-          /\/+$/,
-          "",
-        );
-        await fetch(`${base}/oauth/deauthorize`, {
+        await fetch("https://www.strava.com/oauth/deauthorize", {
           method: "POST",
           headers: { "Content-Type": "application/x-www-form-urlencoded" },
           body: `access_token=${tokenDoc.accessToken}`,