How to Integrate Replit with HealthKit

1// health-server.js — Replit backend receiving HealthKit data from iOS app
2const express = require('express');
3const app = express();
4app.use(express.json({ limit: '1mb' }));
5
6// Validate API key from iOS app
7function validateApiKey(req, res, next) {
8  const apiKey = req.headers['x-api-key'];
9  if (!apiKey || apiKey !== process.env.HEALTH_API_KEY) {
10    return res.status(401).json({ error: 'Invalid or missing API key' });
11  }
12  next();
13}
14
15// In-memory storage for demo (use a real database in production)
16const healthData = [];
17
18// POST /health/sync — receive HealthKit data from iOS app
19app.post('/health/sync', validateApiKey, (req, res) => {
20  const { userId, readings } = req.body;
21  
22  if (!userId || !Array.isArray(readings)) {
23    return res.status(400).json({ error: 'userId and readings array required' });
24  }
25  
26  const validTypes = ['stepCount', 'heartRate', 'activeEnergyBurned', 'sleepAnalysis', 'restingHeartRate'];
27  const validated = readings.filter(r => {
28    return r.dataType && validTypes.includes(r.dataType) &&
29           r.value !== undefined && r.startDate && r.endDate;
30  });
31  
32  // Store validated readings
33  validated.forEach(r => healthData.push({ ...r, userId, receivedAt: new Date().toISOString() }));
34  
35  console.log(`Received ${validated.length} readings from user ${userId}`);
36  res.json({ received: validated.length, rejected: readings.length - validated.length });
37});
38
39// GET /health/summary/:userId — aggregate recent data
40app.get('/health/summary/:userId', validateApiKey, (req, res) => {
41  const { userId } = req.params;
42  const userReadings = healthData.filter(r => r.userId === userId);
43  
44  const summary = {};
45  userReadings.forEach(r => {
46    if (!summary[r.dataType]) summary[r.dataType] = [];
47    summary[r.dataType].push({ value: r.value, date: r.startDate });
48  });
49  
50  res.json({ userId, summary, totalReadings: userReadings.length });
51});
52
53// Health check
54app.get('/health', (req, res) => res.json({ status: 'ok' }));
55
56app.listen(3000, '0.0.0.0', () => console.log('HealthKit sync server running on port 3000'));

1# health_server.py — Replit backend receiving HealthKit data from iOS app (Python)
2import os
3import json
4from datetime import datetime
5from functools import wraps
6from flask import Flask, request, jsonify
7
8app = Flask(__name__)
9
10# In-memory store for demo (use PostgreSQL in production)
11health_data = []
12
13VALID_TYPES = {'stepCount', 'heartRate', 'activeEnergyBurned',
14               'sleepAnalysis', 'restingHeartRate', 'bodyMass', 'bloodOxygen'}
15
16def require_api_key(f):
17    @wraps(f)
18    def decorated(*args, **kwargs):
19        api_key = request.headers.get('X-API-Key')
20        expected = os.environ.get('HEALTH_API_KEY')
21        if not api_key or api_key != expected:
22            return jsonify({'error': 'Invalid or missing API key'}), 401
23        return f(*args, **kwargs)
24    return decorated
25
26@app.route('/health/sync', methods=['POST'])
27@require_api_key
28def sync_health_data():
29    payload = request.get_json()
30    if not payload:
31        return jsonify({'error': 'JSON body required'}), 400
32    
33    user_id = payload.get('userId')
34    readings = payload.get('readings', [])
35    
36    if not user_id or not isinstance(readings, list):
37        return jsonify({'error': 'userId and readings array required'}), 400
38    
39    valid_readings = [
40        r for r in readings
41        if r.get('dataType') in VALID_TYPES
42        and r.get('value') is not None
43        and r.get('startDate') and r.get('endDate')
44    ]
45    
46    for r in valid_readings:
47        health_data.append({
48            **r,
49            'userId': user_id,
50            'receivedAt': datetime.utcnow().isoformat()
51        })
52    
53    return jsonify({
54        'received': len(valid_readings),
55        'rejected': len(readings) - len(valid_readings)
56    })
57
58@app.route('/health/summary/<user_id>')
59@require_api_key
60def get_summary(user_id):
61    user_readings = [r for r in health_data if r['userId'] == user_id]
62    
63    summary = {}
64    for r in user_readings:
65        dt = r['dataType']
66        if dt not in summary:
67            summary[dt] = []
68        summary[dt].append({'value': r['value'], 'unit': r.get('unit'), 'date': r['startDate']})
69    
70    return jsonify({'userId': user_id, 'summary': summary, 'totalReadings': len(user_readings)})
71
72@app.route('/health')
73def health_check():
74    return jsonify({'status': 'ok'})
75
76if __name__ == '__main__':
77    app.run(host='0.0.0.0', port=3000)

