@nativesquare/soma 0.10.2 → 0.12.0

package/dist/component/garmin/public.js

@@ -7,8 +7,8 @@ import { action } from "../_generated/server";
 import { generateState } from "../utils.js";
 import { generateCodeVerifier, generateCodeChallenge, buildAuthUrl, exchangeCode, refreshToken, } from "./auth.js";
 import { createWellnessClient, createTrainingClient, } from "./client.js";
-import { buildTimeRangeQuery, timeRangeQuery } from "./utils.js";
-import { createWorkoutV2 as sdkCreateWorkoutV2, createWorkoutSchedule as sdkCreateWorkoutSchedule, } from "./types/trainingApiWorkouts/sdk.gen";
+import { buildTimeRangeQuery } from "./utils.js";
+import { createWorkoutV2 as sdkCreateWorkoutV2, createWorkoutSchedule as sdkCreateWorkoutSchedule, updateWorkoutV2 as sdkUpdateWorkoutV2, updateWorkoutSchedule as sdkUpdateWorkoutSchedule, deleteWorkoutV2 as sdkDeleteWorkoutV2, deleteWorkoutSchedule as sdkDeleteWorkoutSchedule, } from "./types/trainingApiWorkouts/sdk.gen";
 import { userId as sdkUserId, dereg as sdkDereg, getActivities, getDailies, getSleeps, getBodyComps, getMct, getBloodPressures, getSkinTemp, getUserMetrics, getHrv, getStressDetails, getPulseox, getRespiration, } from "./types/wellnessApi/sdk.gen";
 import { transformActivity } from "./transform/activity.js";
 import { transformDailies } from "./transform/dailies.js";
@@ -24,18 +24,7 @@ import { transformPulseOx } from "./transform/pulseOx.js";
 import { transformRespiration } from "./transform/respiration.js";
 import { transformPlannedWorkoutToGarmin } from "./transform/plannedWorkout.js";
 import { api, internal } from "../_generated/api";
-// Default sync window: last 30 days
-const DEFAULT_SYNC_DAYS = 30;
-// Refresh buffer: refresh tokens 10 minutes before expiry
-const REFRESH_BUFFER_SECONDS = 600;
 // ─── OAuth ──────────────────────────────────────────────────────────────────
