@chainlesschain/personal-data-hub 0.2.1 → 0.2.3

package/__tests__/social-bilibili-snapshot.test.js

@@ -0,0 +1,278 @@
+"use strict";
+
+import { describe, it, expect, beforeEach } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  BilibiliAdapter,
+  SNAPSHOT_SCHEMA_VERSION,
+  VALID_KINDS,
+} = require("../lib/adapters/social-bilibili");
+const { validateBatch } = require("../lib/batch");
+
+// A8 v0.1 (2026-05-22) — snapshot-mode tests, mirroring system-data-android.
+//
+// Why a separate file? `social-adapters.test.js` covers the legacy sqlite
+// path (Phase 7.5 device-pull). Snapshot mode is a brand-new ingestion path
+// driven by in-APK Android cc reading JSON from the phone's own WebView+OkHttp
+// pipeline. Keeping tests separated makes it obvious which mode a regression
+// belongs to.
+
+function writeSnapshot(dir, snapshot) {
+  const p = path.join(dir, "social-bilibili.json");
+  fs.writeFileSync(p, JSON.stringify(snapshot), "utf-8");
+  return p;
+}
+
+describe("BilibiliAdapter snapshot mode", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bili-snap-"));
+  });
+
+  it("exports SNAPSHOT_SCHEMA_VERSION = 1 + 4 VALID_KINDS", () => {
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+    expect(VALID_KINDS).toEqual(["history", "favourite", "dynamic", "follow"]);
+  });
+
+  it("authenticate(inputPath) ok when readable", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new BilibiliAdapter();
+    const res = await a.authenticate({ inputPath: p });
+    expect(res.ok).toBe(true);
+    expect(res.mode).toBe("snapshot-file");
+  });
+
+  it("authenticate(inputPath) fails when path unreadable", async () => {
+    const a = new BilibiliAdapter();
+    const res = await a.authenticate({ inputPath: path.join(tmpDir, "missing.json") });
+    expect(res.ok).toBe(false);
+    expect(res.reason).toBe("INPUT_PATH_UNREADABLE");
+  });
+
+  it("authenticate() with neither inputPath nor dbPath returns NO_INPUT", async () => {
+    const a = new BilibiliAdapter();
+    const res = await a.authenticate({});
+    expect(res.ok).toBe(false);
+    expect(res.reason).toBe("NO_INPUT");
+  });
+
+  it("rejects schemaVersion mismatch", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 99,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new BilibiliAdapter();
+    let threw = null;
+    try {
+      for await (const _r of a.sync({ inputPath: p })) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(threw).toBeTruthy();
+    expect(String(threw.message)).toMatch(/schemaVersion mismatch/);
+  });
+
+  it("empty events array yields nothing (no crash)", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws).toHaveLength(0);
+  });
+
+  it("yields all 4 kinds + normalize produces valid batches", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: 1716000000000,
+      account: { uid: "12345", displayName: "alice" },
+      events: [
+        {
+          kind: "history",
+          id: "BV1abc",
+          capturedAt: 1715000000000,
+          title: "Rust 异步学习",
+          bvid: "BV1abc",
+          avid: 42,
+          duration: 600,
+          uploader: "技术UP主",
+          uploaderMid: 100,
+          part: "01 介绍",
+        },
+        {
+          kind: "favourite",
+          id: "fav-BV2def",
+          capturedAt: 1714000000000,
+          title: "前端架构",
+          bvid: "BV2def",
+          folderName: "学习",
+          uploader: "码农UP",
+        },
+        {
+          kind: "dynamic",
+          id: "dyn-99",
+          capturedAt: 1713000000000,
+          summary: "今天发了一个新视频",
+          dynamicType: "video",
+          rid: 99,
+          authorMid: 200,
+          authorName: "我关注的UP",
+        },
+        {
+          kind: "follow",
+          id: "follow-300",
+          capturedAt: 1712000000000,
+          mid: 300,
+          uname: "美食UP",
+          face: "https://i0.hdslb.com/...",
+          sign: "好吃的视频",
+        },
+      ],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+
+    expect(raws).toHaveLength(4);
+    expect(raws.map((r) => r.kind).sort()).toEqual([
+      "dynamic",
+      "favourite",
+      "follow",
+      "history",
+    ]);
+    // Stable originalId format
+    expect(raws.find((r) => r.kind === "history").originalId).toBe("bilibili:history:BV1abc");
+    expect(raws.find((r) => r.kind === "favourite").originalId).toBe("bilibili:favourite:fav-BV2def");
+    expect(raws.find((r) => r.kind === "dynamic").originalId).toBe("bilibili:dynamic:dyn-99");
+    expect(raws.find((r) => r.kind === "follow").originalId).toBe("bilibili:follow:follow-300");
+
+    // Normalize each + validate
+    for (const raw of raws) {
+      const batch = a.normalize(raw);
+      const v = validateBatch(batch);
+      expect(v.valid).toBe(true);
+
+      if (raw.kind === "history") {
+        expect(batch.events[0].subtype).toBe("browse");
+        expect(batch.events[0].extra.bvid).toBe("BV1abc");
+        expect(batch.events[0].extra.duration).toBe(600);
+        expect(batch.items).toHaveLength(1);
+        expect(batch.items[0].name).toBe("Rust 异步学习");
+      } else if (raw.kind === "favourite") {
+        expect(batch.events[0].subtype).toBe("like");
+        expect(batch.events[0].extra.folderName).toBe("学习");
+        expect(batch.items).toHaveLength(1);
+      } else if (raw.kind === "dynamic") {
+        expect(batch.events[0].subtype).toBe("browse");
+        expect(batch.events[0].extra.dynamicType).toBe("video");
+        expect(batch.events[0].extra.authorName).toBe("我关注的UP");
+      } else if (raw.kind === "follow") {
+        // Follow yields a person, not an event
+        expect(batch.events).toHaveLength(0);
+        expect(batch.persons).toHaveLength(1);
+        expect(batch.persons[0].names[0]).toBe("美食UP");
+        expect(batch.persons[0].identifiers["bilibili-mid"]).toEqual(["300"]);
+      }
+    }
+  });
+
+  it("per-kind include filter (e.g. include.follow=false drops follows)", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [
+        { kind: "history", id: "h1", title: "x" },
+        { kind: "follow", id: "f1", mid: 1, uname: "u" },
+      ],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p, include: { follow: false } })) {
+      raws.push(r);
+    }
+    expect(raws).toHaveLength(1);
+    expect(raws[0].kind).toBe("history");
+  });
+
+  it("limit caps emission", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [
+        { kind: "history", id: "1", title: "a" },
+        { kind: "history", id: "2", title: "b" },
+        { kind: "history", id: "3", title: "c" },
+      ],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p, limit: 2 })) raws.push(r);
+    expect(raws).toHaveLength(2);
+  });
+
+  it("skips unknown kinds (forward-compat with future event types)", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [
+        { kind: "history", id: "1", title: "ok" },
+        { kind: "fancy-new-kind-from-future", id: "x", data: "?" },
+        { kind: "favourite", id: "f", title: "also ok" },
+      ],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws).toHaveLength(2);
+    expect(raws.map((r) => r.kind).sort()).toEqual(["favourite", "history"]);
+  });
+
+  it("uses fallback originalId when event.id absent (no crash, still ingestable)", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [
+        // Missing id — adapter should derive from bvid/mid/rid or generate fallback
+        { kind: "history", bvid: "BV1xyz", title: "no-id" },
+        { kind: "follow", mid: 999, uname: "with-mid-no-id" },
+        { kind: "dynamic", summary: "no id no rid" },
+      ],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws).toHaveLength(3);
+    // history derives from bvid
+    expect(raws[0].originalId).toBe("bilibili:history:BV1xyz");
+    // follow derives from mid
+    expect(raws[1].originalId).toBe("bilibili:follow:999");
+    // dynamic with no id/bvid/mid/rid → fallback unknown- prefix
+    expect(raws[2].originalId).toMatch(/^bilibili:dynamic:unknown-/);
+  });
+
+  it("snapshot account propagates to payload (Path Y can re-attribute later)", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      account: { uid: "55555", displayName: "tester" },
+      events: [{ kind: "history", id: "1", title: "x" }],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws).toHaveLength(1);
+    expect(raws[0].payload.account.uid).toBe("55555");
+  });
+});

