@nativesquare/soma 0.8.0 → 0.9.0

package/dist/component/garmin/webhooks.js

@@ -0,0 +1,766 @@
+// ─── Garmin Webhook Handlers (Push Mode) ─────────────────────────────────────
+// Each handler receives full Garmin data objects from push-mode webhooks.
+// Separate actions per data type because the Garmin developer portal
+// configures separate URLs per type.
+import { v } from "convex/values";
+import { action } from "../_generated/server";
+import { GarminClient } from "../../garmin/client";
+import { refreshToken } from "../../garmin/auth";
+import { transformMenstruation } from "../../garmin/menstruation";
+import { garminSkinTemperaturePingPayloadSchema, garminSkinTemperaturePushPayloadSchema, } from "./schemas/skinTemperature.js";
+import { garminSleepsPingPayloadSchema, garminSleepsPushPayloadSchema, } from "./schemas/sleeps.js";
+import { transformHRV } from "../../garmin/hrv";
+import { transformStressDetails } from "../../garmin/stressDetails";
+import { garminStressPingPayloadSchema, garminStressPushPayloadSchema, } from "./schemas/stress.js";
+import { api, internal } from "../_generated/api";
+import { garminActivityPingPayloadSchema, garminActivityPushPayloadSchema, } from "./schemas/activity.js";
+import { garminActivityDetailsPingPayloadSchema, garminActivityDetailsPushPayloadSchema, } from "./schemas/activityDetails.js";
+import { garminManuallyUpdatedActivitiesPingPayloadSchema, garminManuallyUpdatedActivitiesPushPayloadSchema, } from "./schemas/manuallyUpdatedActivities.js";
+import { garminMoveIQPingPayloadSchema, garminMoveIQPushPayloadSchema, } from "./schemas/moveIQ.js";
+import { garminBloodPressurePingPayloadSchema, garminBloodPressurePushPayloadSchema, } from "./schemas/bloodPressure.js";
+import { garminBodyCompositionsPingPayloadSchema, garminBodyCompositionsPushPayloadSchema, } from "./schemas/bodyCompositions.js";
+import { garminDailiesPingPayloadSchema, garminDailiesPushPayloadSchema, } from "./schemas/dailies.js";
+import { garminEpochPingPayloadSchema, garminEpochPushPayloadSchema, } from "./schemas/epochs.js";
+import { garminHealthSnapshotPingPayloadSchema, garminHealthSnapshotPushPayloadSchema, } from "./schemas/healthSnapshot.js";
+import { garminHRVSummaryPingPayloadSchema, garminHRVSummaryPushPayloadSchema, } from "./schemas/hrvSummary.js";
+import { garminPulseOxPingPayloadSchema, garminPulseOxPushPayloadSchema, } from "./schemas/pulseOx.js";
+import { garminRespirationPingPayloadSchema, garminRespirationPushPayloadSchema, } from "./schemas/respiration.js";
+import { garminUserMetricsPingPayloadSchema, garminUserMetricsPushPayloadSchema, } from "./schemas/userMetrics.js";
+import { garminMenstrualCycleTrackingPingPayloadSchema, garminMenstrualCycleTrackingPushPayloadSchema, } from "./schemas/menstrualCycleTracking.js";
+// Refresh buffer: refresh tokens 10 minutes before expiry
+const REFRESH_BUFFER_SECONDS = 600;
+/**
+ * Discriminate push vs ping webhook payloads.
+ *
+ * Per the Garmin Activity API docs:
+ *   - Ping items always carry `callbackURL` (absent only for deregistrations)
+ *   - Push items never carry `callbackURL`, they contain the full summary data
+ *
+ * Zod schema validation alone can't distinguish the two because both schemas
+ * have all-optional fields and would accept either payload shape.
+ */
+function isWebhookPushMode(payload) {
+    if (payload == null || typeof payload !== "object")
+        return false;
+    // The payload is either a keyed object like { activities: [...] }
+    // or a flat array of items. Extract the first item either way.
+    let firstItem;
+    if (Array.isArray(payload)) {
+        firstItem = payload[0];
+    }
+    else {
+        const key = Object.keys(payload)[0];
+        const list = payload[key];
+        firstItem = Array.isArray(list) ? list[0] : undefined;
+    }
+    if (firstItem == null || typeof firstItem !== "object")
+        return false;
+    return !("callbackURL" in firstItem);
+}
+// ─── Webhook Handlers ────────────────────────────────────────────────────────
+/**
+ * Handle a webhook for Garmin activities (push or ping mode).
+ */
+export const handleGarminWebhookActivities = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminActivityPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success && pushResult.data.activities.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processActivityPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminActivityPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success && pingResult.data.activities.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processActivityPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:activities] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin activity details (push or ping mode).
+ */
+export const handleGarminWebhookActivityDetails = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminActivityDetailsPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.activityDetails.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processActivityDetailsPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminActivityDetailsPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.activityDetails.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processActivityDetailsPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:activityDetails] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin manually updated activities (push or ping mode).
+ */
+export const handleGarminWebhookManuallyUpdatedActivities = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminManuallyUpdatedActivitiesPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.manuallyUpdatedActivities.length > 0) {
+                return await ctx.runAction(internal.garmin.private
+                    .processManuallyUpdatedActivitiesPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminManuallyUpdatedActivitiesPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.manuallyUpdatedActivities.length > 0) {
+                return await ctx.runAction(internal.garmin.private
+                    .processManuallyUpdatedActivitiesPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:manuallyUpdatedActivities] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin Move IQ auto-detected activities (push or ping mode).
+ */
+export const handleGarminWebhookMoveIQ = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminMoveIQPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.moveIQActivities.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processMoveIQPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminMoveIQPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.moveIQActivities.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processMoveIQPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:moveIQ] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin blood pressure summaries (push or ping mode).
+ */
+export const handleGarminWebhookBloodPressures = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminBloodPressurePushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.bloodPressures.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processBloodPressurePushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminBloodPressurePingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.bloodPressures.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processBloodPressurePingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:bloodPressures] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin body composition summaries (push or ping mode).
+ */
+export const handleGarminWebhookBodyCompositions = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminBodyCompositionsPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.bodyComps.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processBodyCompositionsPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminBodyCompositionsPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.bodyComps.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processBodyCompositionsPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:bodyCompositions] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin daily summaries (push or ping mode).
+ */
+export const handleGarminWebhookDailies = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminDailiesPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.dailies.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processDailiesPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminDailiesPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.dailies.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processDailiesPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:dailies] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin epoch summaries (push or ping mode).
+ */
+export const handleGarminWebhookEpochs = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminEpochPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.epochs.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processEpochPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminEpochPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.epochs.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processEpochPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:epochs] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin health snapshot summaries (push or ping mode).
+ */
+export const handleGarminWebhookHealthSnapshot = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminHealthSnapshotPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.healthSnapshot.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processHealthSnapshotPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminHealthSnapshotPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.healthSnapshot.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processHealthSnapshotPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:healthSnapshot] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin sleep summaries (push or ping mode).
+ * Follows the structured dispatch pattern: validates with Zod, then delegates
+ * to internal actions for processing.
+ */
+export const handleGarminWebhookSleeps = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminSleepsPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.sleeps.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processSleepsPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminSleepsPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.sleeps.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processSleepsPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:sleeps] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin menstrual cycle tracking (push or ping mode).
+ */
+export const handleGarminWebhookMenstruation = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        return await processWebhookDualMode(ctx, {
+            items: args.payload,
+            type: "menstruation",
+            transform: (item) => transformMenstruation(item),
+            ingest: api.public.ingestMenstruation,
+            getId: (item) => item.summaryId ??
+                item.calendarDate ??
+                "unknown",
+            fetchData: (client, timeRange) => client.getMenstrualCycleData(timeRange),
+        });
+    },
+});
+/**
+ * Handle a webhook for Garmin skin temperature summaries (push or ping mode).
+ * Follows the structured dispatch pattern: validates with Zod, then delegates
+ * to internal actions for processing.
+ */
+export const handleGarminWebhookSkinTemp = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminSkinTemperaturePushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.skinTemp.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processSkinTemperaturePushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminSkinTemperaturePingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.skinTemp.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processSkinTemperaturePingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:skinTemperature] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin user metrics (push or ping mode).
+ * Follows the structured dispatch pattern: validates with Zod, then delegates
+ * to internal actions for processing.
+ */
+export const handleGarminWebhookUserMetrics = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminUserMetricsPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.userMetrics.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processUserMetricsPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminUserMetricsPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.userMetrics.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processUserMetricsPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:userMetrics] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin menstrual cycle tracking (push or ping mode).
+ * Follows the structured dispatch pattern: validates with Zod, then delegates
+ * to internal actions for processing.
+ */
+export const handleGarminWebhookMenstrualCycleTracking = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminMenstrualCycleTrackingPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.mct.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processMenstrualCycleTrackingPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminMenstrualCycleTrackingPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.mct.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processMenstrualCycleTrackingPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:menstrualCycleTracking] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin HRV summaries (push or ping mode).
+ * Enriches daily records with heart_rate_data.
+ */
+export const handleGarminWebhookHRV = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        return await processWebhookDualMode(ctx, {
+            items: args.payload,
+            type: "hrv",
+            transform: (item) => {
+                const record = item;
+                const data = transformHRV(item);
+                if (!data.heart_rate_data)
+                    return null;
+                return {
+                    metadata: {
+                        start_time: new Date((record.startTimeInSeconds ?? 0) * 1000).toISOString(),
+                        end_time: new Date(((record.startTimeInSeconds ?? 0) + (record.durationInSeconds ?? 86400)) * 1000).toISOString(),
+                        upload_type: 1,
+                    },
+                    heart_rate_data: data.heart_rate_data,
+                };
+            },
+            ingest: api.public.ingestDaily,
+            getId: (item) => item.summaryId ??
+                item.calendarDate ??
+                "unknown",
+            fetchData: (client, timeRange) => client.getHRV(timeRange),
+        });
+    },
+});
+/**
+ * Handle a webhook for Garmin HRV summaries (push or ping mode).
+ * Follows the structured dispatch pattern: validates with Zod, then delegates
+ * to internal actions for processing.
+ */
+export const handleGarminWebhookHRVSummary = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminHRVSummaryPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.hrv.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processHRVSummaryPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminHRVSummaryPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.hrv.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processHRVSummaryPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:hrvSummary] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin stress detail summaries (push or ping mode).
+ * Follows the structured dispatch pattern: validates with Zod, then delegates
+ * to internal actions for processing.
+ */
+export const handleGarminWebhookStress = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminStressPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.stressDetails.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processStressPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminStressPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.stressDetails.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processStressPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:stressDetails] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin pulse oximetry (SpO2) summaries (push or ping mode).
+ * Follows the structured dispatch pattern: validates with Zod, then delegates
+ * to internal actions for processing.
+ */
+export const handleGarminWebhookPulseOx = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminPulseOxPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.pulseox.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processPulseOxPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminPulseOxPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.pulseox.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processPulseOxPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:pulseOx] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+/**
+ * Handle a webhook for Garmin respiration summaries (push or ping mode).
+ * Follows the structured dispatch pattern: validates with Zod, then delegates
+ * to internal actions for processing.
+ */
+export const handleGarminWebhookRespiration = action({
+    args: { payload: v.any() },
+    handler: async (ctx, args) => {
+        if (isWebhookPushMode(args.payload)) {
+            const pushResult = garminRespirationPushPayloadSchema.safeParse(args.payload);
+            if (pushResult.success &&
+                pushResult.data.allDayRespiration.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processRespirationPushPayload, { payload: args.payload });
+            }
+        }
+        else {
+            const pingResult = garminRespirationPingPayloadSchema.safeParse(args.payload);
+            if (pingResult.success &&
+                pingResult.data.allDayRespiration.length > 0) {
+                return await ctx.runAction(internal.garmin.private.processRespirationPingPayload, { payload: args.payload });
+            }
+        }
+        console.warn(`[garmin:webhook:respiration] Payload matched neither ping nor push schema`);
+        return { processed: 0, errors: [] };
+    },
+});
+async function processWebhookPayload(ctx, config) {
+    const { items, type, transform, ingest, getId } = config;
+    let processed = 0;
+    const errors = [];
+    if (!Array.isArray(items)) {
+        errors.push({ type, id: "payload", error: "Expected an array payload" });
+        return { processed, errors };
+    }
+    // Group items by Garmin userId
+    const byUser = new Map();
+    for (const item of items) {
+        const garminUserId = item.userId;
+        if (!garminUserId) {
+            errors.push({ type, id: getId(item), error: "Missing userId in payload item" });
+            continue;
+        }
+        if (!byUser.has(garminUserId))
+            byUser.set(garminUserId, []);
+        byUser.get(garminUserId).push(item);
+    }
+    // Process each Garmin user's items
+    for (const [garminUserId, userItems] of byUser) {
+        const connection = await ctx.runQuery(internal.private.getConnectionByProviderUserId, { providerUserId: garminUserId, provider: "GARMIN" });
+        if (!connection) {
+            for (const item of userItems) {
+                errors.push({
+                    type,
+                    id: getId(item),
+                    error: `No Soma connection found for Garmin userId "${garminUserId}"`,
+                });
+            }
+            continue;
+        }
+        if (!connection.active) {
+            for (const item of userItems) {
+                errors.push({
+                    type,
+                    id: getId(item),
+                    error: `Garmin connection for userId "${garminUserId}" is inactive`,
+                });
+            }
+            continue;
+        }
+        const connectionId = connection._id;
+        const userId = connection.userId;
+        for (const item of userItems) {
+            try {
+                const data = transform(item);
+                if (data == null)
+                    continue; // Skip items with no transformable data
+                await ctx.runMutation(ingest, {
+                    connectionId,
+                    userId,
+                    ...data,
+                });
+                processed++;
+            }
+            catch (err) {
+                errors.push({
+                    type,
+                    id: getId(item),
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        // Update last data timestamp
+        await ctx.runMutation(api.public.updateConnection, {
+            connectionId,
+            lastDataUpdate: new Date().toISOString(),
+        });
+    }
+    return { processed, errors };
+}
+/**
+ * Process a webhook payload in either push or ping mode.
+ *
+ * - Push mode: items contain full data → transform and ingest directly.
+ * - Ping mode: items are notifications → fetch data from the API, then
+ *   transform and ingest.
+ */
+async function processWebhookDualMode(ctx, config) {
+    const mode = isWebhookPushMode(config.items) ? "push" : "ping";
+    console.log(`[garmin:webhook:${config.type}] mode=${mode} items=${config.items.length} payload:`, JSON.stringify(config.items, null, 2));
+    if (mode === "ping") {
+        return await processWebhookPingPayload(ctx, config);
+    }
+    return await processWebhookPayload(ctx, config);
+}
+async function processWebhookPingPayload(ctx, config) {
+    const { items, type, fetchData, transform, ingest, getId } = config;
+    let processed = 0;
+    const errors = [];
+    if (!Array.isArray(items)) {
+        errors.push({ type, id: "payload", error: "Expected an array payload" });
+        return { processed, errors };
+    }
+    // Group by Garmin userId and merge time ranges
+    const byUser = new Map();
+    for (const item of items) {
+        const garminUserId = item.userId;
+        if (!garminUserId) {
+            errors.push({ type, id: "unknown", error: "Missing userId in ping notification" });
+            continue;
+        }
+        const existing = byUser.get(garminUserId);
+        const start = item.uploadStartTimeInSeconds ?? 0;
+        const end = item.uploadEndTimeInSeconds ?? 0;
+        const token = item.userAccessToken;
+        if (existing) {
+            existing.minStart = Math.min(existing.minStart, start);
+            existing.maxEnd = Math.max(existing.maxEnd, end);
+            if (token && !existing.userAccessToken)
+                existing.userAccessToken = token;
+        }
+        else {
+            byUser.set(garminUserId, { userAccessToken: token, minStart: start, maxEnd: end });
+        }
+    }
+    for (const [garminUserId, notification] of byUser) {
+        const connection = await ctx.runQuery(internal.private.getConnectionByProviderUserId, { providerUserId: garminUserId, provider: "GARMIN" });
+        if (!connection) {
+            errors.push({
+                type,
+                id: "ping",
+                error: `No Soma connection found for Garmin userId "${garminUserId}"`,
+            });
+            continue;
+        }
+        if (!connection.active) {
+            errors.push({
+                type,
+                id: "ping",
+                error: `Garmin connection for userId "${garminUserId}" is inactive`,
+            });
+            continue;
+        }
+        const connectionId = connection._id;
+        const userId = connection.userId;
+        // Resolve a valid access token: prefer stored (with refresh), fall back to notification
+        let accessToken = null;
+        const tokenDoc = await ctx.runQuery(internal.garmin.private.getTokens, {
+            connectionId,
+        });
+        if (tokenDoc) {
+            accessToken = tokenDoc.accessToken;
+            const nowSeconds = Math.floor(Date.now() / 1000);
+            if (tokenDoc.expiresAt &&
+                tokenDoc.refreshToken &&
+                nowSeconds >= tokenDoc.expiresAt - REFRESH_BUFFER_SECONDS) {
+                const clientId = process.env.GARMIN_CLIENT_ID;
+                const clientSecret = process.env.GARMIN_CLIENT_SECRET;
+                if (clientId && clientSecret) {
+                    try {
+                        const refreshed = await refreshToken({
+                            clientId,
+                            clientSecret,
+                            refreshToken: tokenDoc.refreshToken,
+                        });
+                        accessToken = refreshed.access_token;
+                        await ctx.runMutation(internal.garmin.private.storeTokens, {
+                            connectionId,
+                            accessToken: refreshed.access_token,
+                            refreshToken: refreshed.refresh_token,
+                            expiresAt: nowSeconds + refreshed.expires_in,
+                        });
+                    }
+                    catch {
+                        // Refresh failed — fall through to notification token
+                    }
+                }
+            }
+        }
+        if (!accessToken) {
+            accessToken = notification.userAccessToken ?? null;
+        }
+        if (!accessToken) {
+            errors.push({
+                type,
+                id: "ping",
+                error: `No access token available for Garmin userId "${garminUserId}"`,
+            });
+            continue;
+        }
+        const client = new GarminClient({ accessToken });
+        // Use the merged time range from all notifications for this user
+        let { minStart, maxEnd } = notification;
+        if (minStart === 0 && maxEnd === 0) {
+            const now = Math.floor(Date.now() / 1000);
+            minStart = now - 86400;
+            maxEnd = now;
+        }
+        try {
+            const records = await fetchData(client, {
+                uploadStartTimeInSeconds: minStart,
+                uploadEndTimeInSeconds: maxEnd,
+            });
+            for (const record of records) {
+                try {
+                    const data = transform(record);
+                    if (data == null)
+                        continue;
+                    await ctx.runMutation(ingest, {
+                        connectionId,
+                        userId,
+                        ...data,
+                    });
+                    processed++;
+                }
+                catch (err) {
+                    errors.push({
+                        type,
+                        id: getId(record),
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+        }
+        catch (err) {
+            errors.push({
+                type,
+                id: "fetch",
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        await ctx.runMutation(api.public.updateConnection, {
+            connectionId,
+            lastDataUpdate: new Date().toISOString(),
+        });
+    }
+    return { processed, errors };
+}
+//# sourceMappingURL=webhooks.js.map