@chainlesschain/personal-data-hub 0.1.0 → 0.2.1

package/lib/adapters/messaging-telegram/index.js

@@ -0,0 +1,142 @@
+/**
+ * Phase 13.6 — Telegram adapter.
+ *
+ * Per sjqz/parsers/telegram.py TelegramParser. Telegram Android stores
+ * messages in a single `cache4.db` (unencrypted SQLite!). Easier than
+ * WeChat — no key extraction needed.
+ *
+ * Tables of interest:
+ *   - users          contacts + groups
+ *   - chats          chat metadata
+ *   - messages_v2    messages (multiple shards in newer versions)
+ *   - dialogs        chat ordering
+ */
+
+"use strict";
+
+const fs = require("node:fs");
+const { newId } = require("../../ids");
+
+const NAME = "messaging-telegram";
+const VERSION = "0.5.0";
+
+class TelegramAdapter {
+  constructor(opts = {}) {
+    if (!opts.account || !opts.account.userId) {
+      throw new Error("TelegramAdapter: opts.account.userId required");
+    }
+    this.account = opts.account;
+    this._dbPath = opts.dbPath || null;
+    this._dbDriverFactory = opts.dbDriverFactory || null;
+
+    this.name = NAME;
+    this.version = VERSION;
+    this.capabilities = ["sync:sqlite", "parse:telegram-messages"];
+    this.extractMode = "device-pull";
+    this.rateLimits = {};
+    this.dataDisclosure = {
+      fields: [
+        "telegram:users / chats / messages / dialogs",
+      ],
+      sensitivity: "high",
+      legalGate: true,
+    };
+  }
+
+  async authenticate() {
+    if (!this._dbPath || !fs.existsSync(this._dbPath)) {
+      return { ok: false, reason: "DB_NOT_PULLED" };
+    }
+    return { ok: true, account: this.account.userId };
+  }
+
+  async healthCheck() {
+    const r = await this.authenticate();
+    return r.ok ? { ok: true, lastChecked: Date.now() } : r;
+  }
+
+  async *sync(opts = {}) {
+    const dbPath = opts.dbPath || this._dbPath;
+    if (!dbPath || !fs.existsSync(dbPath)) return;
+    const Driver = this._dbDriverFactory
+      ? this._dbDriverFactory()
+      : require("better-sqlite3-multiple-ciphers");
+    const db = new Driver(dbPath, { readonly: true });
+    try {
+      const users = trySelect(db, "SELECT * FROM users LIMIT 5000") || [];
+      for (const row of users) {
+        yield { adapter: NAME, originalId: `user-${row.uid}`, capturedAt: Date.now(), payload: { row, kind: "contact" } };
+      }
+      const chats = trySelect(db, "SELECT * FROM chats LIMIT 5000") || [];
+      for (const row of chats) {
+        yield { adapter: NAME, originalId: `chat-${row.uid}`, capturedAt: Date.now(), payload: { row, kind: "chat" } };
+      }
+      const messages = trySelect(db, "SELECT * FROM messages_v2 ORDER BY date DESC LIMIT 10000")
+        || trySelect(db, "SELECT * FROM messages ORDER BY date DESC LIMIT 10000") || [];
+      for (const row of messages) {
+        yield { adapter: NAME, originalId: `msg-${row.mid || row.id}`, capturedAt: parseTime(row.date), payload: { row, kind: "message" } };
+      }
+    } finally {
+      try { db.close(); } catch (_e) {}
+    }
+  }
+
+  normalize(raw) {
+    const { kind, row } = raw.payload;
+    const now = Date.now();
+    const occurredAt = parseTime(row.date) || now;
+    const source = { adapter: NAME, adapterVersion: VERSION, originalId: raw.originalId, capturedAt: occurredAt, capturedBy: "sqlite" };
+
+    if (kind === "contact") {
+      return {
+        events: [], places: [], items: [], topics: [],
+        persons: [{
+          id: `person-telegram-${row.uid}`,
+          type: "person", subtype: "contact",
+          names: [row.name, row.username].filter((x) => typeof x === "string" && x.length > 0),
+          identifiers: { telegramId: String(row.uid), ...(row.phone ? { phone: [String(row.phone)] } : {}) },
+          ingestedAt: now, source,
+          extra: { fromAdapter: NAME, telegramUid: row.uid },
+        }],
+      };
+    }
+    if (kind === "chat") {
+      return {
+        events: [], places: [], items: [], persons: [],
+        topics: [{
+          id: `topic-telegram-${row.uid}`,
+          type: "topic", name: row.name || String(row.uid),
+          ingestedAt: now, source,
+          extra: { fromAdapter: NAME },
+        }],
+      };
+    }
+    // message
+    const isOutgoing = row.out === 1 || row.is_outgoing === 1;
+    return {
+      events: [{
+        id: newId(), type: "event", subtype: "message",
+        occurredAt,
+        actor: isOutgoing ? "person-self" : (row.from_id ? `person-telegram-${row.from_id}` : "person-self"),
+        content: { title: (row.message || "").slice(0, 80) || "(空)", text: row.message || "" },
+        ingestedAt: now, source,
+        extra: {
+          peer: row.uid || null,
+          isOutgoing,
+          mediaType: row.media_type || null,
+        },
+      }],
+      persons: [], places: [], items: [], topics: [],
+    };
+  }
+}
+function trySelect(db, sql) { try { return db.prepare(sql).all(); } catch (_e) { return null; } }
+function parseTime(v) {
+  if (Number.isFinite(v)) return v > 1e12 ? v : v * 1000;
+  if (typeof v === "string") {
+    if (/^\d+$/.test(v)) { const n = parseInt(v, 10); return n > 1e12 ? n : n * 1000; }
+    return Date.parse(v) || null;
+  }
+  return null;
+}
+module.exports = { TelegramAdapter, NAME, VERSION };

