@chainlesschain/personal-data-hub 0.1.0 → 0.2.0

package/__tests__/social-adapters.test.js

@@ -0,0 +1,206 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const { BilibiliAdapter, WeiboAdapter } = require("../lib");
+const { assertAdapter } = require("../lib/adapter-spec");
+const { validateBatch } = require("../lib/batch");
+
+function makeMockDriver(scriptedRows) {
+  return function () {
+    return {
+      prepare(sql) {
+        return {
+          all() {
+            for (const [matchSubstr, rows] of scriptedRows) {
+              if (sql.includes(matchSubstr)) return rows;
+            }
+            throw new Error("no such table");
+          },
+        };
+      },
+      close() {},
+    };
+  };
+}
+
+// ─── BilibiliAdapter ────────────────────────────────────────────────────
+
+describe("BilibiliAdapter", () => {
+  it("contract conformance", () => {
+    const a = new BilibiliAdapter({ account: { uid: "1234" } });
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.extractMode).toBe("device-pull");
+  });
+
+  it("rejects missing account.uid", () => {
+    expect(() => new BilibiliAdapter({})).toThrow();
+    expect(() => new BilibiliAdapter({ account: {} })).toThrow(/uid/);
+  });
+
+  it("sync yields history + favourite records via mocked driver", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bili-"));
+    const dbPath = path.join(dir, "bili.db");
+    fs.writeFileSync(dbPath, "fake");
+    try {
+      const mockDriver = makeMockDriver([
+        ["FROM history", [
+          { id: 1, bvid: "BV1abc", title: "趣味视频", view_at: 1700000000, uploader: "UpA" },
+          { id: 2, bvid: "BV1xyz", title: "教程", view_at: 1700000010, uploader: "UpB", duration: 300 },
+        ]],
+        ["FROM bili_favourite", [
+          { id: 1, bvid: "BV1fav", title: "收藏A", save_time: 1700001000, folder_name: "学习" },
+        ]],
+      ]);
+      const a = new BilibiliAdapter({
+        account: { uid: "1234" },
+        dbPath,
+        dbDriverFactory: () => mockDriver,
+      });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws.length).toBe(3); // 2 history + 1 favourite
+      const histories = raws.filter((r) => r.payload.kind === "history");
+      const favs = raws.filter((r) => r.payload.kind === "favourite");
+      expect(histories).toHaveLength(2);
+      expect(favs).toHaveLength(1);
+
+      // Normalize each
+      for (const raw of raws) {
+        const batch = a.normalize(raw);
+        const v = validateBatch(batch);
+        expect(v.valid).toBe(true);
+        const subtype = batch.events[0].subtype;
+        if (raw.payload.kind === "history") expect(subtype).toBe("browse");
+        if (raw.payload.kind === "favourite") expect(subtype).toBe("like");
+      }
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("idle when DB path missing", async () => {
+    const a = new BilibiliAdapter({ account: { uid: "1234" } });
+    const raws = [];
+    for await (const r of a.sync()) raws.push(r);
+    expect(raws).toHaveLength(0);
+  });
+
+  it("normalize captures bvid/avid/uploader into extra", async () => {
+    const a = new BilibiliAdapter({ account: { uid: "1234" } });
+    const raw = {
+      adapter: "social-bilibili",
+      originalId: "history-1",
+      capturedAt: 1700000000000,
+      payload: {
+        kind: "history",
+        row: {
+          id: 1, bvid: "BV1abc", avid: "1234",
+          title: "Test", view_at: 1700000000,
+          uploader: "UpA", duration: 300,
+        },
+      },
+    };
+    const batch = a.normalize(raw);
+    expect(batch.events[0].extra.bvid).toBe("BV1abc");
+    expect(batch.events[0].extra.avid).toBe("1234");
+    expect(batch.events[0].extra.uploader).toBe("UpA");
+    expect(batch.events[0].extra.duration).toBe(300);
+  });
+});
+
+// ─── WeiboAdapter ───────────────────────────────────────────────────────
+
+describe("WeiboAdapter", () => {
+  it("contract conformance", () => {
+    const a = new WeiboAdapter({ account: { uid: "1234" } });
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.extractMode).toBe("device-pull");
+  });
+
+  it("rejects missing account.uid", () => {
+    expect(() => new WeiboAdapter({})).toThrow();
+    expect(() => new WeiboAdapter({ account: {} })).toThrow(/uid/);
+  });
+
+  it("sync yields posts + search records via mocked driver", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "weibo-"));
+    const dbPath = path.join(dir, "weibo.db");
+    fs.writeFileSync(dbPath, "fake");
+    try {
+      const mockDriver = makeMockDriver([
+        ["FROM post", [
+          { id: 1, mid: "M1", text: "今天天气真好", created_at: 1700000000, reposts_count: 5, comments_count: 3 },
+        ]],
+        ["FROM status", []],
+        ["FROM search_history", [
+          { id: 1, keyword: "iPhone", time: 1700001000 },
+          { id: 2, keyword: "音乐", time: 1700001100 },
+        ]],
+      ]);
+      const a = new WeiboAdapter({
+        account: { uid: "1234" },
+        dbPath,
+        dbDriverFactory: () => mockDriver,
+      });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws.length).toBe(3); // 1 post + 2 searches
+
+      for (const raw of raws) {
+        const batch = a.normalize(raw);
+        const v = validateBatch(batch);
+        expect(v.valid).toBe(true);
+        const subtype = batch.events[0].subtype;
+        if (raw.payload.kind === "post") expect(subtype).toBe("post");
+        if (raw.payload.kind === "search") expect(subtype).toBe("interaction");
+      }
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("normalize captures post metrics", async () => {
+    const a = new WeiboAdapter({ account: { uid: "1234" } });
+    const raw = {
+      adapter: "social-weibo",
+      originalId: "post-M1",
+      capturedAt: 1700000000000,
+      payload: {
+        kind: "post",
+        row: {
+          id: 1, mid: "M1", text: "测试",
+          created_at: 1700000000,
+          reposts_count: 5, comments_count: 3, attitudes_count: 10,
+          location: "上海",
+        },
+      },
+    };
+    const batch = a.normalize(raw);
+    expect(batch.events[0].extra.weiboMid).toBe("M1");
+    expect(batch.events[0].extra.repostsCount).toBe(5);
+    expect(batch.events[0].extra.commentsCount).toBe(3);
+    expect(batch.events[0].extra.likesCount).toBe(10);
+    expect(batch.events[0].extra.location).toBe("上海");
+  });
+
+  it("normalize falls back when text is empty", async () => {
+    const a = new WeiboAdapter({ account: { uid: "1234" } });
+    const raw = {
+      adapter: "social-weibo",
+      originalId: "post-x",
+      capturedAt: Date.now(),
+      payload: {
+        kind: "post",
+        row: { id: 1, mid: "X", text: "", created_at: Math.floor(Date.now() / 1000) },
+      },
+    };
+    const batch = a.normalize(raw);
+    expect(batch.events[0].content.title).toBe("(空)");
+    expect(validateBatch(batch).valid).toBe(true);
+  });
+});