-/**
- * Generate a Garmin OAuth 2.0 authorization URL with PKCE.
- *
- * The PKCE code verifier and state are stored in the component's
- * `pendingOAuth` table so that `completeGarminOAuth` can look them up
- * automatically when the callback fires via `registerRoutes`.
- */
 export const getGarminAuthUrl = action({
     args: {
         clientId: v.string(),
@@ -61,17 +50,6 @@ export const getGarminAuthUrl = action({
         return { authUrl, state, codeVerifier };
     },
 });
-/**
- * Complete a Garmin OAuth 2.0 flow using stored pending state.
- *
- * Called internally by `registerRoutes` — the callback handler calls
- * this with the `code` and `state` from the redirect. The action looks
- * up the pending state (codeVerifier, userId) stored during
- * `getGarminAuthUrl`, exchanges for tokens, creates the connection,
- * stores tokens, and cleans up the pending entry.
- *
- * The host app is responsible for calling `syncGarmin` afterwards.
- */
 export const completeGarminOAuth = action({
     args: {
         code: v.string(),
@@ -129,12 +107,6 @@ export const completeGarminOAuth = action({
         };
     },
 });
-/**
- * Disconnect a user from Garmin.
- *
- * Deregisters the user via the Garmin API (best-effort), deletes stored
- * tokens, and sets the connection to inactive.
- */
 export const disconnectGarmin = action({
     args: {
         userId: v.string(),
@@ -689,572 +661,208 @@ export const pullAll = action({
         return { synced, errors };
     },
 });
-/**
- * Incremental Garmin sync for an already-connected user.
- *
- * Looks up the stored tokens, refreshes if expired, and syncs all data
- * types for the specified time range (defaults to last 30 days).
- */
-export const syncGarmin = action({
+// ─── Push ───────────────────────────────────────────────────────────────────
+export const pushWorkout = action({
     args: {
         userId: v.string(),
         clientId: v.string(),
         clientSecret: v.string(),
-        startTimeInSeconds: v.optional(v.number()),
-        endTimeInSeconds: v.optional(v.number()),
+        plannedWorkoutId: v.string(),
+        workoutProvider: v.optional(v.string()),
     },
     handler: async (ctx, args) => {
-        const connection = await ctx.runQuery(internal.private.getConnectionByProvider, { userId: args.userId, provider: "GARMIN" });
-        if (!connection) {
-            throw new Error(`No Garmin connection found for user "${args.userId}". ` +
-                "Connect to Garmin first via getGarminAuthUrl.");
-        }
-        if (!connection.active) {
-            throw new Error(`Garmin connection for user "${args.userId}" is inactive. Reconnect first.`);
-        }
-        const connectionId = connection._id;
-        const tokenDoc = await ctx.runQuery(internal.garmin.private.getTokens, {
-            connectionId,
-        });
-        if (!tokenDoc) {
-            throw new Error("No Garmin tokens found for this connection. " +
-                "The connection may have been created before token storage was available.");
+        const { connectionId, accessToken } = await ctx.runAction(internal.garmin.private.resolveConnectionAndAccessToken, { userId: args.userId, clientId: args.clientId, clientSecret: args.clientSecret });
+        const plannedWorkout = await ctx.runQuery(api.public.getPlannedWorkout, { plannedWorkoutId: args.plannedWorkoutId });
+        if (!plannedWorkout) {
+            throw new Error(`Planned workout "${args.plannedWorkoutId}" not found.`);
         }
-        let accessToken = tokenDoc.accessToken;
-        // Refresh the token if it's expired or about to expire
-        const nowSeconds = Math.floor(Date.now() / 1000);
-        if (tokenDoc.expiresAt &&
-            tokenDoc.refreshToken &&
-            nowSeconds >= tokenDoc.expiresAt - REFRESH_BUFFER_SECONDS) {
-            const refreshed = await refreshToken({
-                clientId: args.clientId,
-                clientSecret: args.clientSecret,
-                refreshToken: tokenDoc.refreshToken,
-            });
-            accessToken = refreshed.access_token;
-            const newExpiresAt = nowSeconds + refreshed.expires_in;
-            const _refreshed = await ctx.runMutation(internal.garmin.private.storeTokens, {
-                connectionId,
-                accessToken: refreshed.access_token,
-                refreshToken: refreshed.refresh_token,
-                expiresAt: newExpiresAt,
+        const providerName = args.workoutProvider ?? "Soma";
+        const garminWorkout = transformPlannedWorkoutToGarmin(plannedWorkout, providerName);
+        const trainingClient = createTrainingClient(accessToken);
+        const existingWorkoutId = plannedWorkout.metadata?.provider_workout_id;
+        let workoutId;
+        if (existingWorkoutId) {
+            // Update existing workout on Garmin
+            const numericId = Number(existingWorkoutId);
+            garminWorkout.workoutId = numericId;
+            const { error: updateError } = await sdkUpdateWorkoutV2({
+                client: trainingClient,
+                body: garminWorkout,
+                path: { workoutId: numericId },
             });
+            if (updateError) {
+                throw new Error(`Garmin API error updating workout: ${JSON.stringify(updateError)}`);
+            }
+            workoutId = numericId;
         }
-        // Lazy backfill: resolve Garmin user ID if missing (for webhook mapping)
-        if (!connection.providerUserId) {
-            const wellnessClient = createWellnessClient(accessToken);
-            const { data: userIdData } = await sdkUserId({ client: wellnessClient });
-            const garminUserId = userIdData?.userId ?? null;
-            if (garminUserId) {
-                const _updated = await ctx.runMutation(api.public.updateConnection, {
-                    connectionId,
-                    providerUserId: garminUserId,
-                });
+        else {
+            // Create new workout on Garmin
+            const { data: created, error: createError } = await sdkCreateWorkoutV2({
+                client: trainingClient,
+                body: garminWorkout,
+            });
+            if (createError || !created) {
+                throw new Error(`Garmin API error creating workout: ${createError ? JSON.stringify(createError) : "No data"}`);
             }
+            if (!created.workoutId) {
+                throw new Error("Garmin API did not return a workoutId after creation.");
+            }
+            workoutId = created.workoutId;
         }
-        const now = Math.floor(Date.now() / 1000);
-        const timeRange = {
-            uploadStartTimeInSeconds: args.startTimeInSeconds ?? now - DEFAULT_SYNC_DAYS * 86400,
-            uploadEndTimeInSeconds: args.endTimeInSeconds ?? now,
-        };
-        const result = await ctx.runAction(api.garmin.public.syncAllTypes, {
-            accessToken,
-            connectionId,
-            userId: args.userId,
-            uploadStartTimeInSeconds: timeRange.uploadStartTimeInSeconds,
-            uploadEndTimeInSeconds: timeRange.uploadEndTimeInSeconds,
-        });
-        const _updated = await ctx.runMutation(api.public.updateConnection, {
-            connectionId,
-            lastDataUpdate: new Date().toISOString(),
+        // Persist the Garmin workout ID back on the planned workout
+        const _ingested = await ctx.runMutation(api.public.ingestPlannedWorkout, {
+            ...plannedWorkout,
+            _id: undefined,
+            _creationTime: undefined,
+            metadata: {
+                ...plannedWorkout.metadata,
+                provider_workout_id: String(workoutId),
+            },
         });
-        return result;
+        return { garminWorkoutId: workoutId };
     },
 });
-/**
- * Fetch and ingest all Garmin wellness data types for a time range.
- *
- * Called by syncGarmin after obtaining a valid access token.
- * after obtaining a valid access token.
- */
-export const syncAllTypes = action({
+export const pushSchedule = action({
     args: {
-        accessToken: v.string(),
-        connectionId: v.id("connections"),
         userId: v.string(),
-        uploadStartTimeInSeconds: v.number(),
-        uploadEndTimeInSeconds: v.number(),
+        clientId: v.string(),
+        clientSecret: v.string(),
+        plannedWorkoutId: v.string(),
+        date: v.optional(v.string()),
     },
     handler: async (ctx, args) => {
-        const { accessToken, connectionId, userId } = args;
-        const timeRange = {
-            uploadStartTimeInSeconds: args.uploadStartTimeInSeconds,
-            uploadEndTimeInSeconds: args.uploadEndTimeInSeconds,
-        };
-        const wellnessClient = createWellnessClient(accessToken);
-        const query = timeRangeQuery(timeRange, accessToken);
-        const synced = {
-            activities: 0, dailies: 0, sleep: 0, body: 0, menstruation: 0,
-            bloodPressures: 0, skinTemp: 0, userMetrics: 0,
-            hrv: 0, stressDetails: 0, pulseOx: 0, respiration: 0,
-        };
-        const errors = [];
-        // ── Activities ──────────────────────────────────────────────────────────
-        try {
-            const { data: activities, error } = await getActivities({ client: wellnessClient, query });
-            if (error || !activities)
-                throw new Error(error ? JSON.stringify(error) : "No data");
-            for (const activity of activities) {
-                try {
-                    const data = transformActivity(activity);
-                    await ctx.runMutation(api.public.ingestActivity, {
-                        connectionId,
-                        userId,
-                        ...data,
-                    });
-                    synced.activities++;
-                }
-                catch (err) {
-                    errors.push({
-                        type: "activity",
-                        id: activity.summaryId ?? String(activity.activityId),
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
-        }
-        catch (err) {
-            errors.push({
-                type: "activity",
-                id: "fetch",
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-        // ── Dailies ─────────────────────────────────────────────────────────────
-        try {
-            const { data: dailies, error } = await getDailies({ client: wellnessClient, query });
-            if (error || !dailies)
-                throw new Error(error ? JSON.stringify(error) : "No data");
-            for (const daily of dailies) {
-                try {
-                    const data = transformDailies(daily);
-                    if (!data)
-                        continue;
-                    await ctx.runMutation(api.public.ingestDaily, {
-                        connectionId,
-                        userId,
-                        ...data,
-                    });
-                    synced.dailies++;
-                }
-                catch (err) {
-                    errors.push({
-                        type: "daily",
-                        id: daily.summaryId ?? daily.calendarDate ?? "unknown",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
-        }
-        catch (err) {
-            errors.push({
-                type: "daily",
-                id: "fetch",
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-        // ── Sleep ───────────────────────────────────────────────────────────────
-        try {
-            const { data: sleeps, error } = await getSleeps({ client: wellnessClient, query });
-            if (error || !sleeps)
-                throw new Error(error ? JSON.stringify(error) : "No data");
-            for (const sleep of sleeps) {
-                try {
-                    const data = transformSleeps(sleep);
-                    await ctx.runMutation(api.public.ingestSleep, {
-                        connectionId,
-                        userId,
-                        ...data,
-                    });
-                    synced.sleep++;
-                }
-                catch (err) {
-                    errors.push({
-                        type: "sleep",
-                        id: sleep.summaryId ?? sleep.calendarDate ?? "unknown",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
+        const { connectionId, accessToken } = await ctx.runAction(internal.garmin.private.resolveConnectionAndAccessToken, { userId: args.userId, clientId: args.clientId, clientSecret: args.clientSecret });
+        const plannedWorkout = await ctx.runQuery(api.public.getPlannedWorkout, { plannedWorkoutId: args.plannedWorkoutId });
+        if (!plannedWorkout) {
+            throw new Error(`Planned workout "${args.plannedWorkoutId}" not found.`);
         }
-        catch (err) {
-            errors.push({
-                type: "sleep",
-                id: "fetch",
-                error: err instanceof Error ? err.message : String(err),
-            });
+        const providerWorkoutId = plannedWorkout.metadata?.provider_workout_id;
+        if (!providerWorkoutId) {
+            throw new Error("No Garmin workout ID found on this planned workout. Push the workout first via pushWorkout.");
         }
-        // ── Body ────────────────────────────────────────────────────────────────
-        try {
-            const { data: bodyComps, error } = await getBodyComps({ client: wellnessClient, query });
-            if (error || !bodyComps)
-                throw new Error(error ? JSON.stringify(error) : "No data");
-            for (const body of bodyComps) {
-                try {
-                    const data = transformBodyComposition(body);
-                    if (!data)
-                        continue;
-                    await ctx.runMutation(api.public.ingestBody, {
-                        connectionId,
-                        userId,
-                        ...data,
-                    });
-                    synced.body++;
-                }
-                catch (err) {
-                    errors.push({
-                        type: "body",
-                        id: body.summaryId ?? String(body.measurementTimeInSeconds),
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
+        const scheduleDate = args.date ?? plannedWorkout.metadata?.planned_date;
+        if (!scheduleDate) {
+            throw new Error("No date provided and no planned_date on the workout. Provide a date argument.");
         }
-        catch (err) {
-            errors.push({
-                type: "body",
-                id: "fetch",
-                error: err instanceof Error ? err.message : String(err),
+        const trainingClient = createTrainingClient(accessToken);
+        const existingScheduleId = plannedWorkout.metadata?.provider_schedule_id;
+        let scheduleId;
+        if (existingScheduleId) {
+            // Update existing schedule on Garmin
+            const numericScheduleId = Number(existingScheduleId);
+            const { error: updateError } = await sdkUpdateWorkoutSchedule({
+                client: trainingClient,
+                body: { workoutId: Number(providerWorkoutId), date: scheduleDate },
+                path: { workoutScheduleId: numericScheduleId },
             });
-        }
-        // ── Menstruation ────────────────────────────────────────────────────────
-        try {
-            const { data: records, error } = await getMct({ client: wellnessClient, query });
-            if (error || !records)
-                throw new Error(error ? JSON.stringify(error) : "No data");
-            for (const record of records) {
-                try {
-                    const data = transformMenstrualCycleTracking(record);
-                    await ctx.runMutation(api.public.ingestMenstruation, {
-                        connectionId,
-                        userId,
-                        ...data,
-                    });
-                    synced.menstruation++;
-                }
-                catch (err) {
-                    errors.push({
-                        type: "menstruation",
-                        id: record.summaryId ?? record.periodStartDate ?? "unknown",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
+            if (updateError) {
+                throw new Error(`Garmin API error updating schedule: ${JSON.stringify(updateError)}`);
             }
+            scheduleId = numericScheduleId;
         }
-        catch (err) {
-            errors.push({
-                type: "menstruation",
-                id: "fetch",
-                error: err instanceof Error ? err.message : String(err),
+        else {
+            // Create new schedule on Garmin
+            const { data: createdScheduleId, error: scheduleError } = await sdkCreateWorkoutSchedule({
+                client: trainingClient,
+                body: { workoutId: Number(providerWorkoutId), date: scheduleDate },
             });
-        }
-        // ── Blood Pressures (→ body) ───────────────────────────────────────────
-        try {
-            const { data: bpRecords, error } = await getBloodPressures({ client: wellnessClient, query });
-            if (error || !bpRecords)
-                throw new Error(error ? JSON.stringify(error) : "No data");
-            for (const bp of bpRecords) {
-                try {
-                    const data = transformBloodPressure(bp);
-                    if (!data)
-                        continue;
-                    await ctx.runMutation(api.public.ingestBody, {
-                        connectionId, userId, ...data,
-                    });
-                    synced.bloodPressures++;
-                }
-                catch (err) {
-                    errors.push({
-                        type: "bloodPressure",
-                        id: bp.summaryId ?? String(bp.measurementTimeInSeconds),
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
-        }
-        catch (err) {
-            errors.push({ type: "bloodPressure", id: "fetch", error: err instanceof Error ? err.message : String(err) });
-        }
-        // ── Skin Temperature (→ body) ──────────────────────────────────────────
-        try {
-            const { data: skinRecords, error } = await getSkinTemp({ client: wellnessClient, query });
-            if (error || !skinRecords)
-                throw new Error(error ? JSON.stringify(error) : "No data");
-            for (const skin of skinRecords) {
-                try {
-                    const data = transformSkinTemperature(skin);
-                    if (!data)
-                        continue;
-                    await ctx.runMutation(api.public.ingestBody, {
-                        connectionId, userId, ...data,
-                    });
-                    synced.skinTemp++;
-                }
-                catch (err) {
-                    errors.push({
-                        type: "skinTemp",
-                        id: skin.summaryId ?? skin.calendarDate ?? "unknown",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
-        }
-        catch (err) {
-            errors.push({ type: "skinTemp", id: "fetch", error: err instanceof Error ? err.message : String(err) });
-        }
-        // ── User Metrics (→ body) ──────────────────────────────────────────────
-        try {
-            const { data: metricsRecords, error } = await getUserMetrics({ client: wellnessClient, query });
-            if (error || !metricsRecords)
-                throw new Error(error ? JSON.stringify(error) : "No data");
-            for (const metrics of metricsRecords) {
-                try {
-                    const data = transformUserMetrics(metrics);
-                    if (!data)
-                        continue;
-                    await ctx.runMutation(api.public.ingestBody, {
-                        connectionId, userId, ...data,
-                    });
-                    synced.userMetrics++;
-                }
-                catch (err) {
-                    errors.push({
-                        type: "userMetrics",
-                        id: metrics.summaryId ?? metrics.calendarDate ?? "unknown",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
-        }
-        catch (err) {
-            errors.push({ type: "userMetrics", id: "fetch", error: err instanceof Error ? err.message : String(err) });
-        }
-        // ── HRV (enriches daily) ──────────────────────────────────────────────
-        try {
-            const { data: hrvRecords, error } = await getHrv({ client: wellnessClient, query });
-            if (error || !hrvRecords)
-                throw new Error(error ? JSON.stringify(error) : "No data");
-            for (const hrv of hrvRecords) {
-                try {
-                    const data = transformHRVSummary(hrv);
-                    if (data) {
-                        await ctx.runMutation(api.public.ingestDaily, {
-                            connectionId, userId, ...data,
-                        });
-                        synced.hrv++;
-                    }
-                }
-                catch (err) {
-                    errors.push({
-                        type: "hrv",
-                        id: hrv.summaryId ?? hrv.calendarDate ?? "unknown",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
-        }
-        catch (err) {
-            errors.push({ type: "hrv", id: "fetch", error: err instanceof Error ? err.message : String(err) });
-        }
-        // ── Stress Details (enriches daily) ────────────────────────────────────
-        try {
-            const { data: stressRecords, error } = await getStressDetails({ client: wellnessClient, query });
-            if (error || !stressRecords)
-                throw new Error(error ? JSON.stringify(error) : "No data");
-            for (const stress of stressRecords) {
-                try {
-                    const data = transformStress(stress);
-                    if (data) {
-                        await ctx.runMutation(api.public.ingestDaily, {
-                            connectionId, userId, ...data,
-                        });
-                        synced.stressDetails++;
-                    }
-                }
-                catch (err) {
-                    errors.push({
-                        type: "stressDetails",
-                        id: stress.summaryId ?? stress.calendarDate ?? "unknown",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-            }
-        }
-        catch (err) {
-            errors.push({ type: "stressDetails", id: "fetch", error: err instanceof Error ? err.message : String(err) });
-        }
-        // ── Pulse Ox (enriches daily) ──────────────────────────────────────────
-        try {
-            const { data: pulseOxRecords, error } = await getPulseox({ client: wellnessClient, query });
-            if (error || !pulseOxRecords)
-                throw new Error(error ? JSON.stringify(error) : "No data");
-            for (const po of pulseOxRecords) {
-                try {
-                    const data = transformPulseOx(po);
-                    if (data) {
-                        await ctx.runMutation(api.public.ingestDaily, {
-                            connectionId, userId, ...data,
-                        });
-                        synced.pulseOx++;
-                    }
-                }
-                catch (err) {
-                    errors.push({
-                        type: "pulseOx",
-                        id: po.summaryId ?? po.calendarDate ?? "unknown",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
+            if (scheduleError) {
+                throw new Error(`Garmin API error creating schedule: ${JSON.stringify(scheduleError)}`);
             }
-        }
-        catch (err) {
-            errors.push({ type: "pulseOx", id: "fetch", error: err instanceof Error ? err.message : String(err) });
-        }
-        // ── Respiration (enriches daily) ───────────────────────────────────────
-        try {
-            const { data: respRecords, error } = await getRespiration({ client: wellnessClient, query });
-            if (error || !respRecords)
-                throw new Error(error ? JSON.stringify(error) : "No data");
-            for (const resp of respRecords) {
-                try {
-                    const data = transformRespiration(resp);
-                    if (data) {
-                        await ctx.runMutation(api.public.ingestDaily, {
-                            connectionId, userId, ...data,
-                        });
-                        synced.respiration++;
-                    }
-                }
-                catch (err) {
-                    errors.push({
-                        type: "respiration",
-                        id: resp.summaryId ?? "unknown",
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
+            if (createdScheduleId == null) {
+                throw new Error("Garmin API did not return a scheduleId after creation.");
             }
+            scheduleId = createdScheduleId;
         }
-        catch (err) {
-            errors.push({ type: "respiration", id: "fetch", error: err instanceof Error ? err.message : String(err) });
-        }
-        return { synced, errors };
+        // Persist the Garmin schedule ID back on the planned workout
+        const _ingested = await ctx.runMutation(api.public.ingestPlannedWorkout, {
+            ...plannedWorkout,
+            _id: undefined,
+            _creationTime: undefined,
+            metadata: {
+                ...plannedWorkout.metadata,
+                provider_schedule_id: String(scheduleId),
+            },
+        });
+        return { garminScheduleId: scheduleId };
     },
 });
-// ─── Push ───────────────────────────────────────────────────────────────────
-/**
- * Push a planned workout from Soma's DB to Garmin Connect.
- *
- * Reads the planned workout document, transforms it to Garmin Training API V2
- * format, creates the workout at Garmin, and optionally schedules it if a
- * `planned_date` is set in the metadata.
- *
- * Returns the Garmin workout ID and schedule ID (if scheduled).
- */
-export const pushPlannedWorkout = action({
+// ─── Delete ───────────────────────────────────────────────────────────────────
+export const deleteWorkout = action({
     args: {
         userId: v.string(),
         clientId: v.string(),
         clientSecret: v.string(),
         plannedWorkoutId: v.string(),
-        workoutProvider: v.optional(v.string()),
     },
     handler: async (ctx, args) => {
-        const connection = await ctx.runQuery(internal.private.getConnectionByProvider, { userId: args.userId, provider: "GARMIN" });
-        if (!connection) {
-            throw new Error(`No Garmin connection found for user "${args.userId}". ` +
-                "Connect to Garmin first via getGarminAuthUrl.");
+        const { connectionId, accessToken } = await ctx.runAction(internal.garmin.private.resolveConnectionAndAccessToken, { userId: args.userId, clientId: args.clientId, clientSecret: args.clientSecret });
+        const plannedWorkout = await ctx.runQuery(api.public.getPlannedWorkout, { plannedWorkoutId: args.plannedWorkoutId });
+        if (!plannedWorkout) {
+            throw new Error(`Planned workout "${args.plannedWorkoutId}" not found.`);
         }
-        if (!connection.active) {
-            throw new Error(`Garmin connection for user "${args.userId}" is inactive. Reconnect first.`);
+        const providerWorkoutId = plannedWorkout.metadata?.provider_workout_id;
+        if (!providerWorkoutId) {
+            throw new Error("No Garmin workout ID found on this planned workout. Nothing to delete.");
         }
-        const connectionId = connection._id;
-        const tokenDoc = await ctx.runQuery(internal.garmin.private.getTokens, {
-            connectionId,
+        const trainingClient = createTrainingClient(accessToken);
+        const { error: deleteError } = await sdkDeleteWorkoutV2({
+            client: trainingClient,
+            path: { workoutId: Number(providerWorkoutId) },
         });
-        if (!tokenDoc) {
-            throw new Error("No Garmin tokens found for this connection. " +
-                "The connection may have been created before token storage was available.");
-        }
-        // Always force-refresh the token for Training API calls to rule out
-        // stale tokens (the initial sync swallows 401 errors silently).
-        let accessToken = tokenDoc.accessToken;
-        if (tokenDoc.refreshToken) {
-            try {
-                const refreshed = await refreshToken({
-                    clientId: args.clientId,
-                    clientSecret: args.clientSecret,
-                    refreshToken: tokenDoc.refreshToken,
-                });
-                accessToken = refreshed.access_token;
-                const nowSeconds = Math.floor(Date.now() / 1000);
-                const newExpiresAt = nowSeconds + refreshed.expires_in;
-                const _refreshed = await ctx.runMutation(internal.garmin.private.storeTokens, {
-                    connectionId,
-                    accessToken: refreshed.access_token,
-                    refreshToken: refreshed.refresh_token,
-                    expiresAt: newExpiresAt,
-                });
-            }
-            catch (refreshErr) {
-                throw new Error(`Garmin token refresh failed: ${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}. ` +
-                    "The user may need to reconnect their Garmin account.");
-            }
+        if (deleteError) {
+            throw new Error(`Garmin API error deleting workout: ${JSON.stringify(deleteError)}`);
         }
+        // Clear both provider IDs — deleting a workout on Garmin cascades to its schedules
+        const _ingested = await ctx.runMutation(api.public.ingestPlannedWorkout, {
+            ...plannedWorkout,
+            _id: undefined,
+            _creationTime: undefined,
+            metadata: {
+                ...plannedWorkout.metadata,
+                provider_workout_id: undefined,
+                provider_schedule_id: undefined,
+            },
+        });
+        return null;
+    },
+});
+export const deleteSchedule = action({
+    args: {
+        userId: v.string(),
+        clientId: v.string(),
+        clientSecret: v.string(),
+        plannedWorkoutId: v.string(),
+    },
+    handler: async (ctx, args) => {
+        const { connectionId, accessToken } = await ctx.runAction(internal.garmin.private.resolveConnectionAndAccessToken, { userId: args.userId, clientId: args.clientId, clientSecret: args.clientSecret });
         const plannedWorkout = await ctx.runQuery(api.public.getPlannedWorkout, { plannedWorkoutId: args.plannedWorkoutId });
         if (!plannedWorkout) {
             throw new Error(`Planned workout "${args.plannedWorkoutId}" not found.`);
         }
-        const providerName = args.workoutProvider ?? "Soma";
-        const garminWorkout = transformPlannedWorkoutToGarmin(plannedWorkout, providerName);
+        const providerScheduleId = plannedWorkout.metadata?.provider_schedule_id;
+        if (!providerScheduleId) {
+            throw new Error("No Garmin schedule ID found on this planned workout. Nothing to delete.");
+        }
         const trainingClient = createTrainingClient(accessToken);
-        const { data: created, error: createError } = await sdkCreateWorkoutV2({
+        const { error: deleteError } = await sdkDeleteWorkoutSchedule({
             client: trainingClient,
-            body: garminWorkout,
+            path: { workoutScheduleId: Number(providerScheduleId) },
         });
-        if (createError || !created) {
-            throw new Error(`Garmin API error creating workout: ${createError ? JSON.stringify(createError) : "No data"}`);
-        }
-        if (!created.workoutId) {
-            throw new Error("Garmin API did not return a workoutId after creation.");
+        if (deleteError) {
+            throw new Error(`Garmin API error deleting schedule: ${JSON.stringify(deleteError)}`);
         }
-        let garminScheduleId = null;
-        const plannedDate = plannedWorkout.metadata?.planned_date;
-        if (plannedDate) {
-            const { data: scheduleId, error: scheduleError } = await sdkCreateWorkoutSchedule({
-                client: trainingClient,
-                body: { workoutId: Number(created.workoutId), date: plannedDate },
-            });
-            if (scheduleError) {
-                throw new Error(`Garmin API error creating schedule: ${JSON.stringify(scheduleError)}`);
-            }
-            garminScheduleId = scheduleId ?? null;
-        }
-        // Store the Garmin workout/schedule IDs back on the planned workout
-        // so the host app can match completed activities to planned sessions.
+        // Clear only the schedule ID — the workout still exists on Garmin
         const _ingested = await ctx.runMutation(api.public.ingestPlannedWorkout, {
             ...plannedWorkout,
             _id: undefined,
             _creationTime: undefined,
             metadata: {
                 ...plannedWorkout.metadata,
-                provider_workout_id: String(created.workoutId),
-                provider_schedule_id: garminScheduleId != null ? String(garminScheduleId) : undefined,
+                provider_schedule_id: undefined,
             },
         });
-        return {
-            garminWorkoutId: created.workoutId,
-            garminScheduleId,
-        };
+        return null;
     },
 });
 //# sourceMappingURL=public.js.map