@aiao/rxdb-adapter-supabase 0.0.7

package/dist/index.js

@@ -0,0 +1,858 @@
+import { EntityRemoteRemovedEvent as M, EntityRemoteUpdatedEvent as j, EntityRemoteCreatedEvent as O, getEntityMetadata as b, isRuleGroup as x, PropertyType as E, RepositoryBase as W, RxDBAdapterRemoteBase as U } from "@aiao/rxdb";
+import { createClient as K } from "@supabase/supabase-js";
+class S extends Error {
+  constructor(t, e) {
+    super(t), this.code = e, this.name = "SupabaseSyncError";
+  }
+}
+class q extends S {
+  constructor(t) {
+    super(t, "CONFIG_ERROR"), this.name = "SupabaseConfigError";
+  }
+}
+class tt extends S {
+  constructor(t) {
+    super(t, "NETWORK_ERROR"), this.name = "SupabaseNetworkError";
+  }
+}
+class g extends S {
+  constructor(t) {
+    super(t, "DATA_ERROR"), this.name = "SupabaseDataError";
+  }
+}
+const z = {
+  INSERT: O,
+  UPDATE: j,
+  DELETE: M
+};
+function L(r, t) {
+  if (t.table !== "RxDBChange" || t.eventType !== "INSERT") return;
+  const e = t.new;
+  if (!e) return;
+  const { namespace: s, entity: n, entityId: a, type: i, patch: c, clientId: o } = e, l = r.rxdb.context.clientId;
+  if (o && l && o === l || !a || !i) return;
+  const p = z[i];
+  if (!p) return;
+  const d = { id: a, ...c };
+  r.rxdb.dispatchEvent(
+    new p([
+      {
+        type: i,
+        namespace: s || "public",
+        entity: n,
+        id: a,
+        data: d,
+        recordAt: e.createdAt ? new Date(e.createdAt) : /* @__PURE__ */ new Date()
+      }
+    ])
+  );
+}
+function D(r) {
+  const t = /* @__PURE__ */ new Map();
+  for (const e of r) {
+    const s = e.constructor;
+    t.has(s) || t.set(s, /* @__PURE__ */ new Set()), t.get(s).add(e);
+  }
+  return t;
+}
+function k(r, t) {
+  const e = [];
+  for (const [s, n] of r) {
+    const a = b(s), i = Array.from(n);
+    e.push({
+      table: a.name,
+      schema: a.namespace,
+      data: t ? i.map((c) => ({ ...c, createdBy: t, updatedBy: t })) : i
+    });
+  }
+  return e;
+}
+function Q(r) {
+  const t = [];
+  for (const [e, s] of r) {
+    const n = b(e);
+    t.push({
+      table: n.name,
+      schema: n.namespace,
+      ids: Array.from(s).map((a) => a.id)
+    });
+  }
+  return t;
+}
+const V = {
+  "=": "eq",
+  "!=": "neq",
+  "<": "lt",
+  "<=": "lte",
+  ">": "gt",
+  ">=": "gte",
+  in: "in",
+  contains: "ilike",
+  includes: "ilike",
+  startsWith: "ilike",
+  endsWith: "ilike"
+};
+function C(r) {
+  return r instanceof Date ? r.toISOString() : Array.isArray(r) ? r.map(C) : r;
+}
+function T(r, t, e) {
+  return !t || !r.mappedEntity ? e : t.getEntityMetadata(r.mappedEntity, r.mappedNamespace ?? "") ?? e;
+}
+function N(r, t) {
+  const e = C(t);
+  switch (r) {
+    case "=":
+    case "!=":
+    case "<":
+    case "<=":
+    case ">":
+    case ">=":
+      return `${V[r]}.${e}`;
+    case "in":
+      if (!Array.isArray(e)) throw new Error("IN operator requires array");
+      return `in.(${e.join(",")})`;
+    case "contains":
+    case "includes":
+      return `ilike.*${e}*`;
+    case "startsWith":
+      return `ilike.${e}*`;
+    case "endsWith":
+      return `ilike.*${e}`;
+    default:
+      throw new Error(`Unsupported operator: ${r}`);
+  }
+}
+function v(r, t, e) {
+  const [s, ...n] = r.split(".");
+  return n.length === 0 ? { field: r, operator: t, value: e } : {
+    field: s,
+    operator: "exists",
+    where: { combinator: "and", rules: [v(n.join("."), t, e)] }
+  };
+}
+function A(r, t, e, s) {
+  if (!t?.rules?.length) return r;
+  if (t.rules.length === 1) {
+    const a = t.rules[0];
+    return x(a) ? A(r, a, e, s) : R(r, a, e, s);
+  }
+  if (t.combinator === "and")
+    return t.rules.reduce(
+      (a, i) => x(i) ? A(a, i, e, s) : R(a, i, e, s),
+      r
+    );
+  const n = t.rules.map((a) => {
+    if (x(a)) throw new Error("Nested OR conditions not supported");
+    const { field: i, operator: c, value: o } = a;
+    return `${i}.${N(c, o)}`;
+  });
+  return r.or(n.join(","));
+}
+function R(r, t, e, s) {
+  const { field: n, operator: a, value: i } = t;
+  return typeof n == "string" && n.includes(".") ? R(r, v(n, a, i), e, s) : a === "exists" || a === "notExists" ? J(r, t, e, s) : B(r, n, a, i);
+}
+function J(r, t, e, s) {
+  const { field: n, operator: a } = t, i = t.where, c = String(n), o = e?.relationMap?.get(c);
+  if (!o)
+    throw new Error(`Relation '${c}' not found in '${e?.name || "unknown"}'`);
+  const l = o.mappedEntity;
+  if (!i?.rules?.length)
+    return a === "exists" ? r.not(l, "is", null) : r.is(l, null);
+  const p = e ? T(o, s, e) : void 0;
+  if (!p) throw new Error(`Cannot resolve metadata for '${c}'`);
+  return I(r, l, i, p, s, l);
+}
+function I(r, t, e, s, n, a = "") {
+  if (!e?.rules?.length) return r;
+  let i = r;
+  for (const c of e.rules) {
+    if (x(c)) {
+      i = I(i, t, c, s, n, a);
+      continue;
+    }
+    const { field: o, operator: l, value: p } = c;
+    if (l === "exists" || l === "notExists") {
+      const f = s?.relationMap?.get(String(o));
+      if (!f) throw new Error(`Relation '${o}' not found in ${t}`);
+      const h = f.mappedEntity, u = c.where, w = T(f, n, s);
+      if (u?.rules?.length) {
+        const m = a ? `${a}.${h}` : h;
+        i = I(i, h, u, w, n, m);
+      } else
+        i = l === "exists" ? i.not(h, "is", null) : i.is(h, null);
+      continue;
+    }
+    const d = a ? `${a}.${o}` : `${t}.${o}`;
+    i = B(i, d, l, p);
+  }
+  return i;
+}
+function B(r, t, e, s) {
+  const n = C(s);
+  if (t.includes(".")) {
+    if (!r.url?.searchParams)
+      throw new Error("Cannot apply nested filter: query.url.searchParams unavailable");
+    if (e === "between") {
+      const [i, c] = n;
+      return r.url.searchParams.append(t, `gte.${i}`), r.url.searchParams.append(t, `lte.${c}`), r;
+    }
+    return r.url.searchParams.append(t, N(e, n)), r;
+  }
+  switch (e) {
+    case "=":
+      return n === null ? r.is(t, null) : r.eq(t, n);
+    case "!=":
+      return n === null ? r.not(t, "is", null) : r.neq(t, n);
+    case "<":
+      return r.lt(t, n);
+    case ">":
+      return r.gt(t, n);
+    case "<=":
+      return r.lte(t, n);
+    case ">=":
+      return r.gte(t, n);
+    case "in":
+      return r.in(t, n);
+    case "notIn":
+      return r.not(t, "in", `(${n.join(",")})`);
+    case "contains":
+    case "includes":
+      return r.ilike(t, `%${n}%`);
+    case "notContains":
+      return r.not(t, "ilike", `%${n}%`);
+    case "startsWith":
+      return r.ilike(t, `${n}%`);
+    case "notStartsWith":
+      return r.not(t, "ilike", `${n}%`);
+    case "endsWith":
+      return r.ilike(t, `%${n}`);
+    case "notEndsWith":
+      return r.not(t, "ilike", `%${n}`);
+    case "between": {
+      const [i, c] = n;
+      return r.gte(t, i).lte(t, c);
+    }
+    case "notBetween": {
+      const [i, c] = n;
+      return r.or(`${t}.lt.${i},${t}.gt.${c}`);
+    }
+    case "isNull":
+      return r.is(t, null);
+    case "isNotNull":
+      return r.not(t, "is", null);
+    default:
+      throw new Error(`Unsupported operator: ${e}`);
+  }
+}
+function P(r, t) {
+  if (r == null) return r;
+  switch (t.type) {
+    case E.date:
+      return r instanceof Date ? r : new Date(r);
+    case E.keyValue:
+      if (typeof r == "object" && t.properties) {
+        const e = {};
+        for (const s of t.properties)
+          r[s.name] !== void 0 && (e[s.name] = P(r[s.name], s));
+        return e;
+      }
+      return r;
+    case E.boolean:
+      return !!r;
+    case E.json:
+    case E.stringArray:
+    case E.numberArray:
+    default:
+      return r;
+  }
+}
+function X(r, t, e) {
+  const s = new r();
+  for (const n of Object.keys(e)) {
+    const a = t.propertyMap.get(n);
+    s[n] = a ? P(e[n], a) : e[n];
+  }
+  return s;
+}
+class F extends W {
+  constructor(t, e) {
+    super(t.rxdb, e), this.adapter = t, this.metadata = b(e);
+  }
+  metadata;
+  /**
+   * 查询多个实体
+   */
+  async find(t) {
+    const e = this.extract_relation_fields(t.where);
+    let s = "*";
+    if (e.size > 0) {
+      const c = Array.from(e);
+      s = `*, ${c.filter(
+        (l) => !c.some((p) => p !== l && p.startsWith(l + "."))
+      ).map((l) => this.build_relation_select(l)).join(", ")}`;
+    }
+    let n = this.get_client().select(s);
+    if (n = A(n, t.where, this.metadata, this.adapter.rxdb.schemaManager), t.orderBy?.length)
+      for (const c of t.orderBy)
+        n = n.order(c.field, { ascending: c.sort === "asc" });
+    if (t.offset !== void 0) {
+      const c = t.offset, o = t.limit !== void 0 ? c + t.limit - 1 : Number.MAX_SAFE_INTEGER;
+      n = n.range(c, o);
+    } else t.limit !== void 0 && (n = n.limit(t.limit));
+    const { data: a, error: i } = await n;
+    if (i) throw new g(`Failed to find entities: ${i.message}`);
+    return (a || []).map((c) => X(this.EntityType, this.metadata, c));
+  }
+  /**
+   * 查询实体数量
+   */
+  async count(t) {
+    if (t.groupBy) throw new Error("groupBy not supported yet");
+    const e = this.extract_relation_fields(t.where);
+    let s = "*";
+    e.size > 0 && (s = `*, ${Array.from(e).map((c) => this.build_relation_select(c)).join(", ")}`);
+    let n = this.get_client().select(s, { count: "exact", head: !0 });
+    n = A(n, t.where, this.metadata, this.adapter.rxdb.schemaManager);
+    const { count: a, error: i } = await n;
+    if (i) {
+      if (!i.message)
+        return console.warn("Supabase count returned empty error, returning 0. Options:", JSON.stringify(t)), 0;
+      throw new g(`Failed to count entities: ${i.message}`);
+    }
+    return a ?? 0;
+  }
+  /**
+   * 创建实体
+   */
+  async create(t) {
+    const e = { ...t }, s = this.rxdb.context.userId;
+    s && (e.createdBy = s);
+    const { data: n, error: a } = await this.get_client().insert(e).select().single();
+    if (a) throw new g(`Failed to create entity: ${a.message}`);
+    return n;
+  }
+  /**
+   * 更新实体
+   */
+  async update(t, e) {
+    const { data: s, error: n } = await this.get_client().update(e).eq("id", t.id).select().single();
+    if (n) throw new g(`Failed to update entity: ${n.message}`);
+    return s;
+  }
+  /**
+   * 删除实体
+   * @param entity
+   * @returns
+   */
+  async remove(t) {
+    const { error: e } = await this.get_client().delete().eq("id", t.id);
+    if (e) throw new g(`Failed to remove entity: ${e.message}`);
+    return t;
+  }
+  // ============================================
+  // 私有方法
+  // ============================================
+  /** 提取查询中的关系字段路径（用于 EXISTS 查询的 INNER JOIN） */
+  extract_relation_fields(t) {
+    const e = /* @__PURE__ */ new Set(), s = (n, a = "") => {
+      if (n?.rules) {
+        for (const i of n.rules)
+          if (i.rules)
+            s(i, a);
+          else if (typeof i.field == "string" && i.field.includes(".")) {
+            const c = i.field.split(".");
+            for (let o = 1; o < c.length; o++) {
+              const l = c.slice(0, o).join(".");
+              e.add(a ? `${a}.${l}` : l);
+            }
+          } else if (i.operator === "exists" || i.operator === "notExists") {
+            const c = String(i.field), o = a ? `${a}.${c}` : c;
+            this.metadata.relationMap?.has(c) && e.add(o), i.where && s(i.where, o);
+          }
+      }
+    };
+    return s(t), e;
+  }
+  /**
+   * 构建关系字段的 SELECT 语法
+   * 支持嵌套路径：'orders.items' → Order!inner(*, OrderItem!inner(*))
+   */
+  build_relation_select(t) {
+    const e = t.split(".");
+    if (e.length === 1) return this.build_single_relation_select(e[0]);
+    const s = [];
+    let n = this.metadata;
+    for (const i of e) {
+      const c = n.relationMap?.get(i);
+      if (!c) return `${i}(id)`;
+      s.push({ tableName: c.mappedEntity, kind: c.kind, sourceEntity: n.name });
+      const o = this.adapter.rxdb.schemaManager.getEntityMetadata(c.mappedEntity, c.mappedNamespace ?? "");
+      o && (n = o);
+    }
+    let a = this.build_relation_segment(s[s.length - 1], !0);
+    for (let i = s.length - 2; i >= 0; i--)
+      a = this.build_relation_segment(s[i], !0).replace("(*)", `(*, ${a})`);
+    return a;
+  }
+  /**
+   * 构建单层关系 SELECT
+   * 根据关系类型生成正确的消歧语法
+   */
+  build_single_relation_select(t) {
+    const e = this.metadata.relationMap?.get(t);
+    if (!e) return `${t}(id)`;
+    const s = e.mappedEntity, n = this.metadata.name;
+    if (e.kind === "m:1" || e.kind === "1:1") {
+      const a = `${n}_${t}Id_fkey`;
+      return `${s}!${a}(*)`;
+    }
+    if (e.kind === "m:n") {
+      const a = this.get_join_table_name(n, s);
+      return `${s}!${a}(*)`;
+    }
+    return `${s}(*)`;
+  }
+  /** 构建关系 SELECT 片段 */
+  build_relation_segment(t, e) {
+    const s = e ? "!inner" : "";
+    if (t.kind === "m:n") {
+      const n = this.get_join_table_name(t.sourceEntity, t.tableName);
+      return `${t.tableName}!${n}${s}(*)`;
+    }
+    return `${t.tableName}${s}(*)`;
+  }
+  /** 获取 m:n 中间表名（按字母顺序） */
+  get_join_table_name(t, e) {
+    return [t, e].sort().join("_");
+  }
+  /** 获取带 schema 的 client */
+  get_client() {
+    return this.adapter.client.schema(this.metadata.namespace).from(this.metadata.name);
+  }
+}
+class H extends F {
+  constructor(t, e) {
+    super(t, e);
+  }
+  /**
+   * 查询子孙节点
+   *
+   * @remarks
+   * - 指定 entityId 时：包含当前节点 + 子孙节点
+   * - 不指定 entityId 时：返回所有根节点及其子孙
+   */
+  async findDescendants(t) {
+    const { entityId: e, level: s = 100 } = t, { data: n, error: a } = await this.adapter.client.rpc(
+      e ? "get_descendants" : "get_root_descendants",
+      e ? { root_id: e, max_level: s } : { max_level: s }
+    );
+    if (a) {
+      if (a.message.includes("function") || a.message.includes("Could not find"))
+        return this.findDescendantsFallback(t);
+      throw new g(`Failed to find descendants: ${a.message}`);
+    }
+    return (n || []).map((i) => this.transformRowToEntity(i));
+  }
+  /**
+   * 查询子孙节点数量
+   *
+   * @remarks
+   * - 指定 entityId 时：**不包含当前节点**，只统计后代数量
+   * - 不指定 entityId 时：统计所有根节点及其后代的总数
+   */
+  async countDescendants(t) {
+    const { entityId: e } = t, s = await this.findDescendants(t);
+    return e ? s.length - 1 : s.length;
+  }
+  /**
+   * 查询祖先节点
+   *
+   * @remarks
+   * 指定 entityId 时：包含当前节点 + 祖先节点
+   */
+  async findAncestors(t) {
+    const { entityId: e, level: s = 100 } = t;
+    if (!e)
+      return [];
+    const { data: n, error: a } = await this.adapter.client.rpc("get_ancestors", {
+      node_id: e,
+      max_level: s
+    });
+    if (a) {
+      if (a.message.includes("function") || a.message.includes("Could not find"))
+        return this.findAncestorsFallback(t);
+      throw new g(`Failed to find ancestors: ${a.message}`);
+    }
+    return (n || []).map((i) => this.transformRowToEntity(i));
+  }
+  /**
+   * 查询祖先节点数量
+   *
+   * @remarks
+   * 指定 entityId 时：**不包含当前节点**，只统计祖先数量
+   */
+  async countAncestors(t) {
+    const e = await this.findAncestors(t);
+    return Math.max(0, e.length - 1);
+  }
+  /**
+   * 备用的子孙节点查询（不使用存储函数）
+   * 仅支持简单的层级查询
+   *
+   * TODO: 当前实现存在 N+1 查询问题，对于深或宽的树性能较差。
+   * 优化方案：一次查询获取所有节点，在内存中构建树结构。
+   */
+  async findDescendantsFallback(t) {
+    const { entityId: e, level: s = 100 } = t, n = this.metadata.name, a = this.metadata.features?.tree?.hasChildren, i = [], c = /* @__PURE__ */ new Set();
+    let o = this.adapter.client.schema("public").from(n).select("*");
+    e ? o = o.eq("id", e) : o = o.is("parentId", null);
+    const { data: l, error: p } = await o;
+    if (p)
+      throw new g(`Failed to find start nodes: ${p.message}`);
+    const d = async (f, h) => {
+      for (const u of f) {
+        if (c.has(u.id) || h > s) continue;
+        c.add(u.id);
+        const w = this.transformRowToEntity(u);
+        if (a) {
+          const { count: m } = await this.adapter.client.schema("public").from(n).select("*", { count: "exact", head: !0 }).eq("parentId", u.id);
+          w.hasChildren = (m || 0) > 0;
+        }
+        if (i.push(w), h < s) {
+          const { data: m } = await this.adapter.client.schema("public").from(n).select("*").eq("parentId", u.id);
+          m && m.length > 0 && await d(m, h + 1);
+        }
+      }
+    };
+    return await d(l || [], 0), i;
+  }
+  /**
+   * 备用的祖先节点查询（不使用存储函数）
+   *
+   * TODO: 当前实现存在 N+1 查询问题，每个祖先都需要一次查询。
+   * 优化方案：一次查询获取所有节点，在内存中向上遍历。
+   */
+  async findAncestorsFallback(t) {
+    const { entityId: e, level: s = 100 } = t;
+    if (!e)
+      return [];
+    const n = this.metadata.name, a = this.metadata.features?.tree?.hasChildren, i = [];
+    let c = e, o = 0;
+    for (; c && o <= s; ) {
+      const { data: l, error: p } = await this.adapter.client.schema("public").from(n).select("*").eq("id", c);
+      if (p || !l || l.length === 0)
+        break;
+      const d = l[0], f = this.transformRowToEntity(d);
+      if (a) {
+        const { count: h } = await this.adapter.client.schema("public").from(n).select("*", { count: "exact", head: !0 }).eq("parentId", d.id);
+        f.hasChildren = (h || 0) > 0;
+      }
+      i.push(f), c = d.parentId, o++;
+    }
+    return i;
+  }
+  /**
+   * 将数据库行转换为实体
+   */
+  transformRowToEntity(t) {
+    const e = new this.EntityType();
+    return Object.keys(t).forEach((s) => {
+      s !== "level" && (e[s] = t[s]);
+    }), e;
+  }
+}
+const Y = "supabase";
+class et extends U {
+  constructor(t, e) {
+    super(t), this.options = e, this.#t = e.client ?? K(e.supabaseUrl, e.supabaseKey);
+  }
+  #t;
+  #e = null;
+  name = Y;
+  get client() {
+    return this.#t;
+  }
+  // ============================================
+  // 连接管理
+  // ============================================
+  async connect() {
+    return this.#e || (this.#e = this.#t.channel("rxdb-changes").on(
+      "postgres_changes",
+      { event: "INSERT", schema: "public", table: "RxDBChange" },
+      (t) => L(this, t)
+    ).subscribe((t, e) => {
+      e && console.error("Supabase Realtime subscription failed:", e);
+    })), this;
+  }
+  async disconnect() {
+    this.#e && (await this.#t.removeChannel(this.#e), this.#e = null);
+  }
+  async version() {
+    return "2.86.0";
+  }
+  // ============================================
+  // 批量操作
+  // ============================================
+  /**
+   * 批量保存实体（upsert 语义，非事务）
+   */
+  async saveMany(t) {
+    return t.length === 0 ? [] : this.executeUpsert(D(t));
+  }
+  /**
+   * 批量删除实体（非事务）
+   */
+  async removeMany(t) {
+    return t.length === 0 ? [] : this.executeDelete(D(t));
+  }
+  /**
+   * 批量修改实体（事务）
+   *
+   * 通过 PostgreSQL RPC 调用 `rxdb_mutations` 存储过程，
+   * 在单个数据库事务中执行所有操作，确保原子性。
+   */
+  async mutations(t) {
+    const e = this.rxdb.context.userId, s = [...k(t.create, e), ...k(t.update, e)], n = Q(t.remove), { data: a, error: i } = await this.#t.rpc("rxdb_mutations", {
+      p_upserts: s,
+      p_deletes: n
+    });
+    if (i)
+      throw new g(`Transaction failed: ${i.message}`);
+    const c = a?.upserted ?? [];
+    for (const [, o] of t.remove)
+      c.push(...o);
+    return c;
+  }
+  // ============================================
+  // Repository
+  // ============================================
+  getRepository(t) {
+    if (this.repository_cache.has(t))
+      return this.repository_cache.get(t);
+    const s = b(t).features?.tree ? new H(this, t) : new F(this, t);
+    return this.repository_cache.set(t, s), s;
+  }
+  // ============================================
+  // 工具方法
+  // ============================================
+  async isTableExisted(t) {
+    const e = b(t), n = await this.getSchemaClient(e.namespace).from(e.name).select("*", { count: "exact", head: !0 });
+    if (n.status === 200) return !0;
+    if (n.status === 204) return !1;
+    throw new g(
+      `Failed to check table existence: ${n.error?.message || `status ${n.status}`}`
+    );
+  }
+  // ============================================
+  // Pull/Push 同步方法
+  // ============================================
+  /**
+   * 从远程拉取变更记录
+   *
+   * @param sinceId - 拉取此 ID 之后的变更（不包含该 ID）
+   * @param limit - 最大拉取数量
+   * @param repositoryFilter - 可选的实体过滤列表（用于 repository-level sync）
+   * @returns RxDBChange 记录数组，按 id ASC 排序
+   *
+   * @remarks
+   * 使用 id 而非 createdAt 作为游标，避免同毫秒内多条记录导致的重复问题
+   */
+  async pullChanges(t, e = 1e3, s) {
+    const n = [];
+    let a = this.#t.from("RxDBChange").select("*").gt("id", t).order("id", { ascending: !0 }).limit(e);
+    s && s.length > 0 && (a = a.in("entity", s));
+    const { data: i, error: c } = await a;
+    if (c)
+      throw new g(`Failed to pull changes: ${c.message}`);
+    const o = (i ?? []).map((l) => ({
+      ...l,
+      createdAt: new Date(l.createdAt),
+      updatedAt: l.updatedAt ? new Date(l.updatedAt) : null
+    }));
+    return n.push(...o), n;
+  }
+  /**
+   * 获取远程变更数量（轻量级，不下载数据）(T042, US2)
+   *
+   * 此方法只查询远程有多少新变更，不返回实际数据。
+   * 用于实现 checkRepositoryUpdates() 功能，节省带宽。
+   *
+   * @param sinceId - 起始 changeId（不包含该 ID）
+   * @param repositoryFilter - 可选的实体过滤列表
+   * @returns 变更数量和最新 changeId
+   *
+   * @example
+   * ```typescript
+   * // 查询 Todo 实体的新变更数量
+   * const { count, latestChangeId } = await adapter.getChangeCount(100, ['Todo']);
+   * console.log(`有 ${count} 条新变更，最新 ID: ${latestChangeId}`);
+   * ```
+   */
+  async getChangeCount(t, e) {
+    let s = this.#t.from("RxDBChange").select("*", { count: "exact", head: !0 }).gt("id", t);
+    e && e.length > 0 && (s = s.in("entity", e));
+    const { count: n, error: a } = await s;
+    if (a)
+      throw new g(`Failed to get change count: ${a.message}`);
+    let i = t;
+    if (n && n > 0) {
+      let c = this.#t.from("RxDBChange").select("id").gt("id", t).order("id", { ascending: !1 }).limit(1);
+      e && e.length > 0 && (c = c.in("entity", e));
+      const { data: o, error: l } = await c;
+      if (l)
+        throw new g(`Failed to get latest changeId: ${l.message}`);
+      o && o.length > 0 && (i = o[0].id);
+    }
+    return {
+      count: n ?? 0,
+      latestChangeId: i
+    };
+  }
+  /**
+   * 推送变更记录到远程（双写：RxDBChange 表 + 实体表）
+   *
+   * @deprecated 请使用 mergeChanges 代替，该方法不支持事务且效率较低
+   * @param changes - 待推送的变更（已压缩）
+   * @throws 当任何变更推送失败时抛出错误
+   */
+  async pushChanges(t) {
+    if (t.length === 0) return;
+    const e = {
+      inserts: /* @__PURE__ */ new Map(),
+      updates: /* @__PURE__ */ new Map(),
+      deletes: /* @__PURE__ */ new Map()
+    };
+    for (const s of t) {
+      const { entityKey: n, finalType: a, finalPatch: i, inversePatch: c } = s;
+      if (a)
+        switch (a) {
+          case "INSERT":
+            e.inserts.set(n, { patch: i, inversePatch: c });
+            break;
+          case "UPDATE":
+            e.updates.set(n, { patch: i, inversePatch: c });
+            break;
+          case "DELETE":
+            e.deletes.set(n, { patch: null, inversePatch: c });
+            break;
+        }
+    }
+    await this.mergeChanges(e);
+  }
+  /**
+   * 应用压缩后的变更到远程（事务）
+   *
+   * 通过 rxdb_mutations RPC 在单个事务中：
+   * 1. 写入 RxDBChange 表（用于其他客户端 pull）
+   * 2. 应用 actions 到实体表（INSERT/UPDATE/DELETE）
+   * 3. 自动跳过同步触发器（p_skip_sync=true）
+   *
+   * @param actions - 压缩后的变更操作集合
+   */
+  async mergeChanges(t) {
+    const e = (/* @__PURE__ */ new Date()).toISOString(), s = this.rxdb.context.userId, n = [], a = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+    for (const [d, { inversePatch: f }] of t.deletes) {
+      const [h, u, w] = d.split(":"), m = h ? `${h}.${u}` : u;
+      n.push({
+        namespace: h || "public",
+        entity: u,
+        entityId: w,
+        type: "DELETE",
+        patch: null,
+        inversePatch: f,
+        clientId: this.rxdb.context.clientId,
+        createdAt: e,
+        updatedAt: e
+      });
+      const y = i.get(m) ?? [];
+      y.push(w), i.set(m, y);
+    }
+    for (const [d, { patch: f, inversePatch: h }] of t.updates) {
+      const [u, w, m] = d.split(":"), y = u ? `${u}.${w}` : w;
+      n.push({
+        namespace: u || "public",
+        entity: w,
+        entityId: m,
+        type: "UPDATE",
+        patch: f,
+        inversePatch: h,
+        clientId: this.rxdb.context.clientId,
+        createdAt: e,
+        updatedAt: e
+      });
+      const $ = a.get(y) ?? [], _ = { id: m, ...f };
+      s && (_.updatedBy = s), $.push(_), a.set(y, $);
+    }
+    for (const [d, { patch: f, inversePatch: h }] of t.inserts) {
+      const [u, w, m] = d.split(":"), y = u ? `${u}.${w}` : w;
+      n.push({
+        namespace: u || "public",
+        entity: w,
+        entityId: m,
+        type: "INSERT",
+        patch: f,
+        inversePatch: h,
+        clientId: this.rxdb.context.clientId,
+        createdAt: e,
+        updatedAt: e
+      });
+      const $ = a.get(y) ?? [], _ = { id: m, ...f };
+      s && (_.createdBy = s, _.updatedBy = s), $.push(_), a.set(y, $);
+    }
+    const c = Array.from(a.entries()).map(([d, f]) => {
+      const [h, u] = d.includes(".") ? d.split(".") : ["public", d];
+      return { table: u, schema: h, data: f };
+    }), o = Array.from(i.entries()).map(([d, f]) => {
+      const [h, u] = d.includes(".") ? d.split(".") : ["public", d];
+      return { table: u, schema: h, ids: f };
+    }), { data: l, error: p } = await this.#t.rpc("rxdb_mutations", {
+      p_upserts: c,
+      p_deletes: o,
+      p_changes: n,
+      p_skip_sync: !0
+    });
+    if (p)
+      throw new g(`Failed to merge changes: ${p.message}`);
+    return l?.max_change_id ?? void 0;
+  }
+  // ============================================
+  // 私有方法
+  // ============================================
+  /** 获取带 schema 的客户端 */
+  getSchemaClient(t) {
+    return t ? this.#t.schema(t) : this.#t;
+  }
+  /** 执行 upsert（非事务） */
+  async executeUpsert(t) {
+    const e = [], s = this.rxdb.context.userId;
+    for (const [n, a] of t) {
+      const i = b(n), c = this.getSchemaClient(i.namespace), o = Array.from(a), l = s ? o.map((f) => ({ ...f, createdBy: s, updatedBy: s })) : o, { data: p, error: d } = await c.from(i.name).upsert(l).select();
+      if (d)
+        throw new g(`Failed to upsert: ${d.message}`);
+      e.push(...p);
+    }
+    return e;
+  }
+  /** 执行 delete（非事务） */
+  async executeDelete(t) {
+    const e = [];
+    for (const [s, n] of t) {
+      const a = b(s), i = this.getSchemaClient(a.namespace), c = Array.from(n), o = c.map((p) => p.id), { error: l } = await i.from(a.name).delete().in("id", o);
+      if (l)
+        throw new g(`Failed to delete: ${l.message}`);
+      e.push(...c);
+    }
+    return e;
+  }
+}
+export {
+  Y as ADAPTER_NAME,
+  et as RxDBAdapterSupabase,
+  q as SupabaseConfigError,
+  g as SupabaseDataError,
+  tt as SupabaseNetworkError,
+  F as SupabaseRepository,
+  S as SupabaseSyncError,
+  H as SupabaseTreeRepository
+};