package/lib/adapters/messaging-whatsapp/index.js

@@ -0,0 +1,189 @@
+/**
+ * Phase 13.7 — WhatsApp adapter.
+ *
+ * Per sjqz/parsers/whatsapp.py WhatsAppParser. WhatsApp Android stores
+ * messages in `msgstore.db` (encrypted with crypt14/crypt15 layered on
+ * SQLite). v0.5 accepts:
+ *   1. Decrypted msgstore.db at `dbPath` (user used WhatsApp Crypt
+ *      Decrypter or similar tool first), or
+ *   2. Encrypted .crypt14 with `keyProvider` (Phase 13.7b adds the
+ *      actual crypt14 → SQLite decoder; for now we error gracefully).
+ *
+ * Tables of interest:
+ *   - jid                contacts + chats (jid = WhatsApp ID)
+ *   - chat               chat metadata
+ *   - message            messages
+ *   - call_log           call records
+ */
+
+"use strict";
+
+const fs = require("node:fs");
+const { newId } = require("../../ids");
+
+const NAME = "messaging-whatsapp";
+const VERSION = "0.5.0";
+
+class WhatsAppAdapter {
+  constructor(opts = {}) {
+    if (!opts.account || !opts.account.phone) {
+      throw new Error("WhatsAppAdapter: opts.account.phone required");
+    }
+    this.account = opts.account;
+    this._dbPath = opts.dbPath || null;
+    this._keyProvider = opts.keyProvider || null;
+    this._dbDriverFactory = opts.dbDriverFactory || null;
+
+    this.name = NAME;
+    this.version = VERSION;
+    this.capabilities = ["sync:sqlite", "parse:whatsapp-messages"];
+    this.extractMode = "device-pull";
+    this.rateLimits = {};
+    this.dataDisclosure = {
+      fields: [
+        "whatsapp:jid (contacts + chats)",
+        "whatsapp:messages (text / media / time)",
+        "whatsapp:call_log",
+      ],
+      sensitivity: "high",
+      legalGate: true,
+    };
+  }
+
+  async authenticate() {
+    if (!this._dbPath || !fs.existsSync(this._dbPath)) {
+      return { ok: false, reason: "DB_NOT_PULLED" };
+    }
+    return { ok: true, account: this.account.phone };
+  }
+
+  async healthCheck() {
+    const r = await this.authenticate();
+    return r.ok ? { ok: true, lastChecked: Date.now() } : r;
+  }
+
+  async *sync(opts = {}) {
+    const dbPath = opts.dbPath || this._dbPath;
+    if (!dbPath || !fs.existsSync(dbPath)) return;
+    const Driver = this._dbDriverFactory
+      ? this._dbDriverFactory()
+      : require("better-sqlite3-multiple-ciphers");
+    const db = new Driver(dbPath, { readonly: true });
+    try {
+      const jids = trySelect(db, "SELECT * FROM jid LIMIT 5000") || [];
+      for (const row of jids) {
+        yield { adapter: NAME, originalId: `jid-${row._id}`, capturedAt: Date.now(), payload: { row, kind: "contact" } };
+      }
+      const chats = trySelect(db, "SELECT * FROM chat LIMIT 1000") || [];
+      for (const row of chats) {
+        yield { adapter: NAME, originalId: `chat-${row._id}`, capturedAt: Date.now(), payload: { row, kind: "chat" } };
+      }
+      const messages = trySelect(db, "SELECT * FROM message ORDER BY timestamp DESC LIMIT 10000")
+        || trySelect(db, "SELECT * FROM messages ORDER BY timestamp DESC LIMIT 10000") || [];
+      for (const row of messages) {
+        yield { adapter: NAME, originalId: `msg-${row._id}`, capturedAt: parseTime(row.timestamp || row.received_timestamp), payload: { row, kind: "message" } };
+      }
+      const calls = trySelect(db, "SELECT * FROM call_log ORDER BY timestamp DESC LIMIT 5000") || [];
+      for (const row of calls) {
+        yield { adapter: NAME, originalId: `call-${row._id}`, capturedAt: parseTime(row.timestamp), payload: { row, kind: "call" } };
+      }
+    } finally {
+      try { db.close(); } catch (_e) {}
+    }
+  }
+
+  normalize(raw) {
+    const { kind, row } = raw.payload;
+    const now = Date.now();
+    const occurredAt = parseTime(row.timestamp || row.received_timestamp) || now;
+    const source = { adapter: NAME, adapterVersion: VERSION, originalId: raw.originalId, capturedAt: occurredAt, capturedBy: "sqlite" };
+
+    if (kind === "contact") {
+      // WhatsApp jids are "<phone>@s.whatsapp.net" or "<phone>@g.us" (group)
+      const isGroup = typeof row.raw_string === "string" && row.raw_string.includes("@g.us");
+      if (isGroup) {
+        return {
+          events: [], places: [], items: [], persons: [],
+          topics: [{
+            id: `topic-whatsapp-${row.raw_string}`,
+            type: "topic", name: row.display_name || row.raw_string,
+            ingestedAt: now, source,
+            extra: { fromAdapter: NAME, jid: row.raw_string },
+          }],
+        };
+      }
+      const phone = (row.user || "").replace(/[^0-9]/g, "");
+      return {
+        events: [], places: [], items: [], topics: [],
+        persons: [{
+          id: `person-whatsapp-${row.user || row._id}`,
+          type: "person", subtype: "contact",
+          names: [row.display_name, row.user].filter((x) => typeof x === "string" && x.length > 0),
+          identifiers: phone ? { phone: [phone] } : {},
+          ingestedAt: now, source,
+          extra: { fromAdapter: NAME, jid: row.raw_string },
+        }],
+      };
+    }
+
+    if (kind === "chat") {
+      return {
+        events: [], places: [], items: [], persons: [],
+        topics: [{
+          id: `topic-whatsapp-chat-${row._id}`,
+          type: "topic", name: row.subject || row.display_name || String(row._id),
+          ingestedAt: now, source,
+          extra: { fromAdapter: NAME },
+        }],
+      };
+    }
+
+    if (kind === "call") {
+      return {
+        events: [{
+          id: newId(), type: "event", subtype: "call",
+          occurredAt, actor: row.from_me ? "person-self" : (row.jid_row_id ? `person-whatsapp-${row.jid_row_id}` : "person-self"),
+          content: { title: `WhatsApp call (${row.video_call ? "video" : "voice"})` },
+          ingestedAt: now, source,
+          extra: {
+            duration: row.duration || null,
+            isVideo: !!row.video_call,
+            fromMe: !!row.from_me,
+            callResult: row.call_result || null,
+          },
+        }],
+        persons: [], places: [], items: [], topics: [],
+      };
+    }
+
+    // message
+    return {
+      events: [{
+        id: newId(), type: "event", subtype: "message",
+        occurredAt,
+        actor: row.from_me === 1 ? "person-self" : (row.key_remote_jid ? `person-whatsapp-${row.key_remote_jid}` : "person-self"),
+        content: { title: (row.text_data || row.data || "").slice(0, 80) || "(空)", text: row.text_data || row.data || "" },
+        ingestedAt: now, source,
+        extra: {
+          jid: row.key_remote_jid || row.from_jid_row_id || null,
+          isOutgoing: row.from_me === 1,
+          mediaType: row.media_wa_type || null,
+          status: row.status || null,
+        },
+      }],
+      persons: [], places: [], items: [], topics: [],
+    };
+  }
+}
+
+function trySelect(db, sql) { try { return db.prepare(sql).all(); } catch (_e) { return null; } }
+function parseTime(v) {
+  if (Number.isFinite(v)) return v > 1e12 ? v : v * 1000;
+  if (typeof v === "string") {
+    if (/^\d+$/.test(v)) { const n = parseInt(v, 10); return n > 1e12 ? n : n * 1000; }
+    return Date.parse(v) || null;
+  }
+  return null;
+}
+
+module.exports = { WhatsAppAdapter, NAME, VERSION };

