@chainlesschain/personal-data-hub 0.3.8 → 0.4.0

package/lib/adapters/apple-health/index.js

@@ -0,0 +1,329 @@
+"use strict";
+
+/**
+ * Apple Health adapter — file-import of the standard HealthKit `export.xml`.
+ *
+ * This is the MOST reliable health source: the user exports their own data
+ * from the iOS 健康 app ("头像 → 导出所有健康数据" → a zip containing
+ * `export.xml`), unzips, and points the adapter at the XML. The format is a
+ * stable, documented HealthKit schema — no device hacking, no decryption, no
+ * signing. Pure file-import (like local-files / git-activity).
+ *
+ * `export.xml` shape:
+ *   <HealthData ...>
+ *     <Record type="HKQuantityTypeIdentifierStepCount" sourceName="iPhone"
+ *             unit="count" startDate="2024-01-15 08:30:00 +0800"
+ *             endDate="..." value="123"/>
+ *     <Record type="HKCategoryTypeIdentifierSleepAnalysis" value="HKCategoryValueSleepAnalysisAsleep" .../>
+ *     <Workout workoutActivityType="HKWorkoutActivityTypeRunning"
+ *              duration="30" durationUnit="min" totalDistance="5"
+ *              totalDistanceUnit="km" startDate="..." endDate="..."/>
+ *     ...
+ *   </HealthData>
+ *
+ * Each Record/Workout is one line in practice, so we parse line-by-line and
+ * pull attributes with a small regex — robust against attribute reordering
+ * and avoids a heavy XML dependency. `export.xml` can be large (100s of MB);
+ * v1 reads the whole file with a `maxRecords` cap. (A streaming reader is a
+ * later optimization; flagged via diagnostic when the cap truncates.)
+ *
+ * Metrics → EVENT subtype "other" (extra carries metric/value/unit).
+ * Workouts → EVENT subtype "trip" (a bounded activity with duration/distance).
+ */
+
+const fs = require("node:fs");
+const { newId } = require("../../ids");
+const { ENTITY_TYPES, EVENT_SUBTYPES, CAPTURED_BY } = require("../../constants");
+
+const NAME = "apple-health";
+const VERSION = "0.1.0";
+
+const KIND_RECORD = "record";
+const KIND_WORKOUT = "workout";
+
+// Whitelist of high-value metric types → short label. Anything not listed is
+// still ingested (label = the raw type minus the HK prefix) so the user never
+// silently loses a metric; the whitelist just gives nice names for the common
+// ones. null value = skip (too noisy / not useful for a personal profile).
+const METRIC_LABELS = Object.freeze({
+  HKQuantityTypeIdentifierStepCount: "步数",
+  HKQuantityTypeIdentifierDistanceWalkingRunning: "步行跑步距离",
+  HKQuantityTypeIdentifierFlightsClimbed: "爬楼层数",
+  HKQuantityTypeIdentifierActiveEnergyBurned: "活动能量",
+  HKQuantityTypeIdentifierBasalEnergyBurned: "静息能量",
+  HKQuantityTypeIdentifierHeartRate: "心率",
+  HKQuantityTypeIdentifierRestingHeartRate: "静息心率",
+  HKQuantityTypeIdentifierBodyMass: "体重",
+  HKQuantityTypeIdentifierHeight: "身高",
+  HKCategoryTypeIdentifierSleepAnalysis: "睡眠",
+  HKQuantityTypeIdentifierOxygenSaturation: "血氧",
+  HKQuantityTypeIdentifierBodyMassIndex: "BMI",
+  HKQuantityTypeIdentifierDietaryWater: "饮水",
+});
+
+function metricLabel(type) {
+  if (METRIC_LABELS[type]) return METRIC_LABELS[type];
+  if (typeof type !== "string") return "未知指标";
+  return type
+    .replace(/^HKQuantityTypeIdentifier/, "")
+    .replace(/^HKCategoryTypeIdentifier/, "")
+    .replace(/^HK/, "");
+}
+
+function parseAttrs(line) {
+  const attrs = {};
+  const re = /(\w+)="([^"]*)"/g;
+  let m;
+  while ((m = re.exec(line)) !== null) {
+    attrs[m[1]] = m[2];
+  }
+  return attrs;
+}
+
+function parseAppleDate(s) {
+  if (typeof s !== "string" || s.length === 0) return null;
+  const t = Date.parse(s);
+  return Number.isFinite(t) ? t : null;
+}
+
+function stableOriginalId(kind, parts) {
+  const safe = parts.filter(Boolean).join("|") || `unknown-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  return `apple-health:${kind}:${safe}`;
+}
+
+class AppleHealthAdapter {
+  constructor(opts = {}) {
+    this._inputPath = opts.inputPath || null;
+
+    this.name = NAME;
+    this.version = VERSION;
+    this.capabilities = [
+      "sync:file-import",
+      "parse:healthkit-record",
+      "parse:healthkit-workout",
+    ];
+    this.extractMode = "file-import";
+    this.rateLimits = {};
+    this.dataDisclosure = {
+      fields: [
+        "apple-health:records (步数 / 心率 / 睡眠 / 体重 / 距离 / 能量 …)",
+        "apple-health:workouts (运动类型 / 时长 / 距离 / 能量)",
+      ],
+      sensitivity: "high",
+      legalGate: false,
+    };
+
+    this._deps = { fs };
+  }
+
+  async authenticate(ctx = {}) {
+    if (ctx && ctx.readinessOnly) {
+      return {
+        ok: false,
+        reason: "NO_FILE",
+        message:
+          "apple-health: 从 iOS 健康 App 导出 export.xml 后，选择该文件即可采集",
+      };
+    }
+    const inputPath = (ctx && ctx.inputPath) || this._inputPath;
+    if (inputPath) {
+      try {
+        this._deps.fs.accessSync(inputPath, this._deps.fs.constants.R_OK);
+      } catch (err) {
+        return {
+          ok: false,
+          reason: "INPUT_PATH_UNREADABLE",
+          message: `apple-health: export.xml not readable at ${inputPath}: ${err.message}`,
+        };
+      }
+      return { ok: true, mode: "file-import" };
+    }
+    return {
+      ok: false,
+      reason: "NO_INPUT",
+      message: "apple-health.authenticate: needs opts.inputPath (export.xml)",
+    };
+  }
+
+  async healthCheck() {
+    return { ok: true, lastChecked: Date.now() };
+  }
+
+  async *sync(opts = {}) {
+    const inputPath = opts.inputPath || this._inputPath;
+    if (!inputPath) {
+      throw new Error("apple-health.sync: needs opts.inputPath (export.xml)");
+    }
+    if (!this._deps.fs.existsSync(inputPath)) return;
+
+    const maxRecords =
+      Number.isInteger(opts.maxRecords) && opts.maxRecords > 0 ? opts.maxRecords : 200_000;
+    const limit = Number.isInteger(opts.limit) && opts.limit > 0 ? opts.limit : Infinity;
+    const include = opts.include || {};
+
+    const content = this._deps.fs.readFileSync(inputPath, "utf-8");
+    const lines = content.split("\n");
+    let emitted = 0;
+    let seen = 0;
+    let truncated = false;
+
+    for (const line of lines) {
+      if (emitted >= limit) break;
+      const trimmed = line.trimStart();
+      const isRecord = trimmed.startsWith("<Record ");
+      const isWorkout = trimmed.startsWith("<Workout ");
+      if (!isRecord && !isWorkout) continue;
+      seen += 1;
+      if (seen > maxRecords) {
+        truncated = true;
+        break;
+      }
+      const attrs = parseAttrs(trimmed);
+
+      if (isRecord && include[KIND_RECORD] !== false) {
+        const occurredAt =
+          parseAppleDate(attrs.startDate) || parseAppleDate(attrs.creationDate);
+        yield {
+          adapter: NAME,
+          kind: KIND_RECORD,
+          originalId: stableOriginalId(KIND_RECORD, [
+            attrs.type,
+            attrs.startDate,
+            attrs.value,
+          ]),
+          capturedAt: occurredAt || Date.now(),
+          payload: { kind: KIND_RECORD, ...attrs },
+        };
+        emitted += 1;
+      } else if (isWorkout && include[KIND_WORKOUT] !== false) {
+        const occurredAt =
+          parseAppleDate(attrs.startDate) || parseAppleDate(attrs.creationDate);
+        yield {
+          adapter: NAME,
+          kind: KIND_WORKOUT,
+          originalId: stableOriginalId(KIND_WORKOUT, [
+            attrs.workoutActivityType,
+            attrs.startDate,
+            attrs.duration,
+          ]),
+          capturedAt: occurredAt || Date.now(),
+          payload: { kind: KIND_WORKOUT, ...attrs },
+        };
+        emitted += 1;
+      }
+    }
+
+    if (truncated && typeof opts.onProgress === "function") {
+      try {
+        opts.onProgress({
+          phase: "truncated",
+          adapter: NAME,
+          maxRecords,
+          message: `export.xml 超过 ${maxRecords} 条，已截断（提高 maxRecords 可全量导入）`,
+        });
+      } catch (_e) { /* best-effort */ }
+    }
+  }
+
+  normalize(raw) {
+    if (!raw || !raw.payload) {
+      throw new Error("AppleHealthAdapter.normalize: payload missing");
+    }
+    const kind = raw.kind || raw.payload.kind;
+    const ingestedAt = Date.now();
+    if (kind === KIND_RECORD) return normalizeRecord(raw.payload, raw, ingestedAt);
+    if (kind === KIND_WORKOUT) return normalizeWorkout(raw.payload, raw, ingestedAt);
+    throw new Error(`AppleHealthAdapter.normalize: unknown kind ${kind}`);
+  }
+}
+
+function buildSource(raw, occurredAt) {
+  return {
+    adapter: NAME,
+    adapterVersion: VERSION,
+    originalId: raw.originalId,
+    capturedAt: raw.capturedAt || occurredAt,
+    capturedBy: CAPTURED_BY.EXPORT,
+  };
+}
+
+function normalizeRecord(p, raw, ingestedAt) {
+  const occurredAt =
+    parseAppleDate(p.startDate) || parseAppleDate(p.creationDate) || raw.capturedAt || ingestedAt;
+  const source = buildSource(raw, occurredAt);
+  const label = metricLabel(p.type);
+  const value = p.value != null ? p.value : "";
+  const unit = p.unit || "";
+  return {
+    events: [{
+      id: newId(),
+      type: ENTITY_TYPES.EVENT,
+      subtype: EVENT_SUBTYPES.OTHER,
+      occurredAt,
+      actor: "person-self",
+      content: {
+        title: `${label}: ${value}${unit ? " " + unit : ""}`.trim(),
+        text: `${label} ${value} ${unit}`.trim(),
+      },
+      ingestedAt,
+      source,
+      extra: {
+        platform: "apple-health",
+        category: "health",
+        metric: p.type || null,
+        metricLabel: label,
+        value: value || null,
+        unit: unit || null,
+        sourceName: p.sourceName || null,
+        endDate: parseAppleDate(p.endDate),
+      },
+    }],
+    persons: [], places: [], items: [], topics: [],
+  };
+}
+
+function normalizeWorkout(p, raw, ingestedAt) {
+  const occurredAt =
+    parseAppleDate(p.startDate) || parseAppleDate(p.creationDate) || raw.capturedAt || ingestedAt;
+  const source = buildSource(raw, occurredAt);
+  const activity =
+    typeof p.workoutActivityType === "string"
+      ? p.workoutActivityType.replace(/^HKWorkoutActivityType/, "")
+      : "Workout";
+  const duration = p.duration ? `${p.duration}${p.durationUnit || ""}` : "";
+  const distance = p.totalDistance ? `${p.totalDistance}${p.totalDistanceUnit || ""}` : "";
+  return {
+    events: [{
+      id: newId(),
+      type: ENTITY_TYPES.EVENT,
+      subtype: EVENT_SUBTYPES.TRIP,
+      occurredAt,
+      actor: "person-self",
+      content: {
+        title: `运动: ${activity}${duration ? " " + duration : ""}${distance ? " " + distance : ""}`.trim(),
+        text: `${activity} ${duration} ${distance}`.trim(),
+      },
+      ingestedAt,
+      source,
+      extra: {
+        platform: "apple-health",
+        category: "workout",
+        activityType: activity,
+        duration: p.duration || null,
+        durationUnit: p.durationUnit || null,
+        totalDistance: p.totalDistance || null,
+        totalDistanceUnit: p.totalDistanceUnit || null,
+        totalEnergyBurned: p.totalEnergyBurned || null,
+        endDate: parseAppleDate(p.endDate),
+      },
+    }],
+    persons: [], places: [], items: [], topics: [],
+  };
+}
+
+module.exports = {
+  AppleHealthAdapter,
+  NAME,
+  VERSION,
+  _internals: { parseAttrs, parseAppleDate, metricLabel },
+};

package/lib/adapters/dingtalk-pc/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+/**
+ * 钉钉 (DingTalk) 电脑版 — honest best-effort local IM DB reader (qq-pc 模式).
+ *
+ * ⚠️ v0.1: 钉钉桌面本地库为私有结构、可能加密、随版本变化。本 adapter 做到
+ * 可靠开库 + 发现消息表 + 防御探测列 + 保留原始行 + 响亮诊断；文本解析尽力
+ * 而为，真机上按需扩展 colCandidates。建议先把库解密为明文再指向它。
+ */
+
+const { createLocalImPcAdapter } = require("../_local-im-pc-adapter");
+
+const DingTalkPcAdapter = createLocalImPcAdapter({
+  name: "dingtalk-pc",
+  platform: "dingtalk",
+  version: "0.1.0",
+  tablePattern: /msg|message|chat|conversation|im_/i,
+  colCandidates: {
+    // 钉钉常见列猜测（真机微调）
+    time: ["createAt", "create_at", "sendTime", "send_time", "msgCreateTime"],
+    sender: ["senderId", "sender", "fromUid", "creatorId"],
+    peer: ["conversationId", "cid", "openConversationId"],
+    content: ["content", "text", "msgContent", "summary"],
+  },
+  needHint:
+    "dingtalk-pc: 需提供钉钉桌面本地库路径（私有/可能加密，建议先解密为明文或提供 key）",
+});
+
+module.exports = { DingTalkPcAdapter, NAME: "dingtalk-pc", VERSION: "0.1.0" };

package/lib/adapters/edu-huawei-learning/api-client.js

@@ -0,0 +1,47 @@
+/**
+ * HuaweiLearningApiClient — FAMILY-23 v0.1 cookie-scrape（无签名）。
+ *
+ * 华为学习中心走华为账号登录；v0.1 从 accountId / userId / huaweiUid 抽数字 uid。
+ * 课程/学习时长 走 v0.2（华为教育接口 + 账号签名）。
+ */
+"use strict";
+
+class HuaweiLearningApiClient {
+  constructor() {
+    this._lastErrorCode = 0;
+    this._lastErrorMsg = "";
+  }
+  _setLastError(code, msg) {
+    this._lastErrorCode = code;
+    this._lastErrorMsg = msg;
+  }
+  _clearLastError() {
+    this._lastErrorCode = 0;
+    this._lastErrorMsg = "";
+  }
+  get lastError() {
+    return { code: this._lastErrorCode, message: this._lastErrorMsg };
+  }
+
+  /** @param {string} cookie @returns {string|null} */
+  extractUid(cookie) {
+    if (typeof cookie !== "string" || cookie.length === 0) {
+      this._setLastError(-1, "cookie 为空");
+      return null;
+    }
+    for (const key of ["accountId", "userId", "huaweiUid"]) {
+      const m = new RegExp(`(?:^|; ?)${key}=(\\d+)`).exec(cookie);
+      if (m && m[1] && m[1] !== "0") {
+        this._clearLastError();
+        return m[1];
+      }
+    }
+    this._setLastError(
+      -7,
+      "cookie 缺 accountId / userId / huaweiUid — 华为账号未登录",
+    );
+    return null;
+  }
+}
+
+module.exports = { HuaweiLearningApiClient };

package/lib/adapters/edu-huawei-learning/index.js

@@ -0,0 +1,255 @@
+/**
+ * FAMILY-23 v0.1 — 华为学习中心 (Huawei Learning Center) adapter, snapshot mode.
+ *
+ * 家庭守护 telemetry：家长看孩子的课程/学习时长。v0.1 cookie-scrape 占位 —
+ * [HuaweiLearningApiClient.extractUid] 抽 uid；snapshot 模式消费手机端 collector
+ * 快照 (profile + study-session)。课程历史 HTTP fetcher 留 v0.2，故无 inputPath 时
+ * sync 抛 NO_INPUT。
+ *
+ * Snapshot schema (v1):
+ *   { schemaVersion:1, snapshottedAt, account:{uid,displayName}, events:[
+ *     { kind:"profile", id, capturedAt, uid, nickname },
+ *     { kind:"study", id, capturedAt, course, durationMs, startAt } ] }
+ *
+ * Sensitivity: "medium"。
+ */
+"use strict";
+
+const fs = require("node:fs");
+const { newId } = require("../../ids");
+const {
+  ENTITY_TYPES,
+  PERSON_SUBTYPES,
+  EVENT_SUBTYPES,
+  CAPTURED_BY,
+} = require("../../constants");
+const { HuaweiLearningApiClient } = require("./api-client");
+
+const NAME = "edu-huawei-learning";
+const VERSION = "0.1.0";
+const SNAPSHOT_SCHEMA_VERSION = 1;
+const KIND_PROFILE = "profile";
+const KIND_STUDY = "study";
+const VALID_SNAPSHOT_KINDS = Object.freeze([KIND_PROFILE, KIND_STUDY]);
+
+function stableOriginalId(kind, id) {
+  const safe =
+    (typeof id === "string" && id.length > 0 && id) ||
+    (typeof id === "number" && Number.isFinite(id) && String(id)) ||
+    `unknown-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  return `huaweilearning:${kind}:${safe}`;
+}
+
+function parseTime(v) {
+  if (Number.isFinite(v)) return v > 1e12 ? v : v * 1000;
+  if (typeof v === "string") {
+    if (/^\d+$/.test(v)) {
+      const n = parseInt(v, 10);
+      return n > 1e12 ? n : n * 1000;
+    }
+    const t = Date.parse(v);
+    return Number.isFinite(t) ? t : null;
+  }
+  return null;
+}
+
+class HuaweiLearningAdapter {
+  constructor(opts = {}) {
+    this.account = opts.account || null;
+    this.name = NAME;
+    this.version = VERSION;
+    this.capabilities = [
+      "sync:snapshot",
+      "parse:huawei-learning-profile",
+      "parse:huawei-learning-study-session",
+    ];
+    this.extractMode = "web-api";
+    this.rateLimits = {};
+    this.dataDisclosure = {
+      fields: [
+        "huawei-learning:profile (uid / nickname)",
+        "huawei-learning:study_session (course / start / duration)",
+      ],
+      sensitivity: "medium",
+      legalGate: false,
+      defaultInclude: { profile: true, study: true },
+    };
+    this.apiClient = new HuaweiLearningApiClient();
+    this._deps = { fs };
+  }
+
+  async authenticate(ctx = {}) {
+    if (ctx && typeof ctx.inputPath === "string" && ctx.inputPath.length > 0) {
+      try {
+        this._deps.fs.accessSync(ctx.inputPath, this._deps.fs.constants.R_OK);
+      } catch (err) {
+        return {
+          ok: false,
+          reason: "INPUT_PATH_UNREADABLE",
+          message: `snapshot not readable at ${ctx.inputPath}: ${err.message}`,
+        };
+      }
+      return { ok: true, mode: "snapshot-file" };
+    }
+    return {
+      ok: false,
+      reason: "NO_INPUT",
+      message:
+        "edu-huawei-learning.authenticate: v0.1 needs opts.inputPath (snapshot mode); live HTTP fetcher 待 v0.2",
+    };
+  }
+
+  async healthCheck() {
+    return { ok: true, lastChecked: Date.now() };
+  }
+
+  async *sync(opts = {}) {
+    if (typeof opts.inputPath === "string" && opts.inputPath.length > 0) {
+      yield* this._syncViaSnapshot(opts);
+      return;
+    }
+    throw new Error(
+      "edu-huawei-learning.sync: v0.1 needs opts.inputPath (snapshot mode); 课程历史 HTTP fetcher 待 v0.2",
+    );
+  }
+
+  async *_syncViaSnapshot(opts) {
+    const raw = this._deps.fs.readFileSync(opts.inputPath, "utf-8");
+    const snapshot = JSON.parse(raw);
+    if (
+      !snapshot ||
+      typeof snapshot !== "object" ||
+      snapshot.schemaVersion !== SNAPSHOT_SCHEMA_VERSION
+    ) {
+      throw new Error(
+        `edu-huawei-learning.sync: snapshot schemaVersion mismatch (got ${snapshot && snapshot.schemaVersion}, expected ${SNAPSHOT_SCHEMA_VERSION})`,
+      );
+    }
+    const fallbackCapturedAt =
+      Number.isFinite(snapshot.snapshottedAt) && snapshot.snapshottedAt > 0
+        ? Math.floor(snapshot.snapshottedAt)
+        : Date.now();
+    const account =
+      snapshot.account && typeof snapshot.account === "object"
+        ? snapshot.account
+        : null;
+    const include = opts.include || {};
+    const limit =
+      Number.isInteger(opts.limit) && opts.limit > 0 ? opts.limit : Infinity;
+    const events = Array.isArray(snapshot.events) ? snapshot.events : [];
+    let emitted = 0;
+    for (const ev of events) {
+      if (emitted >= limit) return;
+      if (!ev || typeof ev !== "object") continue;
+      const kind = ev.kind;
+      if (!VALID_SNAPSHOT_KINDS.includes(kind)) continue;
+      if (include[kind] === false) continue;
+      const capturedAt = parseTime(ev.capturedAt) || fallbackCapturedAt;
+      const id =
+        (typeof ev.id === "string" && ev.id.length > 0 && ev.id) ||
+        ev.uid ||
+        null;
+      yield {
+        adapter: NAME,
+        kind,
+        originalId: stableOriginalId(kind, id),
+        capturedAt,
+        payload: { ...ev, account },
+      };
+      emitted += 1;
+    }
+  }
+
+  normalize(raw) {
+    if (!raw || !raw.payload) {
+      throw new Error("HuaweiLearningAdapter.normalize: payload missing");
+    }
+    const ingestedAt = Date.now();
+    const kind = raw.kind || raw.payload.kind;
+    const p = raw.payload;
+    if (kind === KIND_PROFILE) return normalizeProfile(p, raw, ingestedAt);
+    if (kind === KIND_STUDY) return normalizeStudy(p, raw, ingestedAt);
+    throw new Error(`HuaweiLearningAdapter.normalize: unknown kind ${kind}`);
+  }
+}
+
+function buildSource(raw, occurredAt) {
+  return {
+    adapter: NAME,
+    adapterVersion: VERSION,
+    originalId: raw.originalId,
+    capturedAt: raw.capturedAt || occurredAt,
+    capturedBy: CAPTURED_BY.API,
+  };
+}
+
+function normalizeProfile(p, raw, ingestedAt) {
+  const uid = p.uid || (p.account && p.account.uid) || null;
+  const nickname =
+    p.nickname || (p.account && p.account.displayName) || "(unnamed)";
+  const occurredAt = parseTime(p.capturedAt) || raw.capturedAt || ingestedAt;
+  const identifiers = {};
+  if (uid) identifiers["huawei-learning-uid"] = [String(uid)];
+  return {
+    events: [],
+    persons: [
+      {
+        id: uid
+          ? `person-huaweilearning-${uid}`
+          : `person-huaweilearning-self-${newId()}`,
+        type: ENTITY_TYPES.PERSON,
+        subtype: PERSON_SUBTYPES.SELF,
+        names: [nickname],
+        ingestedAt,
+        source: buildSource(raw, occurredAt),
+        identifiers,
+        extra: { platform: "huawei-learning", snapshottedAt: occurredAt },
+      },
+    ],
+    places: [],
+    items: [],
+    topics: [],
+  };
+}
+
+function normalizeStudy(p, raw, ingestedAt) {
+  const occurredAt =
+    parseTime(p.startAt) ||
+    parseTime(p.capturedAt) ||
+    raw.capturedAt ||
+    ingestedAt;
+  return {
+    events: [
+      {
+        id: newId(),
+        type: ENTITY_TYPES.EVENT,
+        subtype: EVENT_SUBTYPES.OTHER,
+        occurredAt,
+        actor: "person-self",
+        content: { title: "华为学习中心 学习" },
+        ingestedAt,
+        source: buildSource(raw, occurredAt),
+        extra: {
+          platform: "huawei-learning",
+          kind: "study",
+          course: p.course || null,
+          durationMs: Number.isFinite(p.durationMs) ? p.durationMs : 0,
+        },
+      },
+    ],
+    persons: [],
+    places: [],
+    items: [],
+    topics: [],
+  };
+}
+
+module.exports = {
+  HuaweiLearningAdapter,
+  NAME,
+  VERSION,
+  SNAPSHOT_SCHEMA_VERSION,
+  VALID_SNAPSHOT_KINDS,
+  KIND_PROFILE,
+  KIND_STUDY,
+};