@chainlesschain/personal-data-hub 0.4.28 → 0.4.30

package/__tests__/kg-derive.test.js

@@ -1,219 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const {
-  deriveEventTriples,
-  derivePersonTriples,
-  derivePlaceTriples,
-  deriveItemTriples,
-  deriveTopicTriples,
-  deriveBatchTriples,
-  deriveEntityTriples,
-  triple,
-} = require("../lib/kg-derive");
-
-const { newId } = require("../lib/ids");
-
-const sourceOk = (adapter = "test") => ({
-  adapter,
-  adapterVersion: "0.1.0",
-  capturedAt: Date.now(),
-  capturedBy: "api",
-});
-
-describe("triple()", () => {
-  it("makes an object triple with subject + predicate + object", () => {
-    const t = triple("a", "knows", { object: "b" });
-    expect(t).toEqual({ subject: "a", predicate: "knows", object: "b" });
-  });
-  it("makes a literal triple", () => {
-    const t = triple("a", "name", { literal: "Alice" });
-    expect(t).toEqual({ subject: "a", predicate: "name", literal: "Alice" });
-  });
-  it("skips object/literal when null/undefined", () => {
-    const t = triple("a", "p", {});
-    expect(t).toEqual({ subject: "a", predicate: "p" });
-  });
-});
-
-describe("deriveEventTriples", () => {
-  it("emits the minimal set: rdf:type / subtype / occurred-at / source", () => {
-    const id = newId();
-    const e = {
-      id,
-      type: "event",
-      subtype: "message",
-      occurredAt: 1700000000000,
-      ingestedAt: 1700000000001,
-      content: { text: "hi" },
-      source: sourceOk("wechat"),
-    };
-    const ts = deriveEventTriples(e);
-    expect(ts).toContainEqual({ subject: id, predicate: "rdf:type", literal: "event" });
-    expect(ts).toContainEqual({ subject: id, predicate: "subtype", literal: "message" });
-    expect(ts).toContainEqual({ subject: id, predicate: "occurred-at", literal: 1700000000000 });
-    expect(ts).toContainEqual({ subject: id, predicate: "source", literal: "wechat" });
-  });
-
-  it("emits 'by' for actor and 'involves' for each participant", () => {
-    const id = newId();
-    const e = {
-      id,
-      type: "event",
-      subtype: "payment",
-      occurredAt: 1,
-      ingestedAt: 1,
-      actor: "person-self",
-      participants: ["person-self", "person-mom"],
-      content: { text: "transfer" },
-      source: sourceOk(),
-    };
-    const ts = deriveEventTriples(e);
-    expect(ts).toContainEqual({ subject: id, predicate: "by", object: "person-self" });
-    expect(ts).toContainEqual({ subject: id, predicate: "involves", object: "person-self" });
-    expect(ts).toContainEqual({ subject: id, predicate: "involves", object: "person-mom" });
-  });
-
-  it("emits amount components when content.amount present", () => {
-    const id = newId();
-    const e = {
-      id,
-      type: "event",
-      subtype: "order",
-      occurredAt: 1,
-      ingestedAt: 1,
-      content: { amount: { value: 288.5, currency: "CNY", direction: "out" } },
-      source: sourceOk(),
-    };
-    const ts = deriveEventTriples(e);
-    expect(ts).toContainEqual({ subject: id, predicate: "amount-value", literal: 288.5 });
-    expect(ts).toContainEqual({ subject: id, predicate: "amount-currency", literal: "CNY" });
-    expect(ts).toContainEqual({ subject: id, predicate: "amount-direction", literal: "out" });
-  });
-});
-
-describe("derivePersonTriples", () => {
-  it("emits rdf:type + subtype + every name + identifier", () => {
-    const id = newId();
-    const p = {
-      id,
-      type: "person",
-      subtype: "contact",
-      names: ["妈妈", "陈某某"],
-      identifiers: { phone: ["13800001111", "13900002222"], wechatId: "wxid_xyz" },
-      ingestedAt: 1,
-      source: sourceOk(),
-    };
-    const ts = derivePersonTriples(p);
-    expect(ts).toContainEqual({ subject: id, predicate: "rdf:type", literal: "person" });
-    expect(ts).toContainEqual({ subject: id, predicate: "subtype", literal: "contact" });
-    expect(ts).toContainEqual({ subject: id, predicate: "has-name", literal: "妈妈" });
-    expect(ts).toContainEqual({ subject: id, predicate: "has-name", literal: "陈某某" });
-    expect(ts).toContainEqual({ subject: id, predicate: "id:phone", literal: "13800001111" });
-    expect(ts).toContainEqual({ subject: id, predicate: "id:phone", literal: "13900002222" });
-    expect(ts).toContainEqual({ subject: id, predicate: "id:wechatId", literal: "wxid_xyz" });
-  });
-});
-
-describe("derivePlaceTriples", () => {
-  it("emits has-name + has-alias (deduped) + located-at + address", () => {
-    const id = newId();
-    const pl = {
-      id,
-      type: "place",
-      name: "妈妈家",
-      aliases: ["妈妈家", "妈家", "home"],
-      coordinates: { lat: 24.5, lng: 118.1 },
-      address: "厦门思明区",
-      category: "home",
-      ingestedAt: 1,
-      source: sourceOk(),
-    };
-    const ts = derivePlaceTriples(pl);
-    expect(ts).toContainEqual({ subject: id, predicate: "has-name", literal: "妈妈家" });
-    // The primary name shouldn't duplicate as alias
-    expect(ts.filter((t) => t.predicate === "has-name").length).toBe(1);
-    expect(ts.some((t) => t.predicate === "has-alias" && t.literal === "妈家")).toBe(true);
-    expect(ts).toContainEqual({ subject: id, predicate: "located-at", literal: "24.5,118.1" });
-    expect(ts).toContainEqual({ subject: id, predicate: "address", literal: "厦门思明区" });
-  });
-});
-
-describe("deriveItemTriples", () => {
-  it("emits price + merchant", () => {
-    const id = newId();
-    const i = {
-      id,
-      type: "item",
-      subtype: "product",
-      name: "蛋白粉",
-      price: { value: 288, currency: "CNY" },
-      merchant: "person-xy-store",
-      ingestedAt: 1,
-      source: sourceOk(),
-    };
-    const ts = deriveItemTriples(i);
-    expect(ts).toContainEqual({ subject: id, predicate: "priced-at", literal: "288 CNY" });
-    expect(ts).toContainEqual({ subject: id, predicate: "sold-by", object: "person-xy-store" });
-  });
-});
-
-describe("deriveTopicTriples", () => {
-  it("emits parent + derived-from for each event", () => {
-    const id = newId();
-    const e1 = newId();
-    const e2 = newId();
-    const t = {
-      id,
-      type: "topic",
-      name: "母亲健康",
-      parentTopic: "topic-family",
-      derivedFromEvents: [e1, e2],
-      ingestedAt: 1,
-      source: sourceOk(),
-    };
-    const ts = deriveTopicTriples(t);
-    expect(ts).toContainEqual({ subject: id, predicate: "parent", object: "topic-family" });
-    expect(ts).toContainEqual({ subject: id, predicate: "derived-from", object: e1 });
-    expect(ts).toContainEqual({ subject: id, predicate: "derived-from", object: e2 });
-  });
-});
-
-describe("deriveBatchTriples + deriveEntityTriples", () => {
-  it("walks all 5 entity kinds in a batch", () => {
-    const batch = {
-      events: [{ id: "e", type: "event", subtype: "message", occurredAt: 1, ingestedAt: 1, content: {}, source: sourceOk() }],
-      persons: [{ id: "p", type: "person", subtype: "contact", names: ["x"], ingestedAt: 1, source: sourceOk() }],
-      places: [{ id: "pl", type: "place", name: "home", aliases: [], ingestedAt: 1, source: sourceOk() }],
-      items: [{ id: "i", type: "item", subtype: "product", name: "thing", ingestedAt: 1, source: sourceOk() }],
-      topics: [{ id: "t", type: "topic", name: "x", ingestedAt: 1, source: sourceOk() }],
-    };
-    const ts = deriveBatchTriples(batch);
-    expect(ts.length).toBeGreaterThan(5); // at least the 5 rdf:type rows
-    expect(ts.some((x) => x.subject === "e" && x.predicate === "rdf:type")).toBe(true);
-    expect(ts.some((x) => x.subject === "p" && x.predicate === "rdf:type")).toBe(true);
-    expect(ts.some((x) => x.subject === "pl" && x.predicate === "rdf:type")).toBe(true);
-    expect(ts.some((x) => x.subject === "i" && x.predicate === "rdf:type")).toBe(true);
-    expect(ts.some((x) => x.subject === "t" && x.predicate === "rdf:type")).toBe(true);
-  });
-
-  it("deriveEntityTriples dispatches by .type and returns [] for unknown", () => {
-    expect(deriveEntityTriples(null)).toEqual([]);
-    expect(deriveEntityTriples({ type: "frobnicate" })).toEqual([]);
-    const ts = deriveEntityTriples({
-      id: "p",
-      type: "person",
-      subtype: "contact",
-      names: ["x"],
-      ingestedAt: 1,
-      source: sourceOk(),
-    });
-    expect(ts.length).toBeGreaterThan(0);
-  });
-
-  it("returns [] for non-object batch input", () => {
-    expect(deriveBatchTriples(null)).toEqual([]);
-    expect(deriveBatchTriples("oops")).toEqual([]);
-  });
-});

