react-native-spike-sdk 0.2.10 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-spike-sdk",
-  "version": "0.2.10",
+  "version": "1.0.0",
   "description": "Spike API for health and productivity data from wearables and IoT devices",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/react-native-spike-sdk.podspec

@@ -5,7 +5,7 @@ folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1
 
 Pod::Spec.new do |s|
   s.name         = "react-native-spike-sdk"
-  s.version      = "0.2.10"
+  s.version      = "1.0.0"
   s.summary      = "Spike API for health and productivity data from wearables and IoT devices"
 
   s.description  = <<-DESC
@@ -25,7 +25,7 @@ Pod::Spec.new do |s|
   s.swift_version = "5"
 
   s.dependency "React-Core"
-  s.dependency "SpikeSDK", "0.2.14"
+  s.dependency "SpikeSDK", "1.0.1"
 
   # Don't install the dependencies when we run `pod install` in the old architecture.
   if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then

package/src/{SpikeWorkoutResultData.ts → DataModels/SpikeActivitiesStreamDataEntry.ts}

@@ -1,22 +1,15 @@
-export type SpikeWorkoutResult =
-  | { status: string }
-  | { data: SpikeWorkoutResultData[] };
-
-export interface SpikeWorkoutResultData {
+export type SpikeActivitiesStreamDataEntry = {
   time_start?: string;
   time_end?: string;
   timezone_offset?: number;
   activity_name?: string;
-  activity_type_id?: string;
-  provider_activity_name?: string;
-  provider_activity_type_id?: number;
+  activity_type_id?: number;
   avg_hr?: number;
   max_hr?: number;
   min_hr?: number;
   avg_hr_variability?: number;
   calories?: number;
-  source?: string;
-  hr_zones?: string[];
+  hr_zones?: HRZone[];
   moving_time?: number;
   total_elevation_gain?: number;
   elev_high?: number;
@@ -29,5 +22,14 @@ export interface SpikeWorkoutResultData {
   device_watts?: boolean;
   max_watts?: number;
   weighted_average_watts?: number;
-  map?: any;
-}
+  map?: string;
+  source?: string;
+  data_type?: string;
+};
+
+type HRZone = {
+  max?: number;
+  min?: number;
+  minutes?: number;
+  name?: string;
+};

package/src/{SpikeResultData.ts → DataModels/SpikeActivitiesSummaryDataEntry.ts}

@@ -1,12 +1,11 @@
-export type SpikeResult = { status: string } | { data: SpikeResultData[] };
-
-export interface SpikeResultData {
+export type SpikeActivitiesSummaryDataEntry = {
   date?: string;
   calories_bmr?: number;
   calories_total?: number;
   calories_active?: number;
   steps?: number;
   daily_movement?: number;
+  distance?: number;
   low?: number;
   medium?: number;
   high?: number;
@@ -24,4 +23,5 @@ export interface SpikeResultData {
   medium_stress_duration?: number;
   high_stress_duration?: number;
   source?: string;
-}
+  data_type?: string;
+};

package/src/DataModels/SpikeBreathingDataEntry.ts

@@ -0,0 +1,12 @@
+export type SpikeBreathingDataEntry = {
+  date?: string;
+  avg_value?: number;
+  intraday_data?: IntradayData[];
+  source?: string;
+  data_type?: string;
+};
+
+type IntradayData = {
+  endTime: string;
+  value: number;
+};

package/src/DataModels/SpikeCaloriesDataEntry.ts

@@ -0,0 +1,13 @@
+export type SpikeCaloriesDataEntry = {
+  date?: string;
+  value?: number;
+  intraday_data?: IntradayData[];
+  source?: string;
+  data_type?: string;
+};
+type IntradayData = {
+  level: number;
+  mets: number;
+  time: string;
+  value: number;
+};

package/src/DataModels/SpikeData.ts

@@ -0,0 +1,35 @@
+import type { SpikeActivitiesStreamDataEntry } from './SpikeActivitiesStreamDataEntry';
+import type { SpikeActivitiesSummaryDataEntry } from './SpikeActivitiesSummaryDataEntry';
+import type { SpikeBreathingDataEntry } from './SpikeBreathingDataEntry';
+import type { SpikeCaloriesDataEntry } from './SpikeCaloriesDataEntry';
+import type { SpikeDistanceDataEntry } from './SpikeDistanceDataEntry';
+import type { SpikeGlucoseDataEntry } from './SpikeGlucoseDataEntry';
+import type { SpikeHeartDataEntry } from './SpikeHeartDataEntry';
+import type { SpikeOxygenSaturationDataEntry } from './SpikeOxygenSaturationDataEntry';
+import type { SpikeSleepDataEntry } from './SpikeSleepDataEntry';
+import type { SpikeStepsDataEntry } from './SpikeStepsDataEntry';
+
+export type SpikeDataEntry =
+  | SpikeActivitiesSummaryDataEntry
+  | SpikeActivitiesStreamDataEntry
+  | SpikeBreathingDataEntry
+  | SpikeCaloriesDataEntry
+  | SpikeDistanceDataEntry
+  | SpikeGlucoseDataEntry
+  | SpikeHeartDataEntry
+  | SpikeOxygenSaturationDataEntry
+  | SpikeSleepDataEntry
+  | SpikeStepsDataEntry;
+export interface SpikeData<DataEntry extends SpikeDataEntry> {
+  from: Date;
+  to: Date;
+  endUserId: string;
+  collectedAt: Date;
+  sources: SpikeSource[];
+  entries: DataEntry[];
+}
+
+interface SpikeSource {
+  name: string;
+  status: string;
+}

package/src/DataModels/SpikeDataTypes.ts

@@ -0,0 +1,27 @@
+import {
+  SpikeActivitiesStreamDataType,
+  SpikeActivitiesSummaryDataType,
+  SpikeBreathingDataType,
+  SpikeCaloriesDataType,
+  SpikeDistanceDataType,
+  SpikeGlucoseDataType,
+  SpikeHeartDataType,
+  SpikeOxygenSaturationDataType,
+  SpikeSleepDataType,
+  SpikeStepsDataType,
+  SpikeBodyDataType,
+} from '../DataTypes/SpikeDataType';
+
+export const SpikeDataTypes = {
+  activitiesSummary: new SpikeActivitiesSummaryDataType(),
+  activitiesStream: new SpikeActivitiesStreamDataType(),
+  breathing: new SpikeBreathingDataType(),
+  calories: new SpikeCaloriesDataType(),
+  distance: new SpikeDistanceDataType(),
+  glucose: new SpikeGlucoseDataType(),
+  heart: new SpikeHeartDataType(),
+  oxygenSaturation: new SpikeOxygenSaturationDataType(),
+  sleep: new SpikeSleepDataType(),
+  steps: new SpikeStepsDataType(),
+  body: new SpikeBodyDataType(),
+};

package/src/DataModels/SpikeDistanceDataEntry.ts

@@ -0,0 +1,12 @@
+export type SpikeDistanceDataEntry = {
+  date?: string;
+  value?: number;
+  intraday_data?: IntradayData[];
+  source?: string;
+  data_type?: string;
+};
+
+type IntradayData = {
+  time: string;
+  value: number;
+};

package/src/DataModels/SpikeGlucoseDataEntry.ts

@@ -0,0 +1,3 @@
+export type SpikeGlucoseDataEntry = {
+  date?: string;
+};

package/src/DataModels/SpikeHeartDataEntry.ts

@@ -0,0 +1,34 @@
+export type SpikeHeartDataEntry = {
+  date?: string;
+  resting_hr?: number;
+  min_hr?: number;
+  avg_hr?: number;
+  max_hr?: number;
+  heart_rate_samples?: Sample[];
+  heart_rate_variability?: Variability;
+  intraday_hrv?: IntradayHrv[];
+  source?: string;
+  data_type?: string;
+};
+
+type Sample = {
+  time: string;
+  value: number;
+};
+
+type Variability = {
+  day_hrv?: number;
+  sleep_hrv?: number;
+};
+
+type IntradayHrv = {
+  time: string;
+  value?: Value;
+};
+
+type Value = {
+  rmssd?: number;
+  coverage?: number;
+  hf?: number;
+  lf?: number;
+};

package/src/DataModels/SpikeOxygenSaturationDataEntry.ts

@@ -0,0 +1,14 @@
+export type SpikeOxygenSaturationDataEntry = {
+  date?: string;
+  avg?: number;
+  min?: number;
+  max?: number;
+  intraday_data?: IntradayData[];
+  source?: string;
+  data_type?: string;
+};
+
+type IntradayData = {
+  time: string;
+  value: number;
+};

package/src/{SpikeSleepAnalysisResultData.ts → DataModels/SpikeSleepDataEntry.ts}

@@ -1,8 +1,4 @@
-export type SpikeSleepAnalysisResult =
-  | { status: string }
-  | { data: SpikeSleepAnalysisResultData[] };
-
-export interface SpikeSleepAnalysisResultData {
+export type SpikeSleepDataEntry = {
   date?: string;
   bedtime_start?: string;
   bedtime_end?: string;
@@ -23,5 +19,11 @@ export interface SpikeSleepAnalysisResultData {
   standardized_sleep_score?: number;
   source_specific_sleep_score?: number;
   source?: string;
-  levels?: { date_time?: string; level?: string; seconds?: number }[];
-}
+  levels?: Levels[];
+};
+
+type Levels = {
+  date_time?: string;
+  level?: string;
+  seconds?: number;
+};

package/src/DataModels/SpikeStepsDataEntry.ts

@@ -0,0 +1,11 @@
+export type SpikeStepsDataEntry = {
+  date?: string;
+  value?: number;
+  intraday_data?: IntradayData[];
+  source?: string;
+  data_type?: string;
+};
+type IntradayData = {
+  time: String;
+  value: number;
+};

package/src/DataModels/SpikeWebhookJob.ts

@@ -0,0 +1,10 @@
+export interface SpikeWebhookJob {
+  notificationId?: string;
+  dataType: string;
+  payloadSize: number;
+  callbackUrl: URL;
+  dateFrom: Date;
+  dateTo: Date;
+  collectedAt: Date;
+  submittedAt?: Date;
+}

package/src/DataTypes/SpikeDataType.ts

@@ -0,0 +1,87 @@
+import type { SpikeActivitiesStreamDataEntry } from '../DataModels/SpikeActivitiesStreamDataEntry';
+import type { SpikeDataEntry } from '../DataModels/SpikeData';
+import type { SpikeActivitiesSummaryDataEntry } from '../DataModels/SpikeActivitiesSummaryDataEntry';
+import type { SpikeBreathingDataEntry } from '../DataModels/SpikeBreathingDataEntry';
+import type { SpikeCaloriesDataEntry } from '../DataModels/SpikeCaloriesDataEntry';
+import type { SpikeDistanceDataEntry } from '../DataModels/SpikeDistanceDataEntry';
+import type { SpikeGlucoseDataEntry } from '../DataModels/SpikeGlucoseDataEntry';
+import type { SpikeHeartDataEntry } from '../DataModels/SpikeHeartDataEntry';
+import type { SpikeOxygenSaturationDataEntry } from '../DataModels/SpikeOxygenSaturationDataEntry';
+import type { SpikeSleepDataEntry } from '../DataModels/SpikeSleepDataEntry';
+import type { SpikeStepsDataEntry } from '../DataModels/SpikeStepsDataEntry';
+
+type SpikeDataTypeValues =
+  | 'activities_summary'
+  | 'activities_stream'
+  | 'breathing'
+  | 'calories'
+  | 'distance'
+  | 'glucose'
+  | 'heart'
+  | 'oxygen_saturation'
+  | 'sleep'
+  | 'steps'
+  | 'body';
+
+// @ts-ignore
+export interface SpikeDataType<DataEntryType extends SpikeDataEntry> {
+  rawValue: SpikeDataTypeValues;
+}
+
+export class SpikeActivitiesStreamDataType
+  implements SpikeDataType<SpikeActivitiesStreamDataEntry>
+{
+  rawValue: SpikeDataTypeValues = 'activities_stream';
+}
+
+export class SpikeActivitiesSummaryDataType
+  implements SpikeDataType<SpikeActivitiesSummaryDataEntry>
+{
+  rawValue: SpikeDataTypeValues = 'activities_summary';
+}
+
+export class SpikeBreathingDataType
+  implements SpikeDataType<SpikeBreathingDataEntry>
+{
+  rawValue: SpikeDataTypeValues = 'breathing';
+}
+
+export class SpikeCaloriesDataType
+  implements SpikeDataType<SpikeCaloriesDataEntry>
+{
+  rawValue: SpikeDataTypeValues = 'calories';
+}
+
+export class SpikeDistanceDataType
+  implements SpikeDataType<SpikeDistanceDataEntry>
+{
+  rawValue: SpikeDataTypeValues = 'distance';
+}
+
+export class SpikeGlucoseDataType
+  implements SpikeDataType<SpikeGlucoseDataEntry>
+{
+  rawValue: SpikeDataTypeValues = 'glucose';
+}
+
+export class SpikeHeartDataType implements SpikeDataType<SpikeHeartDataEntry> {
+  rawValue: SpikeDataTypeValues = 'heart';
+}
+
+export class SpikeOxygenSaturationDataType
+  implements SpikeDataType<SpikeOxygenSaturationDataEntry>
+{
+  rawValue: SpikeDataTypeValues = 'oxygen_saturation';
+}
+
+export class SpikeSleepDataType implements SpikeDataType<SpikeSleepDataEntry> {
+  rawValue: SpikeDataTypeValues = 'sleep';
+}
+
+export class SpikeStepsDataType implements SpikeDataType<SpikeStepsDataEntry> {
+  rawValue: SpikeDataTypeValues = 'steps';
+}
+
+export class SpikeBodyDataType implements SpikeDataType<SpikeDataEntry> {
+  rawValue: SpikeDataTypeValues = 'body';
+}

package/src/Spike.ts

@@ -1,77 +1,136 @@
-import type { SpikeDataType } from './SpikeDataType';
-import type { SpikeInterface } from './SpikeInterface';
+import type { SpikeDataEntry } from './DataModels/SpikeData';
+import type { SpikeDataType } from './DataTypes/SpikeDataType';
+import { SpikeConnection } from './SpikeConnection';
+import { SpikeException } from './SpikeException';
+import type { SpikeLogger } from './SpikeLogger';
 import { SpikeSdk } from './SpikeSdk';
-
-export class Spike implements SpikeInterface {
-  async isBackgroundUpdateEnabled(): Promise<boolean> {
-    if (!SpikeSdk) return false;
-
-    return SpikeSdk.isBackgroundUpdateEnabled();
-  }
-
-  enableDebug(): void {
-    if (!SpikeSdk) return;
-
-    SpikeSdk.enableDebug();
-  }
-
-  setup(
-    clientId: string,
-    authToken: string,
-    userId: string,
-    postbackURL?: string
-  ): void {
-    if (!SpikeSdk) return;
-
-    if (postbackURL !== undefined) {
-      SpikeSdk.setupWithURL(clientId, authToken, userId, postbackURL);
-    } else {
-      SpikeSdk.setup(clientId, authToken, userId);
-    }
+import { SpikeWebhookConnection } from './SpikeWebhookConnection';
+
+const createConnection = async (
+  appId: string,
+  authToken: string,
+  customerEndUserId: string,
+  logger: SpikeLogger | null = null
+): Promise<SpikeConnection> => {
+  if (!SpikeSdk) throw new SpikeException();
+
+  const connectionUUID = generateUUID();
+  const spikeConnection = new SpikeConnection(connectionUUID, logger);
+
+  await SpikeSdk.createConnection(
+    connectionUUID,
+    appId,
+    authToken,
+    customerEndUserId,
+    !!logger
+  );
+
+  return spikeConnection;
+};
+
+const createWebhookConnection = async (
+  appId: string,
+  authToken: string,
+  customerEndUserId: string,
+  callbackUrl: string,
+  logger: SpikeLogger | null = null
+): Promise<SpikeWebhookConnection> => {
+  if (!SpikeSdk) throw new SpikeException();
+
+  const connectionUUID = generateUUID();
+  const spikeConnection = new SpikeWebhookConnection(connectionUUID, logger);
+
+  await SpikeSdk.createWebhookConnection(
+    connectionUUID,
+    appId,
+    authToken,
+    customerEndUserId,
+    callbackUrl,
+    !!logger
+  );
+
+  return spikeConnection;
+};
+
+const unpackConnection = async (
+  connection: string,
+  logger: SpikeLogger | null = null
+): Promise<SpikeConnection> => {
+  if (!SpikeSdk) throw new SpikeException();
+
+  const connectionUUID = generateUUID();
+  const webhookConnection = new SpikeWebhookConnection(connectionUUID, logger);
+
+  await SpikeSdk.unpackConnection(connectionUUID, connection, !!logger);
+
+  try {
+    await webhookConnection.getCallbackUrl();
+    return new SpikeWebhookConnection(connectionUUID, logger);
+  } catch (error) {
+    return new SpikeConnection(connectionUUID, logger);
   }
-
-  async getCurrentUUID(): Promise<string | undefined> {
-    if (!SpikeSdk) return undefined;
-
-    const uuid: string = await SpikeSdk.getCurrentUUID();
-    if (uuid) {
-      return uuid;
-    } else {
-      return undefined;
+};
+
+const getBackgroundConnections = async (): Promise<
+  SpikeWebhookConnection[]
+> => {
+  if (!SpikeSdk) throw new SpikeException();
+
+  const connectionUUIDs: string[] = await SpikeSdk.getBackgroundConnections();
+
+  const connections = connectionUUIDs.map(
+    (uuid) => new SpikeWebhookConnection(uuid)
+  );
+  return connections;
+};
+
+const ensurePermissionsAreGranted = async <DataEntry extends SpikeDataEntry>(
+  permissions: SpikeDataType<DataEntry>[]
+): Promise<void> => {
+  if (!SpikeSdk) throw new SpikeException();
+
+  await SpikeSdk.ensurePermissionsAreGranted(
+    permissions.map((permissionType) => permissionType.rawValue)
+  );
+};
+
+const initialize = () => {
+  if (!SpikeSdk) throw new SpikeException();
+
+  SpikeSdk.initialize();
+};
+
+function generateUUID() {
+  const S4 = function () {
+    let str = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXZ';
+    let uuid = [];
+    for (let i = 0; i < 4; i++) {
+      uuid.push(str[Math.floor(Math.random() * str.length)]);
     }
-  }
-
-  clearData(): void {
-    if (!SpikeSdk) return;
-
-    SpikeSdk.clearData();
-  }
-
-  getData(dataTypes: SpikeDataType[]): void {
-    if (!SpikeSdk) return;
-
-    SpikeSdk.getData(dataTypes);
-  }
-
-  getDataInRange(
-    dataTypes: SpikeDataType[],
-    startDate: Date,
-    endDate: Date
-  ): void {
-    if (!SpikeSdk) return;
-
-    SpikeSdk.getDataInRange(dataTypes, startDate.getTime(), endDate.getTime());
-  }
-
-  async enableBackgroundDelivery(dataTypes: SpikeDataType[]): Promise<void> {
-    if (!SpikeSdk) return;
-
-    return SpikeSdk.enableBackgroundDelivery(dataTypes);
-  }
-
-  async disableAllBackgroundDelivery(): Promise<void> {
-    if (!SpikeSdk) return;
-
-    return SpikeSdk.disableAllBackgroundDelivery();
-  }
+    return uuid.join('');
+  };
+
+  return (
+    S4() +
+    S4() +
+    '-' +
+    S4() +
+    '-' +
+    S4() +
+    '-' +
+    S4() +
+    '-' +
+    S4() +
+    S4() +
+    S4()
+  );
 }
+
+export {
+  createConnection,
+  createWebhookConnection,
+  unpackConnection,
+  getBackgroundConnections,
+  ensurePermissionsAreGranted,
+  initialize,
+};