1// HealthKitSync.swift — iOS app code to read HealthKit and POST to Replit
2import HealthKit
3import Foundation
4
5class HealthKitSyncManager {
6    let healthStore = HKHealthStore()
7    let serverURL: URL
8    let apiKey: String
9    
10    init() {
11        // Store these in Info.plist or Keychain in production
12        serverURL = URL(string: ProcessInfo.processInfo.environment["REPLIT_SERVER_URL"] 
13                       ?? "https://yourapp.yourusername.repl.co")!
14        apiKey = ProcessInfo.processInfo.environment["HEALTH_API_KEY"] ?? ""
15    }
16    
17    func requestPermissionsAndSync(userId: String) async throws {
18        guard HKHealthStore.isHealthDataAvailable() else {
19            throw NSError(domain: "HealthKit", code: 0, userInfo: [NSLocalizedDescriptionKey: "HealthKit not available"])
20        }
21        
22        let typesToRead: Set<HKObjectType> = [
23            HKQuantityType.quantityType(forIdentifier: .stepCount)!,
24            HKQuantityType.quantityType(forIdentifier: .heartRate)!,
25            HKQuantityType.quantityType(forIdentifier: .activeEnergyBurned)!
26        ]
27        
28        try await healthStore.requestAuthorization(toShare: [], read: typesToRead)
29        let readings = try await fetchRecentReadings()
30        try await postToReplit(userId: userId, readings: readings)
31    }
32    
33    func fetchRecentReadings() async throws -> [[String: Any]] {
34        var allReadings: [[String: Any]] = []
35        let sevenDaysAgo = Calendar.current.date(byAdding: .day, value: -7, to: Date())!
36        let predicate = HKQuery.predicateForSamples(withStart: sevenDaysAgo, end: Date())
37        
38        // Query step count
39        if let stepType = HKQuantityType.quantityType(forIdentifier: .stepCount) {
40            let steps = try await querySamples(type: stepType, predicate: predicate)
41            allReadings.append(contentsOf: steps.map { sample in
42                let qty = sample as! HKQuantitySample
43                return [
44                    "dataType": "stepCount",
45                    "value": qty.quantity.doubleValue(for: HKUnit.count()),
46                    "unit": "count",
47                    "startDate": ISO8601DateFormatter().string(from: qty.startDate),
48                    "endDate": ISO8601DateFormatter().string(from: qty.endDate)
49                ]
50            })
51        }
52        return allReadings
53    }
54    
55    func querySamples(type: HKSampleType, predicate: NSPredicate) async throws -> [HKSample] {
56        return try await withCheckedThrowingContinuation { continuation in
57            let query = HKSampleQuery(sampleType: type, predicate: predicate, limit: 1000, sortDescriptors: nil) { _, samples, error in
58                if let error = error { continuation.resume(throwing: error) }
59                else { continuation.resume(returning: samples ?? []) }
60            }
61            healthStore.execute(query)
62        }
63    }
64    
65    func postToReplit(userId: String, readings: [[String: Any]]) async throws {
66        var req = URLRequest(url: serverURL.appendingPathComponent("/health/sync"))
67        req.httpMethod = "POST"
68        req.setValue("application/json", forHTTPHeaderField: "Content-Type")
69        req.setValue(apiKey, forHTTPHeaderField: "X-API-Key")
70        req.httpBody = try JSONSerialization.data(withJSONObject: ["userId": userId, "readings": readings])
71        
72        let (data, response) = try await URLSession.shared.data(for: req)
73        let http = response as! HTTPURLResponse
74        print("Server response:", http.statusCode, String(data: data, encoding: .utf8) ?? "")
75    }
76}