package/lib/adapters/shopping-base/index.js

@@ -0,0 +1,208 @@
+/**
+ * Phase 7 — shared shopping adapter base.
+ *
+ * Common normalize logic for Taobao / JD / Meituan (and future Pinduoduo,
+ * Xiaohongshu, etc.) Each per-platform adapter parses platform-specific
+ * JSON into a `OrderRecord` then calls `normalizeOrderRecord()` here.
+ *
+ * OrderRecord shape (vendor-neutral):
+ *   {
+ *     vendorId:          "taobao" | "jd" | "meituan" | ...
+ *     orderId:           string  (vendor's order id, unique)
+ *     placedAt:          ms epoch
+ *     paidAt?:           ms epoch
+ *     status:            "placed" | "shipped" | "delivered" | "refunded" | "cancelled"
+ *     merchantName:      string
+ *     totalAmount:       { value, currency }
+ *     items:             [{ name, quantity, unitPrice, sku? }]
+ *     recipient?:        string
+ *     shippingAddress?:  string
+ *     trackingNumber?:   string
+ *     coupons?:          { value, currency }
+ *     extras?:           { ... vendor-specific }
+ *   }
+ *
+ * Output: Event(subtype="order"|"payment"|"refund") + merchant Person
+ * + Item entities (per ordered SKU).
+ */
+
+"use strict";
+
+const { newId } = require("../../ids");
+
+/**
+ * @param {OrderRecord} rec
+ * @param {object} ctx { adapterName, adapterVersion }
+ * @returns {NormalizedBatch}
+ */
+function normalizeOrderRecord(rec, ctx = {}) {
+  if (!rec || typeof rec !== "object") {
+    throw new Error("normalizeOrderRecord: rec required");
+  }
+  if (!rec.orderId) throw new Error("normalizeOrderRecord: rec.orderId required");
+  if (!rec.merchantName) throw new Error("normalizeOrderRecord: rec.merchantName required");
+
+  const now = Date.now();
+  const occurredAt = Number.isFinite(rec.placedAt) ? rec.placedAt : now;
+  const adapterName = ctx.adapterName || rec.vendorId || "shopping";
+  const adapterVersion = ctx.adapterVersion || "0.1.0";
+
+  const source = {
+    adapter: adapterName,
+    adapterVersion,
+    originalId: String(rec.orderId),
+    capturedAt: occurredAt,
+    capturedBy: "api",
+  };
+
+  // Merchant Person
+  const merchantId = `person-${adapterName}-merchant-${slug(rec.merchantName)}`;
+  const persons = [{
+    id: merchantId,
+    type: "person",
+    subtype: "merchant",
+    names: [rec.merchantName],
+    identifiers: {},
+    ingestedAt: now,
+    source,
+    extra: { fromAdapter: adapterName, merchant: true },
+  }];
+
+  // Items
+  const items = [];
+  if (Array.isArray(rec.items)) {
+    for (const it of rec.items) {
+      if (!it || !it.name) continue;
+      items.push({
+        id: newId(),
+        type: "item",
+        subtype: "product",
+        name: it.name,
+        merchant: merchantId,
+        price: it.unitPrice != null
+          ? { value: Number(it.unitPrice) || 0, currency: rec.totalAmount?.currency || "CNY" }
+          : null,
+        ingestedAt: now,
+        source,
+        extra: {
+          quantity: it.quantity || 1,
+          sku: it.sku || null,
+          fromAdapter: adapterName,
+        },
+      });
+    }
+  }
+
+  // Event
+  const subtype = mapStatusToSubtype(rec.status);
+  const eventId = newId();
+  const event = {
+    id: eventId,
+    type: "event",
+    subtype,
+    occurredAt,
+    actor: "person-self",
+    participants: ["person-self", merchantId],
+    content: {
+      title: `${rec.merchantName} 订单 ${rec.orderId}`,
+      ...(rec.totalAmount && Number.isFinite(rec.totalAmount.value)
+        ? { amount: { value: rec.totalAmount.value, currency: rec.totalAmount.currency || "CNY", direction: subtype === "refund" ? "in" : "out" } }
+        : {}),
+      ...(items.length > 0 ? { text: items.map((i) => `${i.name} x${i.extra.quantity || 1}`).join("; ") } : {}),
+    },
+    ingestedAt: now,
+    source,
+    extra: {
+      vendorId: rec.vendorId,
+      orderId: rec.orderId,
+      merchantName: rec.merchantName,
+      merchantOrderNumber: rec.orderId, // cross-source link to Email + Alipay
+      orderStatus: rec.status || "placed",
+      itemCount: items.length,
+      ...(rec.recipient ? { recipient: rec.recipient } : {}),
+      ...(rec.shippingAddress ? { shippingAddress: rec.shippingAddress } : {}),
+      ...(rec.trackingNumber ? { trackingNumber: rec.trackingNumber } : {}),
+      ...(rec.coupons ? { coupons: rec.coupons } : {}),
+      ...(rec.paidAt ? { paidAt: rec.paidAt } : {}),
+      ...(rec.extras ? { vendorExtras: rec.extras } : {}),
+    },
+  };
+
+  return { events: [event], persons, places: [], items, topics: [] };
+}
+
+function mapStatusToSubtype(status) {
+  const s = String(status || "").toLowerCase();
+  if (s.includes("refund") || s.includes("退款")) return "refund";
+  if (s.includes("cancel") || s.includes("close") || s.includes("已取消") || s.includes("已关闭")) return "cancelled";
+  // All other order states ("placed", "shipped", "delivered") map to
+  // `order` subtype — the lifecycle status is in extra.orderStatus.
+  return "order";
+}
+
+function slug(s) {
+  return String(s || "")
+    .toLowerCase()
+    .replace(/\s+/g, "-")
+    .replace(/[^\w一-鿿-]/g, "")
+    .slice(0, 80);
+}
+
+// ─── CookieAuth helper ──────────────────────────────────────────────────
+
+/**
+ * Cookie storage + validation helper. Each platform adapter constructs
+ * one and uses validate() before sync.
+ */
+class CookieAuth {
+  constructor(opts = {}) {
+    if (!opts.platform) throw new Error("CookieAuth: opts.platform required");
+    this.platform = opts.platform;
+    this.cookies = opts.cookies || ""; // raw "k=v; k2=v2" string
+    this._validator = opts.validator || null; // optional async fn(cookies) → boolean
+  }
+
+  setCookies(raw) {
+    if (typeof raw !== "string") throw new Error("setCookies: string required");
+    this.cookies = raw;
+  }
+
+  /**
+   * Get the cookie string for adding to Headers. Returns null when
+   * cookies are empty.
+   */
+  toHeader() {
+    return this.cookies && this.cookies.length > 0 ? this.cookies : null;
+  }
+
+  /**
+   * Validate that the stored cookies are still good. Without an
+   * injected validator returns true if non-empty (caller decides
+   * whether to probe the platform).
+   */
+  async validate() {
+    if (!this.cookies) return false;
+    if (this._validator) return await this._validator(this.cookies);
+    return true;
+  }
+
+  /**
+   * Read a specific cookie value by name (case-insensitive).
+   */
+  getCookieValue(name) {
+    if (!this.cookies || !name) return null;
+    const re = new RegExp(`(?:^|;\\s*)${escapeRegex(name)}=([^;]*)`, "i");
+    const m = re.exec(this.cookies);
+    return m ? decodeURIComponent(m[1]) : null;
+  }
+}
+
+function escapeRegex(s) {
+  return String(s).replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+
+module.exports = {
+  normalizeOrderRecord,
+  mapStatusToSubtype,
+  CookieAuth,
+};

package/lib/adapters/shopping-jd/index.js

@@ -0,0 +1,150 @@
+/**
+ * Phase 7.3 — JD (京东) adapter.
+ *
+ * Parallels Taobao but with JD's order endpoint + JSON shape:
+ *   url: https://order.jd.com/center/list.action
+ *   fields: orderId, orderTotalPrice, orderStartTime, orderStatusText,
+ *           venderName, productList (with name/quantity/price)
+ */
+
+"use strict";
+
+const { normalizeOrderRecord, CookieAuth } = require("../shopping-base");
+
+const NAME = "shopping-jd";
+const VERSION = "0.5.0";
+
+const JD_ORDERS_URL = "https://order.jd.com/center/list.action";
+
+class JdAdapter {
+  constructor(opts = {}) {
+    if (!opts.account || !opts.account.pin) {
+      throw new Error("JdAdapter: opts.account.pin required (JD user pin)");
+    }
+    this.account = opts.account;
+    this._cookieAuth = new CookieAuth({
+      platform: "jd",
+      cookies: opts.account.cookies || "",
+    });
+    this._fetchFn = typeof opts.fetchFn === "function" ? opts.fetchFn : defaultFetch;
+
+    this.name = NAME;
+    this.version = VERSION;
+    this.capabilities = ["sync:cookie-api", "parse:jd-orders"];
+    this.extractMode = "web-api";
+    this.rateLimits = { perMinute: 6, perDay: 200 };
+    this.dataDisclosure = {
+      fields: ["jd:orderId / venderName / productList / orderTotalPrice / address"],
+      sensitivity: "high",
+      legalGate: false,
+    };
+  }
+
+  async authenticate() {
+    const ok = await this._cookieAuth.validate();
+    if (!ok) return { ok: false, reason: "INVALID_COOKIE", error: "cookies missing" };
+    return { ok: true, account: this.account.pin };
+  }
+
+  async healthCheck() {
+    const r = await this.authenticate();
+    return r.ok
+      ? { ok: true, lastChecked: Date.now() }
+      : { ok: false, reason: r.reason, error: r.error };
+  }
+
+  async *sync(opts = {}) {
+    if (!(await this._cookieAuth.validate())) return;
+    const sinceMs = opts.sinceWatermark != null
+      ? parseInt(String(opts.sinceWatermark), 10) || 0
+      : (Date.now() - 365 * 24 * 3600_000);
+    let page = 1;
+    while (true) {
+      const resp = await this._fetchFn({
+        url: JD_ORDERS_URL,
+        cookies: this._cookieAuth.toHeader(),
+        query: { page },
+      });
+      if (!resp || !Array.isArray(resp.orders)) break;
+      let pageHasNew = false;
+      for (const raw of resp.orders) {
+        const rec = orderToRecord(raw);
+        if (!rec) continue;
+        if (rec.placedAt && rec.placedAt < sinceMs) break;
+        pageHasNew = true;
+        yield {
+          adapter: NAME,
+          originalId: rec.orderId,
+          capturedAt: rec.placedAt || Date.now(),
+          payload: { record: rec },
+        };
+      }
+      if (!pageHasNew || resp.orders.length < 10) break;
+      page += 1;
+    }
+  }
+
+  normalize(raw) {
+    return normalizeOrderRecord(raw.payload.record, {
+      adapterName: NAME, adapterVersion: VERSION,
+    });
+  }
+}
+
+function orderToRecord(o) {
+  if (!o || typeof o !== "object") return null;
+  const orderId = o.orderId || o.id;
+  const merchant = o.venderName || o.shopName || o.merchantName || "京东自营";
+  if (!orderId) return null;
+
+  const items = [];
+  const products = o.productList || o.products || [];
+  for (const it of products) {
+    if (!it) continue;
+    items.push({
+      name: it.productName || it.skuName || it.name,
+      quantity: parseInt(it.productQuantity || it.quantity || 1, 10),
+      unitPrice: parseFloat(it.productPrice || it.unitPrice || 0),
+      sku: it.skuId || it.sku || null,
+    });
+  }
+
+  return {
+    vendorId: "jd",
+    orderId: String(orderId),
+    placedAt: parseTime(o.orderStartTime || o.orderTime || o.createTime),
+    paidAt: parseTime(o.paymentTime || o.payTime),
+    status: mapStatus(o.orderStatusText || o.statusName || o.status),
+    merchantName: merchant,
+    totalAmount: { value: parseFloat(o.orderTotalPrice || o.totalPrice || 0), currency: "CNY" },
+    items,
+    recipient: o.consigneeName || o.receiverName,
+    shippingAddress: o.address || o.consigneeAddress,
+    trackingNumber: o.shipmentNo || o.trackingNumber,
+    extras: { rawStatus: o.orderStatusText || o.statusName },
+  };
+}
+
+function parseTime(v) {
+  if (Number.isFinite(v)) return v < 1e12 ? v * 1000 : v;
+  if (typeof v === "string") {
+    const t = Date.parse(v);
+    if (Number.isFinite(t)) return t;
+  }
+  return null;
+}
+
+function mapStatus(s) {
+  const t = String(s || "").toLowerCase();
+  if (t.includes("退款") || t.includes("refund")) return "refunded";
+  if (t.includes("取消") || t.includes("cancel")) return "cancelled";
+  if (t.includes("已发货") || t.includes("配送") || t.includes("shipped")) return "shipped";
+  if (t.includes("已完成") || t.includes("已收货") || t.includes("delivered")) return "delivered";
+  return "placed";
+}
+
+async function defaultFetch(_opts) {
+  throw new Error("JdAdapter: no fetchFn configured");
+}
+
+module.exports = { JdAdapter, orderToRecord, NAME, VERSION };