package/__tests__/llm-client.test.js

@@ -1,122 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { MockLLMClient, OllamaClient } = require("../lib/llm-client");
-
-// ─── MockLLMClient ────────────────────────────────────────────────────────
-
-describe("MockLLMClient", () => {
-  it("isLocal is always true", () => {
-    expect(new MockLLMClient().isLocal).toBe(true);
-  });
-
-  it("returns the configured static reply", async () => {
-    const c = new MockLLMClient({ reply: "hello [evt-1]" });
-    const r = await c.chat([{ role: "user", content: "x" }]);
-    expect(r.text).toBe("hello [evt-1]");
-    expect(r.model).toBe("mock-llm");
-  });
-
-  it("records every call for assertion", async () => {
-    const c = new MockLLMClient({ reply: "ok" });
-    await c.chat([{ role: "user", content: "a" }]);
-    await c.chat([{ role: "user", content: "b" }]);
-    expect(c.calls.length).toBe(2);
-    expect(c.calls[0].messages[0].content).toBe("a");
-    expect(c.calls[1].messages[0].content).toBe("b");
-  });
-
-  it("function reply gets the messages", async () => {
-    const c = new MockLLMClient({ reply: (messages) => `you said: ${messages[0].content}` });
-    const r = await c.chat([{ role: "user", content: "hi" }]);
-    expect(r.text).toBe("you said: hi");
-  });
-
-  it("replies array exhausts and throws after", async () => {
-    const c = new MockLLMClient({ replies: ["a", "b"] });
-    expect((await c.chat([])).text).toBe("a");
-    expect((await c.chat([])).text).toBe("b");
-    await expect(c.chat([])).rejects.toThrow(/exhausted/);
-  });
-
-  it("returns a usage object even if it's an approximation", async () => {
-    const c = new MockLLMClient({ reply: "reply text" });
-    const r = await c.chat([{ role: "user", content: "question content" }]);
-    expect(r.usage).toBeDefined();
-    expect(typeof r.usage.promptTokens).toBe("number");
-  });
-});
-
-// ─── OllamaClient ─────────────────────────────────────────────────────────
-
-describe("OllamaClient", () => {
-  it("declares isLocal = true unconditionally", () => {
-    const c = new OllamaClient({ fetch: async () => ({ ok: true }) });
-    expect(c.isLocal).toBe(true);
-  });
-
-  it("uses sensible defaults (baseUrl + model)", () => {
-    const c = new OllamaClient({ fetch: async () => ({}) });
-    expect(c.baseUrl).toBe("http://localhost:11434");
-    expect(c.model).toContain("qwen2.5");
-  });
-
-  it("posts to /api/chat with the configured model + messages", async () => {
-    let captured = null;
-    const fakeFetch = async (url, init) => {
-      captured = { url, body: JSON.parse(init.body) };
-      return {
-        ok: true,
-        status: 200,
-        json: async () => ({
-          message: { role: "assistant", content: "hi" },
-          prompt_eval_count: 12,
-          eval_count: 7,
-        }),
-      };
-    };
-    const c = new OllamaClient({ fetch: fakeFetch, model: "llama3:8b" });
-    const r = await c.chat([{ role: "user", content: "ping" }]);
-    expect(captured.url).toBe("http://localhost:11434/api/chat");
-    expect(captured.body.model).toBe("llama3:8b");
-    expect(captured.body.stream).toBe(false);
-    expect(captured.body.messages[0].content).toBe("ping");
-    expect(r.text).toBe("hi");
-    expect(r.usage.promptTokens).toBe(12);
-    expect(r.usage.completionTokens).toBe(7);
-    expect(r.usage.totalTokens).toBe(19);
-  });
-
-  it("wraps fetch errors with cause preserved", async () => {
-    const fakeFetch = async () => { throw new Error("ECONNREFUSED"); };
-    const c = new OllamaClient({ fetch: fakeFetch });
-    await expect(c.chat([{ role: "user", content: "x" }])).rejects.toThrow(/request failed/);
-  });
-
-  it("throws on non-OK status with body excerpt", async () => {
-    const fakeFetch = async () => ({
-      ok: false,
-      status: 500,
-      statusText: "Internal Server Error",
-      text: async () => "internal model crashed",
-    });
-    const c = new OllamaClient({ fetch: fakeFetch });
-    await expect(c.chat([{ role: "user", content: "x" }])).rejects.toThrow(/500/);
-  });
-
-  it("health() returns ok when /api/tags responds 200", async () => {
-    const fakeFetch = async () => ({ ok: true, status: 200 });
-    const c = new OllamaClient({ fetch: fakeFetch });
-    const h = await c.health();
-    expect(h.ok).toBe(true);
-  });
-
-  it("health() returns ok=false on error", async () => {
-    const fakeFetch = async () => { throw new Error("down"); };
-    const c = new OllamaClient({ fetch: fakeFetch });
-    const h = await c.health();
-    expect(h.ok).toBe(false);
-    expect(h.error).toContain("down");
-  });
-});

