@clipin/convex-wearables 0.2.1 → 0.4.0

package/src/client/index.ts

@@ -15,6 +15,11 @@ import type {
 } from "convex/server";
 import { httpActionGeneric } from "convex/server";
 import type { ComponentApi } from "../component/_generated/component.js";
+import {
+  getAllProviderCapabilityInfo as getAllProviderCapabilityInfoValue,
+  getProviderCapabilities as getProviderCapabilitiesValue,
+  getProviderCapabilityInfo as getProviderCapabilityInfoValue,
+} from "./providerCapabilities.js";
 import type {
   AggregateStats,
   BackfillJob,
@@ -26,6 +31,9 @@ import type {
   EventsPage,
   GarminRoutesConfig,
   HealthEvent,
+  LiveSyncMode,
+  ProviderCapabilities,
+  ProviderCapabilityInfo,
   ProviderCredentials,
   ProviderName,
   RegisterRoutesConfig,
@@ -51,6 +59,18 @@ export {
   stravaWebhookEvent,
   stravaWebhookVerify,
 } from "../component/httpHandlers.js";
+export {
+  createProviderCapabilities,
+  getAllProviderCapabilityInfo,
+  getDefaultLiveSyncMode,
+  getProviderCapabilities,
+  getProviderCapabilityInfo,
+  isLiveSyncConfigurable,
+  PROVIDER_NAMES,
+  supportsBackfill,
+  supportsHistoricalSync,
+  supportsManualSync,
+} from "./providerCapabilities.js";
 export type { SeriesType, SleepEvent, SleepStage, WorkoutEvent } from "./types.js";
 export { SERIES_TYPES } from "./types.js";
 // Re-export types for consumers
@@ -65,6 +85,9 @@ export type {
   EventsPage,
   GarminRoutesConfig,
   HealthEvent,
+  LiveSyncMode,
+  ProviderCapabilities,
+  ProviderCapabilityInfo,
   ProviderCredentials,
   ProviderName,
   RegisterRoutesConfig,
@@ -140,6 +163,27 @@ export class WearablesClient {
     this.config = config;
   }
 
+  /**
+   * Get static delivery/sync capabilities for a provider.
+   */
+  getProviderCapabilities(provider: ProviderName): ProviderCapabilities {
+    return getProviderCapabilitiesValue(provider);
+  }
+
+  /**
+   * Get static provider capabilities plus derived UI-friendly flags.
+   */
+  getProviderCapabilityInfo(provider: ProviderName): ProviderCapabilityInfo {
+    return getProviderCapabilityInfoValue(provider);
+  }
+
+  /**
+   * Get static capability info for every supported provider.
+   */
+  getAllProviderCapabilityInfo(): ProviderCapabilityInfo[] {
+    return getAllProviderCapabilityInfoValue();
+  }
+
   // -----------------------------------------------------------------------
   // Connection Management
   // -----------------------------------------------------------------------
@@ -447,12 +491,21 @@ export class WearablesClient {
    */
   async startGarminBackfill(
     ctx: ActionRunner,
-    args: { connectionId: string; lookbackDays?: number },
+    args: {
+      connectionId: string;
+      kind?: "full" | "recent";
+      lookbackDays?: number;
+      windowStart?: number;
+      windowEnd?: number;
+    },
   ): Promise<{ backfillJobId: string; workflowId: string; deduped: boolean }> {
     const credentials = this.requireProviderCredentials("garmin");
     return await ctx.runAction(this.component.garminBackfill.startGarminBackfill, {
       connectionId: args.connectionId,
+      kind: args.kind,
       lookbackDays: args.lookbackDays,
+      windowStart: args.windowStart,
+      windowEnd: args.windowEnd,
       clientId: credentials.clientId,
       clientSecret: credentials.clientSecret,
     });
@@ -789,12 +842,15 @@ function summarizeGarminPayload(payload: unknown) {
     bodyComps: getArrayLength(payload.bodyComps),
     hrv: getArrayLength(payload.hrv),
     stressDetails: getArrayLength(payload.stressDetails),
+    allDayRespiration: getArrayLength(payload.allDayRespiration),
     respiration: getArrayLength(payload.respiration),
     pulseOx: getArrayLength(payload.pulseOx),
+    pulseox: getArrayLength(payload.pulseox),
     bloodPressures: getArrayLength(payload.bloodPressures),
     userMetrics: getArrayLength(payload.userMetrics),
     skinTemp: getArrayLength(payload.skinTemp),
     healthSnapshot: getArrayLength(payload.healthSnapshot),
+    moveIQActivities: getArrayLength(payload.moveIQActivities),
     moveiq: getArrayLength(payload.moveiq),
     menstrualCycleTracking: getArrayLength(payload.menstrualCycleTracking),
     mct: getArrayLength(payload.mct),

package/src/client/providerCapabilities.ts

@@ -0,0 +1,182 @@
+import type {
+  LiveSyncMode,
+  ProviderCapabilities,
+  ProviderCapabilityInfo,
+  ProviderName,
+} from "./types.js";
+
+const DEFAULT_CAPABILITIES: ProviderCapabilities = {
+  restPull: false,
+  clientSdk: false,
+  fileImport: false,
+  webhookCallback: false,
+  webhookStream: false,
+  webhookPing: false,
+  webhookRegistrationApi: false,
+  webhookInboundSecret: false,
+  maxHistoricalDays: null,
+};
+
+const PROVIDER_CAPABILITIES = {
+  garmin: {
+    restPull: false,
+    clientSdk: false,
+    fileImport: false,
+    webhookCallback: true,
+    webhookStream: true,
+    webhookPing: false,
+    webhookRegistrationApi: false,
+    webhookInboundSecret: false,
+    maxHistoricalDays: 30,
+  },
+  suunto: {
+    restPull: true,
+    clientSdk: false,
+    fileImport: false,
+    webhookCallback: false,
+    webhookStream: false,
+    webhookPing: false,
+    webhookRegistrationApi: false,
+    webhookInboundSecret: false,
+    maxHistoricalDays: null,
+  },
+  polar: {
+    restPull: true,
+    clientSdk: false,
+    fileImport: false,
+    webhookCallback: false,
+    webhookStream: false,
+    webhookPing: false,
+    webhookRegistrationApi: false,
+    webhookInboundSecret: false,
+    maxHistoricalDays: null,
+  },
+  whoop: {
+    restPull: true,
+    clientSdk: false,
+    fileImport: false,
+    webhookCallback: false,
+    webhookStream: false,
+    webhookPing: false,
+    webhookRegistrationApi: false,
+    webhookInboundSecret: false,
+    maxHistoricalDays: null,
+  },
+  strava: {
+    restPull: true,
+    clientSdk: false,
+    fileImport: false,
+    webhookCallback: false,
+    webhookStream: false,
+    webhookPing: true,
+    webhookRegistrationApi: false,
+    webhookInboundSecret: false,
+    maxHistoricalDays: null,
+  },
+  apple: {
+    restPull: false,
+    clientSdk: true,
+    fileImport: false,
+    webhookCallback: false,
+    webhookStream: false,
+    webhookPing: false,
+    webhookRegistrationApi: false,
+    webhookInboundSecret: false,
+    maxHistoricalDays: null,
+  },
+  samsung: {
+    restPull: false,
+    clientSdk: true,
+    fileImport: false,
+    webhookCallback: false,
+    webhookStream: false,
+    webhookPing: false,
+    webhookRegistrationApi: false,
+    webhookInboundSecret: false,
+    maxHistoricalDays: null,
+  },
+  google: {
+    restPull: false,
+    clientSdk: true,
+    fileImport: false,
+    webhookCallback: false,
+    webhookStream: false,
+    webhookPing: false,
+    webhookRegistrationApi: false,
+    webhookInboundSecret: false,
+    maxHistoricalDays: null,
+  },
+} satisfies Record<ProviderName, ProviderCapabilities>;
+
+export const PROVIDER_NAMES = Object.keys(PROVIDER_CAPABILITIES) as ProviderName[];
+
+export function getProviderCapabilities(provider: ProviderName): ProviderCapabilities {
+  return { ...PROVIDER_CAPABILITIES[provider] };
+}
+
+export function getProviderCapabilityInfo(provider: ProviderName): ProviderCapabilityInfo {
+  const capabilities = getProviderCapabilities(provider);
+  return {
+    provider,
+    ...capabilities,
+    implemented: true,
+    liveSyncConfigurable: isLiveSyncConfigurable(capabilities),
+    defaultLiveSyncMode: getDefaultLiveSyncMode(provider),
+    supportsManualSync: supportsManualSync(provider),
+    supportsHistoricalSync: supportsHistoricalSync(provider),
+    supportsBackfill: supportsBackfill(provider),
+  };
+}
+
+export function getAllProviderCapabilityInfo(): ProviderCapabilityInfo[] {
+  return PROVIDER_NAMES.map((provider) => getProviderCapabilityInfo(provider));
+}
+
+export function getDefaultLiveSyncMode(provider: ProviderName): LiveSyncMode | null {
+  const capabilities = getProviderCapabilities(provider);
+  if (capabilities.restPull) return "pull";
+  if (capabilities.clientSdk) return null;
+  if (capabilities.webhookStream || capabilities.webhookPing) return "webhook";
+  return null;
+}
+
+export function isLiveSyncConfigurable(
+  providerOrCapabilities: ProviderName | ProviderCapabilities,
+): boolean {
+  const capabilities =
+    typeof providerOrCapabilities === "string"
+      ? getProviderCapabilities(providerOrCapabilities)
+      : providerOrCapabilities;
+  return capabilities.restPull && (capabilities.webhookStream || capabilities.webhookPing);
+}
+
+export function supportsManualSync(provider: ProviderName): boolean {
+  const capabilities = getProviderCapabilities(provider);
+  return capabilities.restPull;
+}
+
+export function supportsHistoricalSync(provider: ProviderName): boolean {
+  const capabilities = getProviderCapabilities(provider);
+  return capabilities.restPull || capabilities.webhookCallback;
+}
+
+export function supportsBackfill(provider: ProviderName): boolean {
+  const capabilities = getProviderCapabilities(provider);
+  return capabilities.webhookCallback;
+}
+
+export function createProviderCapabilities(
+  capabilities: Partial<ProviderCapabilities>,
+): ProviderCapabilities {
+  const merged = { ...DEFAULT_CAPABILITIES, ...capabilities };
+  if (merged.webhookStream && merged.webhookPing) {
+    throw new Error("webhookStream and webhookPing are mutually exclusive");
+  }
+  if (merged.webhookPing && !merged.restPull) {
+    throw new Error("webhookPing requires restPull because data must be fetched after the ping");
+  }
+  if (merged.webhookInboundSecret && !merged.webhookRegistrationApi) {
+    throw new Error("webhookInboundSecret requires webhookRegistrationApi");
+  }
+  return merged;
+}

package/src/client/types.ts

@@ -30,6 +30,57 @@ export type DurationInput = string | number;
 
 export type TimeSeriesRollupAggregation = "avg" | "min" | "max" | "last" | "count";
 
+export type LiveSyncMode = "pull" | "webhook";
+
+export interface ProviderCapabilities {
+  /**
+   * Provider exposes a REST API that can be polled for historical or recent data.
+   */
+  restPull: boolean;
+  /**
+   * Data arrives through the normalized mobile SDK push endpoint.
+   */
+  clientSdk: boolean;
+  /**
+   * Data arrives as a file import rather than provider API calls or SDK pushes.
+   */
+  fileImport: boolean;
+  /**
+   * We request a provider export/backfill and the provider calls back asynchronously.
+   */
+  webhookCallback: boolean;
+  /**
+   * Provider pushes complete data payloads inline to the component webhook.
+   */
+  webhookStream: boolean;
+  /**
+   * Provider sends lightweight notifications and data must be fetched separately.
+   */
+  webhookPing: boolean;
+  /**
+   * Provider supports programmatic webhook subscription registration.
+   */
+  webhookRegistrationApi: boolean;
+  /**
+   * Provider returns or requires a stored inbound webhook signing secret.
+   */
+  webhookInboundSecret: boolean;
+  /**
+   * Known historical sync lookback limit in days. Null means no known component-enforced limit.
+   */
+  maxHistoricalDays: number | null;
+}
+
+export interface ProviderCapabilityInfo extends ProviderCapabilities {
+  provider: ProviderName;
+  implemented: boolean;
+  liveSyncConfigurable: boolean;
+  defaultLiveSyncMode: LiveSyncMode | null;
+  supportsManualSync: boolean;
+  supportsHistoricalSync: boolean;
+  supportsBackfill: boolean;
+}
+
 // ---------------------------------------------------------------------------
 // Provider configuration (passed by app)
 // ---------------------------------------------------------------------------
@@ -98,6 +149,10 @@ export interface SdkDeviceMetadata {
   source?: string;
   deviceType?: string;
   originalSourceName?: string;
+  appId?: string;
+  app_id?: string;
+  bundleIdentifier?: string;
+  bundle_identifier?: string;
 }
 
 export interface SdkSourceMetadata {
@@ -106,6 +161,10 @@ export interface SdkSourceMetadata {
   source?: string;
   deviceType?: string;
   originalSourceName?: string;
+  appId?: string;
+  app_id?: string;
+  bundleIdentifier?: string;
+  bundle_identifier?: string;
 }
 
 export interface SdkPushEvent extends SdkSourceMetadata {
@@ -157,6 +216,10 @@ export interface SdkPushSummary {
   category: string;
   source?: string;
   originalSourceName?: string;
+  appId?: string;
+  app_id?: string;
+  bundleIdentifier?: string;
+  bundle_identifier?: string;
   totalSteps?: number;
   totalCalories?: number;
   activeCalories?: number;
@@ -540,7 +603,7 @@ export const SERIES_TYPES = {
   peripheral_perfusion_index: { id: 27, unit: "score" },
   forced_vital_capacity: { id: 28, unit: "liters" },
   forced_expiratory_volume_1: { id: 29, unit: "liters" },
-  peak_expiratory_flow_rate: { id: 30, unit: "liters" },
+  peak_expiratory_flow_rate: { id: 30, unit: "L/min" },
 
   // Body Composition
   height: { id: 40, unit: "cm" },

package/src/component/garminBackfill.ts

@@ -16,21 +16,31 @@ export const GARMIN_BACKFILL_TYPES = [
   "bodyComps",
   "hrv",
   "stressDetails",
-  "respiration",
+  "allDayRespiration",
   "pulseOx",
   "bloodPressures",
   "userMetrics",
   "skinTemp",
   "healthSnapshot",
-  "moveiq",
+  "moveIQActivities",
   "mct",
 ] as const;
+export const RECENT_GARMIN_BACKFILL_TYPES = ["dailies", "epochs", "sleeps"] as const;
 
 type GarminBackfillType = (typeof GARMIN_BACKFILL_TYPES)[number];
 
+export function getGarminBackfillTypesForJob(dataType: string | undefined): GarminBackfillType[] {
+  if (dataType === "recent") {
+    return [...RECENT_GARMIN_BACKFILL_TYPES];
+  }
+
+  return [...GARMIN_BACKFILL_TYPES];
+}
+
 export const requestGarminBackfill = internalMutation({
   args: {
     connectionId: v.id("connections"),
+    kind: v.optional(v.union(v.literal("full"), v.literal("recent"))),
     windowStart: v.number(),
     windowEnd: v.number(),
   },
@@ -66,7 +76,7 @@ export const requestGarminBackfill = internalMutation({
       connectionId: connection._id,
       userId: connection.userId,
       provider: "garmin",
-      dataType: "full",
+      dataType: args.kind ?? "full",
       status: "queued",
       startedAt: Date.now(),
       windowStart: args.windowStart,
@@ -186,7 +196,7 @@ export const runGarminBackfill = durableWorkflow.define({
 
     const completed = new Set<string>(job.completedDataTypes ?? []);
 
-    for (const dataType of GARMIN_BACKFILL_TYPES) {
+    for (const dataType of getGarminBackfillTypesForJob(job.dataType)) {
       if (completed.has(dataType)) {
         continue;
       }
@@ -293,7 +303,10 @@ export const handleGarminBackfillComplete = internalMutation({
 export const startGarminBackfill = action({
   args: {
     connectionId: v.id("connections"),
+    kind: v.optional(v.union(v.literal("full"), v.literal("recent"))),
     lookbackDays: v.optional(v.number()),
+    windowStart: v.optional(v.number()),
+    windowEnd: v.optional(v.number()),
     clientId: v.optional(v.string()),
     clientSecret: v.optional(v.string()),
   },
@@ -326,12 +339,26 @@ export const startGarminBackfill = action({
     }
 
     const now = Date.now();
+    if (
+      (args.windowStart !== undefined && args.windowEnd === undefined) ||
+      (args.windowStart === undefined && args.windowEnd !== undefined)
+    ) {
+      throw new Error("windowStart and windowEnd must be provided together");
+    }
+
     const lookbackMs = (args.lookbackDays ?? DEFAULT_LOOKBACK_DAYS) * 24 * 60 * 60 * 1000;
+    const windowStart = args.windowStart ?? now - lookbackMs;
+    const windowEnd = args.windowEnd ?? now;
+
+    if (windowStart >= windowEnd) {
+      throw new Error("windowStart must be before windowEnd");
+    }
 
     const result = await ctx.runMutation(internal.garminBackfill.requestGarminBackfill, {
       connectionId: args.connectionId,
-      windowStart: now - lookbackMs,
-      windowEnd: now,
+      kind: args.kind,
+      windowStart,
+      windowEnd,
     });
 
     return {

package/src/component/garminWebhooks.test.ts

@@ -1,7 +1,7 @@
 import { convexTest } from "convex-test";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { api, internal } from "./_generated/api";
-import { GARMIN_BACKFILL_TYPES } from "./garminBackfill";
+import { GARMIN_BACKFILL_TYPES, getGarminBackfillTypesForJob } from "./garminBackfill";
 import { triggerBackfill } from "./providers/garmin";
 import schema from "./schema";
 import { modules } from "./test.setup";
@@ -301,7 +301,7 @@ describe("garminWebhooks", () => {
             },
           },
         ],
-        respiration: [
+        allDayRespiration: [
           {
             userId: "garmin-user-1",
             summaryId: "resp-1",
@@ -364,7 +364,7 @@ describe("garminWebhooks", () => {
             respiration: 13.8,
           },
         ],
-        moveiq: [
+        moveIQActivities: [
           {
             userId: "garmin-user-1",
             summaryId: "moveiq-1",
@@ -413,6 +413,7 @@ describe("garminWebhooks", () => {
     });
 
     expect(result.connection?.scope).toBe("ACTIVITY_EXPORT HEALTH_EXPORT");
+    expect(result.connection?.lastSyncedAt).toEqual(expect.any(Number));
     expect(result.events).toHaveLength(4);
     expect(result.events.map((event) => event.type)).toEqual(
       expect.arrayContaining(["running", "cycling", "sleep_session", "moveiq_walking"]),
@@ -448,7 +449,7 @@ describe("garminWebhooks", () => {
       restingHeartRate: 48,
       avgStressLevel: 30,
       bodyBattery: 45,
-      hrvAvg: 55,
+      hrvRmssd: 55,
       spo2Avg: 97,
     });
     expect(bodySummary).toMatchObject({
@@ -476,7 +477,7 @@ describe("garminWebhooks", () => {
         "garmin_fitness_age",
         "garmin_stress_level",
         "heart_rate",
-        "heart_rate_variability_sdnn",
+        "heart_rate_variability_rmssd",
         "oxygen_saturation",
         "respiratory_rate",
         "resting_heart_rate",
@@ -722,18 +723,23 @@ describe("garminBackfill", () => {
         "bodyComps",
         "hrv",
         "stressDetails",
-        "respiration",
+        "allDayRespiration",
         "pulseOx",
         "bloodPressures",
         "userMetrics",
         "skinTemp",
         "healthSnapshot",
-        "moveiq",
+        "moveIQActivities",
         "mct",
       ]),
     );
   });
 
+  it("limits recent Garmin backfills to freshness-critical feeds", () => {
+    expect(getGarminBackfillTypesForJob("recent")).toEqual(["dailies", "epochs", "sleeps"]);
+    expect(getGarminBackfillTypesForJob("full")).toEqual(GARMIN_BACKFILL_TYPES);
+  });
+
   it("triggers extended Garmin backfill endpoints even when Garmin returns an empty 202 body", async () => {
     const fetchMock = vi.fn().mockResolvedValue(new Response(null, { status: 202 }));
     vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
@@ -751,4 +757,15 @@ describe("garminBackfill", () => {
       Accept: "application/json",
     });
   });
+
+  it("maps legacy Garmin backfill aliases to Garmin's current endpoint names", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(new Response(null, { status: 202 }));
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    await triggerBackfill("garmin-token", "respiration", 100, 200);
+    await triggerBackfill("garmin-token", "moveiq", 100, 200);
+
+    expect(String(fetchMock.mock.calls[0]?.[0])).toContain("/backfill/allDayRespiration?");
+    expect(String(fetchMock.mock.calls[1]?.[0])).toContain("/backfill/moveIQActivities?");
+  });
 });

package/src/component/garminWebhooks.ts

@@ -244,8 +244,12 @@ export const processPushPayload = action({
       }
     }
 
-    if (payload.respiration?.length) {
-      for (const respiration of payload.respiration) {
+    const respirationEntries =
+      payload.allDayRespiration && payload.allDayRespiration.length > 0
+        ? payload.allDayRespiration
+        : payload.respiration;
+    if (respirationEntries?.length) {
+      for (const respiration of respirationEntries) {
         const connection = await resolveConnection(ctx, respiration.userId);
         if (!connection) continue;
 
@@ -257,12 +261,14 @@ export const processPushPayload = action({
           dataSourceId,
           normalizeRespirationDataPoints(respiration),
         );
-        addSignal(signalBuckets, "respiration", connection._id);
+        addSignal(signalBuckets, "allDayRespiration", connection._id);
       }
     }
 
-    if (payload.pulseOx?.length) {
-      for (const pulseOx of payload.pulseOx) {
+    const pulseOxEntries =
+      payload.pulseOx && payload.pulseOx.length > 0 ? payload.pulseOx : payload.pulseox;
+    if (pulseOxEntries?.length) {
+      for (const pulseOx of pulseOxEntries) {
         const connection = await resolveConnection(ctx, pulseOx.userId);
         if (!connection) continue;
 
@@ -344,8 +350,12 @@ export const processPushPayload = action({
       }
     }
 
-    if (payload.moveiq?.length) {
-      for (const moveIQ of payload.moveiq) {
+    const moveIQEntries =
+      payload.moveIQActivities && payload.moveIQActivities.length > 0
+        ? payload.moveIQActivities
+        : payload.moveiq;
+    if (moveIQEntries?.length) {
+      for (const moveIQ of moveIQEntries) {
         const connection = await resolveConnection(ctx, moveIQ.userId);
         if (!connection) continue;
 
@@ -365,7 +375,7 @@ export const processPushPayload = action({
           externalId: event.externalId,
         });
 
-        addSignal(signalBuckets, "moveiq", connection._id);
+        addSignal(signalBuckets, "moveIQActivities", connection._id);
       }
     }
 
@@ -444,6 +454,15 @@ export const processPushPayload = action({
       }
     }
 
+    const syncedConnectionIds = new Set(
+      [...signalBuckets.values()].flatMap((connectionIds) => [...connectionIds]),
+    );
+    for (const connectionId of syncedConnectionIds) {
+      await ctx.runMutation(internal.connections.markSynced, {
+        connectionId: connectionId as Id<"connections">,
+      });
+    }
+
     return null;
   },
 });
@@ -744,10 +763,10 @@ function getPayloadItemCount(payload: GarminPushPayload, dataType: string): numb
       return payload.hrv?.length;
     case "stressDetails":
       return payload.stressDetails?.length;
-    case "respiration":
-      return payload.respiration?.length;
+    case "allDayRespiration":
+      return payload.allDayRespiration?.length ?? payload.respiration?.length;
     case "pulseOx":
-      return payload.pulseOx?.length;
+      return payload.pulseOx?.length ?? payload.pulseox?.length;
     case "bloodPressures":
       return payload.bloodPressures?.length;
     case "userMetrics":
@@ -756,8 +775,8 @@ function getPayloadItemCount(payload: GarminPushPayload, dataType: string): numb
       return payload.skinTemp?.length;
     case "healthSnapshot":
       return payload.healthSnapshot?.length;
-    case "moveiq":
-      return payload.moveiq?.length;
+    case "moveIQActivities":
+      return payload.moveIQActivities?.length ?? payload.moveiq?.length;
     case "mct":
       return payload.menstrualCycleTracking && payload.menstrualCycleTracking.length > 0
         ? payload.menstrualCycleTracking.length