@aiao/rxdb-adapter-sqlite 0.0.3 → 0.0.5

package/dist/index.js

@@ -0,0 +1,1698 @@
+import { RxDBError as We, PropertyType as $, RelationKind as B, getEntityMetadata as R, RxDBChange as Te, getEntityStatus as L, EntityRemoveEvent as Ue, EntityCreateEvent as Ve, EntityUpdateEvent as Pe, RxDBBranch as ie, isEntityMatchWhere as G, isEntityEffectOrderBy as Re, calculateOrderBy as Ne, RepositoryBase as Qe, ENTITY_CREATE_EVENT as se, ENTITY_UPDATE_EVENT as ne, ENTITY_REMOVE_EVENT as P, DATABASE_DELETE as Ge, DATABASE_INSERT as Ke, DATABASE_UPDATE as He, TransactionBeginEvent as Ye, TransactionRollbackEvent as Je, TransactionCommitEvent as Xe, RxDBAdapterLocalBase as ze, uuid as Ze, RxDBAdapterUpdateChangeEvent as et, RxDBAdapterInsertChangeEvent as tt, RxDBAdapterDeleteChangeEvent as st } from "@aiao/rxdb";
+import { proxy as X, wrap as Ee } from "comlink";
+import { firstValueFrom as w, Subject as z, debounceTime as Z, bufferWhen as me, filter as Q, map as g, shareReplay as U, ReplaySubject as re, BehaviorSubject as K, Observable as Ae, takeUntil as Ie, distinctUntilChanged as nt, tap as W, switchMap as m, take as ae, defer as rt, catchError as at, of as ct, from as ye } from "rxjs";
+import { pickBy as ve, isString as ot, isFunction as xe, traverseObjectKeys as it, EventDispatcher as lt, AsyncTaskExecutor as ut, get as ht, once as N } from "@aiao/utils";
+import dt from "object-hash";
+import { Factory as _t, SQLITE_ROW as ft, SQLITE_UTF8 as Oe, SQLITE_DETERMINISTIC as Se } from "wa-sqlite";
+const pt = (s) => `SELECT * FROM sqlite_master WHERE type='table' AND name='${s}' limit 1;`, Et = (s) => !!s.sql && (s.results.length === 0 || s.results[0].rows.length === 0), O = "_rowid", mt = (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";
+  }
+}, yt = (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;
+    }
+}, bt = (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;
+    }
+}, qe = (s, e) => `${e}$${s}`, b = (s) => qe(s.name, s.namespace), Be = (s, e) => `idx_${s.name}_${e.name}`;
+class T extends Error {
+  constructor(e) {
+    super(e), this.name = "RxDBError", Object.setPrototypeOf(this, We.prototype);
+  }
+}
+const le = (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] = yt(e[t], r));
+  }), n;
+}, ke = (s, e) => ve(e, (n, t) => s.propertyMap.has(t) || s.foreignKeyNames.includes(t)), wt = (s, e) => ve(e, (n, t) => s.propertyMap.get(t)?.readonly !== !0), Le = (s) => ot(s) ? `'${s}'` : s ?? "NULL", ee = (s, e = []) => {
+  for (; s.includes("?"); ) {
+    const n = Le(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] = bt(r, o));
+    }
+  }), t;
+}, gt = async (s, e, n) => {
+  const t = s.localRxDBBranch(), r = s.localRxDBChange();
+  let a = !1;
+  try {
+    await w(t.get(e)), a = !0;
+  } catch {
+  }
+  if (a) throw new T(`Branch ID (${e}) already exists`);
+  let c;
+  if (n ? c = await w(
+    t.findOne({
+      where: {
+        combinator: "and",
+        rules: [{ field: "changes.id", operator: "=", value: n }]
+      }
+    })
+  ) : c = await w(
+    t.findOne({
+      where: {
+        combinator: "and",
+        rules: [{ field: "activated", operator: "=", value: !0 }]
+      }
+    })
+  ), !c) throw new T("Source branch not found");
+  n || (n = (await w(
+    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
+  });
+}, Me = (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 = ke(s, u);
+    r && (l.createdBy = n.userId), a && (l.updatedBy = n.userId);
+    const h = le(s, l), d = [];
+    c.forEach((f) => {
+      const p = Le(h[f]);
+      d.push(p);
+    }), o.push(d);
+  });
+  const i = o.map((u) => `(${u.join(",")})`).join(",");
+  return `INSERT INTO "${t}" (${c.join(",")}) VALUES ${i};`;
+}, $t = (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;
+            xe(c.default) && (o = c.default()), n += ` DEFAULT ${o}`;
+          }
+          if (r.mappedEntity) {
+            const c = qe(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 ${Be(e, r)} on "${t}"(${a});`);
+        }
+        break;
+    }
+  }), n;
+}, Tt = (s, e) => {
+  const n = b(e);
+  let t = `CREATE TABLE "${n}" (`;
+  const r = [], a = [], c = [];
+  e.propertyMap.forEach((i) => {
+    let u = `"${i.name}" ${mt(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;
+      xe(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 ${Be(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 T("columns is empty!");
+  return r.length && (t += `
+` + r.join(`
+`)), t;
+}, Rt = (s, e) => {
+  let n = "";
+  return n += Tt(s, e), n += $t(s, e), n;
+}, ue = (s, e, n = "main", t = null) => {
+  const r = b(e), a = R(Te), c = b(a), { propertyMap: o, name: i, foreignKeyNames: u, namespace: l } = e, h = [...o.keys(), ...u].filter((_) => ["id", "updatedAt"].includes(_) === !1), d = "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} (${d}) VALUES (
+      '${l}', '${i}', 'INSERT', '${n}', ${f}, NEW.id, NULL,
+      json_object(${h.map((_) => `'${_}', NEW.${_}`).join(`,
+`)})
+    );
+  END;`, E = `
+  DROP TRIGGER IF EXISTS ${r}_update;
+  CREATE TRIGGER ${r}_update AFTER UPDATE ON "${r}"
+    WHEN ( ${h.map((_) => `OLD.${_} IS NOT NEW.${_}`).join(` OR
+`)} )
+  BEGIN
+    INSERT INTO ${c} (${d}) VALUES (
+      '${l}','${i}','UPDATE', '${n}', ${f}, NEW.id,
+      (
+        SELECT json_group_object(key, value) FROM (
+          ${h.map((_) => `SELECT '${_}' AS key, OLD.${_} AS value WHERE OLD.${_} IS NOT NEW.${_}`).join(`
+ UNION `)}
+        )
+      ),
+      (
+        SELECT json_group_object(key, value) FROM (
+          ${h.map((_) => `SELECT '${_}' AS key, NEW.${_} AS value WHERE OLD.${_} IS NOT NEW.${_}`).join(`
+ UNION `)}
+        )
+      )
+    );
+  END;`, A = `
+  DROP TRIGGER IF EXISTS ${r}_delete;
+  CREATE TRIGGER ${r}_delete AFTER DELETE ON "${r}"
+  BEGIN
+    INSERT INTO ${c} (${d}) VALUES (
+      '${l}', '${i}', 'DELETE', '${n}', ${f}, OLD.id,
+      json_object(${h.map((_) => `'${_}', OLD.${_}`).join(`,
+`)}), NULL
+    );
+  END;`;
+  return p + `
+` + E + `
+` + A;
+}, Nt = (s, e, n) => {
+  let t = "";
+  for (let r = 0; r < e.length; r++) {
+    const a = e[r], c = R(a);
+    if (t += `
+` + Rt(s, c), c.log !== !1) {
+      const o = ue(s, c);
+      t += `
+` + o;
+    }
+  }
+  if (n) {
+    const r = /* @__PURE__ */ new Map();
+    n.forEach((a) => {
+      const c = R(a);
+      r.has(c) === !1 && r.set(c, /* @__PURE__ */ new Set()), r.get(c).add(a);
+    });
+    for (const a of r.keys()) {
+      const c = Me(
+        a,
+        Array.from(r.get(a)),
+        s.rxdb.context
+      );
+      t += `
+` + c;
+    }
+  }
+  return t;
+}, At = (s, e) => {
+  const n = b(s), t = e.map((r) => `'${r.id}'`).join(",");
+  return `DELETE FROM "${n}" WHERE id in (${t});`;
+}, be = async (s, e, n) => {
+  const t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
+  for (let o = 0; o < e.length; o++) {
+    const i = e[o];
+    if (L(i).local) {
+      let l = [];
+      t.has(i.constructor) ? l = t.get(i.constructor) : t.set(i.constructor, l), l.push(i);
+    }
+  }
+  let a = "";
+  t.forEach((o, i) => {
+    const u = R(i), l = At(u, o);
+    o.map((d) => d.id).forEach((d) => r.set(d, i)), a += l;
+  });
+  const c = await w(s.execute(a));
+  return console.log(c), t.forEach((o) => {
+    s.rxdb.dispatchEvent(new Ue(o));
+  }), r.clear(), t.clear(), e.forEach((o) => {
+    const i = L(o);
+    o.removedAt = /* @__PURE__ */ new Date(), i.origin = structuredClone({ ...o }), i.modified = !1, i.removed = !0;
+  }), e;
+}, De = (s, e, n, t) => {
+  const r = wt(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 = le(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 ${O}, *;` : l += ";", {
+    sql: l,
+    params: o
+  };
+}, he = (s) => s?.map((e) => `_."${e.field}" ${e.sort}`).join(", "), C = (s, e = /* @__PURE__ */ new Map()) => {
+  const n = s.rules.map((t) => we(t) ? C(t, e) : It(t, e)).filter(Boolean);
+  return n.length === 0 ? "" : n.length === 1 ? n[0] : `(${n.join(we(s) ? ` ${s.combinator} ` : " ")})`;
+}, It = (s, e) => {
+  let n, t;
+  if (s?.value === null ? s.operator === "=" ? (n = "", t = "is null") : s.operator === "!=" && (n = "", t = "is not null") : (n = xt(s.operator).toLowerCase(), t = Ot(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();
+}, we = (s) => "rules" in s && "combinator" in s, vt = {
+  "=": "=",
+  "!=": "!=",
+  ">": ">",
+  ">=": ">=",
+  "<": "<",
+  "<=": "<=",
+  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"
+}, xt = (s) => vt[s] || s, Ot = (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}'`;
+}, H = (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, d = 1;
+    for (; r.has(h); )
+      h = `${l}_${d}`, d++;
+    return r.add(h), h;
+  }, i = (l) => {
+    if (c.has(l))
+      return c.get(l);
+    const h = l.includes("_") ? l : l.split("_")[0], d = o(h);
+    return c.set(l, d), d;
+  };
+  it(n, (l, h, d) => {
+    const f = h;
+    if (l !== "field" || f.includes(".") === !1) return;
+    const { relations: p, isForeignKey: E, propertyName: A } = s.rxdb.schemaManager.getFieldRelations(
+      e,
+      h
+    );
+    if (E) {
+      d.field = A;
+      return;
+    }
+    const _ = f.replace(`.${A}`, ""), y = (v) => p.length === 1 ? v.name : `${_}_${v.name}`, k = (v) => (t.has(v) || t.set(v, []), t.get(v));
+    p.forEach(({ metadata: v, relation: S }, fe) => {
+      const V = s.rxdb.schemaManager.findMappedRelation(v, S);
+      if (!V) throw new T("mappedRelation not found");
+      const J = () => {
+        const q = k(V.metadata), I = y(S), F = i(I);
+        return {
+          joinArray: q,
+          uniqueAlias: F
+        };
+      };
+      let x = "_";
+      if (fe > 0) {
+        const q = p[fe - 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 } = J();
+            q.push({
+              joinTableName: I,
+              on: `'${I}'.${V.relation.name}Id = ${x === "_" ? x : `'${x}'`}.id`
+            });
+          }
+          break;
+        case B.MANY_TO_ONE:
+          {
+            const { joinArray: q, uniqueAlias: I } = J();
+            q.push({
+              joinTableName: I,
+              on: `'${I}'.id = ${x === "_" ? x : `'${x}'`}.${S.name}Id`
+            });
+          }
+          break;
+        case B.MANY_TO_MANY:
+          {
+            const q = R(S.junctionEntityType), I = k(q), F = o(`${S.name}_m_n`);
+            I.push({
+              joinTableName: F,
+              on: `'${F}'.${V.relation.name}Id = ${x === "_" ? x : `'${x}'`}.id`
+            });
+            const { joinArray: Fe, uniqueAlias: pe } = J();
+            Fe.push({
+              joinTableName: pe,
+              on: `'${pe}'.id = '${F}'.${S.name}Id`
+            });
+          }
+          break;
+      }
+    });
+    const M = p[p.length - 1];
+    if (s.rxdb.schemaManager.findMappedRelation(
+      M.metadata,
+      M.relation
+    )) {
+      const v = y(M.relation), S = i(v);
+      a.set(f, `'${S}'.${A}`);
+    }
+  });
+  let u = "";
+  for (const [l, h] of t.entries()) {
+    const d = b(l);
+    for (const f of h)
+      u += ` LEFT JOIN "${d}" "${f.joinTableName}" ON ${f.on}`;
+  }
+  return { joinSQL: u, fieldAliasMap: a };
+}, Y = (s) => {
+  const { tableName: e, where: n, limit: t, offset: r, orderBy: a, join: c } = s;
+  let o = `SELECT _.rowid as ${O}, _.* 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;
+}, St = (s, e, n) => {
+  const t = n.where, { joinSQL: r, fieldAliasMap: a } = H(s, e, t), c = b(e), o = C(t, a), i = he(n?.orderBy), u = n?.limit || 100, l = n?.offset || 0;
+  return {
+    sql: Y({ 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 } = H(s, e, t), c = b(e), o = C(t, a), i = he(n?.orderBy);
+  return {
+    sql: Y({ tableName: c, where: o, orderBy: i, join: r }),
+    params: []
+  };
+}, qt = (s, e, n) => {
+  const t = n.where, { joinSQL: r, fieldAliasMap: a } = H(s, e, t), c = b(e), o = C(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 } = H(s, e, t), c = b(e), o = C(t, a), i = he(n?.orderBy);
+  return {
+    sql: Y({ tableName: c, where: o, orderBy: i, join: r, limit: 1 }),
+    params: []
+  };
+}, Bt = (s, e) => {
+  const n = `${O} IN (${e.join(",")})`, t = b(s);
+  return {
+    sql: Y({ tableName: t, where: n }),
+    params: []
+  };
+}, ge = 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 (L(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 = R(i), l = Me(u, o, s.rxdb.context), h = o.map((E) => E.id);
+    h.forEach((E) => r.set(E, i));
+    const { sql: d, params: f } = oe(s, u, {
+      where: {
+        combinator: "and",
+        rules: [
+          {
+            field: "id",
+            operator: "in",
+            value: h
+          }
+        ]
+      }
+    }), p = ee(d, f);
+    a += l + p;
+  }), t.forEach((o, i) => {
+    const u = R(i), l = Object.groupBy(o, (h) => {
+      const d = L(h);
+      return dt(d.patch);
+    });
+    Object.values(l).forEach((h) => {
+      const d = h[0], f = L(d), p = /* @__PURE__ */ new Date(), E = De(u, h, f.patch, {
+        ...s.rxdb.context,
+        returning: !1,
+        updatedAt: p
+      }), A = ee(E.sql, E.params);
+      a += A;
+      const _ = h.map((M) => M.id);
+      _.forEach((M) => r.set(M, i));
+      const y = oe(s, u, {
+        where: {
+          combinator: "and",
+          rules: [
+            {
+              field: "id",
+              operator: "in",
+              value: _
+            }
+          ]
+        }
+      }), k = ee(y.sql, y.params);
+      a += k;
+    });
+  }), (await w(s.execute(a))).results.forEach(({ columns: o, rows: i }) => {
+    const u = o.findIndex((d) => d === "id"), l = o.findIndex((d) => d === O), h = s.rxdb.entityManager;
+    i.forEach((d) => {
+      const f = d[u], p = r.get(f), E = R(p);
+      let A;
+      if (h.hasEntityRef(p, f)) {
+        A = h.getEntityRef(p, f);
+        const _ = ce(E, o, d);
+        s.getRepository(p).updateEntity(A, _);
+        const y = L(A);
+        y.local = !0, l !== -1 && (y.rowId = BigInt(d[l])), y.modified = !1;
+      }
+    });
+  }), n.forEach((o) => {
+    s.rxdb.dispatchEvent(new Ve(o));
+  }), t.forEach((o) => {
+    s.rxdb.dispatchEvent(new Pe(o));
+  }), r.clear(), n.clear(), t.clear(), e;
+}, kt = (s, e, n) => {
+  let t = "";
+  if (s.rxdb.options.entities.forEach((r) => {
+    const a = R(r);
+    if (a.log !== !1) {
+      const c = ue(s, a, e, n);
+      t += `
+` + c;
+    }
+  }), t) {
+    const r = R(ie), a = b(r);
+    t = `
+        ${t}
+        UPDATE "${a}" SET activated = 1 WHERE id = '${e}' and activated != 1 RETURNING rowid as ${O},*;
+        UPDATE "${a}" SET activated = 0 WHERE id != '${e}' and activated = 1 RETURNING rowid as ${O},*;
+      `;
+  }
+  return t;
+}, Lt = async (s, e) => {
+  const n = s.localRxDBBranch(), t = s.localRxDBChange(), r = await w(
+    n.findOne({
+      where: {
+        combinator: "and",
+        rules: [{ field: "activated", operator: "=", value: !0 }]
+      }
+    })
+  );
+  if (!r) throw new T("Current branch not found");
+  if (r.id === e) return;
+  const a = await w(
+    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 w(
+    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 = R(i);
+    if (u.log !== !1) {
+      const l = ue(s, u, e, c?.id);
+      o += `
+` + l;
+    }
+  }), o) {
+    o = `
+        BEGIN;
+        ${kt(s, e, c?.id)}
+        COMMIT;
+      `;
+    const u = await w(s.execute(o));
+    s.getRepository(ie).addQueryCache(u, !0);
+  }
+};
+var D = /* @__PURE__ */ ((s) => (s[s.SQLITE_DELETE = 9] = "SQLITE_DELETE", s[s.SQLITE_INSERT = 18] = "SQLITE_INSERT", s[s.SQLITE_UPDATE = 23] = "SQLITE_UPDATE", s))(D || {});
+const Mt = "sqlite", Dt = () => import("wa-sqlite/dist/wa-sqlite-async.mjs").then((s) => s.default), Ct = () => import("wa-sqlite/dist/wa-sqlite.mjs").then((s) => s.default), jt = [
+  {
+    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 = jt.find((a) => a.name === s.vfs), { vfs: n, async: t, worker: r } = s;
+  if (!e) throw new T(`vfs ${n} not found`);
+  if (t !== t) throw new T(`vfs ${n} not support async: ${t}`);
+  if (r && !e.worker) throw new T(`vfs ${n} not support worker`);
+  if (!r && !e.jsContext) throw new T(`vfs ${n} only support worker`);
+  return e;
+}, Ft = async (s) => {
+  const e = Ce(s), n = s.async ?? !0;
+  let t;
+  n ? t = Dt : t = Ct;
+  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 = _t(o), u = await a.create(s.vfs, o, e.vfsOptions);
+  return i.vfs_register(u, !0), i;
+}, Wt = 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 d of a)
+        s.reset(u), t && s.bind_collection(u, d);
+    const l = [];
+    for (; await s.step(u) === ft; ) {
+      const d = s.row(u);
+      l.push(d);
+    }
+    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
+  };
+}, Ut = (s, e) => s.create_function(e, "regexp", 2, Oe | Se, 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);
+}), Vt = (s, e) => s.create_function(e, "regexp_replace", -1, Oe | Se, 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 Pt extends lt {
+  #e;
+  #t;
+  #n = [];
+  #s;
+  #a;
+  #r = !1;
+  async init(e, n) {
+    if (this.#r) return;
+    this.#r = !0, this.#a = new ut(1);
+    const t = await Ft(n), r = e + ".sqlite";
+    this.#t = await t.open_v2(r), this.#e = t, Ut(t, this.#t), Vt(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 (console.log("change"), i !== "public$RxDBChange" || !o || !i) return;
+        const l = {
+          type: c,
+          dbName: o,
+          tableName: i,
+          rowId: u
+        };
+        this.#n.push(l), this.#s && clearTimeout(this.#s), this.#s = setTimeout(() => {
+          this.#o(), this.#s = void 0;
+        });
+      }
+    );
+  }
+  async version() {
+    const e = await this.execute("SELECT sqlite_version()");
+    return ht(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 this.#a.addTask(() => Wt(this.#e, this.#t, e, n));
+  }
+  #o() {
+    const e = Object.groupBy(this.#n, (n) => `${n.type}_${n.dbName}_${n.tableName}`);
+    Object.values(e).forEach((n) => {
+      const t = n[0], r = n.map((c) => c.rowId), a = {
+        type: t.type,
+        dbName: t.dbName,
+        tableName: t.tableName,
+        rowIds: r,
+        recordAt: /* @__PURE__ */ new Date()
+      };
+      this.dispatchEvent(a);
+    }), this.#n.length = 0;
+  }
+}
+const Qt = (s, e, n) => {
+  const t = b(s), r = [e.id];
+  return {
+    sql: `DELETE FROM "${t}" WHERE id = ?;`,
+    params: r
+  };
+}, Gt = (s, e, n) => {
+  const t = b(s), r = ke(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 = le(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 ${O}, *;` : u += ";", {
+    sql: u,
+    params: i
+  };
+}, 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 = N(() => r.map((_) => _.id)), i = N(() => r.some((_) => G(_, a.where))), u = N(
+    () => a.orderBy && r.some(
+      (_) => Re(_, t.resultEntities || [], a.orderBy)
+    )
+  ), l = N(() => u() !== !1), h = N(() => i() === !1), d = N(
+    () => c ? c.some((_) => o().includes(_)) : !0
+  ), f = N(() => d() === !1), p = {
+    match_where: i,
+    not_match_where: h,
+    match_order_by: l,
+    result_contains: d,
+    result_not_contains: f
+  }, E = e.some(
+    (_) => _.every((y) => p[y]())
+  );
+  return {
+    refresh: E === !1 && s.some(
+      (_) => _.every((y) => p[y]())
+    ),
+    recalculate: E
+  };
+}, Kt = (s, e, n) => {
+  switch (e.type) {
+    case "findAll":
+      {
+        const { options: t } = e;
+        let r = s.resultEntities;
+        r = r.concat(n), r = r.filter((a) => G(a, e.options.where)), t.orderBy && t.orderBy.length && (r = Ne(r, t.orderBy)), s.updateResult(r), e.refresh();
+      }
+      break;
+  }
+}, Ht = (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 = de(t, r, e, s, n);
+  a.refresh ? s.refresh() : a.recalculate && Kt(s, e, n);
+}, Yt = (s, e, n) => {
+  if (Array.isArray(s.result)) {
+    const t = s.result.filter((r) => !n.includes(r));
+    s.updateResult(t), e.refresh();
+  }
+}, Jt = (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 = de(t, r, e, s, n);
+  a.refresh ? s.refresh() : a.recalculate && Yt(s, e, n);
+}, Xt = (s, e) => {
+  switch (e.type) {
+    case "findOne":
+    case "findOneOrFail":
+    case "find":
+    case "findAll": {
+      let n = s.resultEntities;
+      n = n.filter((t) => G(t, e.options.where)), e.options.orderBy && e.options.orderBy.length && (n = Ne(n, e.options.orderBy)), s.updateResult(n), e.refresh();
+      return;
+    }
+  }
+}, zt = (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 = de(t, r, e, s, n);
+  a.refresh ? s.refresh() : a.recalculate && Xt(s, e);
+}, $e = (s, e = []) => s + e.join(",");
+class Zt extends Qe {
+  constructor(e, n, t) {
+    super(e.rxdb, t), this.adapter = e, this.client$ = n, this.metadata = R(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(P, (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 === P && 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(Ge, (c) => a(P, c)), this.rxdb.addEventListener(Ke, (c) => a(se, c)), this.rxdb.addEventListener(He, (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(
+    me(() => this.db_changes_next$),
+    Q((e) => e.length > 0),
+    g((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(
+    me(() => this.db_checks_next$),
+    Q((e) => e.length > 0),
+    g((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 === O);
+      a.forEach((i) => {
+        const u = i[c];
+        let l;
+        if (this.hasEntityRef(u)) {
+          if (l = this.getEntityRef(u), t.push(l), n) {
+            const d = ce(this.metadata, r, i);
+            this.updateEntity(l, d);
+          }
+        } else {
+          const d = ce(this.metadata, r, i);
+          l = this.createEntityRef(d), t.push(l);
+        }
+        const h = L(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 = $e(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 d = new Ae((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 E = this.queue_tasks.indexOf(f);
+          E >= 0 && this.queue_tasks.splice(E, 1);
+        }
+      })), f = {
+        sql: n,
+        params: t,
+        observerCount: 0,
+        refreshCount: 0,
+        result$: d,
+        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((E) => E.id));
+        },
+        next: (p) => {
+          h = p, a.forEach((E) => E.next(p));
+        },
+        error: (p) => a.forEach((E) => E.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 = $e(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(
+      Ie(e.destroy$),
+      nt(),
+      W(() => e.refreshCount++),
+      m(
+        () => this.client$.pipe(
+          ae(1),
+          m(() => this.adapter.execute(n, t))
+        )
+      )
+    ).subscribe({
+      next: (a) => e.next(a),
+      error: (a) => e.error(a)
+    });
+  }
+}
+class je extends Zt {
+  #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: (d) => {
+              d.length && this.db_changes_sub.next({ type: c, entities: d }), 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(
+      m((c) => a.calculate(c)),
+      g((c) => {
+        if (c.length === 0) throw new T("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(
+      m((a) => r.calculate(a)),
+      g((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(
+      m((a) => r.calculate(a)),
+      g((a) => {
+        if (a.length === 0)
+          throw new T("not found");
+        return a[0];
+      })
+    );
+  }
+  find(e) {
+    const n = St(this.adapter, this.metadata, e), t = this.create_query_task(n), r = this.#s(t, { type: "find", options: e });
+    return t.result$.pipe(m((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(m((a) => r.calculate(a)));
+  }
+  findByRowIds(e, n = !1) {
+    const t = Bt(this.metadata, e), r = this.create_query_task(t);
+    return r.result$.pipe(g((a) => this.transform_query_result(r, a, n)));
+  }
+  count(e) {
+    const n = qt(this.adapter, this.metadata, e), t = this.create_query_task(n), r = this.#s(t, { type: "count", options: e });
+    return t.result$.pipe(m((a) => r.calculate(a)));
+  }
+  create(e) {
+    return w(this.#t(e));
+  }
+  update(e, n) {
+    return w(this.#n(e, n));
+  }
+  remove(e) {
+    const n = L(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 } = Qt(this.metadata, e, this.rxdb.context), o = this.client$.pipe(
+        ae(1),
+        m(() => this.adapter.execute(a, c)),
+        g(() => (t(), e))
+      );
+      return w(o);
+    } else
+      t();
+    const r = R(e);
+    throw new T(`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:
+          Ht(n, r, t);
+          break;
+        case ne:
+          zt(n, r, t);
+          break;
+        case P:
+          Jt(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 } = Gt(this.metadata, e, this.rxdb.context);
+    return this.#a(n, t).pipe(g((r) => r[0]));
+  }
+  #n(e, n) {
+    const { sql: t, params: r } = De(this.metadata, e, n, this.rxdb.context);
+    return this.#a(t, r).pipe(g((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(g(() => e.result));
+    }, a;
+  }
+  /**
+   * 执行修改语句
+   */
+  #a(e, n) {
+    return this.client$.pipe(
+      ae(1),
+      m(() => this.adapter.execute(e, n)),
+      g((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 && C(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 ${O}, 0 AS level
+  FROM "${a}"
+  WHERE ${t ? "parentId is null" : "id = ?"}
+  UNION ALL
+  SELECT children.*,children.rowid as ${O}, 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]
+  };
+}, es = (s, e) => j(s, { ...e, isFindRoot: !0, descendants: !0 }), ts = (s, e) => j(s, { ...e, isFindRoot: !0, descendants: !0, count: !0 }), ss = (s, e) => j(s, { ...e, descendants: !0 }), ns = (s, e) => j(s, { ...e, descendants: !0, count: !0 }), rs = (s, e) => j(s, { ...e, descendants: !1 }), as = (s, e) => j(s, { ...e, descendants: !1, count: !0 }), _e = (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 = N(() => r.map((_) => _.id)), i = N(
+    () => a?.where ? r.some((_) => G(_, a.where)) : !0
+  ), u = N(
+    () => a.orderBy && r.some(
+      (_) => Re(_, t.resultEntities || [], a.orderBy)
+    )
+  ), l = N(() => u() !== !1), h = N(() => i() === !1), d = N(
+    () => c ? c.some((_) => o().includes(_)) : !0
+  ), f = N(() => d() === !1), p = {
+    match_where: i,
+    not_match_where: h,
+    match_order_by: l,
+    result_contains: d,
+    result_not_contains: f
+  }, E = e.some(
+    (_) => _.every((y) => p[y]())
+  );
+  return {
+    refresh: E === !1 && s.some(
+      (_) => _.every((y) => p[y]())
+    ),
+    recalculate: 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 = _e(t, r, e, s, n);
+  a.refresh ? s.refresh() : a.recalculate && cs(s, e);
+}, is = (s, e, n) => {
+  e.type;
+}, ls = (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 = _e(t, r, e, s, n);
+  a.refresh ? s.refresh() : a.recalculate && is(s, e);
+}, us = (s, e, n) => {
+  e.type;
+}, hs = (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 = _e(t, r, e, s, n);
+  a.refresh ? s.refresh() : a.recalculate && us(s, e);
+};
+class ds extends je {
+  #e = /* @__PURE__ */ new Map();
+  findRoot(e) {
+    const n = es(this.metadata, e), t = this.create_query_task(n), r = this.#t(t, { type: "findRoot", options: e });
+    return t.result$.pipe(m((a) => r.calculate(a)));
+  }
+  countRoot(e) {
+    const n = ts(this.metadata, e), t = this.create_query_task(n), r = this.#t(t, { type: "countRoot", options: e });
+    return t.result$.pipe(m((a) => r.calculate(a)));
+  }
+  findDescendants(e) {
+    const n = ss(this.metadata, e), t = this.create_query_task(n), r = this.#t(t, { type: "findDescendants", options: e });
+    return t.result$.pipe(m((a) => r.calculate(a)));
+  }
+  countDescendants(e) {
+    const n = ns(this.metadata, e), t = this.create_query_task(n), r = this.#t(t, { type: "countDescendants", options: e });
+    return t.result$.pipe(m((a) => r.calculate(a)));
+  }
+  findAncestors(e) {
+    const n = rs(this.metadata, e), t = this.create_query_task(n), r = this.#t(t, { type: "findAncestors", options: e });
+    return t.result$.pipe(m((a) => r.calculate(a)));
+  }
+  countAncestors(e) {
+    const n = as(this.metadata, e), t = this.create_query_task(n), r = this.#t(t, { type: "countAncestors", options: e });
+    return t.result$.pipe(m((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":
+          os(n, r, t);
+          break;
+        case "update":
+          hs(n, r, t);
+          break;
+        case "remove":
+          ls(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(g(() => e.result));
+    }, a;
+  }
+}
+class Ts extends ze {
+  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 };
+      switch (r.type) {
+        case D.SQLITE_DELETE:
+          this.rxdb.dispatchEvent(new st(l, h));
+          break;
+        case D.SQLITE_INSERT:
+          this.rxdb.dispatchEvent(new tt(l, h));
+          break;
+        case D.SQLITE_UPDATE:
+          this.rxdb.dispatchEvent(new et(l, h));
+          break;
+      }
+    };
+    this.#c.subscribe((r) => {
+      r.addEventListener(D.SQLITE_INSERT, X(t)), r.addEventListener(D.SQLITE_DELETE, X(t)), r.addEventListener(D.SQLITE_UPDATE, X(t));
+    }), this.#_.pipe(Ie(this.#e)).subscribe();
+  }
+  #e = new re();
+  #t = /* @__PURE__ */ new Map();
+  #n;
+  #s = !1;
+  // 查询缓存
+  #a = [];
+  #r = /* @__PURE__ */ new Map();
+  #o = !1;
+  #i = new K(0);
+  #h = this.#i.asObservable();
+  // sqlite 客户端
+  #c = new Ae((e) => {
+    const { vfs: n, async: t, worker: r, wasmPath: a, locateFile: c, workerInstance: o, sharedWorkerInstance: i, sharedWorker: u } = this.options, l = {
+      vfs: n,
+      async: t,
+      worker: r,
+      wasmPath: a,
+      locateFile: c
+    };
+    Ce(l);
+    let h;
+    r && o ? h = Ee(o) : u && i ? h = Ee(i.port) : h = new Pt(), this.#n = h, h.init(this.rxdb.options.dbName, l).then(() => e.next(h));
+  }).pipe(U(1));
+  // 已连接
+  #d = rt(() => this.rxdb.connect(this.name)).pipe(U(1));
+  // 队列
+  #_ = this.#h.pipe(
+    Q(() => this.#o === !1),
+    g(() => this.#a.shift()),
+    Q(Boolean),
+    W(() => this.#o = !0),
+    m((e) => {
+      const n = this.#r.get(e.key);
+      return this.#d.pipe(
+        m(() => this.#c),
+        m((t) => t.execute(e.sql, e.bindings)),
+        W((t) => n.next(t)),
+        W(
+          () => setTimeout(() => {
+            this.#r.get(e.key)?.unsubscribe(), this.#r.delete(e.key);
+          }, 0)
+        ),
+        at((t) => {
+          const r = t.message || "执行错误";
+          return n.error(new T(`${r} ${e.sql} ${JSON.stringify(e.bindings)}`)), ct({ error: t });
+        })
+      );
+    }),
+    W(() => {
+      this.#o = !1, this.#l();
+    })
+  );
+  name = Mt;
+  /**
+   * 数据库版本
+   */
+  version$ = this.#c.pipe(
+    m((e) => ye(e.version())),
+    U(1)
+  );
+  /**
+   * 连接 wab sqlite
+   */
+  connect() {
+    return this.#c.pipe(g(() => this));
+  }
+  /**
+   * 断开连接
+   */
+  async disconnect() {
+    this.#n && (await this.#n.disconnect(), this.#e.next(), this.#e.complete());
+  }
+  /**
+   * 获取版本
+   */
+  version() {
+    return w(this.version$);
+  }
+  /**
+   * 获取实体仓库
+   * @param entity 实体类
+   */
+  getRepository(e) {
+    if (!this.#t.has(e)) {
+      const n = R(e);
+      let t;
+      switch (n.repository) {
+        case "Repository":
+          t = new je(this, this.#c, e);
+          break;
+        case "TreeRepository":
+          t = new ds(this, this.#c, e);
+          break;
+        default:
+          throw new T("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 ge(this, e) : e.length > 1 ? await this.transaction(() => ge(this, e)) : e.length === 1 && await e[0].save(), e;
+  }
+  /**
+   * 删除多个实例
+   * @param entities
+   * @returns
+   */
+  async removeMany(e) {
+    return this.#s ? await be(this, e) : e.length > 1 ? await this.transaction(() => be(this, e)) : e.length === 1 && await e[0].save(), e;
+  }
+  /**
+   * 判断表是否存在
+   * @param EntityType
+   */
+  isTableExisted(e) {
+    return w(this.isTableExisted$(e));
+  }
+  /**
+   * 判断表是否存在
+   * @param EntityType
+   */
+  isTableExisted$(e) {
+    const n = R(e), t = b(n);
+    return this.#u(pt(t)).pipe(g((r) => Et(r) === !1));
+  }
+  /**
+   * 创建表和初始化数据
+   * @param entities 表结构
+   * @param data 视图数据
+   * @returns
+   */
+  createTables(e, n) {
+    const t = Nt(this, e, n);
+    return w(this.#u(t).pipe(g(() => !0)));
+  }
+  /**
+   * 创建分支
+   * @param branchId 分支 ID
+   * @param fromChangeId
+   */
+  async createBranch(e, n) {
+    return gt(this, e, n);
+  }
+  /**
+   * 切换分支
+   * @param branchId
+   * @returns
+   */
+  async switchBranch(e) {
+    return Lt(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.#r.has(t)) {
+      const r = new re(1);
+      this.#r.set(t, r), this.#a.push({ key: t, sql: e, bindings: n }), this.#l();
+    }
+    return this.#r.get(t).asObservable();
+  }
+  /**
+   * 处理事务
+   * @param callback
+   */
+  transaction(e) {
+    return w(this.transaction$(e));
+  }
+  transaction$(e, n = !0) {
+    return this.rxdb.connect(this.name).pipe(
+      m(() => this.#c),
+      m(async (t) => {
+        this.#s = !0, this.rxdb.dispatchEvent(_s);
+        let r = "", a = "";
+        if (n) {
+          const c = Ze(), 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(ps), c;
+        } catch (c) {
+          await t.execute("ROLLBACK"), this.#s = !1, this.rxdb.dispatchEvent(fs);
+          const o = c?.message || "Transaction Error";
+          throw new T(o);
+        }
+      })
+    );
+  }
+  /**
+   * 本地分支仓库
+   */
+  localRxDBBranch() {
+    return this.getRepository(ie);
+  }
+  /**
+   * 本地变更仓库
+   */
+  localRxDBChange() {
+    return this.getRepository(Te);
+  }
+  #l() {
+    this.#i.next(this.#i.value + 1);
+  }
+  /**
+   * 内部执行的 sql
+   * @param sql
+   * @param bindings
+   */
+  #u(e, n) {
+    return this.#c.pipe(m((t) => ye(t.execute(e, n))));
+  }
+}
+const _s = new Ye(), fs = new Je(), ps = new Xe();
+export {
+  Ts as RxDBAdapterSqlite,
+  T as RxdbAdapterSqliteError,
+  Pt as SqliteClient,
+  jt as WA_SQLITE_VFS_LIST,
+  Ft as sqliteLoad
+};