@aiao/rxdb-adapter-sqlite 0.0.2 → 0.0.4

package/dist/index.js

@@ -0,0 +1,1683 @@
+import { RxDBError as Le, PropertyType as $, RelationKind as B, getEntityMetadata as N, RxDBChange as we, getEntityStatus as M, EntityCreateEvent as je, EntityUpdateEvent as Fe, RxDBBranch as ie, isEntityMatchWhere as Q, isEntityEffectOrderBy as ge, calculateOrderBy as $e, RepositoryBase as Ue, ENTITY_CREATE_EVENT as se, ENTITY_UPDATE_EVENT as ne, ENTITY_REMOVE_EVENT as V, DATABASE_DELETE as We, DATABASE_INSERT as Ve, DATABASE_UPDATE as Pe, TransactionBeginEvent as Ge, TransactionRollbackEvent as Qe, TransactionCommitEvent as Ke, RxDBAdapterLocalBase as He, uuid as Ye, RxDBAdapterUpdateChangeEvent as Je, RxDBAdapterInsertChangeEvent as Xe, RxDBAdapterDeleteChangeEvent as ze } from "@aiao/rxdb";
+import { proxy as Ze, wrap as et } from "comlink";
+import { firstValueFrom as g, Subject as z, debounceTime as Z, bufferWhen as pe, filter as G, map as w, shareReplay as U, ReplaySubject as re, BehaviorSubject as K, Observable as Re, takeUntil as Te, distinctUntilChanged as tt, tap as D, switchMap as E, take as ae, defer as st, catchError as nt, of as rt, from as me } from "rxjs";
+import { pickBy as Ne, isString as at, isFunction as Ae, traverseObjectKeys as ct, get as ot, once as T } from "@aiao/utils";
+import it from "object-hash";
+import { Factory as lt, SQLITE_ROW as ut, SQLITE_UTF8 as Ie, SQLITE_DETERMINISTIC as ve } from "wa-sqlite";
+const ht = (s) => `SELECT * FROM sqlite_master WHERE type='table' AND name='${s}' limit 1;`, dt = (s) => !!s.sql && (s.results.length === 0 || s.results[0].rows.length === 0), v = "_rowid", _t = (s) => {
+  switch (s.type) {
+    case $.uuid:
+    case $.string:
+    case $.json:
+      return "TEXT";
+    case $.number:
+      return "REAL";
+    case $.integer:
+    case $.boolean:
+      return "INTEGER";
+    default:
+      return "TEXT";
+  }
+}, ft = (s, e) => {
+  if (s === null && e.nullable) return null;
+  if (s !== void 0)
+    switch (e.type) {
+      case $.boolean:
+        return s ? 1 : 0;
+      case $.date:
+        return s instanceof Date ? s.toISOString() : s;
+      default:
+        return s;
+    }
+}, pt = (s, e) => {
+  if (s === null && e.nullable) return null;
+  if (s !== void 0)
+    switch (e.type) {
+      case $.boolean:
+        return !!s;
+      case $.date:
+        return new Date(s);
+      case $.json:
+        return s ? JSON.parse(s) : null;
+      default:
+        return s;
+    }
+}, Oe = (s, e) => `${e}$${s}`, b = (s) => Oe(s.name, s.namespace), xe = (s, e) => `idx_${s.name}_${e.name}`;
+class R extends Error {
+  constructor(e) {
+    super(e), this.name = "RxDBError", Object.setPrototypeOf(this, Le.prototype);
+  }
+}
+const H = (s, e) => {
+  const n = {};
+  return Object.keys(e).forEach((t) => {
+    t.endsWith("Id") && (n[t] = e[t]);
+    const r = s.propertyMap.get(t);
+    r && (n[t] = ft(e[t], r));
+  }), n;
+}, Se = (s, e) => Ne(e, (n, t) => s.propertyMap.has(t) || s.foreignKeyNames.includes(t)), mt = (s, e) => Ne(e, (n, t) => s.propertyMap.get(t)?.readonly !== !0), qe = (s) => at(s) ? `'${s}'` : s ?? "NULL", ee = (s, e = []) => {
+  for (; s.includes("?"); ) {
+    const n = qe(e.shift());
+    s = s.replace("?", n);
+  }
+  return s;
+}, ce = (s, e, n) => {
+  const t = {};
+  return n.forEach((r, a) => {
+    const c = e[a];
+    if (s.isForeignKey(c))
+      t[c] = r;
+    else {
+      const o = s.propertyMap.get(c);
+      o && (t[c] = pt(r, o));
+    }
+  }), t;
+}, Et = async (s, e, n) => {
+  const t = s.localRxDBBranch(), r = s.localRxDBChange();
+  let a = !1;
+  try {
+    await g(t.get(e)), a = !0;
+  } catch {
+  }
+  if (a) throw new R(`Branch ID (${e}) already exists`);
+  let c;
+  if (n ? c = await g(
+    t.findOne({
+      where: {
+        combinator: "and",
+        rules: [{ field: "changes.id", operator: "=", value: n }]
+      }
+    })
+  ) : c = await g(
+    t.findOne({
+      where: {
+        combinator: "and",
+        rules: [{ field: "activated", operator: "=", value: !0 }]
+      }
+    })
+  ), !c) throw new R("Source branch not found");
+  n || (n = (await g(
+    r.findOne({
+      where: {
+        combinator: "and",
+        rules: [
+          { field: "branchId", operator: "=", value: c.id },
+          {
+            field: "revertChangedAt",
+            operator: "=",
+            value: null
+          }
+        ]
+      },
+      orderBy: [{ field: "id", sort: "desc" }]
+    })
+  ))?.id), console.log("创建分支", {
+    fromBranch: c,
+    fromChangeId: n,
+    newBranchId: e
+  });
+}, Be = (s, e, n) => {
+  const t = b(s), r = n?.userId && s.propertyMap.has("createdBy"), a = n?.userId && s.propertyMap.has("updatedBy"), c = [...s.propertyMap.keys(), ...s.foreignKeyNames], o = [];
+  e.forEach((u) => {
+    const l = Se(s, u);
+    r && (l.createdBy = n.userId), a && (l.updatedBy = n.userId);
+    const h = H(s, l), _ = [];
+    c.forEach((f) => {
+      const p = qe(h[f]);
+      _.push(p);
+    }), o.push(_);
+  });
+  const i = o.map((u) => `(${u.join(",")})`).join(",");
+  return `INSERT INTO "${t}" (${c.join(",")}) VALUES ${i};`;
+}, yt = (s, e) => {
+  let n = "";
+  const t = b(e);
+  return Array.from(e.relationMap.values()).forEach((r) => {
+    switch (r.kind) {
+      case B.ONE_TO_ONE:
+      case B.MANY_TO_ONE:
+        {
+          const a = `${r.name}Id`;
+          if (n += `
+ALTER TABLE "${t}" ADD COLUMN "${a}" TEXT`, r.nullable || (n += " NOT NULL"), r.kind === B.MANY_TO_ONE && Reflect.get(r, "default") !== void 0) {
+            const c = r;
+            let o = c.default;
+            Ae(c.default) && (o = c.default()), n += ` DEFAULT ${o}`;
+          }
+          if (r.mappedEntity) {
+            const c = Oe(r.mappedEntity, r.mappedNamespace);
+            n += ` REFERENCES ${c}(id)`;
+          }
+          r.kind === B.MANY_TO_ONE && (n += " ON DELETE CASCADE"), n += ";", (r.unique || r.kind === B.ONE_TO_ONE) && (n += `
+ CREATE UNIQUE INDEX ${xe(e, r)} on "${t}"(${a});`);
+        }
+        break;
+    }
+  }), n;
+}, bt = (s, e) => {
+  const n = b(e);
+  let t = `CREATE TABLE "${n}" (`;
+  const r = [], a = [], c = [];
+  e.propertyMap.forEach((i) => {
+    let u = `"${i.name}" ${_t(i)}`;
+    if (i.type === $.integer && i.primary ? u += " PRIMARY KEY AUTOINCREMENT" : (i.type === $.uuid || i.type === $.string) && i.primary && (u += " PRIMARY KEY"), !i.nullable) u += " NOT NULL";
+    else if (Reflect.get(i, "default") !== void 0) {
+      let l = i.default;
+      Ae(i.default) && (l = i.default()), l === "CURRENT_TIMESTAMP" ? u += " DEFAULT(strftime('%FT%H:%M:%fZ'))" : u += ` DEFAULT ${String(l)}`;
+    }
+    switch (i.type) {
+      case $.json:
+        a.push(`CHECK ( JSON_VALID(${i.name})=1 )`);
+        break;
+      case $.boolean:
+        a.push(`CHECK (${i.name} in(0,1))`);
+        break;
+    }
+    i.unique && r.push(
+      `CREATE UNIQUE INDEX ${xe(e, i)} on "${n}"(${i.name});`
+    ), c.push(u);
+  });
+  const o = [...c, ...a];
+  if (o.length)
+    t += o.map((i) => `
+${i}`).join(","), t += `
+);`;
+  else
+    throw new R("columns is empty!");
+  return r.length && (t += `
+` + r.join(`
+`)), t;
+}, wt = (s, e) => {
+  let n = "";
+  return n += bt(s, e), n += yt(s, e), n;
+}, le = (s, e, n = "main", t = null) => {
+  const r = b(e), a = N(we), c = b(a), { propertyMap: o, name: i, foreignKeyNames: u, namespace: l } = e, h = [...o.keys(), ...u].filter((d) => ["id", "updatedAt"].includes(d) === !1), _ = "namespace, entity, type, branchId, parentId, entityId, inversePatch, patch", f = t !== null && t >= 0 ? t : "NULL", p = `
+  DROP TRIGGER IF EXISTS ${r}_insert;
+  CREATE TRIGGER ${r}_insert AFTER INSERT ON "${r}"
+  BEGIN
+    INSERT INTO ${c} (${_}) VALUES (
+      '${l}', '${i}', 'INSERT', '${n}', ${f}, NEW.id, NULL,
+      json_object(${h.map((d) => `'${d}', NEW.${d}`).join(`,
+`)})
+    );
+  END;`, m = `
+  DROP TRIGGER IF EXISTS ${r}_update;
+  CREATE TRIGGER ${r}_update AFTER UPDATE ON "${r}"
+    WHEN ( ${h.map((d) => `OLD.${d} IS NOT NEW.${d}`).join(` OR
+`)} )
+  BEGIN
+    INSERT INTO ${c} (${_}) VALUES (
+      '${l}','${i}','UPDATE', '${n}', ${f}, NEW.id,
+      (
+        SELECT json_group_object(key, value) FROM (
+          ${h.map((d) => `SELECT '${d}' AS key, OLD.${d} AS value WHERE OLD.${d} IS NOT NEW.${d}`).join(`
+ UNION `)}
+        )
+      ),
+      (
+        SELECT json_group_object(key, value) FROM (
+          ${h.map((d) => `SELECT '${d}' AS key, NEW.${d} AS value WHERE OLD.${d} IS NOT NEW.${d}`).join(`
+ UNION `)}
+        )
+      )
+    );
+  END;`, A = `
+  DROP TRIGGER IF EXISTS ${r}_delete;
+  CREATE TRIGGER ${r}_delete AFTER DELETE ON "${r}"
+  BEGIN
+    INSERT INTO ${c} (${_}) VALUES (
+      '${l}', '${i}', 'DELETE', '${n}', ${f}, OLD.id,
+      json_object(${h.map((d) => `'${d}', OLD.${d}`).join(`,
+`)}), NULL
+    );
+  END;`;
+  return p + `
+` + m + `
+` + A;
+}, gt = (s, e, n) => {
+  let t = "";
+  for (let r = 0; r < e.length; r++) {
+    const a = e[r], c = N(a);
+    if (t += `
+` + wt(s, c), c.log !== !1) {
+      const o = le(s, c);
+      t += `
+` + o;
+    }
+  }
+  if (n) {
+    const r = /* @__PURE__ */ new Map();
+    n.forEach((a) => {
+      const c = N(a);
+      r.has(c) === !1 && r.set(c, /* @__PURE__ */ new Set()), r.get(c).add(a);
+    });
+    for (const a of r.keys()) {
+      const c = Be(
+        a,
+        Array.from(r.get(a)),
+        s.rxdb.context
+      );
+      t += `
+` + c;
+    }
+  }
+  return t;
+}, ke = (s, e, n, t) => {
+  const r = mt(s, n);
+  s.propertyMap.has("updatedAt") && (r.updatedAt = t?.updatedAt ?? /* @__PURE__ */ new Date()), t?.userId && s.propertyMap.has("updatedBy") && (r.updatedBy = t.userId);
+  const a = H(s, r), c = Object.keys(r).map((h) => `${h} = ?`).join(","), o = [...Object.values(a)], i = b(s), u = Array.isArray(e) ? e : [e];
+  let l = `UPDATE "${i}" SET ${c} WHERE id `;
+  return Array.isArray(e) ? l += `in (${u.map((h) => `'${h.id}'`).join(",")})` : (o.push(e.id), l += "= ?"), t?.returning !== !1 ? l += ` RETURNING rowid as ${v}, *;` : l += ";", {
+    sql: l,
+    params: o
+  };
+}, ue = (s) => s?.map((e) => `_."${e.field}" ${e.sort}`).join(", "), L = (s, e = /* @__PURE__ */ new Map()) => {
+  const n = s.rules.map((t) => Ee(t) ? L(t, e) : $t(t, e)).filter(Boolean);
+  return n.length === 0 ? "" : n.length === 1 ? n[0] : `(${n.join(Ee(s) ? ` ${s.combinator} ` : " ")})`;
+}, $t = (s, e) => {
+  let n, t;
+  if (s?.value === null ? s.operator === "=" ? (n = "", t = "is null") : s.operator === "!=" && (n = "", t = "is not null") : (n = Tt(s.operator).toLowerCase(), t = Nt(s)), !t && ["in", "notIn", "between", "notBetween"].includes(s.operator)) return "";
+  let r = String(s.field);
+  if (e.has(r))
+    r = e.get(r);
+  else if (r.includes(".")) {
+    const a = r.lastIndexOf("."), c = r.slice(0, a), o = r.slice(a + 1);
+    r = `'${c}'.${o}`;
+  }
+  return `${r} ${n} ${t}`.replaceAll(/ +/g, " ").trim();
+}, Ee = (s) => "rules" in s && "combinator" in s, Rt = {
+  "=": "=",
+  "!=": "!=",
+  ">": ">",
+  ">=": ">=",
+  "<": "<",
+  "<=": "<=",
+  in: "IN",
+  notIn: "NOT IN",
+  between: "BETWEEN",
+  notBetween: "NOT BETWEEN",
+  contains: "LIKE",
+  notContain: "NOT LIKE",
+  beginWith: "LIKE",
+  notBeginWith: "NOT LIKE",
+  endWith: "LIKE",
+  notEndWith: "NOT LIKE"
+}, Tt = (s) => Rt[s] || s, Nt = (s) => {
+  switch (s.operator) {
+    case "in":
+    case "notIn":
+      return `(${s.value.map((e) => `'${e}'`).join(", ")})`;
+    case "between":
+    case "notBetween": {
+      const [e, n] = s.value;
+      return `'${e}' and '${n}'`;
+    }
+    case "contains":
+    case "notContain":
+      return `'%${s.value}%'`;
+    case "beginWith":
+    case "notBeginWith":
+      return `'${s.value}%'`;
+    case "endWith":
+    case "notEndWith":
+      return `'%${s.value}'`;
+  }
+  return typeof s.value == "boolean" ? s.value ? "1" : "0" : typeof s.value == "string" ? `'${s.value}'` : typeof s.value == "number" ? s.value.toString() : s.value instanceof Date ? `'${s.value.toISOString()}'` : `'${s.value}'`;
+}, Y = (s, e, n) => {
+  const t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), o = (l) => {
+    let h = l, _ = 1;
+    for (; r.has(h); )
+      h = `${l}_${_}`, _++;
+    return r.add(h), h;
+  }, i = (l) => {
+    if (c.has(l))
+      return c.get(l);
+    const h = l.includes("_") ? l : l.split("_")[0], _ = o(h);
+    return c.set(l, _), _;
+  };
+  ct(n, (l, h, _) => {
+    const f = h;
+    if (l !== "field" || f.includes(".") === !1) return;
+    const { relations: p, isForeignKey: m, propertyName: A } = s.rxdb.schemaManager.getFieldRelations(
+      e,
+      h
+    );
+    if (m) {
+      _.field = A;
+      return;
+    }
+    const d = f.replace(`.${A}`, ""), y = (O) => p.length === 1 ? O.name : `${d}_${O.name}`, k = (O) => (t.has(O) || t.set(O, []), t.get(O));
+    p.forEach(({ metadata: O, relation: S }, _e) => {
+      const W = s.rxdb.schemaManager.findMappedRelation(O, S);
+      if (!W) throw new R("mappedRelation not found");
+      const X = () => {
+        const q = k(W.metadata), I = y(S), F = i(I);
+        return {
+          joinArray: q,
+          uniqueAlias: F
+        };
+      };
+      let x = "_";
+      if (_e > 0) {
+        const q = p[_e - 1], I = y(q.relation);
+        x = i(I);
+      }
+      switch (S.kind) {
+        case B.ONE_TO_ONE:
+        case B.ONE_TO_MANY:
+          {
+            const { joinArray: q, uniqueAlias: I } = X();
+            q.push({
+              joinTableName: I,
+              on: `'${I}'.${W.relation.name}Id = ${x === "_" ? x : `'${x}'`}.id`
+            });
+          }
+          break;
+        case B.MANY_TO_ONE:
+          {
+            const { joinArray: q, uniqueAlias: I } = X();
+            q.push({
+              joinTableName: I,
+              on: `'${I}'.id = ${x === "_" ? x : `'${x}'`}.${S.name}Id`
+            });
+          }
+          break;
+        case B.MANY_TO_MANY:
+          {
+            const q = N(S.junctionEntityType), I = k(q), F = o(`${S.name}_m_n`);
+            I.push({
+              joinTableName: F,
+              on: `'${F}'.${W.relation.name}Id = ${x === "_" ? x : `'${x}'`}.id`
+            });
+            const { joinArray: De, uniqueAlias: fe } = X();
+            De.push({
+              joinTableName: fe,
+              on: `'${fe}'.id = '${F}'.${S.name}Id`
+            });
+          }
+          break;
+      }
+    });
+    const C = p[p.length - 1];
+    if (s.rxdb.schemaManager.findMappedRelation(
+      C.metadata,
+      C.relation
+    )) {
+      const O = y(C.relation), S = i(O);
+      a.set(f, `'${S}'.${A}`);
+    }
+  });
+  let u = "";
+  for (const [l, h] of t.entries()) {
+    const _ = b(l);
+    for (const f of h)
+      u += ` LEFT JOIN "${_}" "${f.joinTableName}" ON ${f.on}`;
+  }
+  return { joinSQL: u, fieldAliasMap: a };
+}, J = (s) => {
+  const { tableName: e, where: n, limit: t, offset: r, orderBy: a, join: c } = s;
+  let o = `SELECT _.rowid as ${v}, _.* FROM '${e}' _`;
+  return c && (o += c), n && (o += ` where ${n}`), a && (o += ` order by ${a}`), t && (o += ` limit ${t}`), r && (o += ` offset ${r}`), o += ";", o;
+}, At = (s, e, n) => {
+  const t = n.where, { joinSQL: r, fieldAliasMap: a } = Y(s, e, t), c = b(e), o = L(t, a), i = ue(n?.orderBy), u = n?.limit || 100, l = n?.offset || 0;
+  return {
+    sql: J({ tableName: c, where: o, orderBy: i, join: r, limit: u, offset: l }),
+    params: []
+  };
+}, oe = (s, e, n) => {
+  const t = n.where, { joinSQL: r, fieldAliasMap: a } = Y(s, e, t), c = b(e), o = L(t, a), i = ue(n?.orderBy);
+  return {
+    sql: J({ tableName: c, where: o, orderBy: i, join: r }),
+    params: []
+  };
+}, It = (s, e, n) => {
+  const t = n.where, { joinSQL: r, fieldAliasMap: a } = Y(s, e, t), c = b(e), o = L(t, a);
+  let i = `SELECT count(_.rowid) as count FROM "${c}" _`;
+  return n?.groupBy, r && (i += r), o && (i += ` where ${o}`), {
+    sql: i,
+    params: []
+  };
+}, te = (s, e, n) => {
+  const t = n.where, { joinSQL: r, fieldAliasMap: a } = Y(s, e, t), c = b(e), o = L(t, a), i = ue(n?.orderBy);
+  return {
+    sql: J({ tableName: c, where: o, orderBy: i, join: r, limit: 1 }),
+    params: []
+  };
+}, vt = (s, e) => {
+  const n = `${v} IN (${e.join(",")})`, t = b(s);
+  return {
+    sql: J({ tableName: t, where: n }),
+    params: []
+  };
+}, ye = async (s, e) => {
+  const n = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
+  for (let o = 0; o < e.length; o++) {
+    const i = e[o];
+    if (M(i).local) {
+      let l = [];
+      t.has(i.constructor) ? l = t.get(i.constructor) : t.set(i.constructor, l), l.push(i);
+    } else {
+      let l = [];
+      n.has(i.constructor) ? l = n.get(i.constructor) : n.set(i.constructor, l), l.push(i);
+    }
+  }
+  let a = "";
+  return n.forEach((o, i) => {
+    const u = N(i), l = Be(u, o, s.rxdb.context), h = o.map((m) => m.id);
+    h.forEach((m) => r.set(m, i));
+    const { sql: _, params: f } = oe(s, u, {
+      where: {
+        combinator: "and",
+        rules: [
+          {
+            field: "id",
+            operator: "in",
+            value: h
+          }
+        ]
+      }
+    }), p = ee(_, f);
+    a += l + p;
+  }), t.forEach((o, i) => {
+    const u = N(i), l = Object.groupBy(o, (h) => {
+      const _ = M(h);
+      return it(_.patch);
+    });
+    Object.values(l).forEach((h) => {
+      const _ = h[0], f = M(_), p = /* @__PURE__ */ new Date(), m = ke(u, h, f.patch, {
+        ...s.rxdb.context,
+        returning: !1,
+        updatedAt: p
+      }), A = ee(m.sql, m.params);
+      a += A;
+      const d = h.map((C) => C.id);
+      d.forEach((C) => r.set(C, i));
+      const y = oe(s, u, {
+        where: {
+          combinator: "and",
+          rules: [
+            {
+              field: "id",
+              operator: "in",
+              value: d
+            }
+          ]
+        }
+      }), k = ee(y.sql, y.params);
+      a += k;
+    });
+  }), (await g(s.execute(a))).results.forEach(({ columns: o, rows: i }) => {
+    const u = o.findIndex((_) => _ === "id"), l = o.findIndex((_) => _ === v), h = s.rxdb.entityManager;
+    i.forEach((_) => {
+      const f = _[u], p = r.get(f), m = N(p);
+      let A;
+      if (h.hasEntityRef(p, f)) {
+        A = h.getEntityRef(p, f);
+        const d = ce(m, o, _);
+        s.getRepository(p).updateEntity(A, d);
+        const y = M(A);
+        y.local = !0, l !== -1 && (y.rowId = BigInt(_[l])), y.modified = !1;
+      }
+    });
+  }), n.forEach((o) => {
+    s.rxdb.dispatchEvent(new je(o));
+  }), t.forEach((o) => {
+    s.rxdb.dispatchEvent(new Fe(o));
+  }), r.clear(), n.clear(), t.clear(), e;
+}, Ot = (s, e, n) => {
+  let t = "";
+  if (s.rxdb.options.entities.forEach((r) => {
+    const a = N(r);
+    if (a.log !== !1) {
+      const c = le(s, a, e, n);
+      t += `
+` + c;
+    }
+  }), t) {
+    const r = N(ie), a = b(r);
+    t = `
+        ${t}
+        UPDATE "${a}" SET activated = 1 WHERE id = '${e}' and activated != 1 RETURNING rowid as ${v},*;
+        UPDATE "${a}" SET activated = 0 WHERE id != '${e}' and activated = 1 RETURNING rowid as ${v},*;
+      `;
+  }
+  return t;
+}, xt = async (s, e) => {
+  const n = s.localRxDBBranch(), t = s.localRxDBChange(), r = await g(
+    n.findOne({
+      where: {
+        combinator: "and",
+        rules: [{ field: "activated", operator: "=", value: !0 }]
+      }
+    })
+  );
+  if (!r) throw new R("Current branch not found");
+  if (r.id === e) return;
+  const a = await g(
+    t.findOne({
+      where: {
+        combinator: "and",
+        rules: [
+          { field: "branchId", operator: "=", value: r.id },
+          {
+            field: "revertChangedAt",
+            operator: "=",
+            value: null
+          }
+        ]
+      },
+      orderBy: [{ field: "id", sort: "desc" }]
+    })
+  );
+  a && (a.parentId ? console.log("把当前分支的数据切换记录到:", a.parentId) : console.log("不应该出现这个情况，如果为空，应该还原所有记录"));
+  const c = await g(
+    t.findOne({
+      where: {
+        combinator: "and",
+        rules: [{ field: "branchId", operator: "=", value: e }]
+      },
+      orderBy: [{ field: "id", sort: "desc" }]
+    })
+  );
+  let o = "";
+  if (s.rxdb.options.entities.forEach((i) => {
+    const u = N(i);
+    if (u.log !== !1) {
+      const l = le(s, u, e, c?.id);
+      o += `
+` + l;
+    }
+  }), o) {
+    o = `
+        BEGIN;
+        ${Ot(s, e, c?.id)}
+        COMMIT;
+      `;
+    const u = await g(s.execute(o));
+    s.getRepository(ie).addQueryCache(u, !0);
+  }
+};
+var P = /* @__PURE__ */ ((s) => (s[s.SQLITE_DELETE = 9] = "SQLITE_DELETE", s[s.SQLITE_INSERT = 18] = "SQLITE_INSERT", s[s.SQLITE_UPDATE = 23] = "SQLITE_UPDATE", s))(P || {});
+const St = "sqlite", qt = () => import("wa-sqlite/dist/wa-sqlite-async.mjs").then((s) => s.default), Bt = () => import("wa-sqlite/dist/wa-sqlite.mjs").then((s) => s.default), kt = [
+  {
+    name: "MemoryVFS",
+    vfsModule: () => import("wa-sqlite/src/examples/MemoryVFS.js").then((s) => s.MemoryVFS),
+    sync: !0,
+    async: !0,
+    worker: !0,
+    sharedWorker: !0,
+    jsContext: !0,
+    multipleConnections: !1
+  },
+  {
+    name: "MemoryAsyncVFS",
+    vfsModule: () => import("wa-sqlite/src/examples/MemoryAsyncVFS.js").then((s) => s.MemoryAsyncVFS),
+    sync: !1,
+    async: !0,
+    worker: !0,
+    sharedWorker: !0,
+    jsContext: !0,
+    multipleConnections: !1
+  },
+  {
+    name: "IDBBatchAtomicVFS",
+    vfsModule: () => import("wa-sqlite/src/examples/IDBBatchAtomicVFS.js").then((s) => s.IDBBatchAtomicVFS),
+    vfsOptions: { lockPolicy: "shared+hint" },
+    sync: !1,
+    async: !0,
+    worker: !0,
+    sharedWorker: !0,
+    jsContext: !0,
+    multipleConnections: !0
+  },
+  {
+    name: "OPFSAdaptiveVFS",
+    vfsModule: () => import("wa-sqlite/src/examples/OPFSAdaptiveVFS.js").then((s) => s.OPFSAdaptiveVFS),
+    vfsOptions: { lockPolicy: "shared+hint" },
+    sync: !1,
+    async: !0,
+    worker: !0,
+    sharedWorker: !1,
+    jsContext: !1,
+    multipleConnections: !0
+  },
+  {
+    name: "AccessHandlePoolVFS",
+    vfsModule: () => import("wa-sqlite/src/examples/AccessHandlePoolVFS.js").then((s) => s.AccessHandlePoolVFS),
+    sync: !0,
+    async: !0,
+    worker: !0,
+    sharedWorker: !1,
+    jsContext: !1,
+    multipleConnections: !1
+  },
+  {
+    name: "OPFSAnyContextVFS",
+    vfsModule: () => import("wa-sqlite/src/examples/OPFSAnyContextVFS.js").then((s) => s.OPFSAnyContextVFS),
+    vfsOptions: { lockPolicy: "shared+hint" },
+    sync: !1,
+    async: !0,
+    worker: !0,
+    sharedWorker: !1,
+    jsContext: !0,
+    multipleConnections: !0
+  },
+  {
+    name: "OPFSCoopSyncVFS",
+    vfsModule: () => import("wa-sqlite/src/examples/OPFSCoopSyncVFS.js").then((s) => s.OPFSCoopSyncVFS),
+    sync: !0,
+    async: !0,
+    worker: !0,
+    sharedWorker: !1,
+    jsContext: !1,
+    multipleConnections: !0
+  },
+  {
+    name: "OPFSPermutedVFS",
+    vfsModule: () => import("wa-sqlite/src/examples/OPFSPermutedVFS.js").then((s) => s.OPFSPermutedVFS),
+    sync: !1,
+    async: !0,
+    worker: !0,
+    sharedWorker: !1,
+    jsContext: !1,
+    multipleConnections: !0
+  }
+], Ce = (s) => {
+  const e = kt.find((a) => a.name === s.vfs), { vfs: n, async: t, worker: r } = s;
+  if (!e) throw new R(`vfs ${n} not found`);
+  if (t !== t) throw new R(`vfs ${n} not support async: ${t}`);
+  if (r && !e.worker) throw new R(`vfs ${n} not support worker`);
+  if (!r && !e.jsContext) throw new R(`vfs ${n} only support worker`);
+  return e;
+}, Ct = async (s) => {
+  const e = Ce(s), n = s.async ?? !0;
+  let t;
+  n ? t = qt : t = Bt;
+  const [r, a] = await Promise.all([t(), e.vfsModule()]), c = {};
+  s.locateFile ? c.locateFile = s.locateFile : s.wasmPath && (c.locateFile = () => s.wasmPath);
+  const o = await r(c), i = lt(o), u = await a.create(s.vfs, o, e.vfsOptions);
+  return i.vfs_register(u, !0), i;
+}, Mt = async (s, e, n, t) => {
+  const r = performance.now(), a = t ? [t] : [[]], c = [];
+  let o = 0;
+  const i = {
+    sql: n,
+    results: c
+  };
+  for await (const u of s.statements(e, n)) {
+    if (t)
+      for (const _ of a)
+        s.reset(u), t && s.bind_collection(u, _);
+    const l = [];
+    for (; await s.step(u) === ut; ) {
+      const _ = s.row(u);
+      l.push(_);
+    }
+    const h = s.column_names(u);
+    h.length && c.push({ columns: h, rows: l }), o += s.changes(e);
+  }
+  return {
+    ...i,
+    rowsAffected: o,
+    elapsed: performance.now() - r
+  };
+}, Dt = (s, e) => s.create_function(e, "regexp", 2, Ie | ve, 0, (n, t) => {
+  const r = new RegExp(s.value_text(t[0])), a = s.value_text(t[1]);
+  s.result(n, r.test(a) ? 1 : 0);
+}), Lt = (s, e) => s.create_function(e, "regexp_replace", -1, Ie | ve, 0, (n, t) => {
+  if (t.length < 3) {
+    s.result(n, "");
+    return;
+  }
+  const r = s.value_text(t[0]), a = s.value_text(t[1]), c = s.value_text(t[2]), o = t.length > 3 ? s.value_text(t[3]) : "";
+  s.result(n, a.replace(new RegExp(r, o), c));
+});
+class jt {
+  #e;
+  #t;
+  #r = [];
+  #s;
+  #n;
+  set onChange(e) {
+    this.#n = e;
+  }
+  async init(e, n) {
+    const t = await Ct(n), r = e + ".sqlite";
+    this.#t = await t.open_v2(r), this.#e = t, Dt(t, this.#t), Lt(t, this.#t);
+    const a = n?.cacheSizeKb || 50 * 1024;
+    await this.execute(`
+      PRAGMA temp_store = memory;
+      PRAGMA journal_mode = delete;
+      PRAGMA foreign_keys = ON;
+      PRAGMA cache_size = -${a};
+    `), this.#e.update_hook(
+      this.#t,
+      (c, o, i, u) => {
+        if (i !== "public$RxDBChange" || !o || !i || !this.#n) return;
+        const l = {
+          type: c,
+          dbName: o,
+          tableName: i,
+          rowId: u
+        };
+        this.#r.push(l), this.#s && clearTimeout(this.#s), this.#s = setTimeout(() => {
+          this.#a(), this.#s = void 0;
+        });
+      }
+    );
+  }
+  async version() {
+    const e = await this.execute("SELECT sqlite_version()");
+    return ot(e, "results[0].rows[0][0]");
+  }
+  async disconnect() {
+    await this.#e.close(this.#t);
+  }
+  /**
+   * 执行 sql
+   * @param sql
+   * @param bindings
+   * @returns
+   */
+  async execute(e, n) {
+    return Mt(this.#e, this.#t, e, n);
+  }
+  #a() {
+    const e = Object.groupBy(this.#r, (n) => `${n.type}_${n.dbName}_${n.tableName}`);
+    Object.values(e).forEach((n) => {
+      const t = n[0], r = n.map((a) => a.rowId);
+      this.#n?.({
+        type: t.type,
+        dbName: t.dbName,
+        tableName: t.tableName,
+        rowIds: r,
+        recordAt: /* @__PURE__ */ new Date()
+      });
+    }), this.#r.length = 0;
+  }
+}
+const Ft = (s, e, n) => {
+  const t = b(s), r = [e.id];
+  return {
+    sql: `DELETE FROM "${t}" WHERE id = ?;`,
+    params: r
+  };
+}, Ut = (s, e, n) => {
+  const t = b(s), r = Se(s, e);
+  n?.userId && (s.propertyMap.has("createdBy") && (r.createdBy = n.userId), s.propertyMap.has("updatedBy") && (r.updatedBy = n.userId));
+  const a = Object.keys(r), c = H(s, r), o = Array(a.length).fill("?").join(","), i = Object.values(c);
+  let u = `INSERT INTO "${t}" (${a.join(",")}) VALUES (${o})`;
+  return n?.returning !== !1 ? u += ` RETURNING rowid as ${v}, *;` : u += ";", {
+    sql: u,
+    params: i
+  };
+}, Wt = (s, e, n) => {
+  const t = {};
+  s.propertyMap.has("removedAt") && (t.removedAt = /* @__PURE__ */ new Date()), n?.userId && s.propertyMap.has("removedBy") && (t.removedBy = n.userId);
+  const r = b(s), c = Object.keys(t).map((l) => `${l} = ?`).join(","), o = H(s, t), i = [...Object.values(o), e.id];
+  let u = `UPDATE "${r}" SET ${c} WHERE id = ? and removedAt is null and removedBy is null`;
+  return n?.returning !== !1 ? u += ` RETURNING rowid as ${v}, *;` : u += ";", {
+    sql: u,
+    params: i
+  };
+}, he = (s, e, n, t, r) => {
+  if (s.length === 0 && e.length === 0) return { refresh: !1, recalculate: !1 };
+  const { options: a } = n, c = t.resultEntityIds, o = T(() => r.map((d) => d.id)), i = T(() => r.some((d) => Q(d, a.where))), u = T(
+    () => a.orderBy && r.some(
+      (d) => ge(d, t.resultEntities || [], a.orderBy)
+    )
+  ), l = T(() => u() !== !1), h = T(() => i() === !1), _ = T(
+    () => c ? c.some((d) => o().includes(d)) : !0
+  ), f = T(() => _() === !1), p = {
+    match_where: i,
+    not_match_where: h,
+    match_order_by: l,
+    result_contains: _,
+    result_not_contains: f
+  }, m = e.some(
+    (d) => d.every((y) => p[y]())
+  );
+  return {
+    refresh: m === !1 && s.some(
+      (d) => d.every((y) => p[y]())
+    ),
+    recalculate: m
+  };
+}, Vt = (s, e, n) => {
+  switch (e.type) {
+    case "findAll":
+      {
+        const { options: t } = e;
+        let r = s.resultEntities;
+        r = r.concat(n), r = r.filter((a) => Q(a, e.options.where)), t.orderBy && t.orderBy.length && (r = $e(r, t.orderBy)), s.updateResult(r), e.refresh();
+      }
+      break;
+  }
+}, Pt = (s, e, n) => {
+  const t = [], r = [];
+  switch (e.type) {
+    case "find":
+      t.push(["match_where"]);
+      break;
+    case "findAll":
+      r.push(["match_where"]);
+      break;
+    case "findOne":
+    case "findOneOrFail":
+    case "count":
+      t.push(["match_where"]);
+      break;
+  }
+  const a = he(t, r, e, s, n);
+  a.refresh ? s.refresh() : a.recalculate && Vt(s, e, n);
+}, Gt = (s, e, n) => {
+  if (Array.isArray(s.result)) {
+    const t = s.result.filter((r) => !n.includes(r));
+    s.updateResult(t), e.refresh();
+  }
+}, Qt = (s, e, n) => {
+  const t = [], r = [];
+  switch (e.type) {
+    case "find":
+      t.push(["match_where"], ["not_match_where", "result_contains"]);
+      break;
+    case "findAll":
+      r.push(["result_contains"]);
+      break;
+    case "findOne":
+    case "findOneOrFail":
+    case "count":
+      t.push(["match_where"]);
+      break;
+  }
+  const a = he(t, r, e, s, n);
+  a.refresh ? s.refresh() : a.recalculate && Gt(s, e, n);
+}, Kt = (s, e) => {
+  switch (e.type) {
+    case "findOne":
+    case "findOneOrFail":
+    case "find":
+    case "findAll": {
+      let n = s.resultEntities;
+      n = n.filter((t) => Q(t, e.options.where)), e.options.orderBy && e.options.orderBy.length && (n = $e(n, e.options.orderBy)), s.updateResult(n), e.refresh();
+      return;
+    }
+  }
+}, Ht = (s, e, n) => {
+  const t = [], r = [];
+  switch (e.type) {
+    case "find":
+      t.push(["match_where"], ["not_match_where", "result_contains"]);
+      break;
+    case "findAll":
+      r.push(["match_where"], ["not_match_where", "result_contains"]);
+      break;
+    case "findOne":
+    case "findOneOrFail":
+    case "count":
+      t.push(["match_where"], ["not_match_where", "result_contains"]);
+      break;
+  }
+  const a = he(t, r, e, s, n);
+  a.refresh ? s.refresh() : a.recalculate && Kt(s, e);
+}, be = (s, e = []) => s + e.join(",");
+class Yt extends Ue {
+  constructor(e, n, t) {
+    super(e.rxdb, t), this.adapter = e, this.client$ = n, this.metadata = N(t), this.run_task$.subscribe(() => this.#e());
+    const r = (c) => {
+      const o = c.entities.filter((i) => i.constructor === t);
+      o.length && this.db_changes_sub.next({ ...c, entities: o });
+    };
+    this.rxdb.addEventListener(se, (c) => r(c)), this.rxdb.addEventListener(ne, (c) => r(c)), this.rxdb.addEventListener(V, (c) => r(c));
+    const a = (c, o) => {
+      if (o.EntityType !== t || this.cache_query_task_map.size === 0) return;
+      const { rowIds: i, recordAt: u } = o.data, l = [], h = [];
+      if (i.forEach((f) => {
+        const p = this.rxdb.entityManager.getEntityByRowId(t, f);
+        p ? l.push(p) : h.push(f);
+      }), c === V && l.length) {
+        this.db_changes_sub.next({ type: c, entities: l });
+        return;
+      }
+      h.length && this.db_checks_sub.next({ type: c, changes: o.data }), l.filter(
+        (f) => f.updatedAt && f.updatedAt.getTime && u.getTime() - f.updatedAt.getTime() > 500
+      ).length && this.db_checks_sub.next({ type: c, changes: o.data });
+    };
+    this.rxdb.addEventListener(We, (c) => a(V, c)), this.rxdb.addEventListener(Ve, (c) => a(se, c)), this.rxdb.addEventListener(Pe, (c) => a(ne, c));
+  }
+  metadata;
+  // 任务队列
+  need_run_task = new z();
+  run_task$ = this.need_run_task.asObservable().pipe(Z(0));
+  // 根据条件缓存的任务
+  cache_query_task_map = /* @__PURE__ */ new Map();
+  // 任务队列
+  queue_tasks = [];
+  // db changes
+  db_changes_sub = new z();
+  db_changes_next$ = this.db_changes_sub.asObservable().pipe(Z(16));
+  db_changes$ = this.db_changes_sub.asObservable().pipe(
+    pe(() => this.db_changes_next$),
+    G((e) => e.length > 0),
+    w((e) => {
+      const n = /* @__PURE__ */ new Map();
+      e.forEach(({ type: r, entities: a }) => {
+        n.has(r) || n.set(r, /* @__PURE__ */ new Set()), a.forEach((c) => n.get(r).add(c));
+      });
+      const t = Array.from(n.entries()).map(([r, a]) => ({
+        type: r,
+        entities: Array.from(a)
+      }));
+      return n.clear(), t;
+    }),
+    U(1)
+  );
+  // db checks
+  db_checks_sub = new z();
+  db_checks_next$ = this.db_checks_sub.asObservable().pipe(Z(16));
+  db_checks$ = this.db_checks_sub.asObservable().pipe(
+    pe(() => this.db_checks_next$),
+    G((e) => e.length > 0),
+    w((e) => {
+      const n = /* @__PURE__ */ new Map();
+      return e.forEach(({ type: t, changes: r }) => {
+        n.has(t) || n.set(t, /* @__PURE__ */ new Set());
+        const a = n.get(t);
+        r.rowIds.forEach((c) => a.add(c));
+      }), Array.from(n.entries()).map(([t, r]) => ({
+        type: t,
+        rowIds: Array.from(r)
+      }));
+    }),
+    U(1)
+  );
+  /**
+   * 添加缓存
+   * @param sqliteSuccessResult
+   * @param forcedUpdate 强制刷新，在数据有的情况下也会更新数据，在修改数据的情况下需要
+   */
+  addQueryCache(e, n = !1) {
+    const t = [];
+    return e.results.forEach(({ columns: r, rows: a }) => {
+      const c = r.findIndex((i) => i === "id"), o = r.findIndex((i) => i === v);
+      a.forEach((i) => {
+        const u = i[c];
+        let l;
+        if (this.hasEntityRef(u)) {
+          if (l = this.getEntityRef(u), t.push(l), n) {
+            const _ = ce(this.metadata, r, i);
+            this.updateEntity(l, _);
+          }
+        } else {
+          const _ = ce(this.metadata, r, i);
+          l = this.createEntityRef(_), t.push(l);
+        }
+        const h = M(l);
+        h.local = !0, o !== -1 && (h.rowId = BigInt(i[o])), h.modified = !1;
+      });
+    }), t;
+  }
+  /**
+   * 创建查询任务
+   */
+  create_query_task(e) {
+    const { sql: n, params: t } = e, r = be(n, t), a = /* @__PURE__ */ new Set();
+    let c = !1;
+    const o = new re(), i = o.asObservable(), u = new K(0), l = u.asObservable();
+    let h;
+    if (this.cache_query_task_map.has(r) === !1) {
+      const _ = new Re((p) => (f.observerCount++, h && p.next(h), a.add(p), c || (c = !0, this.queue_tasks.push(f), this.need_run_task.next()), () => {
+        if (f.observerCount--, f.observerCount <= 0) {
+          o.next(), o.complete(), u.unsubscribe(), o.unsubscribe(), a.delete(p), this.cache_query_task_map.delete(r);
+          const m = this.queue_tasks.indexOf(f);
+          m >= 0 && this.queue_tasks.splice(m, 1);
+        }
+      })), f = {
+        sql: n,
+        params: t,
+        observerCount: 0,
+        refreshCount: 0,
+        result$: _,
+        destroy$: i,
+        refresh$: l,
+        resultEntities: [],
+        resultEntityIds: [],
+        refresh: () => u.next(f.refreshCount + 1),
+        updateResult: (p) => {
+          f.result = p, Array.isArray(p) && (f.resultEntities = p, f.resultEntityIds = p.map((m) => m.id));
+        },
+        next: (p) => {
+          h = p, a.forEach((m) => m.next(p));
+        },
+        error: (p) => a.forEach((m) => m.error(p))
+      };
+      return this.cache_query_task_map.set(r, f), f;
+    }
+    return this.cache_query_task_map.get(r);
+  }
+  delete_task(e) {
+    const n = be(e.sql, e.params);
+    this.cache_query_task_map.delete(n);
+  }
+  /**
+   * 队列执行任务
+   */
+  #e() {
+    const e = this.queue_tasks.shift();
+    if (!e) return;
+    const { sql: n, params: t, refresh$: r } = e;
+    r.pipe(
+      Te(e.destroy$),
+      tt(),
+      D(() => e.refreshCount++),
+      E(
+        () => this.client$.pipe(
+          ae(1),
+          E(() => this.adapter.execute(n, t))
+        )
+      )
+    ).subscribe({
+      next: (a) => e.next(a),
+      error: (a) => e.error(a)
+    });
+  }
+}
+class Me extends Yt {
+  #e = /* @__PURE__ */ new Map();
+  constructor(e, n, t) {
+    super(e, n, t), this.db_changes$.subscribe((r) => {
+      for (let a = 0; a < r.length; a++) {
+        const { type: c, entities: o } = r[a];
+        for (const i of this.cache_query_task_map.values()) {
+          if (!i.resultEntityIds) return;
+          this.merge_cache(c, i, o);
+        }
+      }
+    }), this.db_checks$.subscribe((r) => {
+      for (let a = 0; a < r.length; a++) {
+        const { type: c, rowIds: o } = r[a];
+        for (const i of this.cache_query_task_map.values()) {
+          if (!i.resultEntityIds || !this.#e.get(i)) return;
+          const l = () => setTimeout(() => h.unsubscribe(), 0), h = this.findByRowIds(o, !0).subscribe({
+            next: (_) => {
+              _.length && this.db_changes_sub.next({ type: c, entities: _ }), l();
+            },
+            complete: l
+          });
+        }
+      }
+    });
+  }
+  get(e) {
+    const n = {
+      where: {
+        combinator: "and",
+        rules: [
+          {
+            field: "id",
+            operator: "=",
+            value: e
+          }
+        ]
+      }
+    }, t = te(this.adapter, this.metadata, n), r = this.create_query_task(t), a = this.#s(r, { type: "get", options: n });
+    return r.result$.pipe(
+      E((c) => a.calculate(c)),
+      w((c) => {
+        if (c.length === 0) throw new R("not found");
+        return c[0];
+      })
+    );
+  }
+  findOne(e) {
+    const n = te(this.adapter, this.metadata, e), t = this.create_query_task(n), r = this.#s(t, { type: "findOne", options: e });
+    return t.result$.pipe(
+      E((a) => r.calculate(a)),
+      w((a) => a[0])
+    );
+  }
+  findOneOrFail(e) {
+    const n = te(this.adapter, this.metadata, e), t = this.create_query_task(n), r = this.#s(t, { type: "findOneOrFail", options: e });
+    return t.result$.pipe(
+      E((a) => r.calculate(a)),
+      w((a) => {
+        if (a.length === 0)
+          throw new R("not found");
+        return a[0];
+      })
+    );
+  }
+  find(e) {
+    const n = At(this.adapter, this.metadata, e), t = this.create_query_task(n), r = this.#s(t, { type: "find", options: e });
+    return t.result$.pipe(E((a) => r.calculate(a)));
+  }
+  findAll(e) {
+    const n = oe(this.adapter, this.metadata, e), t = this.create_query_task(n), r = this.#s(t, { type: "findAll", options: e });
+    return t.result$.pipe(E((a) => r.calculate(a)));
+  }
+  findByRowIds(e, n = !1) {
+    const t = vt(this.metadata, e), r = this.create_query_task(t);
+    return r.result$.pipe(w((a) => this.transform_query_result(r, a, n)));
+  }
+  count(e) {
+    const n = It(this.adapter, this.metadata, e), t = this.create_query_task(n), r = this.#s(t, { type: "count", options: e });
+    return t.result$.pipe(E((a) => r.calculate(a)));
+  }
+  create(e) {
+    return g(this.#t(e));
+  }
+  update(e, n) {
+    return g(this.#r(e, n));
+  }
+  remove(e) {
+    const n = M(e), t = () => {
+      this.rxdb.context?.userId && (e.removedBy = this.rxdb.context.userId), n.origin = structuredClone({ ...e }), n.modified = !1, e.removedAt = /* @__PURE__ */ new Date(), n.removed = !0;
+    };
+    if (n.local === !0) {
+      const { sql: a, params: c } = Ft(this.metadata, e, this.rxdb.context), o = this.client$.pipe(
+        ae(1),
+        E(() => this.adapter.execute(a, c)),
+        w(() => (t(), e))
+      );
+      return g(o);
+    } else if (n.remote === !0) {
+      const { sql: a, params: c } = Wt(this.metadata, e, this.rxdb.context), o = this.#n(a, c).pipe(
+        D(() => t()),
+        w((i) => i[0])
+      );
+      return g(o);
+    }
+    const r = N(e);
+    throw new R(`Remove Error${r.name}(${e.id}) not saved local.`);
+  }
+  merge_cache(e, n, t) {
+    const r = this.#e.get(n);
+    if (r)
+      switch (e) {
+        case se:
+          Pt(n, r, t);
+          break;
+        case ne:
+          Ht(n, r, t);
+          break;
+        case V:
+          Qt(n, r, t);
+          break;
+      }
+  }
+  transform_query_result(e, n, t = !1) {
+    const r = this.addQueryCache(n, t);
+    return e.resultEntities = r, e.resultEntityIds = r.map((a) => a.id), r;
+  }
+  #t(e) {
+    const { sql: n, params: t } = Ut(this.metadata, e, this.rxdb.context);
+    return this.#n(n, t).pipe(w((r) => r[0]));
+  }
+  #r(e, n) {
+    const { sql: t, params: r } = ke(this.metadata, e, n, this.rxdb.context);
+    return this.#n(t, r).pipe(w((a) => a[0]));
+  }
+  #s(e, n) {
+    this.#e.set(e, n), e.destroy$.subscribe(() => this.#e.delete(e));
+    const t = new K(0), r = t.asObservable(), a = n;
+    return a.refresh = () => t.next(t.value + 1), a.calculate = (c) => {
+      switch (n.type) {
+        case "get":
+        case "find":
+        case "findAll":
+        case "findOne":
+        case "findOneOrFail":
+          {
+            const o = this.addQueryCache(c);
+            e.updateResult(o);
+          }
+          break;
+        case "count":
+          e.updateResult(c.results[0].rows[0][0]);
+          break;
+      }
+      return r.pipe(w(() => e.result));
+    }, a;
+  }
+  /**
+   * 执行修改语句
+   */
+  #n(e, n) {
+    return this.client$.pipe(
+      ae(1),
+      E(() => this.adapter.execute(e, n)),
+      w((t) => this.addQueryCache(t, !0))
+    );
+  }
+}
+const j = (s, e) => {
+  const n = e.where, t = e.isFindRoot ?? !1, r = e?.level || 0, a = b(s), c = `c.level < ${r}`;
+  let o = "";
+  const i = [c, n && L(n)].filter(Boolean).join(" AND ");
+  i && (o = `WHERE ${i}`);
+  let u = "*";
+  return e.count && (e.isFindRoot ? u = "count(*)" : u = "count(*)-1"), {
+    sql: `WITH RECURSIVE __children AS (
+  SELECT *,rowid as ${v}, 0 AS level
+  FROM "${a}"
+  WHERE ${t ? "parentId is null" : "id = ?"}
+  UNION ALL
+  SELECT children.*,children.rowid as ${v}, c.level + 1
+  FROM "${a}" children
+  JOIN __children c ON ${e.descendants ? "children.parentId = c.id" : "children.id = c.parentId"}
+  ${o}
+)
+
+SELECT ${u} FROM __children ORDER BY level, id;`,
+    params: t ? [] : [e.entity && e.entity.id || e.entity]
+  };
+}, Jt = (s, e) => j(s, { ...e, isFindRoot: !0, descendants: !0 }), Xt = (s, e) => j(s, { ...e, isFindRoot: !0, descendants: !0, count: !0 }), zt = (s, e) => j(s, { ...e, descendants: !0 }), Zt = (s, e) => j(s, { ...e, descendants: !0, count: !0 }), es = (s, e) => j(s, { ...e, descendants: !1 }), ts = (s, e) => j(s, { ...e, descendants: !1, count: !0 }), de = (s, e, n, t, r) => {
+  if (s.length === 0 && e.length === 0) return { refresh: !1, recalculate: !1 };
+  const { options: a } = n, c = t.resultEntityIds, o = T(() => r.map((d) => d.id)), i = T(
+    () => a?.where ? r.some((d) => Q(d, a.where)) : !0
+  ), u = T(
+    () => a.orderBy && r.some(
+      (d) => ge(d, t.resultEntities || [], a.orderBy)
+    )
+  ), l = T(() => u() !== !1), h = T(() => i() === !1), _ = T(
+    () => c ? c.some((d) => o().includes(d)) : !0
+  ), f = T(() => _() === !1), p = {
+    match_where: i,
+    not_match_where: h,
+    match_order_by: l,
+    result_contains: _,
+    result_not_contains: f
+  }, m = e.some(
+    (d) => d.every((y) => p[y]())
+  );
+  return {
+    refresh: m === !1 && s.some(
+      (d) => d.every((y) => p[y]())
+    ),
+    recalculate: m
+  };
+}, ss = (s, e, n) => {
+  e.type;
+}, ns = (s, e, n) => {
+  const t = [], r = [];
+  switch (e.type) {
+    case "countRoot":
+    case "countAncestors":
+    case "countDescendants":
+      t.push(["match_where"]);
+      break;
+    case "findRoot":
+    case "findDescendants":
+    case "findAncestors":
+      t.push(["match_where"]);
+      break;
+  }
+  const a = de(t, r, e, s, n);
+  a.refresh ? s.refresh() : a.recalculate && ss(s, e);
+}, rs = (s, e, n) => {
+  e.type;
+}, as = (s, e, n) => {
+  const t = [], r = [];
+  switch (e.type) {
+    case "countRoot":
+    case "countAncestors":
+    case "countDescendants":
+      t.push(["match_where"]);
+      break;
+    case "findRoot":
+    case "findDescendants":
+    case "findAncestors":
+      t.push(["match_where"]);
+      break;
+  }
+  const a = de(t, r, e, s, n);
+  a.refresh ? s.refresh() : a.recalculate && rs(s, e);
+}, cs = (s, e, n) => {
+  e.type;
+}, os = (s, e, n) => {
+  const t = [], r = [];
+  switch (e.type) {
+    case "countRoot":
+    case "countAncestors":
+    case "countDescendants":
+      t.push(["match_where"]);
+      break;
+    case "findRoot":
+    case "findDescendants":
+    case "findAncestors":
+      t.push(["match_where"]);
+      break;
+  }
+  const a = de(t, r, e, s, n);
+  a.refresh ? s.refresh() : a.recalculate && cs(s, e);
+};
+class is extends Me {
+  #e = /* @__PURE__ */ new Map();
+  findRoot(e) {
+    const n = Jt(this.metadata, e), t = this.create_query_task(n), r = this.#t(t, { type: "findRoot", options: e });
+    return t.result$.pipe(E((a) => r.calculate(a)));
+  }
+  countRoot(e) {
+    const n = Xt(this.metadata, e), t = this.create_query_task(n), r = this.#t(t, { type: "countRoot", options: e });
+    return t.result$.pipe(E((a) => r.calculate(a)));
+  }
+  findDescendants(e) {
+    const n = zt(this.metadata, e), t = this.create_query_task(n), r = this.#t(t, { type: "findDescendants", options: e });
+    return t.result$.pipe(E((a) => r.calculate(a)));
+  }
+  countDescendants(e) {
+    const n = Zt(this.metadata, e), t = this.create_query_task(n), r = this.#t(t, { type: "countDescendants", options: e });
+    return t.result$.pipe(E((a) => r.calculate(a)));
+  }
+  findAncestors(e) {
+    const n = es(this.metadata, e), t = this.create_query_task(n), r = this.#t(t, { type: "findAncestors", options: e });
+    return t.result$.pipe(E((a) => r.calculate(a)));
+  }
+  countAncestors(e) {
+    const n = ts(this.metadata, e), t = this.create_query_task(n), r = this.#t(t, { type: "countAncestors", options: e });
+    return t.result$.pipe(E((a) => r.calculate(a)));
+  }
+  /**
+   * 根据 type 计算主动更新缓存策略
+   */
+  merge_cache(e, n, t) {
+    super.merge_cache(e, n, t);
+    const r = this.#e.get(n);
+    if (r)
+      switch (e) {
+        case "create":
+          ns(n, r, t);
+          break;
+        case "update":
+          os(n, r, t);
+          break;
+        case "remove":
+          as(n, r, t);
+          break;
+      }
+  }
+  #t(e, n) {
+    this.#e.set(e, n), e.destroy$.subscribe(() => this.#e.delete(e));
+    const t = new K(0), r = t.asObservable(), a = n;
+    return a.calculate = (c) => {
+      switch (a.refresh = () => t.next(t.value + 1), n.type) {
+        case "findRoot":
+        case "findDescendants":
+        case "findAncestors":
+          {
+            const o = this.addQueryCache(c);
+            e.updateResult(o);
+          }
+          break;
+        case "countRoot":
+        case "countAncestors":
+        case "countDescendants":
+          e.updateResult(c.results[0].rows[0][0]);
+          break;
+      }
+      return r.pipe(w(() => e.result));
+    }, a;
+  }
+}
+class bs extends He {
+  constructor(e, n) {
+    super(e), this.options = n;
+    const t = (r) => {
+      const { tableName: a, rowIds: c, recordAt: o } = r, [i, u] = a.split("$"), l = this.rxdb.schemaManager.getEntityType(u, i);
+      if (!l) return;
+      const h = {
+        rowIds: c,
+        recordAt: o
+      };
+      setTimeout(() => {
+        switch (r.type) {
+          case P.SQLITE_DELETE:
+            this.rxdb.dispatchEvent(new ze(l, h));
+            break;
+          case P.SQLITE_INSERT:
+            this.rxdb.dispatchEvent(new Xe(l, h));
+            break;
+          case P.SQLITE_UPDATE:
+            this.rxdb.dispatchEvent(new Je(l, h));
+            break;
+        }
+      }, 100);
+    };
+    this.#c.subscribe((r) => r.onChange = Ze(t)), this.#_.pipe(Te(this.#e)).subscribe();
+  }
+  #e = new re();
+  #t = /* @__PURE__ */ new Map();
+  #r;
+  #s = !1;
+  // 查询缓存
+  #n = [];
+  #a = /* @__PURE__ */ new Map();
+  #o = !1;
+  #i = new K(0);
+  #h = this.#i.asObservable();
+  // sqlite 客户端
+  #c = new Re((e) => {
+    const { vfs: n, async: t, worker: r, wasmPath: a, locateFile: c, workerInstance: o } = this.options, i = {
+      vfs: n,
+      async: t,
+      worker: r,
+      wasmPath: a,
+      locateFile: c
+    };
+    Ce(i);
+    let u;
+    r && o ? u = et(o) : u = new jt(), this.#r = u, u.init(this.rxdb.options.dbName, i).then(() => e.next(u));
+  }).pipe(U(1));
+  // 已连接
+  #d = st(() => this.rxdb.connect(this.name)).pipe(U(1));
+  // 队列
+  #_ = this.#h.pipe(
+    G(() => this.#o === !1),
+    w(() => this.#n.shift()),
+    G(Boolean),
+    D(() => this.#o = !0),
+    E((e) => {
+      const n = this.#a.get(e.key);
+      return this.#d.pipe(
+        E(() => this.#c),
+        E((t) => t.execute(e.sql, e.bindings)),
+        D((t) => n.next(t)),
+        D(
+          () => setTimeout(() => {
+            this.#a.get(e.key)?.unsubscribe(), this.#a.delete(e.key);
+          }, 0)
+        ),
+        nt((t) => {
+          const r = t.message || "执行错误";
+          return n.error(new R(`${r} ${e.sql} ${JSON.stringify(e.bindings)}`)), rt({ error: t });
+        })
+      );
+    }),
+    D(() => {
+      this.#o = !1, this.#l();
+    })
+  );
+  name = St;
+  /**
+   * 数据库版本
+   */
+  version$ = this.#c.pipe(
+    E((e) => me(e.version())),
+    U(1)
+  );
+  /**
+   * 连接 wab sqlite
+   */
+  connect() {
+    return this.#c.pipe(w(() => this));
+  }
+  /**
+   * 断开连接
+   */
+  async disconnect() {
+    this.#r && (await this.#r.disconnect(), this.#e.next(), this.#e.complete());
+  }
+  /**
+   * 获取版本
+   */
+  version() {
+    return g(this.version$);
+  }
+  /**
+   * 获取实体仓库
+   * @param entity 实体类
+   */
+  getRepository(e) {
+    if (!this.#t.has(e)) {
+      const n = N(e);
+      let t;
+      switch (n.repository) {
+        case "Repository":
+          t = new Me(this, this.#c, e);
+          break;
+        case "TreeRepository":
+          t = new is(this, this.#c, e);
+          break;
+        default:
+          throw new R("Unsupported repository type: " + n.repository);
+      }
+      return this.#t.set(e, t), t;
+    }
+    return this.#t.get(e);
+  }
+  /**
+   * 保存多个实体
+   * TODO: 优化事件
+   * @param entities
+   */
+  async saveMany(e) {
+    return this.#s ? await ye(this, e) : e.length > 1 ? await this.transaction(() => ye(this, e)) : e.length === 1 && await e[0].save(), e;
+  }
+  /**
+   * 判断表是否存在
+   * @param EntityType
+   */
+  isTableExisted(e) {
+    return g(this.isTableExisted$(e));
+  }
+  /**
+   * 判断表是否存在
+   * @param EntityType
+   */
+  isTableExisted$(e) {
+    const n = N(e), t = b(n);
+    return this.#u(ht(t)).pipe(w((r) => dt(r) === !1));
+  }
+  /**
+   * 创建表和初始化数据
+   * @param entities 表结构
+   * @param data 视图数据
+   * @returns
+   */
+  createTables(e, n) {
+    const t = gt(this, e, n);
+    return g(this.#u(t).pipe(w(() => !0)));
+  }
+  /**
+   * 创建分支
+   * @param branchId 分支 ID
+   * @param fromChangeId
+   */
+  async createBranch(e, n) {
+    return Et(this, e, n);
+  }
+  /**
+   * 切换分支
+   * @param branchId
+   * @returns
+   */
+  async switchBranch(e) {
+    return xt(this, e);
+  }
+  /**
+   * 恢复某个实体
+   * @param entity
+   * @param options
+   */
+  restoreEntity(e, n) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * 执行 sql
+   * @param sql
+   * @param bindings
+   */
+  execute(e, n) {
+    const t = e + n?.join(",");
+    if (!this.#a.has(t)) {
+      const r = new re(1);
+      this.#a.set(t, r), this.#n.push({ key: t, sql: e, bindings: n }), this.#l();
+    }
+    return this.#a.get(t).asObservable();
+  }
+  /**
+   * 处理事务
+   * @param callback
+   */
+  transaction(e) {
+    return g(this.transaction$(e));
+  }
+  transaction$(e, n = !0) {
+    return this.rxdb.connect(this.name).pipe(
+      E(() => this.#c),
+      E(async (t) => {
+        this.#s = !0, this.rxdb.dispatchEvent(ls);
+        let r = "", a = "";
+        if (n) {
+          const c = Ye(), o = (i) => `INSERT INTO "public$RxDBChange" (type,branchId,transactionId) VALUES ('${i}','main','${c}');`;
+          r = o("TRANSACTION_BEGIN"), a = o("TRANSACTION_COMMIT");
+        }
+        await t.execute(`
+          BEGIN;
+          PRAGMA defer_foreign_keys = ON;
+          ${r}
+         `);
+        try {
+          const c = await e();
+          return await t.execute(`${a}
+COMMIT;`), this.#s = !1, this.rxdb.dispatchEvent(hs), c;
+        } catch (c) {
+          await t.execute("ROLLBACK"), this.#s = !1, this.rxdb.dispatchEvent(us);
+          const o = c?.message || "Transaction Error";
+          throw new R(o);
+        }
+      })
+    );
+  }
+  /**
+   * 本地分支仓库
+   */
+  localRxDBBranch() {
+    return this.getRepository(ie);
+  }
+  /**
+   * 本地变更仓库
+   */
+  localRxDBChange() {
+    return this.getRepository(we);
+  }
+  #l() {
+    this.#i.next(this.#i.value + 1);
+  }
+  /**
+   * 内部执行的 sql
+   * @param sql
+   * @param bindings
+   */
+  #u(e, n) {
+    return this.#c.pipe(E((t) => me(t.execute(e, n))));
+  }
+}
+const ls = new Ge(), us = new Qe(), hs = new Ke();
+export {
+  bs as RxDBAdapterSqlite,
+  R as RxdbAdapterSqliteError,
+  jt as SqliteClient,
+  kt as WA_SQLITE_VFS_LIST,
+  Ct as sqliteLoad
+};