package/__tests__/travel-adapters.test.js

@@ -0,0 +1,325 @@
+"use strict";
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  normalizeTravelRecord,
+  parseChineseDateTime,
+  Train12306Adapter,
+  CtripAdapter,
+  AmapAdapter,
+  BaiduMapAdapter,
+} = require("../lib");
+const { parseRecords: parse12306 } = require("../lib/adapters/travel-12306");
+const { parseRecords: parseCtripRecords, TYPE_MAP: CTRIP_TYPE_MAP } = require("../lib/adapters/travel-ctrip");
+const { assertAdapter } = require("../lib/adapter-spec");
+const { validateBatch } = require("../lib/batch");
+
+// ─── travel-base ────────────────────────────────────────────────────────
+
+describe("parseChineseDateTime", () => {
+  it("YYYY-MM-DD HH:MM:SS", () => {
+    const ms = parseChineseDateTime("2026-04-15 14:30:00");
+    expect(new Date(ms).getFullYear()).toBe(2026);
+    expect(new Date(ms).getMonth()).toBe(3);
+    expect(new Date(ms).getDate()).toBe(15);
+    expect(new Date(ms).getHours()).toBe(14);
+  });
+
+  it("YYYY/MM/DD HH:MM", () => {
+    const ms = parseChineseDateTime("2026/04/15 09:00");
+    expect(new Date(ms).getMonth()).toBe(3);
+  });
+
+  it("YYYY年M月D日 HH:MM", () => {
+    const ms = parseChineseDateTime("2026年4月15日 14:30");
+    expect(new Date(ms).getMonth()).toBe(3);
+    expect(new Date(ms).getDate()).toBe(15);
+  });
+
+  it("YYYY年M月D日 (no time)", () => {
+    const ms = parseChineseDateTime("2026年4月15日");
+    expect(new Date(ms).getMonth()).toBe(3);
+  });
+
+  it("invalid input → null", () => {
+    expect(parseChineseDateTime("")).toBeNull();
+    expect(parseChineseDateTime(null)).toBeNull();
+    expect(parseChineseDateTime("notadate")).toBeNull();
+  });
+});
+
+describe("normalizeTravelRecord", () => {
+  it("produces Event + Places + carrier Person", () => {
+    const rec = {
+      vendorId: "12306",
+      recordId: "ORDER-1",
+      vehicleType: "train",
+      from: { station: "上海虹桥", city: "上海" },
+      to: { station: "北京南", city: "北京" },
+      departureMs: new Date(2026, 3, 15, 9).getTime(),
+      arrivalMs: new Date(2026, 3, 15, 14).getTime(),
+      carrier: "12306",
+      vehicleNumber: "G2",
+      totalCost: { value: 553.5, currency: "CNY" },
+      traveler: "张三",
+      confirmationCode: "E123456789",
+    };
+    const b = normalizeTravelRecord(rec, { adapterName: "travel-12306", adapterVersion: "0.5.0" });
+    expect(b.events).toHaveLength(1);
+    expect(b.events[0].subtype).toBe("trip");
+    expect(b.events[0].content.title).toContain("train:");
+    expect(b.events[0].content.amount.value).toBe(553.5);
+    expect(b.events[0].extra.vehicleNumber).toBe("G2");
+    expect(b.events[0].extra.arrivalMs).toBe(rec.arrivalMs);
+    expect(b.places).toHaveLength(2);
+    expect(b.persons.some((p) => p.subtype === "merchant")).toBe(true);
+    const v = validateBatch(b);
+    expect(v.valid).toBe(true);
+  });
+
+  it("missing record id throws", () => {
+    expect(() => normalizeTravelRecord({})).toThrow();
+  });
+
+  it("traveler that matches selfName not added as Person", () => {
+    const b = normalizeTravelRecord(
+      { vendorId: "12306", recordId: "X", vehicleType: "train", traveler: "自己" },
+      { adapterName: "travel-12306", selfName: "自己" },
+    );
+    expect(b.persons.find((p) => p.extra && p.extra.role === "traveler")).toBeUndefined();
+  });
+});
+
+// ─── 12306 adapter ──────────────────────────────────────────────────────
+
+describe("Train12306Adapter", () => {
+  it("adapter contract conformance", () => {
+    const a = new Train12306Adapter({ account: { username: "test" } });
+    const r = assertAdapter(a);
+    expect(r.ok).toBe(true);
+    if (!r.ok) console.log(r.errors);
+    expect(a.extractMode).toBe("file-import");
+  });
+
+  it("parseRecords parses JSON array", () => {
+    const json = JSON.stringify([
+      {
+        orderId: "ORD-1", trainNumber: "G2",
+        fromStation: "上海虹桥", toStation: "北京南",
+        departureTime: "2026-04-15 09:00:00",
+        arrivalTime: "2026-04-15 14:00:00",
+        passengerName: "张三", price: "553.5",
+        ticketNumber: "T-1",
+        seatNumber: "01车05A号", seat: "二等座",
+      },
+    ]);
+    const recs = parse12306(json);
+    expect(recs).toHaveLength(1);
+    expect(recs[0].vehicleType).toBe("train");
+    expect(recs[0].vehicleNumber).toBe("G2");
+    expect(recs[0].departureMs).toBeGreaterThan(0);
+  });
+
+  it("parseRecords handles JSONL format", () => {
+    const jsonl = '{"orderId":"a","trainNumber":"G1","fromStation":"X","toStation":"Y","passengerName":"p","ticketNumber":"t1"}\n{"orderId":"b","trainNumber":"G2","fromStation":"X","toStation":"Y","passengerName":"p","ticketNumber":"t2"}';
+    const recs = parse12306(jsonl);
+    expect(recs).toHaveLength(2);
+  });
+
+  it("sync yields raw events from a file", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "12306-"));
+    const dataPath = path.join(dir, "12306.json");
+    fs.writeFileSync(dataPath, JSON.stringify([
+      { orderId: "x", trainNumber: "G3", fromStation: "上海虹桥", toStation: "北京南", passengerName: "张三", ticketNumber: "tx" },
+    ]));
+    try {
+      const a = new Train12306Adapter({ account: { username: "test" }, dataPath });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws).toHaveLength(1);
+      expect(raws[0].adapter).toBe("travel-12306");
+      const batch = a.normalize(raws[0]);
+      const v = validateBatch(batch);
+      expect(v.valid).toBe(true);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("rejects missing account.username", () => {
+    expect(() => new Train12306Adapter({})).toThrow();
+    expect(() => new Train12306Adapter({ account: {} })).toThrow(/username/);
+  });
+});
+
+// ─── Ctrip adapter ───────────────────────────────────────────────────────
+
+describe("CtripAdapter", () => {
+  it("adapter contract", () => {
+    const a = new CtripAdapter({ account: { email: "test@example.com" } });
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.extractMode).toBe("file-import");
+  });
+
+  it("parseRecords maps Ctrip flight type", () => {
+    const json = JSON.stringify([
+      {
+        orderId: "C-1", type: "flight",
+        depCity: "上海", arrCity: "北京",
+        flightNumber: "CA1234",
+        airline: "中国国际航空",
+        departureTime: "2026-04-15 09:00:00",
+        arrivalTime: "2026-04-15 11:30:00",
+        passengerName: "张三",
+        price: 1234.5,
+        pnr: "ABC123",
+      },
+    ]);
+    const recs = parseCtripRecords(json);
+    expect(recs[0].vehicleType).toBe("flight");
+    expect(recs[0].vehicleNumber).toBe("CA1234");
+    expect(recs[0].carrier).toBe("中国国际航空");
+  });
+
+  it("parseRecords maps Ctrip hotel type", () => {
+    const json = JSON.stringify([
+      {
+        orderId: "H-1", type: "hotel",
+        hotelCity: "上海", hotelName: "外滩英迪格酒店",
+        checkIn: "2026-04-15", checkOut: "2026-04-17",
+        guestName: "张三", price: 1980, nights: 2,
+      },
+    ]);
+    const recs = parseCtripRecords(json);
+    expect(recs[0].vehicleType).toBe("hotel");
+    expect(recs[0].carrier).toBe("外滩英迪格酒店");
+    expect(recs[0].extras.nights).toBe(2);
+  });
+
+  it("TYPE_MAP covers expected types", () => {
+    expect(CTRIP_TYPE_MAP.flight).toBe("flight");
+    expect(CTRIP_TYPE_MAP.hotel).toBe("hotel");
+    expect(CTRIP_TYPE_MAP.train).toBe("train");
+    expect(CTRIP_TYPE_MAP.cruise).toBe("cruise");
+  });
+});
+
+// ─── Amap adapter (mocked SQLite) ───────────────────────────────────────
+
+describe("AmapAdapter", () => {
+  it("adapter contract", () => {
+    const a = new AmapAdapter({ account: { deviceId: "dev-1" } });
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.extractMode).toBe("device-pull");
+  });
+
+  it("sync yields route + search records via mocked driver", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "amap-"));
+    const dbPath = path.join(dir, "amap.db");
+    fs.writeFileSync(dbPath, "fake");
+
+    const mockDriver = function (path, opts) {
+      return {
+        prepare(sql) {
+          return {
+            all() {
+              if (sql.includes("history_route")) {
+                return [
+                  { id: "r1", from_name: "上海", to_name: "北京", time: 1700000000000, mode: "drive" },
+                ];
+              }
+              if (sql.includes("history_search")) {
+                return [
+                  { id: "s1", keyword: "外滩", time: 1700000001000, lat: 31.23, lng: 121.49 },
+                ];
+              }
+              throw new Error("no such table");
+            },
+          };
+        },
+        close() {},
+      };
+    };
+
+    try {
+      const a = new AmapAdapter({
+        account: { deviceId: "dev-1" },
+        dbPath,
+        dbDriverFactory: () => mockDriver,
+      });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws.length).toBeGreaterThan(0);
+      const route = raws.find((r) => r.payload.kind === "route");
+      const search = raws.find((r) => r.payload.kind === "search");
+      expect(route).toBeDefined();
+      expect(search).toBeDefined();
+      // Normalize succeeds + validates
+      const batch = a.normalize(route);
+      const v = validateBatch(batch);
+      expect(v.valid).toBe(true);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+// ─── BaiduMap adapter (mocked SQLite) ────────────────────────────────────
+
+describe("BaiduMapAdapter", () => {
+  it("adapter contract", () => {
+    const a = new BaiduMapAdapter({ account: { deviceId: "dev-1" } });
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.extractMode).toBe("device-pull");
+  });
+
+  it("sync yields route from mocked driver", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bd-"));
+    const dbPath = path.join(dir, "baidu.db");
+    fs.writeFileSync(dbPath, "fake");
+
+    const mockDriver = function () {
+      return {
+        prepare(sql) {
+          return {
+            all() {
+              if (sql.includes("route_history")) {
+                return [
+                  { _id: 1, start_name: "上海", end_name: "杭州", time: 1700000000, type: "drive" },
+                ];
+              }
+              if (sql.includes("search_history")) {
+                return [
+                  { _id: 2, key: "西湖", time: 1700000001 },
+                ];
+              }
+              throw new Error("no such table");
+            },
+          };
+        },
+        close() {},
+      };
+    };
+
+    try {
+      const a = new BaiduMapAdapter({
+        account: { deviceId: "dev-1" },
+        dbPath,
+        dbDriverFactory: () => mockDriver,
+      });
+      const raws = [];
+      for await (const r of a.sync()) raws.push(r);
+      expect(raws.length).toBeGreaterThan(0);
+      const batch = a.normalize(raws[0]);
+      const v = validateBatch(batch);
+      expect(v.valid).toBe(true);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/__tests__/vault.test.js

@@ -104,7 +104,7 @@ afterEach(() => {
 describe("LocalVault open + migrations", () => {
   it("opens a fresh vault and runs initial migrations", () => {
     freshVault();
-    expect(vault.schemaVersion()).toBe(1);
+    expect(vault.schemaVersion()).toBe(2);
     expect(fs.existsSync(vaultPath)).toBe(true);
   });
 
@@ -116,7 +116,7 @@ describe("LocalVault open + migrations", () => {
 
     const reopen = new LocalVault({ path: vaultPath, key, skipAudit: true });
     reopen.open();
-    expect(reopen.schemaVersion()).toBe(1);
+    expect(reopen.schemaVersion()).toBe(2);
     expect(reopen.stats().persons).toBe(1);
     reopen.close();
   });
@@ -494,7 +494,7 @@ describe("LocalVault.stats", () => {
     vault.audit("hello");
 
     const s = vault.stats();
-    expect(s.schemaVersion).toBe(1);
+    expect(s.schemaVersion).toBe(2);
     expect(s.events).toBe(3);
     expect(s.persons).toBe(1);
     expect(s.places).toBe(2);