@nativesquare/soma 0.16.2 → 0.16.3

package/src/client/healthkit.ts

@@ -7,18 +7,6 @@ import type {
   HKActivitySummary,
   HKCharacteristics,
 } from "../component/healthkit/types.js";
-import { transformWorkout } from "../component/healthkit/transform/activity.js";
-import { transformSleep } from "../component/healthkit/transform/sleep.js";
-import { transformBody } from "../component/healthkit/transform/body.js";
-import {
-  transformDaily,
-  transformDailyFromSummary,
-} from "../component/healthkit/transform/daily.js";
-import { transformNutrition } from "../component/healthkit/transform/nutrition.js";
-import { transformMenstruation } from "../component/healthkit/transform/menstruation.js";
-import { transformAthlete } from "../component/healthkit/transform/athlete.js";
-
-const PROVIDER = "APPLE";
 
 /**
  * Client class for Apple HealthKit integration with Soma.
@@ -26,8 +14,8 @@ const PROVIDER = "APPLE";
  * Unlike {@link import("./strava.js").SomaStrava | SomaStrava} and
  * {@link import("./garmin.js").SomaGarmin | SomaGarmin}, HealthKit is an
  * on-device provider — data is queried locally on iOS, not fetched from a
- * cloud API. This class wraps the transform + ingest pipeline so the host
- * app gets the same ergonomic interface as cloud providers.
+ * cloud API. This class is a thin wrapper over the component's public
+ * mutations, which own the transform + ingest pipeline.
  *
  * Because HealthKit permissions are managed in iOS Settings, the server
  * cannot independently verify whether the user has granted or revoked
@@ -78,10 +66,6 @@ export class SomaHealthKit {
    * permissions were granted. Creates the APPLE connection if missing,
    * or re-activates it if previously disconnected. Idempotent.
    *
-   * Because iOS permission grants happen on-device, the server cannot
-   * verify them independently — this method records the host app's
-   * assertion that the user has authorized HealthKit access.
-   *
    * @param ctx - Mutation context from the host app
    * @param args.userId - The host app's user identifier
    * @returns The connection document ID
@@ -90,10 +74,7 @@ export class SomaHealthKit {
     ctx: MutationCtx,
     args: { userId: string },
   ): Promise<string> {
-    return (await ctx.runMutation(this.component.public.connect, {
-      userId: args.userId,
-      provider: PROVIDER,
-    })) as string;
+    return await ctx.runMutation(this.component.healthkit.public.connect, args);
   }
 
   /**
@@ -114,10 +95,7 @@ export class SomaHealthKit {
     ctx: MutationCtx,
     args: { userId: string },
   ): Promise<null> {
-    return await ctx.runMutation(this.component.public.disconnect, {
-      userId: args.userId,
-      provider: PROVIDER,
-    });
+    return await ctx.runMutation(this.component.healthkit.public.disconnect, args);
   }
 
   // ─── Per-Type Sync Methods ─────────────────────────────────────────────
@@ -127,39 +105,15 @@ export class SomaHealthKit {
    *
    * Transforms each `HKWorkout` into the Soma Activity schema and ingests it
    * with automatic deduplication by `workout.uuid`.
-   *
-   * @param ctx - Mutation (or action) context from the host app
-   * @param args.userId - The host app's user identifier
-   * @param args.workouts - Array of HKWorkout objects from HealthKit
    */
   async syncActivities(
     ctx: MutationCtx,
     args: { userId: string; workouts: HKWorkout[] },
   ): Promise<SomaResult<{ activities: number }>> {
-    const connectionId = await this.requireActiveConnection(ctx, args.userId);
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    for (const workout of args.workouts) {
-      try {
-        const data = transformWorkout(workout);
-        await ctx.runMutation(this.component.public.ingestActivity, {
-          connectionId,
-          userId: args.userId,
-          ...data,
-        });
-        count++;
-      } catch (err) {
-        errors.push({
-          type: "activity",
-          id: workout.uuid,
-          message: err instanceof Error ? err.message : String(err),
-        });
-      }
-    }
-
-    await this.updateLastDataUpdate(ctx, connectionId);
-    return { data: { activities: count }, errors };
+    return (await ctx.runMutation(
+      this.component.healthkit.public.syncActivities,
+      args,
+    )) as SomaResult<{ activities: number }>;
   }
 
   /**
@@ -168,40 +122,15 @@ export class SomaHealthKit {
    * Each inner array represents one sleep session (all `HKCategorySample`
    * stage records for a single night). Each session is aggregated into a
    * single Soma Sleep document.
-   *
-   * @param ctx - Mutation (or action) context from the host app
-   * @param args.userId - The host app's user identifier
-   * @param args.sessions - Array of sessions, each an array of sleep-stage samples
    */
   async syncSleep(
     ctx: MutationCtx,
     args: { userId: string; sessions: HKCategorySample[][] },
   ): Promise<SomaResult<{ sleep: number }>> {
-    const connectionId = await this.requireActiveConnection(ctx, args.userId);
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    for (const session of args.sessions) {
-      const sessionId = session[0]?.uuid ?? "unknown";
-      try {
-        const data = transformSleep(session);
-        await ctx.runMutation(this.component.public.ingestSleep, {
-          connectionId,
-          userId: args.userId,
-          ...data,
-        });
-        count++;
-      } catch (err) {
-        errors.push({
-          type: "sleep",
-          id: sessionId,
-          message: err instanceof Error ? err.message : String(err),
-        });
-      }
-    }
-
-    await this.updateLastDataUpdate(ctx, connectionId);
-    return { data: { sleep: count }, errors };
+    return (await ctx.runMutation(
+      this.component.healthkit.public.syncSleep,
+      args,
+    )) as SomaResult<{ sleep: number }>;
   }
 
   /**
@@ -210,11 +139,6 @@ export class SomaHealthKit {
    * Accepts a mixed array of body-related quantity samples (heart rate, HRV,
    * blood pressure, SpO2, weight, etc.) for a single time window and produces
    * one Soma Body document.
-   *
-   * @param ctx - Mutation (or action) context from the host app
-   * @param args.userId - The host app's user identifier
-   * @param args.samples - Array of HKQuantitySample for the desired time range
-   * @param args.timeRange - Optional explicit time range; auto-detected from samples if omitted
    */
   async syncBody(
     ctx: MutationCtx,
@@ -224,40 +148,14 @@ export class SomaHealthKit {
       timeRange?: { start_time: string; end_time: string };
     },
   ): Promise<SomaResult<{ body: number }>> {
-    const connectionId = await this.requireActiveConnection(ctx, args.userId);
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    try {
-      const data = transformBody(args.samples, args.timeRange);
-      await ctx.runMutation(this.component.public.ingestBody, {
-        connectionId,
-        userId: args.userId,
-        ...data,
-      });
-      count++;
-    } catch (err) {
-      errors.push({
-        type: "body",
-        id: "transform",
-        message: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    await this.updateLastDataUpdate(ctx, connectionId);
-    return { data: { body: count }, errors };
+    return (await ctx.runMutation(
+      this.component.healthkit.public.syncBody,
+      args,
+    )) as SomaResult<{ body: number }>;
   }
 
   /**
    * Sync daily activity data from HealthKit quantity samples.
-   *
-   * Accepts samples for a single day (steps, distance, energy, exercise time,
-   * heart rate, etc.) and produces one Soma Daily document.
-   *
-   * @param ctx - Mutation (or action) context from the host app
-   * @param args.userId - The host app's user identifier
-   * @param args.samples - Array of HKQuantitySample for the desired day
-   * @param args.timeRange - Optional explicit time range; auto-detected from samples if omitted
    */
   async syncDaily(
     ctx: MutationCtx,
@@ -267,82 +165,27 @@ export class SomaHealthKit {
       timeRange?: { start_time: string; end_time: string };
     },
   ): Promise<SomaResult<{ daily: number }>> {
-    const connectionId = await this.requireActiveConnection(ctx, args.userId);
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    try {
-      const data = transformDaily(args.samples, args.timeRange);
-      await ctx.runMutation(this.component.public.ingestDaily, {
-        connectionId,
-        userId: args.userId,
-        ...data,
-      });
-      count++;
-    } catch (err) {
-      errors.push({
-        type: "daily",
-        id: "transform",
-        message: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    await this.updateLastDataUpdate(ctx, connectionId);
-    return { data: { daily: count }, errors };
+    return (await ctx.runMutation(
+      this.component.healthkit.public.syncDaily,
+      args,
+    )) as SomaResult<{ daily: number }>;
   }
 
   /**
    * Sync daily activity data from HealthKit activity ring summaries.
-   *
-   * Each `HKActivitySummary` represents one day's activity rings (Move,
-   * Exercise, Stand). Each summary produces one Soma Daily document.
-   *
-   * @param ctx - Mutation (or action) context from the host app
-   * @param args.userId - The host app's user identifier
-   * @param args.summaries - Array of HKActivitySummary from HealthKit
    */
   async syncDailyFromSummary(
     ctx: MutationCtx,
     args: { userId: string; summaries: HKActivitySummary[] },
   ): Promise<SomaResult<{ daily: number }>> {
-    const connectionId = await this.requireActiveConnection(ctx, args.userId);
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    for (const summary of args.summaries) {
-      const { year, month, day } = summary.dateComponents;
-      const summaryId = `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
-      try {
-        const data = transformDailyFromSummary(summary);
-        await ctx.runMutation(this.component.public.ingestDaily, {
-          connectionId,
-          userId: args.userId,
-          ...data,
-        });
-        count++;
-      } catch (err) {
-        errors.push({
-          type: "daily",
-          id: summaryId,
-          message: err instanceof Error ? err.message : String(err),
-        });
-      }
-    }
-
-    await this.updateLastDataUpdate(ctx, connectionId);
-    return { data: { daily: count }, errors };
+    return (await ctx.runMutation(
+      this.component.healthkit.public.syncDailyFromSummary,
+      args,
+    )) as SomaResult<{ daily: number }>;
   }
 
   /**
    * Sync nutrition data from HealthKit.
-   *
-   * Accepts dietary quantity samples for a single time window and produces
-   * one Soma Nutrition document with macros and micros.
-   *
-   * @param ctx - Mutation (or action) context from the host app
-   * @param args.userId - The host app's user identifier
-   * @param args.samples - Array of HKQuantitySample with dietary type identifiers
-   * @param args.timeRange - Optional explicit time range; auto-detected from samples if omitted
    */
   async syncNutrition(
     ctx: MutationCtx,
@@ -352,40 +195,14 @@ export class SomaHealthKit {
       timeRange?: { start_time: string; end_time: string };
     },
   ): Promise<SomaResult<{ nutrition: number }>> {
-    const connectionId = await this.requireActiveConnection(ctx, args.userId);
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    try {
-      const data = transformNutrition(args.samples, args.timeRange);
-      await ctx.runMutation(this.component.public.ingestNutrition, {
-        connectionId,
-        userId: args.userId,
-        ...data,
-      });
-      count++;
-    } catch (err) {
-      errors.push({
-        type: "nutrition" as SomaError["type"],
-        id: "transform",
-        message: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    await this.updateLastDataUpdate(ctx, connectionId);
-    return { data: { nutrition: count }, errors };
+    return (await ctx.runMutation(
+      this.component.healthkit.public.syncNutrition,
+      args,
+    )) as SomaResult<{ nutrition: number }>;
   }
 
   /**
    * Sync menstruation data from HealthKit.
-   *
-   * Accepts menstrual flow category samples for a single time window and
-   * produces one Soma Menstruation document.
-   *
-   * @param ctx - Mutation (or action) context from the host app
-   * @param args.userId - The host app's user identifier
-   * @param args.samples - Array of HKCategorySample with menstrual flow values
-   * @param args.timeRange - Optional explicit time range; auto-detected from samples if omitted
    */
   async syncMenstruation(
     ctx: MutationCtx,
@@ -395,28 +212,10 @@ export class SomaHealthKit {
       timeRange?: { start_time: string; end_time: string };
     },
   ): Promise<SomaResult<{ menstruation: number }>> {
-    const connectionId = await this.requireActiveConnection(ctx, args.userId);
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    try {
-      const data = transformMenstruation(args.samples, args.timeRange);
-      await ctx.runMutation(this.component.public.ingestMenstruation, {
-        connectionId,
-        userId: args.userId,
-        ...data,
-      });
-      count++;
-    } catch (err) {
-      errors.push({
-        type: "menstruation",
-        id: "transform",
-        message: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    await this.updateLastDataUpdate(ctx, connectionId);
-    return { data: { menstruation: count }, errors };
+    return (await ctx.runMutation(
+      this.component.healthkit.public.syncMenstruation,
+      args,
+    )) as SomaResult<{ menstruation: number }>;
   }
 
   /**
@@ -424,37 +223,15 @@ export class SomaHealthKit {
    *
    * HealthKit exposes limited profile data (biological sex, date of birth).
    * Produces one Soma Athlete document per connection.
-   *
-   * @param ctx - Mutation (or action) context from the host app
-   * @param args.userId - The host app's user identifier
-   * @param args.characteristics - The HKCharacteristics from HealthKit
    */
   async syncAthlete(
     ctx: MutationCtx,
     args: { userId: string; characteristics: HKCharacteristics },
   ): Promise<SomaResult<{ athletes: number }>> {
-    const connectionId = await this.requireActiveConnection(ctx, args.userId);
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    try {
-      const data = transformAthlete(args.characteristics);
-      await ctx.runMutation(this.component.public.ingestAthlete, {
-        connectionId,
-        userId: args.userId,
-        ...data,
-      });
-      count++;
-    } catch (err) {
-      errors.push({
-        type: "athlete",
-        id: "transform",
-        message: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    await this.updateLastDataUpdate(ctx, connectionId);
-    return { data: { athletes: count }, errors };
+    return (await ctx.runMutation(
+      this.component.healthkit.public.syncAthlete,
+      args,
+    )) as SomaResult<{ athletes: number }>;
   }
 
   // ─── Orchestrator ────────────────────────────────────────────────────────
@@ -465,17 +242,6 @@ export class SomaHealthKit {
    * Only data types with values provided are synced. Errors from individual
    * data types are collected — one failing type does not block others.
    *
-   * @param ctx - Mutation (or action) context from the host app
-   * @param args.userId - The host app's user identifier
-   * @param args.workouts - Optional array of HKWorkout objects
-   * @param args.sleepSessions - Optional array of sleep sessions (each an array of stage samples)
-   * @param args.bodySamples - Optional body-related quantity samples
-   * @param args.dailySamples - Optional daily activity quantity samples
-   * @param args.dailySummaries - Optional daily activity ring summaries
-   * @param args.nutritionSamples - Optional dietary quantity samples
-   * @param args.menstruationSamples - Optional menstrual flow category samples
-   * @param args.characteristics - Optional user characteristics
-   *
    * @example
    * ```ts
    * const result = await soma.healthkit.syncAll(ctx, {
@@ -506,359 +272,12 @@ export class SomaHealthKit {
       characteristics?: HKCharacteristics;
     },
   ): Promise<SomaResult<Record<string, number>>> {
-    const connectionId = await this.requireActiveConnection(ctx, args.userId);
-    const allErrors: SomaError[] = [];
-    const counts: Record<string, number> = {};
-
-    const run = async <T extends Record<string, number>>(
-      fn: () => Promise<SomaResult<T>>,
-      fallbackType: SomaError["type"],
-    ) => {
-      try {
-        const result = await fn();
-        Object.assign(counts, result.data);
-        allErrors.push(...result.errors);
-      } catch (err) {
-        allErrors.push({
-          type: fallbackType,
-          id: "sync",
-          message: err instanceof Error ? err.message : String(err),
-        });
-      }
-    };
-
-    if (args.workouts) {
-      await run(
-        () => this.syncActivitiesInternal(ctx, connectionId, args.userId, args.workouts!),
-        "activity",
-      );
-    }
-    if (args.sleepSessions) {
-      await run(
-        () => this.syncSleepInternal(ctx, connectionId, args.userId, args.sleepSessions!),
-        "sleep",
-      );
-    }
-    if (args.bodySamples) {
-      await run(
-        () => this.syncBodyInternal(ctx, connectionId, args.userId, args.bodySamples!, args.bodyTimeRange),
-        "body",
-      );
-    }
-    if (args.dailySamples) {
-      await run(
-        () => this.syncDailyInternal(ctx, connectionId, args.userId, args.dailySamples!, args.dailyTimeRange),
-        "daily",
-      );
-    }
-    if (args.dailySummaries) {
-      await run(
-        () => this.syncDailyFromSummaryInternal(ctx, connectionId, args.userId, args.dailySummaries!),
-        "daily",
-      );
-    }
-    if (args.nutritionSamples) {
-      await run(
-        () => this.syncNutritionInternal(ctx, connectionId, args.userId, args.nutritionSamples!, args.nutritionTimeRange),
-        "nutrition" as SomaError["type"],
-      );
-    }
-    if (args.menstruationSamples) {
-      await run(
-        () => this.syncMenstruationInternal(ctx, connectionId, args.userId, args.menstruationSamples!, args.menstruationTimeRange),
-        "menstruation",
-      );
-    }
-    if (args.characteristics) {
-      await run(
-        () => this.syncAthleteInternal(ctx, connectionId, args.userId, args.characteristics!),
-        "athlete",
-      );
-    }
-
-    // Update lastDataUpdate once at the end
-    await this.updateLastDataUpdate(ctx, connectionId);
-
-    return { data: counts, errors: allErrors };
-  }
-
-  // ─── Private Helpers ───────────��─────────────────────────────────────────
-
-  /**
-   * Load the active APPLE connection for a user, or throw if missing/inactive.
-   *
-   * HealthKit permissions are managed on-device, so the connection state is
-   * an assertion made by the host app via {@link SomaHealthKit.connect} and
-   * {@link SomaHealthKit.disconnect}. Sync methods refuse to run without an
-   * active connection — the host app must explicitly reconnect to resume.
-   */
-  private async requireActiveConnection(
-    ctx: MutationCtx,
-    userId: string,
-  ): Promise<string> {
-    const connection = await ctx.runQuery(
-      this.component.public.getConnectionByProvider,
-      { userId, provider: PROVIDER },
-    );
-    if (!connection) {
-      throw new Error(
-        `No HealthKit connection for user "${userId}". Call soma.healthkit.connect(ctx, { userId }) after the React Native HealthKit library confirms permissions.`,
-      );
-    }
-    if (connection.active === false) {
-      throw new Error(
-        `HealthKit connection for user "${userId}" is disconnected. Call soma.healthkit.connect(ctx, { userId }) to re-activate.`,
-      );
-    }
-    return connection._id;
-  }
-
-  private async updateLastDataUpdate(
-    ctx: MutationCtx,
-    connectionId: string,
-  ): Promise<void> {
-    await ctx.runMutation(this.component.public.updateConnection, {
-      connectionId,
-      lastDataUpdate: new Date().toISOString(),
-    });
-  }
-
-  // ─── Internal sync methods (skip connection resolution + lastDataUpdate) ─
-
-  private async syncActivitiesInternal(
-    ctx: MutationCtx,
-    connectionId: string,
-    userId: string,
-    workouts: HKWorkout[],
-  ): Promise<SomaResult<{ activities: number }>> {
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    for (const workout of workouts) {
-      try {
-        const data = transformWorkout(workout);
-        await ctx.runMutation(this.component.public.ingestActivity, {
-          connectionId,
-          userId,
-          ...data,
-        });
-        count++;
-      } catch (err) {
-        errors.push({
-          type: "activity",
-          id: workout.uuid,
-          message: err instanceof Error ? err.message : String(err),
-        });
-      }
-    }
-
-    return { data: { activities: count }, errors };
-  }
-
-  private async syncSleepInternal(
-    ctx: MutationCtx,
-    connectionId: string,
-    userId: string,
-    sessions: HKCategorySample[][],
-  ): Promise<SomaResult<{ sleep: number }>> {
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    for (const session of sessions) {
-      const sessionId = session[0]?.uuid ?? "unknown";
-      try {
-        const data = transformSleep(session);
-        await ctx.runMutation(this.component.public.ingestSleep, {
-          connectionId,
-          userId,
-          ...data,
-        });
-        count++;
-      } catch (err) {
-        errors.push({
-          type: "sleep",
-          id: sessionId,
-          message: err instanceof Error ? err.message : String(err),
-        });
-      }
-    }
-
-    return { data: { sleep: count }, errors };
-  }
-
-  private async syncBodyInternal(
-    ctx: MutationCtx,
-    connectionId: string,
-    userId: string,
-    samples: HKQuantitySample[],
-    timeRange?: { start_time: string; end_time: string },
-  ): Promise<SomaResult<{ body: number }>> {
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    try {
-      const data = transformBody(samples, timeRange);
-      await ctx.runMutation(this.component.public.ingestBody, {
-        connectionId,
-        userId,
-        ...data,
-      });
-      count++;
-    } catch (err) {
-      errors.push({
-        type: "body",
-        id: "transform",
-        message: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    return { data: { body: count }, errors };
-  }
-
-  private async syncDailyInternal(
-    ctx: MutationCtx,
-    connectionId: string,
-    userId: string,
-    samples: HKQuantitySample[],
-    timeRange?: { start_time: string; end_time: string },
-  ): Promise<SomaResult<{ daily: number }>> {
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    try {
-      const data = transformDaily(samples, timeRange);
-      await ctx.runMutation(this.component.public.ingestDaily, {
-        connectionId,
-        userId,
-        ...data,
-      });
-      count++;
-    } catch (err) {
-      errors.push({
-        type: "daily",
-        id: "transform",
-        message: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    return { data: { daily: count }, errors };
-  }
-
-  private async syncDailyFromSummaryInternal(
-    ctx: MutationCtx,
-    connectionId: string,
-    userId: string,
-    summaries: HKActivitySummary[],
-  ): Promise<SomaResult<{ daily: number }>> {
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    for (const summary of summaries) {
-      const { year, month, day } = summary.dateComponents;
-      const summaryId = `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
-      try {
-        const data = transformDailyFromSummary(summary);
-        await ctx.runMutation(this.component.public.ingestDaily, {
-          connectionId,
-          userId,
-          ...data,
-        });
-        count++;
-      } catch (err) {
-        errors.push({
-          type: "daily",
-          id: summaryId,
-          message: err instanceof Error ? err.message : String(err),
-        });
-      }
-    }
-
-    return { data: { daily: count }, errors };
-  }
-
-  private async syncNutritionInternal(
-    ctx: MutationCtx,
-    connectionId: string,
-    userId: string,
-    samples: HKQuantitySample[],
-    timeRange?: { start_time: string; end_time: string },
-  ): Promise<SomaResult<{ nutrition: number }>> {
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    try {
-      const data = transformNutrition(samples, timeRange);
-      await ctx.runMutation(this.component.public.ingestNutrition, {
-        connectionId,
-        userId,
-        ...data,
-      });
-      count++;
-    } catch (err) {
-      errors.push({
-        type: "nutrition" as SomaError["type"],
-        id: "transform",
-        message: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    return { data: { nutrition: count }, errors };
-  }
-
-  private async syncMenstruationInternal(
-    ctx: MutationCtx,
-    connectionId: string,
-    userId: string,
-    samples: HKCategorySample[],
-    timeRange?: { start_time: string; end_time: string },
-  ): Promise<SomaResult<{ menstruation: number }>> {
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    try {
-      const data = transformMenstruation(samples, timeRange);
-      await ctx.runMutation(this.component.public.ingestMenstruation, {
-        connectionId,
-        userId,
-        ...data,
-      });
-      count++;
-    } catch (err) {
-      errors.push({
-        type: "menstruation",
-        id: "transform",
-        message: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    return { data: { menstruation: count }, errors };
-  }
-
-  private async syncAthleteInternal(
-    ctx: MutationCtx,
-    connectionId: string,
-    userId: string,
-    characteristics: HKCharacteristics,
-  ): Promise<SomaResult<{ athletes: number }>> {
-    const errors: SomaError[] = [];
-    let count = 0;
-
-    try {
-      const data = transformAthlete(characteristics);
-      await ctx.runMutation(this.component.public.ingestAthlete, {
-        connectionId,
-        userId,
-        ...data,
-      });
-      count++;
-    } catch (err) {
-      errors.push({
-        type: "athlete",
-        id: "transform",
-        message: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    return { data: { athletes: count }, errors };
+    return (await ctx.runMutation(
+      this.component.healthkit.public.syncAll,
+      args,
+    )) as SomaResult<Record<string, number>>;
   }
 }
+
+// Re-export for JSDoc link resolution above.
+export type { SomaError };