hae-vault 0.1.0

package/src/server/app.ts

@@ -0,0 +1,46 @@
+import express, { type Request, type Response } from 'express';
+import type Database from 'better-sqlite3';
+import { ingest } from './ingest.js';
+import type { HaePayload } from '../types/hae.js';
+
+export function createApp(db: Database.Database, opts: { token?: string } = {}) {
+  const app = express();
+  app.use(express.json({ limit: '50mb' }));
+
+  app.post('/api/ingest', (req: Request, res: Response) => {
+    // Optional bearer token auth
+    if (opts.token) {
+      const authHeader = req.headers['authorization'] ?? '';
+      const apiKey = (req.headers['x-api-key'] as string) ?? '';
+      const bearer = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : '';
+      if (bearer !== opts.token && apiKey !== opts.token) {
+        res.status(401).json({ error: 'Unauthorized' });
+        return;
+      }
+    }
+
+    try {
+      const payload = req.body as HaePayload;
+      if (!payload?.data) {
+        res.status(400).json({ error: 'Missing data field' });
+        return;
+      }
+
+      ingest(db, payload, {
+        target: (req.query['target'] as string) ?? 'default',
+        sessionId: (req.headers['session-id'] as string) ?? null,
+        automationName: req.headers['automation-name'] as string | undefined,
+        automationPeriod: req.headers['automation-period'] as string | undefined,
+      });
+
+      res.json({ ok: true });
+    } catch (err) {
+      console.error('Ingest error:', err);
+      res.status(400).json({ error: String(err) });
+    }
+  });
+
+  app.get('/health', (_req, res) => res.json({ status: 'ok' }));
+
+  return app;
+}

package/src/server/ingest.ts

