@chainlesschain/personal-data-hub 0.3.1 → 0.3.7

package/__tests__/adapters/social-douyin-adb-snapshot-builder.test.js

@@ -0,0 +1,216 @@
+"use strict";
+
+/**
+ * Phase 2a — Douyin snapshot-builder unit cover.
+ *
+ * Mirrors social-bilibili-adb-snapshot-builder.test.js but with the
+ * Douyin event shapes (kind=message / kind=contact).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { existsSync, readFileSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const {
+  buildSnapshot,
+  writeSnapshotJson,
+  cleanupSnapshotJson,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/social-douyin-adb/snapshot-builder");
+
+let tmpDir;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "cc-douyin-snap-test-"));
+});
+
+afterEach(() => {
+  try {
+    rmSync(tmpDir, { recursive: true, force: true });
+  } catch (_e) {
+    // ignore
+  }
+});
+
+describe("buildSnapshot — schema contract", () => {
+  it("returns documented schema shape", () => {
+    const snap = buildSnapshot({
+      uid: "1234567890123456789",
+      displayName: "alice",
+      messages: [],
+      contacts: [],
+      snapshottedAt: 1716383021000,
+    });
+    expect(snap.schemaVersion).toBe(SNAPSHOT_SCHEMA_VERSION);
+    expect(snap.schemaVersion).toBe(1);
+    expect(snap.snapshottedAt).toBe(1716383021000);
+    expect(snap.account).toEqual({
+      secUid: null, // unknown via pure-db extraction
+      shortId: "1234567890123456789",
+      displayName: "alice",
+    });
+    expect(Array.isArray(snap.events)).toBe(true);
+  });
+
+  it("rejects non-string / empty uid", () => {
+    expect(() => buildSnapshot({ uid: 123 })).toThrow(TypeError);
+    expect(() => buildSnapshot({ uid: "" })).toThrow(TypeError);
+    expect(() => buildSnapshot({})).toThrow(TypeError);
+  });
+
+  it("defaults snapshottedAt to Date.now() when omitted", () => {
+    const before = Date.now();
+    const snap = buildSnapshot({ uid: "1" });
+    const after = Date.now();
+    expect(snap.snapshottedAt).toBeGreaterThanOrEqual(before);
+    expect(snap.snapshottedAt).toBeLessThanOrEqual(after);
+  });
+
+  it("defaults displayName to empty string", () => {
+    const snap = buildSnapshot({ uid: "1" });
+    expect(snap.account.displayName).toBe("");
+  });
+});
+
+describe("buildSnapshot — events", () => {
+  it("maps messages → kind=message events with composite id", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      messages: [
+        {
+          senderUid: "10001",
+          conversationId: "conv-A",
+          createdTimeMs: 1716383021000,
+          text: "hi",
+          readStatus: 1,
+          contentBlob: '{"text":"hi"}',
+        },
+      ],
+    });
+    expect(snap.events).toHaveLength(1);
+    expect(snap.events[0]).toMatchObject({
+      kind: "message",
+      id: "msg-conv-A-1716383021000",
+      capturedAt: 1716383021000,
+      senderUid: "10001",
+      conversationId: "conv-A",
+      text: "hi",
+      readStatus: 1,
+      contentBlob: '{"text":"hi"}',
+    });
+  });
+
+  it("falls back to senderUid+time when conversationId absent", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      messages: [
+        {
+          senderUid: "10001",
+          conversationId: null,
+          createdTimeMs: 1716383021000,
+          text: "hi",
+        },
+      ],
+    });
+    expect(snap.events[0].id).toBe("msg-10001-1716383021000");
+  });
+
+  it("falls back to index when both conversationId + senderUid absent", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      messages: [{ text: "stray" }],
+    });
+    expect(snap.events[0].id).toBe("msg-msg-0");
+  });
+
+  it("maps contacts → kind=contact events with uid-based id", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      contacts: [
+        { uid: "111", shortId: "222", name: "Alice", avatarUrl: "https://a.png", followStatus: 1 },
+      ],
+    });
+    expect(snap.events[0]).toMatchObject({
+      kind: "contact",
+      id: "contact-111",
+      uid: "111",
+      shortId: "222",
+      name: "Alice",
+      followStatus: 1,
+    });
+  });
+
+  it("preserves message → contact ordering", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      messages: [{ senderUid: "a", createdTimeMs: 1 }],
+      contacts: [{ uid: "b" }],
+    });
+    expect(snap.events.map((e) => e.kind)).toEqual(["message", "contact"]);
+  });
+
+  it("uses snapshottedAt fallback when message has no createdTimeMs", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      snapshottedAt: 999,
+      messages: [{ senderUid: "x", text: "no time" }],
+    });
+    expect(snap.events[0].capturedAt).toBe(999);
+  });
+
+  it("skips null / non-object items", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      messages: [null, { senderUid: "a", createdTimeMs: 1 }, "junk"],
+      contacts: [undefined, { uid: "b" }],
+    });
+    expect(snap.events).toHaveLength(2);
+  });
+
+  it("handles non-array fields gracefully", () => {
+    const snap = buildSnapshot({
+      uid: "1",
+      messages: "not an array",
+      contacts: null,
+    });
+    expect(snap.events).toEqual([]);
+  });
+});
+
+describe("writeSnapshotJson + cleanupSnapshotJson", () => {
+  it("writes JSON to default tmpdir", () => {
+    const snap = buildSnapshot({ uid: "1" });
+    const filePath = writeSnapshotJson(snap);
+    expect(existsSync(filePath)).toBe(true);
+    expect(filePath).toContain("cc-douyin-snapshot-");
+    expect(filePath).toMatch(/\.json$/);
+    const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+    expect(parsed.schemaVersion).toBe(1);
+    cleanupSnapshotJson(filePath);
+    expect(existsSync(filePath)).toBe(false);
+  });
+
+  it("respects custom dir + fileName", () => {
+    const snap = buildSnapshot({ uid: "1" });
+    const filePath = writeSnapshotJson(snap, {
+      dir: tmpDir,
+      fileName: "custom.json",
+    });
+    expect(filePath).toBe(join(tmpDir, "custom.json"));
+  });
+
+  it("rejects path separators in fileName", () => {
+    const snap = buildSnapshot({ uid: "1" });
+    expect(() => writeSnapshotJson(snap, { fileName: "../evil.json" })).toThrow(
+      /must be a basename/,
+    );
+  });
+
+  it("cleanupSnapshotJson tolerates missing / null", () => {
+    cleanupSnapshotJson(null);
+    cleanupSnapshotJson(undefined);
+    cleanupSnapshotJson(join(tmpDir, "nonexistent.json"));
+    // does not throw
+  });
+});

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

@@ -0,0 +1,432 @@
+"use strict";
+
+import { describe, it, expect, vi } from "vitest";
+
+const {
+  KuaishouApiClient,
+  _internals,
+} = require("../../lib/adapters/social-kuaishou-adb/api-client");
+const { NULL_SIGN_PROVIDER } = require("../../lib/sign-providers");
+
+function makeFakeFetch(responses) {
+  const calls = [];
+  const fakeFetch = async (urlStr, opts) => {
+    calls.push({ url: urlStr, opts });
+    for (const [pattern, payload] of responses) {
+      if (urlStr.includes(pattern)) {
+        const resolved =
+          typeof payload === "function" ? await payload(urlStr, opts) : payload;
+        return {
+          ok: resolved.status == null || resolved.status === 200,
+          status: resolved.status || 200,
+          text: async () => resolved.body,
+        };
+      }
+    }
+    throw new Error("fake fetch: no response for " + urlStr);
+  };
+  return { fakeFetch, calls };
+}
+
+const HAPPY_GRAPHQL_RESPONSE = {
+  body: JSON.stringify({
+    data: {
+      visionFeedRecommend: {
+        feeds: [
+          {
+            photo: {
+              id: "P1",
+              caption: "Watch 1",
+              timestamp: 1700000000,
+              duration: 30,
+            },
+            author: { id: "AUTH1", name: "AuthorOne" },
+          },
+        ],
+      },
+    },
+  }),
+};
+
+const apiPhPayload = encodeURIComponent(
+  JSON.stringify({
+    user_id: "12345",
+    user_name: "Alice",
+    kuaishou_id: "alice_ks",
+    headurl: "https://a.example/avatar.jpg",
+    sex: "F",
+    city: "Beijing",
+  }),
+);
+
+describe("KuaishouApiClient — extractUid", () => {
+  it("prefers direct userId cookie", () => {
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    expect(c.extractUid("userId=12345; did=anon")).toBe("12345");
+  });
+
+  it("falls back to api_ph nested user_id", () => {
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    expect(c.extractUid(`kuaishou.web.cp.api_ph=${apiPhPayload}`)).toBe(
+      "12345",
+    );
+  });
+
+  it("returns null when only anti-bot cookies present", () => {
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    expect(c.extractUid("did=anonid; ttwid=x")).toBe(null);
+    expect(c.lastErrorCode).toBe(-7);
+  });
+
+  it("returns null on empty cookie", () => {
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    expect(c.extractUid("")).toBe(null);
+    expect(c.lastErrorCode).toBe(-1);
+  });
+
+  it("returns null on userId=0 sentinel", () => {
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    expect(c.extractUid("userId=0")).toBe(null);
+  });
+});
+
+describe("KuaishouApiClient — fetchProfile (cookie parse, no HTTP)", () => {
+  it("parses URL-encoded api_ph JSON", async () => {
+    // NO fetch needed — pure cookie parse
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    const p = await c.fetchProfile(
+      `userId=12345; kuaishou.web.cp.api_ph=${apiPhPayload}`,
+    );
+    expect(p).toMatchObject({
+      uid: "12345",
+      nickname: "Alice",
+      kuaishouId: "alice_ks",
+      avatarUrl: "https://a.example/avatar.jpg",
+      sex: "F",
+      city: "Beijing",
+    });
+  });
+
+  it("returns null when api_ph absent", async () => {
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    expect(await c.fetchProfile("userId=12345")).toBe(null);
+    expect(c.lastErrorCode).toBe(-8);
+  });
+
+  it("returns null on un-decodable api_ph (non-JSON)", async () => {
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    expect(
+      await c.fetchProfile(`kuaishou.web.cp.api_ph=${encodeURIComponent("base64junk")}`),
+    ).toBe(null);
+    expect(c.lastErrorCode).toBe(-9);
+  });
+
+  it("returns null when JSON lacks user_id", async () => {
+    const cookie = `kuaishou.web.cp.api_ph=${encodeURIComponent(
+      JSON.stringify({ user_name: "noUid" }),
+    )}`;
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    expect(await c.fetchProfile(cookie)).toBe(null);
+    expect(c.lastErrorCode).toBe(-7);
+  });
+
+  it("normalizes user_id from number to string", async () => {
+    const cookie = `kuaishou.web.cp.api_ph=${encodeURIComponent(
+      JSON.stringify({ user_id: 98765, user_name: "Num" }),
+    )}`;
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    const p = await c.fetchProfile(cookie);
+    expect(p.uid).toBe("98765");
+  });
+
+  it("treats user_id=0 as missing (guest)", async () => {
+    const cookie = `kuaishou.web.cp.api_ph=${encodeURIComponent(
+      JSON.stringify({ user_id: "0", user_name: "Guest" }),
+    )}`;
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    expect(await c.fetchProfile(cookie)).toBe(null);
+  });
+});
+
+describe("KuaishouApiClient — signProvider injection", () => {
+  it("defaults to NULL_SIGN_PROVIDER", () => {
+    const c = new KuaishouApiClient({ fetch: () => {} });
+    expect(c.signProvider).toBe(NULL_SIGN_PROVIDER);
+  });
+
+  it("3 signed endpoints SHORT-CIRCUIT (-99) when NullSignProvider", async () => {
+    const { fakeFetch, calls } = makeFakeFetch([]);
+    const c = new KuaishouApiClient({ fetch: fakeFetch });
+    const w = await c.fetchWatchHistory("userId=1");
+    const p = await c.fetchProfilePhotos("userId=1", "1");
+    const s = await c.fetchSearchHistory("userId=1");
+    expect(w).toEqual([]);
+    expect(p).toEqual([]);
+    expect(s).toEqual([]);
+    expect(c.lastErrorCode).toBe(-99);
+    expect(c._fallbackHits).toBe(3);
+    expect(c._bridgeHits).toBe(0);
+    // Critical: no HTTP traffic when bridge cold
+    expect(calls).toHaveLength(0);
+  });
+
+  it("sends GraphQL POST with __NS_sig3 query + kpf/kpn headers when bridge present", async () => {
+    const { fakeFetch, calls } = makeFakeFetch([
+      ["graphql", HAPPY_GRAPHQL_RESPONSE],
+    ]);
+    const sign = {
+      signUrl: vi.fn(async (url, _purpose) => {
+        const u = new URL(String(url));
+        u.searchParams.set("__NS_sig3", "BRIDGE_SIG");
+        return u;
+      }),
+      signedHeaders: vi.fn(async (_url, _purpose) => ({
+        kpf: "PC_WEB",
+        kpn: "KUAISHOU_VISION",
+      })),
+    };
+    const c = new KuaishouApiClient({ fetch: fakeFetch, signProvider: sign });
+    const items = await c.fetchWatchHistory("userId=1", { limit: 5 });
+    expect(items).toHaveLength(1);
+    expect(items[0].photoId).toBe("P1");
+    expect(sign.signUrl).toHaveBeenCalledOnce();
+    expect(sign.signedHeaders).toHaveBeenCalledOnce();
+    expect(calls[0].url).toContain("__NS_sig3=BRIDGE_SIG");
+    expect(calls[0].opts.method).toBe("POST");
+    expect(calls[0].opts.headers.kpf).toBe("PC_WEB");
+    expect(calls[0].opts.headers.kpn).toBe("KUAISHOU_VISION");
+    // body MUST be valid JSON with operationName + variables + query
+    const body = JSON.parse(calls[0].opts.body);
+    expect(body.operationName).toBe("visionFeedRecommend");
+    expect(body.variables).toEqual({ pcursor: "", count: 5 });
+    expect(c._bridgeHits).toBe(1);
+    expect(c._fallbackHits).toBe(0);
+  });
+
+  it("forwards <op>|<body> purpose to signUrl + signedHeaders", async () => {
+    const { fakeFetch } = makeFakeFetch([
+      ["graphql", { body: JSON.stringify({ data: {} }) }],
+    ]);
+    const sign = {
+      signUrl: vi.fn(async (url) => {
+        const u = new URL(String(url));
+        u.searchParams.set("__NS_sig3", "X");
+        return u;
+      }),
+      signedHeaders: vi.fn(async () => ({})),
+    };
+    const c = new KuaishouApiClient({ fetch: fakeFetch, signProvider: sign });
+    await c.fetchWatchHistory("userId=1");
+    const [, signPurpose] = sign.signUrl.mock.calls[0];
+    expect(signPurpose).toMatch(/^visionFeedRecommend\|/);
+    // purpose carries the exact body bytes for hash matching
+    expect(signPurpose).toContain('"pcursor"');
+    expect(signPurpose).toContain('"count"');
+    // signedHeaders receives same purpose
+    const [, hdrPurpose] = sign.signedHeaders.mock.calls[0];
+    expect(hdrPurpose).toBe(signPurpose);
+  });
+});
+
+describe("KuaishouApiClient — fetchWatchHistory parsing", () => {
+  const sign = {
+    signUrl: vi.fn(async (url) => {
+      const u = new URL(String(url));
+      u.searchParams.set("__NS_sig3", "X");
+      return u;
+    }),
+    signedHeaders: vi.fn(async () => ({ kpf: "PC_WEB", kpn: "KUAISHOU_VISION" })),
+  };
+
+  it("parses nested photo + author", async () => {
+    const { fakeFetch } = makeFakeFetch([["graphql", HAPPY_GRAPHQL_RESPONSE]]);
+    const c = new KuaishouApiClient({ fetch: fakeFetch, signProvider: sign });
+    const items = await c.fetchWatchHistory("userId=1");
+    expect(items[0]).toMatchObject({
+      photoId: "P1",
+      caption: "Watch 1",
+      authorName: "AuthorOne",
+      authorId: "AUTH1",
+      duration: 30,
+    });
+    expect(items[0].viewedAt).toBe(1700000000 * 1000);
+  });
+
+  it("handles flat-shape items (no nested photo)", async () => {
+    const { fakeFetch } = makeFakeFetch([
+      [
+        "graphql",
+        {
+          body: JSON.stringify({
+            data: {
+              visionFeedRecommend: {
+                feeds: [
+                  {
+                    id: "FLAT1",
+                    caption: "Flat watch",
+                    timestamp: 1700001000,
+                  },
+                ],
+              },
+            },
+          }),
+        },
+      ],
+    ]);
+    const c = new KuaishouApiClient({ fetch: fakeFetch, signProvider: sign });
+    const items = await c.fetchWatchHistory("userId=1");
+    expect(items[0].photoId).toBe("FLAT1");
+  });
+
+  it("returns [] on GraphQL errors response", async () => {
+    const { fakeFetch } = makeFakeFetch([
+      [
+        "graphql",
+        {
+          body: JSON.stringify({
+            errors: [{ message: "401 unauthorized" }],
+          }),
+        },
+      ],
+    ]);
+    const c = new KuaishouApiClient({ fetch: fakeFetch, signProvider: sign });
+    const items = await c.fetchWatchHistory("userId=1");
+    expect(items).toEqual([]);
+    expect(c.lastErrorCode).toBe(-5);
+    expect(c.lastErrorMessage).toMatch(/401 unauthorized/);
+  });
+
+  it("returns [] on HTTP 412 anti-bot", async () => {
+    const { fakeFetch } = makeFakeFetch([
+      ["graphql", { status: 412, body: "<html>blocked" }],
+    ]);
+    const c = new KuaishouApiClient({ fetch: fakeFetch, signProvider: sign });
+    expect(await c.fetchWatchHistory("userId=1")).toEqual([]);
+    expect(c.lastErrorCode).toBe(412);
+  });
+});
+
+describe("KuaishouApiClient — fetchProfilePhotos parsing", () => {
+  const sign = {
+    signUrl: vi.fn(async (url) => {
+      const u = new URL(String(url));
+      u.searchParams.set("__NS_sig3", "X");
+      return u;
+    }),
+    signedHeaders: vi.fn(async () => ({ kpf: "PC_WEB", kpn: "KUAISHOU_VISION" })),
+  };
+
+  it("parses own posted photos", async () => {
+    const { fakeFetch, calls } = makeFakeFetch([
+      [
+        "graphql",
+        {
+          body: JSON.stringify({
+            data: {
+              visionProfilePhotoList: {
+                feeds: [
+                  {
+                    photo: {
+                      id: "OWN1",
+                      caption: "My photo",
+                      timestamp: 1700002000,
+                    },
+                  },
+                ],
+              },
+            },
+          }),
+        },
+      ],
+    ]);
+    const c = new KuaishouApiClient({ fetch: fakeFetch, signProvider: sign });
+    const items = await c.fetchProfilePhotos("userId=1", "12345");
+    expect(items[0]).toMatchObject({
+      photoId: "OWN1",
+      caption: "My photo",
+    });
+    // body must carry userId variable
+    const body = JSON.parse(calls[0].opts.body);
+    expect(body.variables.userId).toBe("12345");
+    expect(body.variables.page).toBe("profile");
+  });
+});
+
+describe("KuaishouApiClient — fetchSearchHistory parsing", () => {
+  const sign = {
+    signUrl: vi.fn(async (url) => {
+      const u = new URL(String(url));
+      u.searchParams.set("__NS_sig3", "X");
+      return u;
+    }),
+    signedHeaders: vi.fn(async () => ({ kpf: "PC_WEB", kpn: "KUAISHOU_VISION" })),
+  };
+
+  it("parses recentSearchList object shape", async () => {
+    const { fakeFetch } = makeFakeFetch([
+      [
+        "graphql",
+        {
+          body: JSON.stringify({
+            data: {
+              visionSearchPhoto: {
+                recentSearchList: [
+                  { keyword: "AI", time: 1700003000 },
+                  { keyword: "rust", time: 1700004000 },
+                ],
+              },
+            },
+          }),
+        },
+      ],
+    ]);
+    const c = new KuaishouApiClient({ fetch: fakeFetch, signProvider: sign });
+    const items = await c.fetchSearchHistory("userId=1");
+    expect(items).toHaveLength(2);
+    expect(items[0]).toEqual({ keyword: "AI", searchedAt: 1700003000 * 1000 });
+  });
+
+  it("falls back to data.visionSearchPhoto.history shape", async () => {
+    const { fakeFetch } = makeFakeFetch([
+      [
+        "graphql",
+        {
+          body: JSON.stringify({
+            data: {
+              visionSearchPhoto: {
+                history: [{ keyword: "fallback", time: 1 }],
+              },
+            },
+          }),
+        },
+      ],
+    ]);
+    const c = new KuaishouApiClient({ fetch: fakeFetch, signProvider: sign });
+    const items = await c.fetchSearchHistory("userId=1");
+    expect(items[0].keyword).toBe("fallback");
+  });
+
+  it("returns [] when both shapes missing", async () => {
+    const { fakeFetch } = makeFakeFetch([
+      [
+        "graphql",
+        {
+          body: JSON.stringify({
+            data: { visionSearchPhoto: {} },
+          }),
+        },
+      ],
+    ]);
+    const c = new KuaishouApiClient({ fetch: fakeFetch, signProvider: sign });
+    expect(await c.fetchSearchHistory("userId=1")).toEqual([]);
+  });
+});
+
+describe("normalizeMs", () => {
+  it("passes ms through, multiplies seconds, returns 0 for invalid", () => {
+    expect(_internals.normalizeMs(1700000000000)).toBe(1700000000000);
+    expect(_internals.normalizeMs(1700000000)).toBe(1700000000 * 1000);
+    expect(_internals.normalizeMs(0)).toBe(0);
+    expect(_internals.normalizeMs(-1)).toBe(0);
+  });
+});