@nativesquare/soma 0.10.0 → 0.10.2

package/src/component/garmin/utils.ts

@@ -23,3 +23,20 @@ export function timeRangeQuery(params: TimeRangeParams, accessToken: string) {
     token: accessToken,
   };
 }
+
+export function buildTimeRangeQuery(
+  input: { startTimeInSeconds?: number; endTimeInSeconds?: number },
+  accessToken: string,
+  nowSeconds = Math.floor(Date.now() / 1000),
+  defaultSyncDays = 30,
+) {
+  const uploadStartTimeInSeconds =
+    input.startTimeInSeconds ?? nowSeconds - defaultSyncDays * 86400;
+  const uploadEndTimeInSeconds = input.endTimeInSeconds ?? nowSeconds;
+
+  return {
+    uploadStartTimeInSeconds: String(uploadStartTimeInSeconds),
+    uploadEndTimeInSeconds: String(uploadEndTimeInSeconds),
+    token: accessToken,
+  };
+}

package/src/component/strava/public.ts

@@ -28,20 +28,16 @@ import { transformAthlete } from "./transform/athlete.js";
 /**
  * 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.
+ * The state parameter is stored in the component's `pendingOAuth` table
+ * so that `completeStravaOAuth` can look it up automatically when the
+ * callback fires via `registerRoutes`.
  */
 export const getStravaAuthUrl = action({
   args: {
     clientId: v.string(),
     redirectUri: v.string(),
     scope: v.optional(v.string()),
-    userId: v.optional(v.string()),
+    userId: v.string(),
   },
   handler: async (ctx, args) => {
     const state = generateState();
@@ -53,103 +49,26 @@ export const getStravaAuthUrl = action({
       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(),
-    clientId: v.string(),
-    clientSecret: v.string(),
-    code: v.string(),
-  },
-  returns: v.object({
-    connectionId: 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">;
-    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,
-    });
-
-    // 2. Create/reactivate the Soma connection
-    const connectionId: Id<"connections"> = await ctx.runMutation(
-      api.public.connect,
-      {
-        userId: args.userId,
-        provider: "STRAVA",
-      },
-    );
-
-    // 3. Store OAuth tokens in providerTokens table
-    await ctx.runMutation(
-      internal.strava.private.storeTokens,
-      {
-        connectionId,
-        accessToken: tokens.access_token,
-        refreshToken: tokens.refresh_token,
-        expiresAt: tokens.expires_at,
-      },
-    );
-
-    // 4. Sync all data types
-    const result = await ctx.runAction(api.strava.public.syncAllTypes, {
-      accessToken: tokens.access_token,
-      connectionId,
+    await ctx.runMutation(internal.strava.private.storePendingOAuth, {
+      provider: "STRAVA",
+      state,
       userId: args.userId,
     });
 
-    // 5. Update lastDataUpdate timestamp
-    await ctx.runMutation(
-      api.public.updateConnection,
-      {
-        connectionId,
-        lastDataUpdate: new Date().toISOString(),
-      },
-    );
-
-    return { connectionId, synced: result.synced, errors: result.errors };
+    return { authUrl, state };
   },
 });
 
 /**
  * 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.
+ * Called internally 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, stores tokens, and
+ * cleans up the pending entry.
+ *
+ * The host app is responsible for calling `syncStrava` afterwards.
  */
 export const completeStravaOAuth = action({
   args: {
@@ -161,16 +80,10 @@ export const completeStravaOAuth = action({
   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(
@@ -217,27 +130,9 @@ export const completeStravaOAuth = action({
       },
     );
 
-    // 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,
-        lastDataUpdate: new Date().toISOString(),
-      },
-    );
-
     return {
       connectionId,
       userId: pending.userId,
-      synced: result.synced,
-      errors: result.errors,
     };
   },
 });
@@ -275,7 +170,7 @@ export const syncStrava = action({
     if (!connection) {
       throw new Error(
         `No Strava connection found for user "${args.userId}". ` +
-        "Call connectStrava first.",
+        "Connect to Strava first via getStravaAuthUrl.",
       );
     }
     if (!connection.active) {
@@ -351,8 +246,7 @@ export const syncStrava = action({
 /**
  * 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.
+ * Called by syncStrava after obtaining a valid access token.
  */
 export const syncAllTypes = action({
   args: {