package/__tests__/social-douyin-snapshot.test.js

@@ -0,0 +1,253 @@
+"use strict";
+
+import { describe, it, expect, beforeEach } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  DouyinAdapter,
+  SNAPSHOT_SCHEMA_VERSION,
+  VALID_SNAPSHOT_KINDS,
+} = require("../lib/adapters/social-douyin");
+const { validateBatch } = require("../lib/batch");
+
+// §A8 v0.2 — Douyin snapshot mode tests, mirror of social-weibo-snapshot.
+//
+// Snapshot mode is in-APK Android cc reading JSON written by
+// DouyinLocalCollector (WebView cookie + 1 endpoint `passport/account/info/v2/`
+// that works without X-Bogus). v0.2 SURFACE = profile kind only;
+// history/favourite/like kinds are reserved in VALID_SNAPSHOT_KINDS for v0.3
+// (X-Bogus path).
+
+function writeSnapshot(dir, snapshot) {
+  const p = path.join(dir, "social-douyin.json");
+  fs.writeFileSync(p, JSON.stringify(snapshot), "utf-8");
+  return p;
+}
+
+describe("DouyinAdapter snapshot mode", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "douyin-snap-"));
+  });
+
+  it("exports SNAPSHOT_SCHEMA_VERSION = 1 + 4 VALID_SNAPSHOT_KINDS", () => {
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+    // v0.2 emits only profile; v0.3 will add history/favourite/like.
+    expect(VALID_SNAPSHOT_KINDS).toEqual([
+      "profile",
+      "history",
+      "favourite",
+      "like",
+    ]);
+  });
+
+  it("authenticate(inputPath) ok when readable", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new DouyinAdapter();
+    const res = await a.authenticate({ inputPath: p });
+    expect(res.ok).toBe(true);
+    expect(res.mode).toBe("snapshot-file");
+  });
+
+  it("authenticate(inputPath) fails when path unreadable", async () => {
+    const a = new DouyinAdapter();
+    const res = await a.authenticate({ inputPath: path.join(tmpDir, "missing.json") });
+    expect(res.ok).toBe(false);
+    expect(res.reason).toBe("INPUT_PATH_UNREADABLE");
+  });
+
+  it("authenticate() with neither inputPath nor dbPath returns NO_INPUT", async () => {
+    const a = new DouyinAdapter();
+    const res = await a.authenticate({});
+    expect(res.ok).toBe(false);
+    expect(res.reason).toBe("NO_INPUT");
+  });
+
+  it("rejects schemaVersion mismatch", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 99,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new DouyinAdapter();
+    let threw = null;
+    try {
+      for await (const _r of a.sync({ inputPath: p })) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(threw).toBeTruthy();
+    expect(String(threw.message)).toMatch(/schemaVersion mismatch/);
+  });
+
+  it("empty events array yields nothing (no crash)", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new DouyinAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(0);
+  });
+
+  it("profile event round-trips normalize cleanly", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      account: {
+        secUid: "MS4wLjABAAAA_alice",
+        shortId: "12345678",
+        displayName: "alice",
+      },
+      events: [
+        {
+          kind: "profile",
+          id: "profile-MS4wLjABAAAA_alice",
+          capturedAt: now - 1000,
+          secUid: "MS4wLjABAAAA_alice",
+          shortId: "12345678",
+          nickname: "alice",
+          signature: "hello world",
+          followingCount: 100,
+          followerCount: 200,
+          awemeCount: 5,
+          favoritingCount: 30,
+          totalFavorited: 1500,
+        },
+      ],
+    });
+    const a = new DouyinAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(1);
+    expect(raws[0].kind).toBe("profile");
+    expect(raws[0].originalId).toMatch(/^douyin:profile:/);
+
+    const batch = a.normalize(raws[0]);
+    expect(validateBatch(batch).valid).toBe(true);
+    // v0.2 emits a person record (self) not an event — repeated syncs
+    // dedupe on the same id.
+    expect(batch.events.length).toBe(0);
+    expect(batch.persons.length).toBe(1);
+    const person = batch.persons[0];
+    expect(person.id).toBe("person-douyin-MS4wLjABAAAA_alice");
+    expect(person.subtype).toBe("self");
+    expect(person.names).toEqual(["alice"]);
+    expect(person.identifiers["douyin-sec-uid"]).toEqual(["MS4wLjABAAAA_alice"]);
+    expect(person.identifiers["douyin-short-id"]).toEqual(["12345678"]);
+    expect(person.extra.platform).toBe("douyin");
+    expect(person.extra.signature).toBe("hello world");
+    expect(person.extra.followerCount).toBe(200);
+    expect(person.extra.awemeCount).toBe(5);
+    expect(person.extra.totalFavorited).toBe(1500);
+    expect(person.source.capturedBy).toBe("api");
+  });
+
+  it("respects per-kind include opt-out", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      events: [
+        { kind: "profile", id: "profile-X", capturedAt: now, secUid: "X", nickname: "x" },
+      ],
+    });
+    const a = new DouyinAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p, include: { profile: false } })) {
+      raws.push(r);
+    }
+    expect(raws.length).toBe(0);
+  });
+
+  it("respects opts.limit", async () => {
+    // v0.2 unlikely to emit more than 1 profile, but verify the gate is wired.
+    const now = Date.now();
+    const events = [
+      { kind: "profile", id: "p1", capturedAt: now, secUid: "X1", nickname: "x1" },
+      // simulate forward-compat: a v0.3 snapshot with history events
+      { kind: "history", id: "h1", capturedAt: now - 1000, awemeId: "A1", title: "t1" },
+      { kind: "history", id: "h2", capturedAt: now - 2000, awemeId: "A2", title: "t2" },
+    ];
+    const p = writeSnapshot(tmpDir, { schemaVersion: 1, snapshottedAt: now, events });
+    const a = new DouyinAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p, limit: 2 })) raws.push(r);
+    expect(raws.length).toBe(2);
+  });
+
+  it("filters out unknown kinds (forward compat)", async () => {
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      events: [
+        { kind: "profile", id: "p1", capturedAt: now, secUid: "X", nickname: "x" },
+        { kind: "future-kind", id: "x", capturedAt: now },
+        { kind: "search", id: "s", capturedAt: now }, // search is sqlite-only
+      ],
+    });
+    const a = new DouyinAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(1);
+    expect(raws[0].kind).toBe("profile");
+  });
+
+  it("snapshottedAt fallback when event capturedAt missing", async () => {
+    const ts = 1700000000000;
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: ts,
+      events: [
+        { kind: "profile", id: "p1", secUid: "X", nickname: "x" },
+      ],
+    });
+    const a = new DouyinAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws[0].capturedAt).toBe(ts);
+  });
+
+  it("v0.3 forward-compat: history events round-trip if a future snapshot ships them", async () => {
+    // The Kotlin LocalCollector won't emit these in v0.2, but the JS adapter
+    // already knows how to ingest them — so when v0.3 lands we won't have to
+    // bump SNAPSHOT_SCHEMA_VERSION.
+    const now = Date.now();
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: now,
+      events: [
+        {
+          kind: "history",
+          id: "history-A1",
+          capturedAt: now - 1000,
+          awemeId: "A1",
+          title: "future video",
+          author: "creator",
+          duration: 30,
+        },
+      ],
+    });
+    const a = new DouyinAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws.length).toBe(1);
+    expect(raws[0].kind).toBe("history");
+    const batch = a.normalize(raws[0]);
+    expect(validateBatch(batch).valid).toBe(true);
+    expect(batch.events[0].subtype).toBe("browse");
+    expect(batch.events[0].extra.awemeId).toBe("A1");
+    expect(batch.events[0].extra.duration).toBe(30);
+  });
+});