@tryterra/react-native 0.0.0-stage → 2.1.0

package/src/createTerra.ts

@@ -0,0 +1,18 @@
+import { Platform } from "react-native";
+
+import NativeTerraBridge from "./NativeTerraBridge";
+import { Terra, type TerraOptions } from "./Terra";
+
+/**
+ * Attaches this JavaScript runtime to the native client the app built at launch.
+ *
+ * Call it once, at module scope. The native client outlives a reload, so a reload attaches again
+ * rather than building a second client.
+ */
+export function createTerra(options: TerraOptions = {}): Terra {
+  const platform = Platform.OS;
+  if (platform !== "ios" && platform !== "android") {
+    throw new Error(`@tryterra/react-native runs on iOS and Android, not ${platform}`);
+  }
+  return new Terra(NativeTerraBridge, platform, options);
+}

package/src/generated/client.ts

@@ -0,0 +1,243 @@
+// Generated from surface/terra-surface.json by surface/gen. Do not edit by hand.
+// Regenerate with: node surface/gen/src/cli.ts generate
+
+import type { BodyEntryList, BoolResult, BootstrapState, CategoryRequest, ConnectRequest, Connection, ConnectionList, DiagnosticsState, Empty, HealthAccess, HeartRateEntryList, HeartRateList, LastDeliveryResult, MarkCompleteRequest, NutritionEntryList, PermissionGrant, PermissionRequest, PlannedWorkoutList, RangeRequest, RecordIdList, RecordIdRequest, SleepEntryList, SleepSegmentList, SourceRequest, StatusResult, StatusesResult, StepCountList, StepEntryList, SupportReport, TokenProviderRequest, TokenRejectRequest, TokenResolveRequest, WorkoutEntryList, WorkoutList, WorkoutScheduling } from "./types";
+import { encodeBodyEntryList, encodeCategoryRequest, encodeConnectRequest, encodeEmpty, encodeHeartRateEntryList, encodeMarkCompleteRequest, encodeNutritionEntryList, encodePermissionRequest, encodeRangeRequest, encodeRecordIdRequest, encodeSleepEntryList, encodeSourceRequest, encodeStepEntryList, encodeTokenProviderRequest, encodeTokenRejectRequest, encodeTokenResolveRequest, encodeWorkoutEntryList, decodeBoolResult, decodeBootstrapState, decodeConnection, decodeConnectionList, decodeDiagnosticsState, decodeEmpty, decodeHealthAccess, decodeHeartRateList, decodeLastDeliveryResult, decodePermissionGrant, decodePlannedWorkoutList, decodeRecordIdList, decodeSleepSegmentList, decodeStatusResult, decodeStatusesResult, decodeStepCountList, decodeSupportReport, decodeWorkoutList, decodeWorkoutScheduling } from "./codecs";
+import type { OpId } from "./ops";
+import { TerraError } from "../TerraError";
+
+/** What the facade needs from the native module. The TurboModule spec satisfies it; so does a test double. */
+export interface Invoker {
+  invoke(op: OpId, payload: string): Promise<string>;
+}
+
+/**
+ * One generated method per op, and nothing else.
+ *
+ * The `op` string exists only between this file and the generated native dispatch, and a vector
+ * in `vectors/bridge` pins the two to each other. A caller never sees it.
+ */
+export class GeneratedClient {
+  protected readonly invoker: Invoker;
+
+  constructor(invoker: Invoker) {
+    this.invoker = invoker;
+  }
+
+  private async call<T>(op: OpId, encode: () => Record<string, unknown>, decode: (raw: unknown) => T): Promise<T> {
+    let payload: string;
+    try {
+      payload = JSON.stringify(encode());
+    } catch (thrown) {
+      throw TerraError.invalidPayload(op, thrown);
+    }
+    let text: string;
+    try {
+      text = await this.invoker.invoke(op, payload);
+    } catch (thrown) {
+      throw TerraError.from(thrown);
+    }
+    try {
+      return decode(JSON.parse(text));
+    } catch (thrown) {
+      throw TerraError.invalidPayload(op, thrown);
+    }
+  }
+
+  /**
+   * Reports the native client the JS side is attaching to. Idempotent, and safe to call after a
+   * JS reload.
+   */
+  async clientAttach(request: Empty): Promise<BootstrapState> {
+    return this.call("client.attach", () => encodeEmpty(request), (raw) => decodeBootstrapState(raw, "BootstrapState"));
+  }
+
+  async clientConnect(request: ConnectRequest): Promise<Connection> {
+    return this.call("client.connect", () => encodeConnectRequest(request), (raw) => decodeConnection(raw, "Connection"));
+  }
+
+  async clientConnections(request: Empty): Promise<ConnectionList> {
+    return this.call("client.connections", () => encodeEmpty(request), (raw) => decodeConnectionList(raw, "ConnectionList"));
+  }
+
+  async clientDisconnect(request: SourceRequest): Promise<Empty> {
+    return this.call("client.disconnect", () => encodeSourceRequest(request), (raw) => decodeEmpty(raw, "Empty"));
+  }
+
+  /**
+   * Tells the broker whether JS can answer at all. Without it a link asks a provider that is not
+   * there and waits out the timeout.
+   */
+  async tokenSetProviderPresent(request: TokenProviderRequest): Promise<Empty> {
+    return this.call("token.setProviderPresent", () => encodeTokenProviderRequest(request), (raw) => decodeEmpty(raw, "Empty"));
+  }
+
+  /**
+   * An unknown or already-settled requestId is ignored rather than rejected, so a reload cannot
+   * fail a link that has already moved on.
+   */
+  async tokenResolve(request: TokenResolveRequest): Promise<Empty> {
+    return this.call("token.resolve", () => encodeTokenResolveRequest(request), (raw) => decodeEmpty(raw, "Empty"));
+  }
+
+  async tokenReject(request: TokenRejectRequest): Promise<Empty> {
+    return this.call("token.reject", () => encodeTokenRejectRequest(request), (raw) => decodeEmpty(raw, "Empty"));
+  }
+
+  async permissionsRequest(request: PermissionRequest): Promise<PermissionGrant> {
+    return this.call("permissions.request", () => encodePermissionRequest(request), (raw) => decodePermissionGrant(raw, "PermissionGrant"));
+  }
+
+  async permissionsStatus(request: CategoryRequest): Promise<StatusResult> {
+    return this.call("permissions.status", () => encodeCategoryRequest(request), (raw) => decodeStatusResult(raw, "StatusResult"));
+  }
+
+  async permissionsWriteStatus(request: CategoryRequest): Promise<StatusResult> {
+    return this.call("permissions.writeStatus", () => encodeCategoryRequest(request), (raw) => decodeStatusResult(raw, "StatusResult"));
+  }
+
+  async permissionsRequested(request: SourceRequest): Promise<HealthAccess> {
+    return this.call("permissions.requested", () => encodeSourceRequest(request), (raw) => decodeHealthAccess(raw, "HealthAccess"));
+  }
+
+  /** Available on android only. */
+  async permissionsStatuses(request: SourceRequest): Promise<StatusesResult> {
+    return this.call("permissions.statuses", () => encodeSourceRequest(request), (raw) => decodeStatusesResult(raw, "StatusesResult"));
+  }
+
+  /** Available on android only. */
+  async permissionsBackgroundReadStatus(request: SourceRequest): Promise<StatusResult> {
+    return this.call("permissions.backgroundReadStatus", () => encodeSourceRequest(request), (raw) => decodeStatusResult(raw, "StatusResult"));
+  }
+
+  /** Available on android only. */
+  async permissionsHistoryReadStatus(request: SourceRequest): Promise<StatusResult> {
+    return this.call("permissions.historyReadStatus", () => encodeSourceRequest(request), (raw) => decodeStatusResult(raw, "StatusResult"));
+  }
+
+  async diagnosticsState(request: SourceRequest): Promise<DiagnosticsState> {
+    return this.call("diagnostics.state", () => encodeSourceRequest(request), (raw) => decodeDiagnosticsState(raw, "DiagnosticsState"));
+  }
+
+  async diagnosticsLastDelivery(request: SourceRequest): Promise<LastDeliveryResult> {
+    return this.call("diagnostics.lastDelivery", () => encodeSourceRequest(request), (raw) => decodeLastDeliveryResult(raw, "LastDeliveryResult"));
+  }
+
+  async diagnosticsReport(request: SourceRequest): Promise<SupportReport> {
+    return this.call("diagnostics.report", () => encodeSourceRequest(request), (raw) => decodeSupportReport(raw, "SupportReport"));
+  }
+
+  async diagnosticsSend(request: SourceRequest): Promise<Empty> {
+    return this.call("diagnostics.send", () => encodeSourceRequest(request), (raw) => decodeEmpty(raw, "Empty"));
+  }
+
+  /**
+   * False means bootstrap did not run. The SDK reports the same thing independently as
+   * backgroundRefreshUnscheduled.
+   */
+  async backgroundIsRegistered(request: Empty): Promise<BoolResult> {
+    return this.call("background.isRegistered", () => encodeEmpty(request), (raw) => decodeBoolResult(raw, "BoolResult"));
+  }
+
+  /** Available on android only. */
+  async backgroundCancel(request: Empty): Promise<BoolResult> {
+    return this.call("background.cancel", () => encodeEmpty(request), (raw) => decodeBoolResult(raw, "BoolResult"));
+  }
+
+  async bodyHeartRate(request: RangeRequest): Promise<HeartRateList> {
+    return this.call("body.heartRate", () => encodeRangeRequest(request), (raw) => decodeHeartRateList(raw, "HeartRateList"));
+  }
+
+  /** Its own op rather than an overload: Swift overloads log by element type and JS cannot. */
+  async bodyLogHeartRate(request: HeartRateEntryList): Promise<RecordIdList> {
+    return this.call("body.logHeartRate", () => encodeHeartRateEntryList(request), (raw) => decodeRecordIdList(raw, "RecordIdList"));
+  }
+
+  async bodyLog(request: BodyEntryList): Promise<RecordIdList> {
+    return this.call("body.log", () => encodeBodyEntryList(request), (raw) => decodeRecordIdList(raw, "RecordIdList"));
+  }
+
+  async bodyDelete(request: RecordIdRequest): Promise<Empty> {
+    return this.call("body.delete", () => encodeRecordIdRequest(request), (raw) => decodeEmpty(raw, "Empty"));
+  }
+
+  async dailySteps(request: RangeRequest): Promise<StepCountList> {
+    return this.call("daily.steps", () => encodeRangeRequest(request), (raw) => decodeStepCountList(raw, "StepCountList"));
+  }
+
+  async dailyLog(request: StepEntryList): Promise<RecordIdList> {
+    return this.call("daily.log", () => encodeStepEntryList(request), (raw) => decodeRecordIdList(raw, "RecordIdList"));
+  }
+
+  async dailyDelete(request: RecordIdRequest): Promise<Empty> {
+    return this.call("daily.delete", () => encodeRecordIdRequest(request), (raw) => decodeEmpty(raw, "Empty"));
+  }
+
+  async sleepSegments(request: RangeRequest): Promise<SleepSegmentList> {
+    return this.call("sleep.segments", () => encodeRangeRequest(request), (raw) => decodeSleepSegmentList(raw, "SleepSegmentList"));
+  }
+
+  async sleepLog(request: SleepEntryList): Promise<RecordIdList> {
+    return this.call("sleep.log", () => encodeSleepEntryList(request), (raw) => decodeRecordIdList(raw, "RecordIdList"));
+  }
+
+  async sleepDelete(request: RecordIdRequest): Promise<Empty> {
+    return this.call("sleep.delete", () => encodeRecordIdRequest(request), (raw) => decodeEmpty(raw, "Empty"));
+  }
+
+  async activityWorkouts(request: RangeRequest): Promise<WorkoutList> {
+    return this.call("activity.workouts", () => encodeRangeRequest(request), (raw) => decodeWorkoutList(raw, "WorkoutList"));
+  }
+
+  async activityLog(request: WorkoutEntryList): Promise<RecordIdList> {
+    return this.call("activity.log", () => encodeWorkoutEntryList(request), (raw) => decodeRecordIdList(raw, "RecordIdList"));
+  }
+
+  async activityDelete(request: RecordIdRequest): Promise<Empty> {
+    return this.call("activity.delete", () => encodeRecordIdRequest(request), (raw) => decodeEmpty(raw, "Empty"));
+  }
+
+  async nutritionLog(request: NutritionEntryList): Promise<RecordIdList> {
+    return this.call("nutrition.log", () => encodeNutritionEntryList(request), (raw) => decodeRecordIdList(raw, "RecordIdList"));
+  }
+
+  async nutritionDelete(request: RecordIdRequest): Promise<Empty> {
+    return this.call("nutrition.delete", () => encodeRecordIdRequest(request), (raw) => decodeEmpty(raw, "Empty"));
+  }
+
+  /** Available on ios only. */
+  async plannedWorkoutsPlanned(request: Empty): Promise<PlannedWorkoutList> {
+    return this.call("plannedWorkouts.planned", () => encodeEmpty(request), (raw) => decodePlannedWorkoutList(raw, "PlannedWorkoutList"));
+  }
+
+  /** Available on ios only. */
+  async plannedWorkoutsMarkComplete(request: MarkCompleteRequest): Promise<Empty> {
+    return this.call("plannedWorkouts.markComplete", () => encodeMarkCompleteRequest(request), (raw) => decodeEmpty(raw, "Empty"));
+  }
+
+  /** Available on ios only. */
+  async plannedWorkoutsDelete(request: RecordIdRequest): Promise<Empty> {
+    return this.call("plannedWorkouts.delete", () => encodeRecordIdRequest(request), (raw) => decodeEmpty(raw, "Empty"));
+  }
+
+  /**
+   * Never prompts.
+   *
+   * Available on ios only.
+   */
+  async plannedWorkoutsSchedulingStatus(request: Empty): Promise<WorkoutScheduling> {
+    return this.call("plannedWorkouts.schedulingStatus", () => encodeEmpty(request), (raw) => decodeWorkoutScheduling(raw, "WorkoutScheduling"));
+  }
+
+  /**
+   * Shows WorkoutKit's sheet if the person has not been asked, and reconciles straight away once
+   * authorized.
+   *
+   * Available on ios only.
+   */
+  async plannedWorkoutsRequestScheduling(request: Empty): Promise<WorkoutScheduling> {
+    return this.call("plannedWorkouts.requestScheduling", () => encodeEmpty(request), (raw) => decodeWorkoutScheduling(raw, "WorkoutScheduling"));
+  }
+
+}
+