package/__tests__/longtail-adapters.test.js

@@ -1,281 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const fs = require("node:fs");
-const path = require("node:path");
-const os = require("node:os");
-
-const {
-  DouyinAdapter,
-  XiaohongshuAdapter,
-  QQAdapter,
-  TelegramAdapter,
-} = 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");
-          },
-        };
-      },
-      pragma() {},
-      close() {},
-    };
-  };
-}
-
-function tmpDb() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "longtail-"));
-  const dbPath = path.join(dir, "fake.db");
-  fs.writeFileSync(dbPath, "fake");
-  return { dir, dbPath };
-}
-
-function cleanup(dir) {
-  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) {}
-}
-
-// ─── DouyinAdapter ──────────────────────────────────────────────────────
-
-describe("DouyinAdapter", () => {
-  it("contract conformance", () => {
-    const a = new DouyinAdapter({ account: { uid: "u-1" } });
-    expect(assertAdapter(a).ok).toBe(true);
-  });
-
-  it("snapshot mode constructs without account.uid (stateless)", () => {
-    // §A8 v0.2: constructor loosened — snapshot mode pulls account from the
-    // snapshot file. Sqlite mode still requires account.uid, checked at sync
-    // time not construction (see _syncViaSqlite throw at runtime).
-    const a = new DouyinAdapter({});
-    expect(assertAdapter(a).ok).toBe(true);
-    expect(a.account).toBeNull();
-  });
-
-  it("sync yields history + favourite + search", async () => {
-    const { dir, dbPath } = tmpDb();
-    try {
-      const mockDriver = makeMockDriver([
-        ["FROM video_history", [{ id: 1, aweme_id: "v1", title: "Cat", view_time: 1700000000, author: "@cat", duration: 30 }]],
-        ["FROM history", []],
-        ["FROM user_favorite", [{ id: 1, aweme_id: "v2", title: "Saved", create_time: 1700001000 }]],
-        ["FROM favourite", []],
-        ["FROM search_history", [{ id: 1, keyword: "music", time: 1700002000 }]],
-      ]);
-      const a = new DouyinAdapter({ account: { uid: "u-1" }, dbPath, dbDriverFactory: () => mockDriver });
-      const raws = [];
-      for await (const r of a.sync()) raws.push(r);
-      expect(raws.length).toBe(3);
-      for (const r of raws) {
-        expect(validateBatch(a.normalize(r)).valid).toBe(true);
-      }
-    } finally { cleanup(dir); }
-  });
-});
-
-// ─── XiaohongshuAdapter ─────────────────────────────────────────────────
-
-describe("XiaohongshuAdapter", () => {
-  it("contract conformance", () => {
-    const a = new XiaohongshuAdapter({ account: { uid: "u-1" } });
-    expect(assertAdapter(a).ok).toBe(true);
-    expect(a.capabilities).toContain("sync:snapshot");
-    expect(a.capabilities).toContain("sync:sqlite");
-  });
-
-  it("snapshot mode constructs without account.uid (stateless)", () => {
-    // §A8 v0.2: constructor loosened — snapshot mode pulls account from the
-    // snapshot file. Sqlite mode still requires account.uid, checked at sync
-    // time not construction.
-    const a = new XiaohongshuAdapter({});
-    expect(assertAdapter(a).ok).toBe(true);
-    expect(a.account).toBeNull();
-  });
-
-  it("sync yields history + likes + favourites", async () => {
-    const { dir, dbPath } = tmpDb();
-    try {
-      const mockDriver = makeMockDriver([
-        ["FROM browse_history", [{ id: 1, note_id: "n1", title: "Recipe", view_time: 1700000000, author: "chef" }]],
-        ["FROM note", []],
-        ["FROM liked_note", [{ id: 1, note_id: "n2", title: "Liked", like_time: 1700001000 }]],
-        ["FROM favourite", [{ id: 1, note_id: "n3", title: "Saved", save_time: 1700002000 }]],
-      ]);
-      const a = new XiaohongshuAdapter({ account: { uid: "u-1" }, dbPath, dbDriverFactory: () => mockDriver });
-      const raws = [];
-      for await (const r of a.sync()) raws.push(r);
-      expect(raws.length).toBe(3);
-      for (const r of raws) {
-        const batch = a.normalize(r);
-        expect(validateBatch(batch).valid).toBe(true);
-      }
-    } finally { cleanup(dir); }
-  });
-});
-
-// ─── QQAdapter ──────────────────────────────────────────────────────────
-
-describe("QQAdapter", () => {
-  it("contract conformance", () => {
-    const a = new QQAdapter({ account: { qq: "12345" } });
-    expect(assertAdapter(a).ok).toBe(true);
-    expect(a.dataDisclosure.legalGate).toBe(true);
-    expect(a.capabilities).toContain("sync:snapshot");
-    expect(a.capabilities).toContain("sync:sqlite");
-  });
-
-  it("snapshot mode constructs without account.qq (stateless)", () => {
-    // §Phase 13.5 v0.2: constructor loosened — snapshot mode pulls account
-    // from the snapshot file. Sqlite mode still requires account.qq, checked
-    // at sync time not construction. Mirror of weibo / bilibili A8 pattern.
-    const a = new QQAdapter({});
-    expect(assertAdapter(a).ok).toBe(true);
-    expect(a.account).toBeNull();
-  });
-
-  it("sqlite mode throws at sync time when account.qq missing", async () => {
-    const { dir, dbPath } = tmpDb();
-    try {
-      const a = new QQAdapter({ dbPath, keyProvider: { getKey: async () => "k" } });
-      let threw = null;
-      try {
-        for await (const _r of a.sync()) { /* drain */ }
-      } catch (err) {
-        threw = err;
-      }
-      expect(threw).toBeTruthy();
-      expect(String(threw.message)).toMatch(/account\.qq/);
-    } finally { cleanup(dir); }
-  });
-
-  it("authenticate({}) without inputPath nor dbPath returns NO_INPUT", async () => {
-    const a = new QQAdapter({ account: { qq: "12345" }, keyProvider: { getKey: async () => "k" } });
-    const r = await a.authenticate();
-    expect(r.ok).toBe(false);
-    expect(r.reason).toBe("NO_INPUT");
-  });
-
-  it("authenticate fails without keyProvider", async () => {
-    const { dir, dbPath } = tmpDb();
-    try {
-      const a = new QQAdapter({ account: { qq: "12345" }, dbPath });
-      const r = await a.authenticate();
-      expect(r.reason).toBe("NO_KEY_PROVIDER");
-    } finally { cleanup(dir); }
-  });
-
-  it("sync yields contact + group + message types", async () => {
-    const { dir, dbPath } = tmpDb();
-    try {
-      // §Phase 13.5 v0.2 mock — new SQL targets:
-      //   - Friends / friends / tb_recent_contact (probe order)
-      //   - TroopInfoV2
-      //   - sqlite_master LIKE 'mr_friend_%_New'
-      //   - mr_friend_<MD5(peer).upper()>_New
-      const mockDriver = makeMockDriver([
-        ["FROM Friends", [{ uin: "999", nickname: "好友A", remark: "" }]],
-        ["FROM TroopInfoV2", [{ troop_uin: "888", troop_name: "测试群", member_count: 5, owner_uin: "777" }]],
-        ["FROM sqlite_master", [{ name: "mr_friend_ABCDEF1234_New" }]],
-        [
-          "FROM mr_friend_ABCDEF1234_New",
-          [{
-            msgId: "m1", msgtype: -1000, senderuin: "999", time: 1700000000,
-            // msgData is XOR-encrypted bytes; with imei="123456789012345" key,
-            // "hi" encrypts to bytes [0x51, 0x5d] (0x68^0x31=0x59 — actually
-            // depends on imei[0] = '1' = 0x31). Use Buffer for cross-platform.
-            msgData: Buffer.from([0x68 ^ 0x31, 0x69 ^ 0x32]),
-            issend: 0, frienduin: "999", troopuin: null,
-          }],
-        ],
-      ]);
-      const a = new QQAdapter({
-        account: { qq: "12345" },
-        dbPath,
-        keyProvider: { getKey: async () => "123456789012345" },
-        dbDriverFactory: () => mockDriver,
-      });
-      const raws = [];
-      for await (const r of a.sync()) raws.push(r);
-      expect(raws.length).toBe(3); // contact + group + message
-      const contact = raws.find((r) => r.kind === "contact");
-      const group = raws.find((r) => r.kind === "group");
-      const message = raws.find((r) => r.kind === "message");
-      expect(contact).toBeDefined();
-      expect(group).toBeDefined();
-      expect(message).toBeDefined();
-      // XOR-decrypt round-trip: bytes(0x68^0x31, 0x69^0x32) XOR "12" = "hi"
-      expect(message.payload.text).toBe("hi");
-      for (const r of raws) {
-        expect(validateBatch(a.normalize(r)).valid).toBe(true);
-      }
-    } finally { cleanup(dir); }
-  });
-});
-
-// ─── TelegramAdapter ────────────────────────────────────────────────────
-
-describe("TelegramAdapter", () => {
-  it("contract conformance", () => {
-    const a = new TelegramAdapter({ account: { userId: "u-1" } });
-    expect(assertAdapter(a).ok).toBe(true);
-    expect(a.dataDisclosure.legalGate).toBe(true);
-  });
-
-  it("no-arg ctor passes contract (2026-05-25 v0.6 — account.userId OPTIONAL for snapshot mode)", () => {
-    const a = new TelegramAdapter();
-    expect(assertAdapter(a).ok).toBe(true);
-    expect(a.capabilities).toContain("sync:snapshot");
-    expect(a.capabilities).toContain("sync:sqlite");
-  });
-
-  it("authenticate(ctx.inputPath) returns ok when file readable (snapshot mode)", async () => {
-    const { dir, dbPath } = tmpDb();
-    try {
-      const a = new TelegramAdapter();
-      const auth = await a.authenticate({ inputPath: dbPath });
-      expect(auth.ok).toBe(true);
-      expect(auth.mode).toBe("snapshot-file");
-    } finally { cleanup(dir); }
-  });
-
-  it("sync yields user + chat + messages (no key needed)", async () => {
-    const { dir, dbPath } = tmpDb();
-    try {
-      const mockDriver = makeMockDriver([
-        ["FROM users", [{ uid: "111", name: "Alice", username: "alice", phone: "13800001111" }]],
-        ["FROM chats", [{ uid: "222", name: "Group A" }]],
-        ["FROM messages_v2", [{ mid: "m1", uid: "111", message: "Hi", date: 1700000000, out: 0 }]],
-        ["FROM messages", []],
-      ]);
-      const a = new TelegramAdapter({ account: { userId: "u-1" }, dbPath, dbDriverFactory: () => mockDriver });
-      const raws = [];
-      for await (const r of a.sync()) raws.push(r);
-      expect(raws.length).toBe(3);
-      for (const r of raws) {
-        expect(validateBatch(a.normalize(r)).valid).toBe(true);
-      }
-    } finally { cleanup(dir); }
-  });
-
-  it("normalize contact includes phone identifier", async () => {
-    const a = new TelegramAdapter({ account: { userId: "u-1" } });
-    const batch = a.normalize({
-      adapter: "messaging-telegram",
-      originalId: "user-111",
-      capturedAt: Date.now(),
-      payload: { kind: "contact", row: { uid: "111", name: "Bob", phone: "13800001111" } },
-    });
-    expect(batch.persons[0].identifiers.telegramId).toBe("111");
-    expect(batch.persons[0].identifiers.phone).toEqual(["13800001111"]);
-  });
-});