@@ -0,0 +1,68 @@
+import type Database from 'better-sqlite3';
+import type { HaePayload, SleepDatapoint } from '../types/hae.js';
+import { parseMetric } from '../parse/metrics.js';
+import { normalizeSleep } from '../parse/sleep.js';
+import { parseWorkout } from '../parse/workouts.js';
+import { upsertMetrics } from '../db/metrics.js';
+import { upsertSleep } from '../db/sleep.js';
+import { upsertWorkout } from '../db/workouts.js';
+
+export interface IngestOptions {
+  target: string;
+  sessionId: string | null;
+  automationName?: string;
+  automationPeriod?: string;
+}
+
+export interface IngestResult {
+  metricsAdded: number;
+  sleepAdded: number;
+  workoutsAdded: number;
+}
+
+export function ingest(db: Database.Database, payload: HaePayload, opts: IngestOptions): IngestResult {
+  const { target, sessionId } = opts;
+  const { data } = payload;
+
+  let metricsAdded = 0;
+  let sleepAdded = 0;
+  let workoutsAdded = 0;
+
+  // Process metrics
+  for (const m of data.metrics ?? []) {
+    if (m.name === 'sleep_analysis') {
+      for (const dp of (m.data as SleepDatapoint[])) {
+        const row = normalizeSleep(dp, target, sessionId);
+        upsertSleep(db, row);
+        sleepAdded++;
+      }
+    } else {
+      const rows = parseMetric(m, target, sessionId);
+      upsertMetrics(db, rows);
+      metricsAdded += rows.length;
+    }
+  }
+
+  // Process workouts
+  for (const w of data.workouts ?? []) {
+    const row = parseWorkout(w, target, sessionId);
+    upsertWorkout(db, row);
+    workoutsAdded++;
+  }
+
+  // Log sync
+  db.prepare(`
+    INSERT INTO sync_log (received_at, target, session_id, metrics_count, workouts_count, automation_name, automation_period)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    new Date().toISOString(),
+    target,
+    sessionId,
+    metricsAdded,
+    workoutsAdded,
+    opts.automationName ?? null,
+    opts.automationPeriod ?? null,
+  );
+
+  return { metricsAdded, sleepAdded, workoutsAdded };
+}

package/src/types/hae.ts

@@ -0,0 +1,94 @@
+// Raw datapoint from HAE — most metrics
+export interface RawDatapoint {
+  date: string;
+  qty?: number;
+  // heart_rate: Min/Avg/Max instead of qty
+  Min?: number;
+  Avg?: number;
+  Max?: number;
+  // blood_pressure: systolic/diastolic
+  systolic?: number;
+  diastolic?: number;
+  units?: string;
+  source?: string;
+}
+
+// Non-aggregated sleep_analysis (each phase as a separate entry)
+export interface SleepAnalysisRaw {
+  startDate: string;
+  endDate: string;
+  value: string; // 'ASLEEP_CORE' | 'ASLEEP_DEEP' | 'ASLEEP_REM' | 'INBED' | 'AWAKE'
+  source: string;
+  qty?: number;
+}
+
+// Aggregated sleep v2 (HAE >= 6.6.2): has `source` field
+export interface AggregatedSleepV2 {
+  sleepStart: string;
+  sleepEnd: string;
+  core: number;
+  deep: number;
+  rem: number;
+  awake: number;
+  asleep: number;
+  inBed: number;
+  source: string;
+}
+
+// Aggregated sleep v1 (HAE < 6.6.2): has sleepSource/inBedSource instead
+export interface AggregatedSleepV1 {
+  sleepStart: string;
+  sleepEnd: string;
+  inBedStart: string;
+  inBedEnd: string;
+  asleep: number;
+  inBed: number;
+  sleepSource?: string;
+  inBedSource?: string;
+}
+
+export type SleepDatapoint = SleepAnalysisRaw | AggregatedSleepV2 | AggregatedSleepV1;
+
+export interface MetricData {
+  name: string;
+  units: string;
+  data: RawDatapoint[] | SleepDatapoint[];
+}
+
+export interface WorkoutData {
+  name: string;
+  start: string;
+  end: string;
+  duration?: number;
+  activeEnergyBurned?: { qty: number; units: string };
+  distance?: { qty: number; units: string };
+  heartRateData?: Array<{ date: string; qty: number; units: string }>;
+  heartRateRecovery?: Array<{ date: string; qty: number; units: string }>;
+  route?: Array<{ lat: number; lon: number; altitude: number; timestamp: string }>;
+  elevation?: { ascent: number; descent: number; units: string };
+  [key: string]: unknown; // dynamic fields
+}
+
+export interface HaePayload {
+  data: {
+    metrics?: MetricData[];
+    workouts?: WorkoutData[];
+    stateOfMind?: unknown[];
+    medications?: unknown[];
+    symptoms?: unknown[];
+    cycleTracking?: unknown[];
+    ecg?: unknown[];
+    heartRateNotifications?: unknown[];
+  };
+}
+
+// HAE request headers
+export interface HaeHeaders {
+  'automation-name'?: string;
+  'automation-id'?: string;
+  'automation-aggregation'?: string;
+  'automation-period'?: string;
+  'session-id'?: string;
+  'authorization'?: string;
+  'x-api-key'?: string;
+}

package/src/util/zip.ts

@@ -0,0 +1,24 @@
+import AdmZip from 'adm-zip';
+import type { HaePayload } from '../types/hae.js';
+
+const HAE_JSON_PATTERN = /HealthAutoExport.*\.json$/i;
+
+export function extractPayloadFromZip(buf: Buffer): HaePayload | null {
+  try {
+    const zip = new AdmZip(buf);
+    const entry = zip.getEntries().find(e => HAE_JSON_PATTERN.test(e.entryName));
+    if (!entry) return null;
+
+    let payload: unknown;
+    try {
+      payload = JSON.parse(entry.getData().toString('utf-8'));
+    } catch {
+      return null;
+    }
+
+    if (!payload || typeof payload !== 'object' || !('data' in payload)) return null;
+    return payload as HaePayload;
+  } catch {
+    return null;
+  }
+}

package/tests/cli-watch.test.ts

@@ -0,0 +1,64 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { openDb, closeDb } from '../src/db/schema.js';
+import { tick } from '../src/cli/watch.js';
+import type Database from 'better-sqlite3';
+
+const testDir = join(tmpdir(), 'hae-vault-test-watch-' + Date.now());
+const watchDir = join(testDir, 'watch');
+let db: Database.Database;
+
+const haeJson = JSON.stringify({
+  data: {
+    metrics: [{ name: 'step_count', units: 'count', data: [{ date: '2026-01-10 10:00:00 +0000', qty: 5000 }] }],
+    workouts: []
+  }
+});
+
+before(() => {
+  mkdirSync(testDir, { recursive: true });
+  mkdirSync(watchDir, { recursive: true });
+  db = openDb(join(testDir, 'test.db'));
+});
+
+after(() => {
+  closeDb(db);
+  rmSync(testDir, { recursive: true });
+});
+
+test('tick imports a new HealthAutoExport-*.json file', () => {
+  writeFileSync(join(watchDir, 'HealthAutoExport-test.json'), haeJson);
+  const result = tick(db, watchDir, 'default');
+  assert.equal(result.found, 1);
+  assert.equal(result.imported, 1);
+  assert.equal(result.skipped, 0);
+});
+
+test('tick skips already-imported file (dedup)', () => {
+  // Same file still in dir — hash already in import_log
+  const result = tick(db, watchDir, 'default');
+  assert.equal(result.found, 1);
+  assert.equal(result.imported, 0);
+  assert.equal(result.skipped, 1);
+});
+
+test('tick ignores non-HAE files', () => {
+  writeFileSync(join(watchDir, 'random.txt'), 'not a health export');
+  writeFileSync(join(watchDir, 'workout.gpx'), '<gpx/>');
+  const result = tick(db, watchDir, 'default');
+  assert.equal(result.found, 1); // only the HAE json counts as "found"
+  assert.equal(result.imported, 0);
+});
+
+test('tick records import in import_log so second tick skips', () => {
+  writeFileSync(join(watchDir, 'HealthAutoExport-new.json'), JSON.stringify({
+    data: { metrics: [{ name: 'step_count', units: 'count', data: [{ date: '2026-01-11 10:00:00 +0000', qty: 6000 }] }], workouts: [] }
+  }));
+  tick(db, watchDir, 'default');
+  // Second tick: all files should be skipped now
+  const result2 = tick(db, watchDir, 'default');
+  assert.equal(result2.imported, 0);
+});

package/tests/db-import-log.test.ts

@@ -0,0 +1,40 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { openDb, closeDb } from '../src/db/schema.js';
+import { hasBeenImported, logImport } from '../src/db/importLog.js';
+import type Database from 'better-sqlite3';
+
+const testDir = join(tmpdir(), 'hae-vault-test-importlog-' + Date.now());
+let db: Database.Database;
+before(() => { mkdirSync(testDir, { recursive: true }); db = openDb(join(testDir, 'test.db')); });
+after(() => { closeDb(db); rmSync(testDir, { recursive: true }); });
+
+test('hasBeenImported returns false for unknown hash', () => {
+  assert.equal(hasBeenImported(db, 'deadbeef1234'), false);
+});
+
+test('logImport records the import', () => {
+  logImport(db, 'export.zip', 'abc123hash', { metricsAdded: 100, sleepAdded: 7, workoutsAdded: 3 });
+  const row = db.prepare('SELECT * FROM import_log WHERE file_hash = ?').get('abc123hash') as {
+    filename: string; metrics_added: number; sleep_added: number; workouts_added: number;
+  } | undefined;
+  assert.ok(row);
+  assert.equal(row!.filename, 'export.zip');
+  assert.equal(row!.metrics_added, 100);
+  assert.equal(row!.sleep_added, 7);
+  assert.equal(row!.workouts_added, 3);
+});
+
+test('hasBeenImported returns true after logImport', () => {
+  assert.equal(hasBeenImported(db, 'abc123hash'), true);
+});
+
+test('logImport with duplicate hash is a no-op (INSERT OR IGNORE)', () => {
+  // Should not throw
+  logImport(db, 'export-copy.zip', 'abc123hash', { metricsAdded: 999, sleepAdded: 999, workoutsAdded: 999 });
+  const count = db.prepare('SELECT COUNT(*) as c FROM import_log WHERE file_hash = ?').get('abc123hash') as { c: number };
+  assert.equal(count.c, 1); // still only one row
+});

package/tests/db-metrics.test.ts

@@ -0,0 +1,44 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { openDb, closeDb } from '../src/db/schema.js';
+import { upsertMetrics } from '../src/db/metrics.js';
+import type Database from 'better-sqlite3';
+
+const testDir = join(tmpdir(), 'hae-vault-test-metrics-' + Date.now());
+let db: Database.Database;
+
+before(() => { mkdirSync(testDir, { recursive: true }); db = openDb(join(testDir, 'test.db')); });
+after(() => { closeDb(db); rmSync(testDir, { recursive: true }); });
+
+const row = {
+  ts: '2026-01-15T10:00:00.000Z', date: '2026-01-15',
+  metric: 'step_count', qty: 5000, min: null, avg: null, max: null,
+  units: 'count', source: 'iPhone', target: 'default', meta: null, session_id: 'sess-1'
+};
+
+test('inserts a metric row', () => {
+  upsertMetrics(db, [row]);
+  const result = db.prepare('SELECT * FROM metrics WHERE metric = ?').get('step_count') as { qty: number };
+  assert.equal(result.qty, 5000);
+});
+
+test('upserts on conflict — updates qty', () => {
+  upsertMetrics(db, [{ ...row, qty: 6000 }]);
+  const result = db.prepare('SELECT COUNT(*) as c FROM metrics WHERE metric = ?').get('step_count') as { c: number };
+  assert.equal(result.c, 1);
+  const updated = db.prepare('SELECT qty FROM metrics WHERE metric = ?').get('step_count') as { qty: number };
+  assert.equal(updated.qty, 6000);
+});
+
+test('inserts multiple rows in a single call', () => {
+  const rows = [
+    { ...row, ts: '2026-01-16T10:00:00.000Z', date: '2026-01-16', qty: 7000 },
+    { ...row, ts: '2026-01-17T10:00:00.000Z', date: '2026-01-17', qty: 8000 },
+  ];
+  upsertMetrics(db, rows);
+  const result = db.prepare('SELECT COUNT(*) as c FROM metrics WHERE metric = ?').get('step_count') as { c: number };
+  assert.equal(result.c, 3);
+});

package/tests/db-schema.test.ts

@@ -0,0 +1,55 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { openDb, closeDb } from '../src/db/schema.js';
+import type Database from 'better-sqlite3';
+
+const testDir = join(tmpdir(), 'hae-vault-test-schema-' + Date.now());
+let db: Database.Database;
+
+before(() => {
+  mkdirSync(testDir, { recursive: true });
+  db = openDb(join(testDir, 'test.db'));
+});
+
+after(() => {
+  closeDb(db);
+  rmSync(testDir, { recursive: true });
+});
+
+test('creates metrics table', () => {
+  const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='metrics'").get();
+  assert.ok(row);
+});
+
+test('creates sleep table', () => {
+  const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='sleep'").get();
+  assert.ok(row);
+});
+
+test('creates workouts table', () => {
+  const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='workouts'").get();
+  assert.ok(row);
+});
+
+test('creates sync_log table', () => {
+  const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='sync_log'").get();
+  assert.ok(row);
+});
+
+test('WAL mode is enabled', () => {
+  const row = db.prepare('PRAGMA journal_mode').get() as { journal_mode: string };
+  assert.equal(row.journal_mode, 'wal');
+});
+
+test('openDb is idempotent — calling twice does not throw', () => {
+  const db2 = openDb(join(testDir, 'test.db'));
+  closeDb(db2);
+});
+
+test('creates import_log table', () => {
+  const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='import_log'").get();
+  assert.ok(row);
+});

package/tests/db-sleep.test.ts

@@ -0,0 +1,36 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { openDb, closeDb } from '../src/db/schema.js';
+import { upsertSleep } from '../src/db/sleep.js';
+import type Database from 'better-sqlite3';
+
+const testDir = join(tmpdir(), 'hae-vault-test-sleep-' + Date.now());
+let db: Database.Database;
+before(() => { mkdirSync(testDir, { recursive: true }); db = openDb(join(testDir, 'test.db')); });
+after(() => { closeDb(db); rmSync(testDir, { recursive: true }); });
+
+const row = {
+  date: '2026-01-15',
+  sleep_start: '2026-01-14T22:00:00.000Z', sleep_end: '2026-01-15T06:00:00.000Z',
+  in_bed_start: null, in_bed_end: null,
+  core_h: 3.0, deep_h: 1.0, rem_h: 1.5, awake_h: 0.5, asleep_h: 5.5, in_bed_h: 6.0,
+  schema_ver: 'aggregated_v2' as const,
+  source: 'Apple Watch', target: 'default', meta: null, session_id: 'sess-1'
+};
+
+test('inserts sleep row', () => {
+  upsertSleep(db, row);
+  const result = db.prepare('SELECT core_h FROM sleep WHERE date = ?').get('2026-01-15') as { core_h: number };
+  assert.equal(result.core_h, 3.0);
+});
+
+test('upserts sleep — overwrites on same date+source+target', () => {
+  upsertSleep(db, { ...row, core_h: 3.5 });
+  const count = db.prepare('SELECT COUNT(*) as c FROM sleep').get() as { c: number };
+  assert.equal(count.c, 1);
+  const updated = db.prepare('SELECT core_h FROM sleep WHERE date = ?').get('2026-01-15') as { core_h: number };
+  assert.equal(updated.core_h, 3.5);
+});

package/tests/db-workouts.test.ts

@@ -0,0 +1,34 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { openDb, closeDb } from '../src/db/schema.js';
+import { upsertWorkout } from '../src/db/workouts.js';
+import type Database from 'better-sqlite3';
+
+const testDir = join(tmpdir(), 'hae-vault-test-workouts-' + Date.now());
+let db: Database.Database;
+before(() => { mkdirSync(testDir, { recursive: true }); db = openDb(join(testDir, 'test.db')); });
+after(() => { closeDb(db); rmSync(testDir, { recursive: true }); });
+
+const row = {
+  ts: '2026-01-15T07:00:00.000Z', date: '2026-01-15',
+  name: 'Running', duration_s: 2700, calories_kj: 450,
+  distance: 5.2, distance_unit: 'km', avg_hr: 145, max_hr: 165,
+  target: 'default', meta: '{}', session_id: 'sess-1'
+};
+
+test('inserts workout row', () => {
+  upsertWorkout(db, row);
+  const result = db.prepare('SELECT name FROM workouts WHERE date = ?').get('2026-01-15') as { name: string };
+  assert.equal(result.name, 'Running');
+});
+
+test('upserts workout — overwrites on same ts+name+target', () => {
+  upsertWorkout(db, { ...row, calories_kj: 500 });
+  const count = db.prepare('SELECT COUNT(*) as c FROM workouts').get() as { c: number };
+  assert.equal(count.c, 1);
+  const updated = db.prepare('SELECT calories_kj FROM workouts WHERE date = ?').get('2026-01-15') as { calories_kj: number };
+  assert.equal(updated.calories_kj, 500);
+});

package/tests/ingest.test.ts

@@ -0,0 +1,99 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { openDb, closeDb } from '../src/db/schema.js';
+import { ingest } from '../src/server/ingest.js';
+import type Database from 'better-sqlite3';
+import type { HaePayload } from '../src/types/hae.js';
+
+const testDir = join(tmpdir(), 'hae-vault-test-ingest-' + Date.now());
+let db: Database.Database;
+before(() => { mkdirSync(testDir, { recursive: true }); db = openDb(join(testDir, 'test.db')); });
+after(() => { closeDb(db); rmSync(testDir, { recursive: true }); });
+
+const payload: HaePayload = {
+  data: {
+    metrics: [
+      { name: 'step_count', units: 'count', data: [{ date: '2026-01-15 10:00:00 +0000', qty: 8532 }] },
+      { name: 'heart_rate', units: 'bpm', data: [{ date: '2026-01-15 10:00:00 +0000', Min: 55, Avg: 72, Max: 130 }] },
+      {
+        name: 'sleep_analysis', units: 'hr',
+        data: [{
+          sleepStart: '2026-01-14 22:00:00 +0000',
+          sleepEnd: '2026-01-15 06:00:00 +0000',
+          core: 3.0, deep: 1.0, rem: 1.5, awake: 0.5, asleep: 5.5, inBed: 6.0,
+          source: 'Apple Watch'
+        }]
+      }
+    ],
+    workouts: [
+      { name: 'Running', start: '2026-01-15 07:00:00 +0000', end: '2026-01-15 07:45:00 +0000', activeEnergyBurned: { qty: 450, units: 'kJ' } }
+    ]
+  }
+};
+
+test('ingests metrics into DB', () => {
+  ingest(db, payload, { target: 'default', sessionId: 'sess-1', automationName: 'morning', automationPeriod: 'Today' });
+  const count = db.prepare('SELECT COUNT(*) as c FROM metrics').get() as { c: number };
+  assert.ok(count.c >= 2);
+});
+
+test('ingests sleep into DB', () => {
+  const row = db.prepare('SELECT * FROM sleep WHERE date = ?').get('2026-01-14') as { core_h: number } | undefined;
+  assert.ok(row);
+  assert.equal(row!.core_h, 3.0);
+});
+
+test('ingests workout into DB', () => {
+  const row = db.prepare("SELECT * FROM workouts WHERE name = 'Running'").get() as { calories_kj: number } | undefined;
+  assert.ok(row);
+  assert.equal(row!.calories_kj, 450);
+});
+
+test('writes to sync_log', () => {
+  const row = db.prepare('SELECT * FROM sync_log WHERE session_id = ?').get('sess-1') as { metrics_count: number } | undefined;
+  assert.ok(row);
+  assert.ok(row!.metrics_count >= 2);
+});
+
+test('second ingest with same data is idempotent — no duplicates', () => {
+  ingest(db, payload, { target: 'default', sessionId: 'sess-2', automationName: 'morning', automationPeriod: 'Today' });
+  const metricsCount = db.prepare('SELECT COUNT(*) as c FROM metrics').get() as { c: number };
+  const sleepCount = db.prepare('SELECT COUNT(*) as c FROM sleep').get() as { c: number };
+  const workoutsCount = db.prepare('SELECT COUNT(*) as c FROM workouts').get() as { c: number };
+  // Upsert should not create duplicates — same data for same timestamps
+  assert.ok(metricsCount.c >= 2);
+  assert.equal(sleepCount.c, 1);
+  assert.equal(workoutsCount.c, 1);
+});
+
+test('ingest returns IngestResult with counts', () => {
+  const freshPayload: HaePayload = {
+    data: {
+      metrics: [
+        { name: 'step_count', units: 'count', data: [{ date: '2026-02-01 10:00:00 +0000', qty: 1000 }] },
+        {
+          name: 'sleep_analysis', units: 'hr',
+          data: [{
+            sleepStart: '2026-02-01 22:00:00 +0000',
+            sleepEnd: '2026-02-02 06:00:00 +0000',
+            core: 2.0, deep: 1.0, rem: 1.0, awake: 0.2, asleep: 4.0, inBed: 4.5,
+            source: 'Apple Watch'
+          }]
+        }
+      ],
+      workouts: [
+        { name: 'Cycling', start: '2026-02-01 07:00:00 +0000', end: '2026-02-01 08:00:00 +0000' }
+      ]
+    }
+  };
+  const result = ingest(db, freshPayload, { target: 'test', sessionId: 'sess-count', automationName: 'test', automationPeriod: 'manual' });
+  assert.ok(typeof result.metricsAdded === 'number');
+  assert.ok(typeof result.sleepAdded === 'number');
+  assert.ok(typeof result.workoutsAdded === 'number');
+  assert.equal(result.metricsAdded, 1);   // step_count only (sleep goes to sleep table)
+  assert.equal(result.sleepAdded, 1);
+  assert.equal(result.workoutsAdded, 1);
+});

package/tests/parse-metrics.test.ts

@@ -0,0 +1,55 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { parseMetric } from '../src/parse/metrics.js';
+import type { MetricData } from '../src/types/hae.js';
+
+const stepMetric: MetricData = {
+  name: 'step_count', units: 'count',
+  data: [
+    { date: '2026-01-15 10:00:00 +0000', qty: 5000 },
+    { date: '2026-01-15 11:00:00 +0000', qty: 3000 },
+  ]
+};
+
+const hrMetric: MetricData = {
+  name: 'heart_rate', units: 'bpm',
+  data: [{ date: '2026-01-15 10:00:00 +0000', Min: 55, Avg: 72, Max: 130 }]
+};
+
+const bpMetric: MetricData = {
+  name: 'blood_pressure', units: 'mmHg',
+  data: [{ date: '2026-01-15 10:00:00 +0000', systolic: 120, diastolic: 80 }]
+};
+
+test('parses basic step_count metric', () => {
+  const rows = parseMetric(stepMetric, 'default', 'sess-1');
+  assert.equal(rows.length, 2);
+  assert.equal(rows[0].metric, 'step_count');
+  assert.equal(rows[0].qty, 5000);
+  assert.equal(rows[0].units, 'count');
+  assert.ok(rows[0].ts);
+  assert.ok(rows[0].date);
+});
+
+test('parses heart_rate metric with Min/Avg/Max', () => {
+  const rows = parseMetric(hrMetric, 'default', 'sess-1');
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].min, 55);
+  assert.equal(rows[0].avg, 72);
+  assert.equal(rows[0].max, 130);
+  assert.equal(rows[0].qty, null);
+});
+
+test('parses blood_pressure into meta JSON', () => {
+  const rows = parseMetric(bpMetric, 'default', 'sess-1');
+  assert.equal(rows.length, 1);
+  const meta = JSON.parse(rows[0].meta!);
+  assert.equal(meta.systolic, 120);
+  assert.equal(meta.diastolic, 80);
+});
+
+test('returns empty array for sleep_analysis (handled elsewhere)', () => {
+  const sleepMetric: MetricData = { name: 'sleep_analysis', units: 'hr', data: [] };
+  const rows = parseMetric(sleepMetric, 'default', 'sess-1');
+  assert.equal(rows.length, 0);
+});