@chainlesschain/personal-data-hub 0.4.2 → 0.4.4

package/__tests__/adapters/messaging-whatsapp.test.js

@@ -0,0 +1,289 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+
+const {
+  WhatsAppAdapter,
+  NAME,
+  VERSION,
+} = require("../../lib/adapters/messaging-whatsapp");
+
+function writeTmpDb() {
+  const p = path.join(
+    os.tmpdir(),
+    `cc-whatsapp-test-${crypto.randomUUID()}.db`,
+  );
+  fs.writeFileSync(p, "fake");
+  return p;
+}
+
+async function collect(gen) {
+  const out = [];
+  for await (const x of gen) out.push(x);
+  return out;
+}
+
+function makeFakeDriverFactory(tables, log = {}) {
+  return () =>
+    class FakeDb {
+      constructor(dbPath, opts) {
+        log.opened = { dbPath, opts };
+      }
+      prepare(sql) {
+        for (const [needle, rows] of Object.entries(tables)) {
+          if (sql.includes(needle)) return { all: () => rows };
+        }
+        throw new Error(`no such table in: ${sql}`);
+      }
+      close() {
+        log.closed = true;
+      }
+    };
+}
+
+describe("constants", () => {
+  it("exposes name/version + high sensitivity & legal gate", () => {
+    expect(NAME).toBe("messaging-whatsapp");
+    expect(VERSION).toBe("0.6.0");
+    const a = new WhatsAppAdapter();
+    expect(a.dataDisclosure.sensitivity).toBe("high");
+    expect(a.dataDisclosure.legalGate).toBe(true);
+  });
+});
+
+describe("authenticate", () => {
+  it("fails DB_NOT_PULLED without a real db file", async () => {
+    const a = new WhatsAppAdapter();
+    const r = await a.authenticate({});
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("DB_NOT_PULLED");
+  });
+
+  it("ok when dbPath exists (inputPath alias too)", async () => {
+    const p = writeTmpDb();
+    try {
+      const a = new WhatsAppAdapter({ account: { phone: "8613800138000" } });
+      expect(await a.authenticate({ inputPath: p })).toEqual({
+        ok: true,
+        account: "8613800138000",
+        mode: "snapshot-file",
+      });
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+});
+
+describe("sync — fake sqlite driver", () => {
+  const JID_ROW = {
+    _id: 1,
+    user: "8613800138000",
+    raw_string: "8613800138000@s.whatsapp.net",
+    display_name: "Alice",
+  };
+  const CHAT_ROW = { _id: 2, subject: "Family group" };
+  const MSG_ROW = {
+    _id: 3,
+    key_remote_jid: "8613800138000@s.whatsapp.net",
+    from_me: 1,
+    text_data: "hello",
+    timestamp: 1716383021, // seconds
+  };
+  const CALL_ROW = {
+    _id: 4,
+    jid_row_id: 1,
+    from_me: 0,
+    video_call: 1,
+    duration: 65,
+    timestamp: 1716383021000,
+  };
+
+  it("yields contact/chat/message/call rows with kind tags, closes db", async () => {
+    const p = writeTmpDb();
+    const log = {};
+    try {
+      const a = new WhatsAppAdapter({
+        dbPath: p,
+        dbDriverFactory: makeFakeDriverFactory(
+          {
+            "FROM jid": [JID_ROW],
+            "FROM chat": [CHAT_ROW],
+            "FROM message ": [MSG_ROW],
+            "FROM call_log": [CALL_ROW],
+          },
+          log,
+        ),
+      });
+      const items = await collect(a.sync({}));
+      expect(items.map((i) => i.originalId)).toEqual([
+        "jid-1",
+        "chat-2",
+        "msg-3",
+        "call-4",
+      ]);
+      expect(items.map((i) => i.payload.kind)).toEqual([
+        "contact",
+        "chat",
+        "message",
+        "call",
+      ]);
+      // message timestamp seconds → ms
+      expect(items[2].capturedAt).toBe(1716383021 * 1000);
+      expect(log.opened.opts).toEqual({ readonly: true });
+      expect(log.closed).toBe(true);
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("falls back to legacy `messages` table when `message` missing", async () => {
+    const p = writeTmpDb();
+    try {
+      const a = new WhatsAppAdapter({
+        dbPath: p,
+        dbDriverFactory: makeFakeDriverFactory({
+          "FROM jid": [],
+          "FROM chat": [],
+          "FROM messages ": [MSG_ROW],
+          "FROM call_log": [],
+        }),
+      });
+      const items = await collect(a.sync({}));
+      expect(items).toHaveLength(1);
+      expect(items[0].payload.kind).toBe("message");
+    } finally {
+      fs.unlinkSync(p);
+    }
+  });
+
+  it("returns silently when db file missing", async () => {
+    const a = new WhatsAppAdapter({
+      dbPath: path.join(os.tmpdir(), "nonexistent-wa.db"),
+      dbDriverFactory: makeFakeDriverFactory({}),
+    });
+    expect(await collect(a.sync({}))).toEqual([]);
+  });
+});
+
+describe("normalize", () => {
+  const a = new WhatsAppAdapter();
+
+  it("personal jid → contact person with digits-only phone identifier", () => {
+    const batch = a.normalize({
+      originalId: "jid-1",
+      payload: {
+        kind: "contact",
+        row: {
+          _id: 1,
+          user: "+86 138-0013-8000",
+          raw_string: "8613800138000@s.whatsapp.net",
+          display_name: "Alice",
+        },
+      },
+    });
+    const person = batch.persons[0];
+    expect(person.subtype).toBe("contact");
+    expect(person.names).toEqual(["Alice", "+86 138-0013-8000"]);
+    expect(person.identifiers).toEqual({ phone: ["8613800138000"] });
+    expect(batch.topics).toEqual([]);
+  });
+
+  it("group jid (@g.us) → topic, not person", () => {
+    const batch = a.normalize({
+      originalId: "jid-9",
+      payload: {
+        kind: "contact",
+        row: {
+          _id: 9,
+          raw_string: "1234-5678@g.us",
+          display_name: "Family group",
+        },
+      },
+    });
+    expect(batch.persons).toEqual([]);
+    expect(batch.topics[0]).toMatchObject({
+      id: "topic-whatsapp-1234-5678@g.us",
+      name: "Family group",
+    });
+  });
+
+  it("chat row → topic named by subject", () => {
+    const batch = a.normalize({
+      originalId: "chat-2",
+      payload: { kind: "chat", row: { _id: 2, subject: "Work chat" } },
+    });
+    expect(batch.topics[0]).toMatchObject({
+      id: "topic-whatsapp-chat-2",
+      name: "Work chat",
+    });
+  });
+
+  it("outgoing message → message event from person-self, title truncated to 80", () => {
+    const longText = "x".repeat(200);
+    const batch = a.normalize({
+      originalId: "msg-3",
+      payload: {
+        kind: "message",
+        row: {
+          _id: 3,
+          key_remote_jid: "8613800138000@s.whatsapp.net",
+          from_me: 1,
+          text_data: longText,
+          timestamp: 1716383021000,
+        },
+      },
+    });
+    const ev = batch.events[0];
+    expect(ev.subtype).toBe("message");
+    expect(ev.actor).toBe("person-self");
+    expect(ev.occurredAt).toBe(1716383021000);
+    expect(ev.content.title).toHaveLength(80);
+    expect(ev.content.text).toHaveLength(200);
+    expect(ev.extra.isOutgoing).toBe(true);
+  });
+
+  it("incoming empty message → '(空)' title, actor from jid", () => {
+    const batch = a.normalize({
+      originalId: "msg-4",
+      payload: {
+        kind: "message",
+        row: {
+          _id: 4,
+          key_remote_jid: "86139@s.whatsapp.net",
+          from_me: 0,
+          timestamp: 1716383021000,
+        },
+      },
+    });
+    const ev = batch.events[0];
+    expect(ev.content.title).toBe("(空)");
+    expect(ev.actor).toBe("person-whatsapp-86139@s.whatsapp.net");
+    expect(ev.extra.isOutgoing).toBe(false);
+  });
+
+  it("incoming video call → call event with duration/isVideo extras", () => {
+    const batch = a.normalize({
+      originalId: "call-5",
+      payload: {
+        kind: "call",
+        row: {
+          _id: 5,
+          jid_row_id: 1,
+          from_me: 0,
+          video_call: 1,
+          duration: 65,
+          timestamp: 1716383021000,
+        },
+      },
+    });
+    const ev = batch.events[0];
+    expect(ev.subtype).toBe("call");
+    expect(ev.content.title).toBe("WhatsApp call (video)");
+    expect(ev.actor).toBe("person-whatsapp-1");
+    expect(ev.extra).toMatchObject({ duration: 65, isVideo: true, fromMe: false });
+  });
+});

package/__tests__/adapters/qq-pc-direct-read.test.js

@@ -189,3 +189,39 @@ describe("QQPcAdapter — edge cases", () => {
     expect(() => a.normalize({ kind: "x", payload: { kind: "x" } })).toThrow(/unknown kind/);
   });
 });
+
+describe("QQPcAdapter — QQ NT sidecar path (passphrase)", () => {
+  const fakeCollector = (result) => async (_opts) => result;
+
+  it("opts.passphrase routes through the sidecar collector and yields messages", async () => {
+    const a = new QQPcAdapter({
+      qqCollector: fakeCollector({
+        account: "896075341",
+        messageCount: 2,
+        c2c: 1,
+        group: 1,
+        messages: [
+          { kind: "group", peer: 88966001, peerUid: "u_x", senderUin: 38181604, senderName: "疯子", type: 0, createTime: 1780941580, text: "保持高贵的沉默。", originalId: "qq-pc:group:88966001:1" },
+          { kind: "c2c", peer: 2747277822, peerUid: "u_y", senderUin: 12345, senderName: "张三", type: 0, createTime: 1780900000, text: "在吗", originalId: "qq-pc:c2c:2747277822:2" },
+        ],
+      }),
+    });
+    const raws = await collect(a.sync({ passphrase: "5{sww#,6aq=)8=A@" }));
+    expect(raws).toHaveLength(2);
+    expect(raws[0].payload.text).toBe("保持高贵的沉默。");
+    expect(raws[0].payload.isGroup).toBe(true);
+    expect(raws[0].payload.senderName).toBe("疯子");
+    expect(raws[1].payload.isGroup).toBe(false);
+
+    const merged = { events: [], persons: [], places: [], items: [], topics: [] };
+    for (const r of raws) {
+      const n = a.normalize(r);
+      for (const k of Object.keys(merged)) if (Array.isArray(n[k])) merged[k].push(...n[k]);
+    }
+    const { valid } = partitionBatch(merged);
+    expect(valid.events.length).toBe(2);
+    const texts = valid.events.map((e) => e.content && e.content.text);
+    expect(texts).toContain("保持高贵的沉默。");
+    expect(valid.events.find((e) => e.content.text === "保持高贵的沉默。").extra.senderName).toBe("疯子");
+  });
+});

package/__tests__/adapters/shopping-base.test.js

@@ -0,0 +1,179 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const {
+  normalizeOrderRecord,
+  mapStatusToSubtype,
+  CookieAuth,
+} = require("../../lib/adapters/shopping-base");
+
+describe("normalizeOrderRecord", () => {
+  const ORDER = {
+    vendorId: "jd",
+    orderId: "JD123456",
+    placedAt: 1716383021000,
+    paidAt: 1716383100000,
+    status: "delivered",
+    merchantName: "京东自营旗舰店",
+    totalAmount: { value: 299.9, currency: "CNY" },
+    items: [
+      { name: "机械键盘", quantity: 1, unitPrice: 249.9, sku: "SKU1" },
+      { name: "键帽", quantity: 2, unitPrice: 25 },
+    ],
+    recipient: "张三",
+    shippingAddress: "上海市幸福路1号",
+    trackingNumber: "SF123",
+    extras: { shopId: "S1" },
+  };
+
+  it("throws on missing rec / orderId / merchantName", () => {
+    expect(() => normalizeOrderRecord(null)).toThrow(/rec required/);
+    expect(() => normalizeOrderRecord({})).toThrow(/orderId required/);
+    expect(() => normalizeOrderRecord({ orderId: "X" })).toThrow(
+      /merchantName required/,
+    );
+  });
+
+  it("emits order event with amount out + items text + cross-source link extras", () => {
+    const batch = normalizeOrderRecord(ORDER, {
+      adapterName: "shopping-jd",
+      adapterVersion: "0.5.0",
+    });
+    expect(batch.events).toHaveLength(1);
+    const ev = batch.events[0];
+    expect(ev.subtype).toBe("order");
+    expect(ev.occurredAt).toBe(1716383021000);
+    expect(ev.actor).toBe("person-self");
+    expect(ev.content.title).toBe("京东自营旗舰店 订单 JD123456");
+    expect(ev.content.amount).toEqual({
+      value: 299.9,
+      currency: "CNY",
+      direction: "out",
+    });
+    expect(ev.content.text).toBe("机械键盘 x1; 键帽 x2");
+    expect(ev.extra).toMatchObject({
+      vendorId: "jd",
+      orderId: "JD123456",
+      merchantOrderNumber: "JD123456", // Email/Alipay cross-source link key
+      orderStatus: "delivered",
+      itemCount: 2,
+      recipient: "张三",
+      trackingNumber: "SF123",
+      paidAt: 1716383100000,
+      vendorExtras: { shopId: "S1" },
+    });
+    expect(ev.source).toMatchObject({
+      adapter: "shopping-jd",
+      adapterVersion: "0.5.0",
+      originalId: "JD123456",
+      capturedBy: "api",
+    });
+  });
+
+  it("emits merchant person + per-SKU item entities inheriting order currency", () => {
+    const batch = normalizeOrderRecord(ORDER, { adapterName: "shopping-jd" });
+    expect(batch.persons).toHaveLength(1);
+    expect(batch.persons[0]).toMatchObject({
+      subtype: "merchant",
+      names: ["京东自营旗舰店"],
+    });
+    expect(batch.items).toHaveLength(2);
+    expect(batch.items[0]).toMatchObject({
+      type: "item",
+      subtype: "product",
+      name: "机械键盘",
+      merchant: batch.persons[0].id,
+      price: { value: 249.9, currency: "CNY" },
+    });
+    expect(batch.items[0].extra).toMatchObject({ quantity: 1, sku: "SKU1" });
+    // nameless item entries are dropped
+    const withJunk = normalizeOrderRecord(
+      { ...ORDER, items: [{ quantity: 3 }, { name: "ok" }] },
+      {},
+    );
+    expect(withJunk.items).toHaveLength(1);
+  });
+
+  it("refund order → refund subtype with money direction IN", () => {
+    const batch = normalizeOrderRecord(
+      { ...ORDER, status: "refunded" },
+      { adapterName: "shopping-jd" },
+    );
+    expect(batch.events[0].subtype).toBe("refund");
+    expect(batch.events[0].content.amount.direction).toBe("in");
+  });
+
+  it("omits amount when totalAmount missing; occurredAt falls back to now", () => {
+    const before = Date.now();
+    const batch = normalizeOrderRecord({
+      orderId: "X1",
+      merchantName: "店",
+    });
+    expect(batch.events[0].content.amount).toBeUndefined();
+    expect(batch.events[0].occurredAt).toBeGreaterThanOrEqual(before);
+    expect(batch.events[0].extra.orderStatus).toBe("placed");
+  });
+});
+
+describe("mapStatusToSubtype", () => {
+  it("maps refund variants (en + 中文)", () => {
+    expect(mapStatusToSubtype("refunded")).toBe("refund");
+    expect(mapStatusToSubtype("REFUND_PENDING")).toBe("refund");
+    expect(mapStatusToSubtype("退款中")).toBe("refund");
+  });
+
+  it("maps cancel variants (en + 中文)", () => {
+    expect(mapStatusToSubtype("cancelled")).toBe("cancelled");
+    expect(mapStatusToSubtype("closed")).toBe("cancelled");
+    expect(mapStatusToSubtype("已取消")).toBe("cancelled");
+    expect(mapStatusToSubtype("已关闭")).toBe("cancelled");
+  });
+
+  it("everything else (placed/shipped/delivered/blank) → order", () => {
+    expect(mapStatusToSubtype("placed")).toBe("order");
+    expect(mapStatusToSubtype("shipped")).toBe("order");
+    expect(mapStatusToSubtype("delivered")).toBe("order");
+    expect(mapStatusToSubtype(undefined)).toBe("order");
+  });
+});
+
+describe("CookieAuth", () => {
+  it("requires platform; setCookies type-checks", () => {
+    expect(() => new CookieAuth({})).toThrow(/platform required/);
+    const c = new CookieAuth({ platform: "jd" });
+    expect(() => c.setCookies(42)).toThrow(/string required/);
+  });
+
+  it("toHeader returns raw string or null when empty", () => {
+    const c = new CookieAuth({ platform: "jd" });
+    expect(c.toHeader()).toBe(null);
+    c.setCookies("pt_key=abc; pt_pin=u1");
+    expect(c.toHeader()).toBe("pt_key=abc; pt_pin=u1");
+  });
+
+  it("validate: false on empty, true on non-empty, defers to injected validator", async () => {
+    const empty = new CookieAuth({ platform: "jd" });
+    expect(await empty.validate()).toBe(false);
+    const plain = new CookieAuth({ platform: "jd", cookies: "k=v" });
+    expect(await plain.validate()).toBe(true);
+    const probed = new CookieAuth({
+      platform: "jd",
+      cookies: "k=v",
+      validator: async (raw) => raw.includes("pt_key"),
+    });
+    expect(await probed.validate()).toBe(false);
+  });
+
+  it("getCookieValue: case-insensitive, URI-decodes, escapes regex metachars", () => {
+    const c = new CookieAuth({
+      platform: "taobao",
+      cookies: "Name=%E5%BC%A0%E4%B8%89; a.b+c=literal; last=v",
+    });
+    expect(c.getCookieValue("name")).toBe("张三");
+    // dot/plus in cookie name must be treated literally, not as regex
+    expect(c.getCookieValue("a.b+c")).toBe("literal");
+    expect(c.getCookieValue("missing")).toBe(null);
+    expect(c.getCookieValue("")).toBe(null);
+  });
+});

package/__tests__/adapters/social-kuaishou-adb-api-client.test.js

@@ -430,3 +430,67 @@ describe("normalizeMs", () => {
     expect(_internals.normalizeMs(-1)).toBe(0);
   });
 });
+
+describe("api_ph base64 fallback (v0.3)", () => {
+  const profileJson = JSON.stringify({
+    user_id: "424242",
+    user_name: "B64User",
+    kuaishou_id: "b64_ks",
+  });
+  const b64 = Buffer.from(profileJson, "utf-8").toString("base64");
+
+  it("apiPhDecodeCandidates yields base64-decoded JSON as 2nd candidate", () => {
+    const cands = _internals.apiPhDecodeCandidates(encodeURIComponent(b64));
+    expect(cands).toHaveLength(2);
+    expect(cands[1]).toBe(profileJson);
+  });
+
+  it("apiPhDecodeCandidates yields 1 candidate for plain JSON (no double decode)", () => {
+    const cands = _internals.apiPhDecodeCandidates(
+      encodeURIComponent(profileJson),
+    );
+    expect(cands).toEqual([profileJson]);
+  });
+
+  it("apiPhDecodeCandidates suppresses garbage base64 (decoded ≠ JSON)", () => {
+    expect(_internals.apiPhDecodeCandidates("base64junk")).toEqual([
+      "base64junk",
+    ]);
+  });
+
+  it("apiPhDecodeCandidates handles url-safe base64 (- _ alphabet)", () => {
+    const urlSafe = b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    const cands = _internals.apiPhDecodeCandidates(urlSafe);
+    expect(cands[1]).toBe(profileJson);
+  });
+
+  it("fetchProfile parses base64-encoded api_ph", async () => {
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    const p = await c.fetchProfile(
+      `kuaishou.web.cp.api_ph=${encodeURIComponent(b64)}`,
+    );
+    expect(p).toMatchObject({
+      uid: "424242",
+      nickname: "B64User",
+      kuaishouId: "b64_ks",
+    });
+    expect(c.lastErrorCode).toBe(0);
+  });
+
+  it("fetchProfile still rejects non-JSON non-base64 payload with -9", async () => {
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    expect(
+      await c.fetchProfile(
+        `kuaishou.web.cp.api_ph=${encodeURIComponent("%%not-b64%%")}`,
+      ),
+    ).toBe(null);
+    expect(c.lastErrorCode).toBe(-9);
+  });
+
+  it("extractUid falls back to base64 api_ph nested user_id", () => {
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    expect(
+      c.extractUid(`kuaishou.web.cp.api_ph=${encodeURIComponent(b64)}`),
+    ).toBe("424242");
+  });
+});

package/__tests__/adapters/social-kuaishou-adb-cookies-extension.test.js

@@ -70,6 +70,17 @@ describe("pickUidFromCookieMap", () => {
     const map = make([["did", "anonid"]]);
     expect(_internals.pickUidFromCookieMap(map)).toBe(null);
   });
+
+  it("falls back to base64-encoded api_ph (v0.3 newer Kuaishou builds)", () => {
+    const b64 = Buffer.from(
+      JSON.stringify({ user_id: "424242" }),
+      "utf-8",
+    ).toString("base64");
+    const map = make([
+      ["kuaishou.web.cp.api_ph", encodeURIComponent(b64)],
+    ]);
+    expect(_internals.pickUidFromCookieMap(map)).toBe("424242");
+  });
 });
 
 describe("assembleKuaishouCookieHeader", () => {