@aiao/rxdb-adapter-sqlite 0.0.1

package/index.js

@@ -0,0 +1,1136 @@
+import { RxDBError as Ee, PropertyType as m, RelationKind as y, getEntityMetadata as q, RxDBChange as ye, RepositoryBase as $e, TRANSACTION_BEGIN as be, TRANSACTION_COMMIT as Ne, TRANSACTION_ROLLBACK as Te, getEntityStatus as ae, isEntityMatchRuleGroup as S, isEntityEffectOrderBy as we, TransactionBeginEvent as ge, TransactionCommitEvent as Oe, TransactionRollbackEvent as Ie, RxDBAdapterLocalBase as Ae, RxDBAdapterUpdateChangeEvent as qe, RxDBAdapterInsertChangeEvent as Re, RxDBAdapterDeleteChangeEvent as Se } from "@aiao/rxdb";
+import { wrap as ve } from "comlink";
+import { Subject as ke, auditTime as xe, ReplaySubject as U, BehaviorSubject as ie, Observable as oe, shareReplay as L, switchMap as w, take as Q, takeUntil as K, map as f, firstValueFrom as I, tap as A, fromEvent as Ce, defer as Le, filter as Z, catchError as Me, of as je, from as ee } from "rxjs";
+import { pickBy as ce, isFunction as De, get as Be, traverseObjectKeys as Fe } from "@aiao/utils";
+import { Factory as We, SQLITE_ROW as Pe } from "@journeyapps/wa-sqlite";
+const Ve = (r) => `SELECT * FROM sqlite_master WHERE type='table' AND name='${r}' limit 1;`, Ue = (r) => !!r.sql && (r.results.length === 0 || r.results[0].rows.length === 0), R = "_rowid", te = (r) => {
+  switch (r.type) {
+    case m.uuid:
+    case m.string:
+    case m.json:
+      return "TEXT";
+    case m.number:
+      return "REAL";
+    case m.integer:
+    case m.boolean:
+      return "INTEGER";
+    case m.date:
+      return "TEXT";
+  }
+}, Qe = (r, e) => {
+  if (r === null && e.nullable) return null;
+  if (r !== void 0)
+    switch (e.type) {
+      case m.boolean:
+        return r ? 1 : 0;
+      case m.date:
+        return r instanceof Date ? r.toISOString() : r;
+      default:
+        return r;
+    }
+}, Ke = (r, e) => {
+  if (r === null && e.nullable) return null;
+  if (r !== void 0)
+    switch (e.type) {
+      case m.boolean:
+        return !!r;
+      case m.date:
+        return r;
+      case m.json:
+        return r ? JSON.parse(r) : null;
+      default:
+        return r;
+    }
+}, le = (r, e) => `${e}$${r}`, E = (r) => le(r.name, r.namespace), ue = (r, e) => `idx_${r.name}_${e.name}`;
+class $ extends Ee {
+}
+const Y = (r, e) => {
+  const t = {};
+  return Object.keys(e).forEach((s) => {
+    s.endsWith("Id") && (t[s] = e[s]);
+    const n = r.propertyMap.get(s);
+    n && (t[s] = Qe(e[s], n));
+  }), t;
+}, Ye = (r, e) => ce(e, (t, s) => r.propertyMap.has(s) || r.foreignKeyNames.includes(s)), He = (r, e) => ce(e, (t, s) => r.propertyMap.get(s)?.readonly !== !0), se = (r, e, t) => {
+  const s = {};
+  return t.forEach((n, a) => {
+    const o = e[a];
+    if (r.isForeignKey(o))
+      s[o] = n;
+    else {
+      const c = r.propertyMap.get(o);
+      c && (s[o] = Ke(n, c));
+    }
+  }), s;
+}, ne = {
+  [y.ONE_TO_ONE]: 0,
+  [y.ONE_TO_MANY]: 1,
+  [y.MANY_TO_ONE]: 2,
+  [y.MANY_TO_MANY]: 3
+}, Je = (r, e) => {
+  let t = "";
+  const s = E(e);
+  return Array.from(e.relationMap.values())?.toSorted((n, a) => ne[n.kind] - ne[a.kind]).forEach((n) => {
+    switch (n.kind) {
+      case y.ONE_TO_ONE:
+      case y.MANY_TO_ONE:
+        {
+          const a = `${n.name}Id`;
+          if (t += `
+ALTER TABLE ${s} ADD COLUMN "${a}" TEXT`, n.nullable || (t += " NOT NULL"), n.mappedEntity) {
+            const o = le(n.mappedEntity, n.mappedNamespace);
+            t += ` REFERENCES ${o}(id)`;
+          }
+          n.kind === y.MANY_TO_ONE && (t += " ON DELETE CASCADE"), t += ";", (n.unique || n.kind === y.ONE_TO_ONE) && (t += `
+ CREATE UNIQUE INDEX ${ue(e, n)} on ${s}(${a});`);
+        }
+        break;
+    }
+  }), t;
+}, Ge = (r, e) => {
+  const t = E(e);
+  let s = `CREATE TABLE ${t} (`;
+  const n = [], a = [], o = [];
+  e.propertyMap.forEach((i) => {
+    let l = "";
+    if (l += `"${i.name}"`, i.primary ? i.type === m.integer ? l += " INTEGER PRIMARY KEY AUTOINCREMENT" : l += ` ${te(i)} PRIMARY KEY` : l += ` ${te(i)}`, !i.nullable) l += " NOT NULL";
+    else if (Reflect.get(i, "default") !== void 0) {
+      let u = i.default;
+      De(i.default) && (u = i.default()), l += ` DEFAULT ${String(u)}`;
+    }
+    switch (i.type) {
+      case m.json:
+        a.push(`CHECK ( JSON_VALID(${i.name})=1 )`);
+        break;
+      case m.boolean:
+        a.push(`CHECK (${i.name} in(0,1))`);
+        break;
+    }
+    i.unique && n.push(
+      `CREATE UNIQUE INDEX ${ue(e, i)} on ${t}(${i.name});`
+    ), o.push(l);
+  });
+  const c = [...o, ...a];
+  if (c.length)
+    s += c.map((i) => `
+${i}`).join(","), s += `
+);`;
+  else
+    throw new $("columns is empty!");
+  return n.length && (s += `
+` + n.join(`
+`)), s;
+}, ze = (r, e) => {
+  let t = "";
+  return t += Ge(r, e), t += Je(r, e), t;
+}, Xe = (r, e) => {
+  const t = E(e), s = q(ye), n = E(s), { propertyMap: a, name: o, foreignKeyNames: c, namespace: i } = e, l = [...a.keys(), ...c].filter((d) => ["id", "updatedAt"].includes(d) === !1), u = "namespace, entity, type, entityId, inversePatch, patch", h = `CREATE TRIGGER ${t}_insert AFTER INSERT ON ${t}
+BEGIN
+  INSERT INTO ${n} (${u}) VALUES (
+    '${i}', '${o}', 'INSERT', NEW.id, NULL,
+    json_object(${l.map((d) => `'${d}', NEW.${d}`).join(`,
+`)})
+  );
+END;`, _ = `CREATE TRIGGER ${t}_update AFTER UPDATE ON ${t}
+WHEN ( ${l.map((d) => `OLD.${d} IS NOT NEW.${d}`).join(` OR
+`)} )
+BEGIN
+  INSERT INTO ${n} (${u}) VALUES (
+    '${i}','${o}','UPDATE', NEW.id,
+    (
+      SELECT json_group_object(key, value) FROM (
+        ${l.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 (
+        ${l.map((d) => `SELECT '${d}' AS key, NEW.${d} AS value WHERE OLD.${d} IS NOT NEW.${d}`).join(`
+ UNION `)}
+      )
+    )
+  );
+END;
+`, p = `CREATE TRIGGER ${t}_delete AFTER DELETE ON ${t}
+BEGIN
+  INSERT INTO ${n} (${u}) VALUES (
+    '${i}', '${o}', 'DELETE', OLD.id,
+    json_object(${l.map((d) => `'${d}', OLD.${d}`).join(`,
+`)}), NULL
+  );
+END;`;
+  return h + `
+` + _ + `
+` + p;
+};
+var M = /* @__PURE__ */ ((r) => (r[r.SQLITE_DELETE = 9] = "SQLITE_DELETE", r[r.SQLITE_INSERT = 18] = "SQLITE_INSERT", r[r.SQLITE_UPDATE = 23] = "SQLITE_UPDATE", r))(M || {});
+const de = "sqlite", Ze = () => import("@journeyapps/wa-sqlite/dist/wa-sqlite-async.mjs").then((r) => r.default), et = () => import("@journeyapps/wa-sqlite/dist/wa-sqlite.mjs").then((r) => r.default), tt = [
+  {
+    name: "MemoryVFS",
+    vfsModule: () => import("@journeyapps/wa-sqlite/src/examples/MemoryVFS.js").then((r) => r.MemoryVFS),
+    sync: !0,
+    async: !0,
+    worker: !0,
+    sharedWorker: !0,
+    jsContext: !0,
+    multipleConnections: !1
+  },
+  {
+    name: "MemoryAsyncVFS",
+    vfsModule: () => import("@journeyapps/wa-sqlite/src/examples/MemoryAsyncVFS.js").then((r) => r.MemoryAsyncVFS),
+    sync: !1,
+    async: !0,
+    worker: !0,
+    sharedWorker: !0,
+    jsContext: !0,
+    multipleConnections: !1
+  },
+  {
+    name: "IDBBatchAtomicVFS",
+    vfsModule: () => import("@journeyapps/wa-sqlite/src/examples/IDBBatchAtomicVFS.js").then((r) => r.IDBBatchAtomicVFS),
+    vfsOptions: { lockPolicy: "shared+hint" },
+    sync: !1,
+    async: !0,
+    worker: !0,
+    sharedWorker: !0,
+    jsContext: !0,
+    multipleConnections: !0
+  },
+  {
+    name: "OPFSAdaptiveVFS",
+    vfsModule: () => import("@journeyapps/wa-sqlite/src/examples/OPFSAdaptiveVFS.js").then((r) => r.OPFSAdaptiveVFS),
+    vfsOptions: { lockPolicy: "shared+hint" },
+    sync: !1,
+    async: !0,
+    worker: !0,
+    sharedWorker: !1,
+    jsContext: !1,
+    multipleConnections: !0
+  },
+  {
+    name: "AccessHandlePoolVFS",
+    vfsModule: () => import("@journeyapps/wa-sqlite/src/examples/AccessHandlePoolVFS.js").then((r) => r.AccessHandlePoolVFS),
+    sync: !0,
+    async: !0,
+    worker: !0,
+    sharedWorker: !1,
+    jsContext: !1,
+    multipleConnections: !1
+  },
+  {
+    name: "OPFSAnyContextVFS",
+    vfsModule: () => import("@journeyapps/wa-sqlite/src/examples/OPFSAnyContextVFS.js").then((r) => r.OPFSAnyContextVFS),
+    vfsOptions: { lockPolicy: "shared+hint" },
+    sync: !1,
+    async: !0,
+    worker: !0,
+    sharedWorker: !1,
+    jsContext: !0,
+    multipleConnections: !0
+  },
+  {
+    name: "OPFSCoopSyncVFS",
+    vfsModule: () => import("@journeyapps/wa-sqlite/src/examples/OPFSCoopSyncVFS.js").then((r) => r.OPFSCoopSyncVFS),
+    sync: !0,
+    async: !0,
+    worker: !0,
+    sharedWorker: !1,
+    jsContext: !1,
+    multipleConnections: !0
+  },
+  {
+    name: "OPFSPermutedVFS",
+    vfsModule: () => import("@journeyapps/wa-sqlite/src/examples/OPFSPermutedVFS.js").then((r) => r.OPFSPermutedVFS),
+    sync: !1,
+    async: !0,
+    worker: !0,
+    sharedWorker: !1,
+    jsContext: !1,
+    multipleConnections: !0
+  }
+], he = (r) => {
+  const e = tt.find((a) => a.name === r.vfs), { vfs: t, async: s, worker: n } = r;
+  if (!e) throw new $(`vfs ${t} not found`);
+  if (s !== s) throw new $(`vfs ${t} not support async: ${s}`);
+  if (n && !e.worker) throw new $(`vfs ${t} not support worker`);
+  if (!n && !e.jsContext) throw new $(`vfs ${t} only support worker`);
+  return e;
+}, st = async (r) => {
+  const e = he(r), t = r.async ?? !0;
+  let s;
+  t ? s = Ze : s = et;
+  const [n, a] = await Promise.all([s(), e.vfsModule()]), o = {};
+  r.wasmPath && (o.locateFile = () => r.wasmPath);
+  const c = await n(o), i = We(c), l = await a.create(r.vfs, c, e.vfsOptions);
+  return i.vfs_register(l, !0), i;
+}, _e = (r, e) => `${de}:${r}:${e}`, nt = async (r, e, t, s) => {
+  const n = performance.now(), a = s ? [s] : [[]], o = [];
+  let c = 0;
+  const i = {
+    sql: t,
+    runStart: n,
+    results: o
+  };
+  for await (const l of r.statements(e, t)) {
+    if (s)
+      for (const _ of a)
+        r.reset(l), s && r.bind_collection(l, _);
+    const u = [];
+    for (; await r.step(l) === Pe; ) {
+      const _ = r.row(l);
+      u.push(_);
+    }
+    const h = r.column_names(l);
+    h.length && o.push({ columns: h, rows: u }), c += r.changes(e);
+  }
+  return {
+    ...i,
+    rowsAffected: c,
+    runEnd: performance.now()
+  };
+};
+class rt {
+  #e;
+  #t;
+  changeChanel;
+  async init(e, t) {
+    const s = await st(t), n = e + ".sqlite";
+    this.#t = await s.open_v2(n), this.#e = s, await this.execute("PRAGMA temp_store = memory;"), await this.execute("PRAGMA foreign_keys = ON;");
+    const a = t?.cacheSizeKb || 50 * 1024;
+    await this.execute(`PRAGMA cache_size = -${a};`);
+    const o = _e(e, "changes");
+    this.changeChanel = new BroadcastChannel(o), this.#e.update_hook(
+      this.#t,
+      (c, i, l, u) => {
+        if (!l) return;
+        const h = {
+          type: c,
+          dbName: i,
+          tableName: l,
+          rowid: u,
+          recordAt: Date.now(),
+          timeStamp: performance.now()
+        };
+        this.changeChanel.postMessage(h);
+      }
+    );
+  }
+  async version() {
+    const e = await this.execute("SELECT sqlite_version()");
+    return Be(e, "results[0].rows[0][0]");
+  }
+  async disconnect() {
+    await this.#e.close(this.#t);
+  }
+  async execute(e, t) {
+    return nt(this.#e, this.#t, e, t);
+  }
+}
+const at = (r, e, t) => {
+  const s = E(r), n = [e.id];
+  return {
+    sql: `DELETE FROM ${s} WHERE id = ?;`,
+    params: n
+  };
+}, it = (r, e, t) => {
+  const s = E(r), n = Ye(r, e);
+  t?.userId && (n.createdBy = t.userId, n.updatedBy = t.userId), n.createdAt = /* @__PURE__ */ new Date(), n.updatedAt = n.createdAt;
+  const a = Object.keys(n), o = Y(r, n), c = Array(a.length).fill("?").join(","), i = Object.values(o);
+  return {
+    sql: `INSERT INTO ${s} (${a.join(",")}) VALUES (${c}) RETURNING rowid as ${R},*;`,
+    params: i
+  };
+}, ot = (r, e, t) => {
+  const s = {};
+  s.removedAt = /* @__PURE__ */ new Date(), t?.userId && (s.removedBy = t.userId);
+  const n = E(r), o = Object.keys(s).map((l) => `${l} = ?`).join(","), c = Y(r, s), i = [...Object.values(c), e.id];
+  return {
+    sql: `UPDATE ${n} SET ${o} WHERE id = ? and removedAt is null and removedBy is null RETURNING rowid as ${R},*;`,
+    params: i
+  };
+}, ct = (r, e, t, s) => {
+  const n = He(r, t);
+  n.updatedAt = /* @__PURE__ */ new Date(), s?.userId && (n.updatedBy = s.userId);
+  const a = Object.keys(n), o = Y(r, n), c = a.map((h) => `${h} = ?`).join(","), i = [...Object.values(o), e.id];
+  return {
+    sql: `UPDATE ${E(r)} SET ${c} WHERE id = ? RETURNING rowid as ${R},*;`,
+    params: i
+  };
+}, H = (r) => r?.map((e) => `${e.field} ${e.order}`).join(", "), v = (r, e = /* @__PURE__ */ new Map()) => {
+  const t = r.rules.map((s) => re(s) ? v(s, e) : lt(s, e)).filter(Boolean);
+  return t.length === 0 ? "" : t.length === 1 ? t[0] : `(${t.join(re(r) ? ` ${r.combinator} ` : " ")})`;
+}, lt = (r, e) => {
+  let t, s;
+  if (r?.value === null ? r.operator === "=" ? (t = "", s = "is null") : r.operator === "!=" && (t = "", s = "is not null") : (t = dt(r.operator).toLowerCase(), s = ht(r)), !s && ["in", "notIn", "between", "notBetween"].includes(r.operator)) return "";
+  let n = String(r.field);
+  if (e.has(n))
+    n = e.get(n);
+  else if (n.includes(".")) {
+    const a = n.lastIndexOf("."), o = n.slice(0, a), c = n.slice(a + 1);
+    n = `'${o}'.${c}`;
+  }
+  return `${n} ${t} ${s}`.replaceAll(/ +/g, " ").trim();
+}, re = (r) => "rules" in r && "combinator" in r, ut = {
+  "=": "=",
+  "!=": "!=",
+  ">": ">",
+  ">=": ">=",
+  "<": "<",
+  "<=": "<=",
+  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"
+}, dt = (r) => ut[r] || r, ht = (r) => {
+  switch (r.operator) {
+    case "in":
+    case "notIn":
+      return `(${r.value.map((e) => `'${e}'`).join(", ")})`;
+    case "between":
+    case "notBetween": {
+      const [e, t] = r.value;
+      return `'${e}' and '${t}'`;
+    }
+    case "contains":
+    case "notContain":
+      return `'%${r.value}%'`;
+    case "beginWith":
+    case "notBeginWith":
+      return `'${r.value}%'`;
+    case "endWith":
+    case "notEndWith":
+      return `'%${r.value}'`;
+  }
+  return typeof r.value == "boolean" ? r.value ? "1" : "0" : typeof r.value == "string" ? `'${r.value}'` : typeof r.value == "number" ? r.value.toString() : r.value instanceof Date ? `'${r.value.toISOString()}'` : `'${r.value}'`;
+}, j = (r, e, t) => {
+  const s = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), c = (u) => {
+    let h = u, _ = 1;
+    for (; n.has(h); )
+      h = `${u}_${_}`, _++;
+    return n.add(h), h;
+  }, i = (u) => {
+    if (o.has(u))
+      return o.get(u);
+    const h = u.includes("_") ? u : u.split("_")[0], _ = c(h);
+    return o.set(u, _), _;
+  };
+  Fe(t, (u, h, _) => {
+    const p = h;
+    if (u !== "field" || p.includes(".") === !1) return;
+    const { relations: d, isForeignKey: x, propertyName: B } = r.rxdb.schema.getFieldRelations(e, h);
+    if (x) {
+      _.field = B;
+      return;
+    }
+    const pe = p.replace(`.${B}`, ""), F = (N) => d.length === 1 ? N.name : `${pe}_${N.name}`, G = (N) => (s.has(N) || s.set(N, []), s.get(N));
+    d.forEach(({ metadata: N, relation: g }, z) => {
+      const C = r.rxdb.schema.findMappedRelation(N, g);
+      if (!C) throw new $("mappedRelation not found");
+      const P = () => {
+        const O = G(C.metadata), b = F(g), k = i(b);
+        return {
+          joinArray: O,
+          uniqueAlias: k
+        };
+      };
+      let T = "_";
+      if (z > 0) {
+        const O = d[z - 1], b = F(O.relation);
+        T = i(b);
+      }
+      switch (g.kind) {
+        case y.ONE_TO_ONE:
+        case y.ONE_TO_MANY:
+          {
+            const { joinArray: O, uniqueAlias: b } = P();
+            O.push({
+              joinTableName: b,
+              on: `'${b}'.${C.relation.name}Id = ${T === "_" ? T : `'${T}'`}.id`
+            });
+          }
+          break;
+        case y.MANY_TO_ONE:
+          {
+            const { joinArray: O, uniqueAlias: b } = P();
+            O.push({
+              joinTableName: b,
+              on: `'${b}'.id = ${T === "_" ? T : `'${T}'`}.${g.name}Id`
+            });
+          }
+          break;
+        case y.MANY_TO_MANY:
+          {
+            const O = q(g.junctionEntityType), b = G(O), k = c(`${g.name}_m_n`);
+            b.push({
+              joinTableName: k,
+              on: `'${k}'.${C.relation.name}Id = ${T === "_" ? T : `'${T}'`}.id`
+            });
+            const { joinArray: me, uniqueAlias: X } = P();
+            me.push({
+              joinTableName: X,
+              on: `'${X}'.id = '${k}'.${g.name}Id`
+            });
+          }
+          break;
+      }
+    });
+    const W = d[d.length - 1];
+    if (r.rxdb.schema.findMappedRelation(W.metadata, W.relation)) {
+      const N = F(W.relation), g = i(N);
+      a.set(p, `'${g}'.${B}`);
+    }
+  });
+  let l = "";
+  for (const [u, h] of s.entries()) {
+    const _ = E(u);
+    for (const p of h)
+      l += ` LEFT JOIN ${_} '${p.joinTableName}' ON ${p.on}`;
+  }
+  return { joinSQL: l, fieldAliasMap: a };
+}, J = (r) => {
+  const { tableName: e, where: t, limit: s, orderBy: n, join: a } = r;
+  let o = `SELECT _.rowid as ${R}, _.* FROM ${e} _`;
+  return a && (o += a), t && (o += ` where ${t}`), n && (o += ` order by ${n}`), s && (o += ` limit ${s}`), o += ";", o;
+}, _t = (r, e, t, s) => {
+  t = structuredClone(t);
+  const { joinSQL: n, fieldAliasMap: a } = j(r, e, t), o = E(e), c = v(t, a), i = H(s?.orderBy);
+  return {
+    sql: J({ tableName: o, where: c, orderBy: i, join: n }),
+    params: []
+  };
+}, ft = (r, e, t, s) => {
+  t = structuredClone(t);
+  const { joinSQL: n, fieldAliasMap: a } = j(r, e, t), o = E(e), c = v(t, a), i = H(s?.orderBy);
+  return {
+    sql: J({ tableName: o, where: c, orderBy: i, join: n }),
+    params: []
+  };
+}, pt = (r, e, t, s) => {
+  t = structuredClone(t);
+  const { joinSQL: n, fieldAliasMap: a } = j(r, e, t), o = E(e), c = v(t, a);
+  let i = `SELECT count(_.rowid) as count FROM ${o} _`;
+  return n && (i += n), c && (i += ` where ${c}`), {
+    sql: i,
+    params: []
+  };
+}, V = (r, e, t, s) => {
+  t = structuredClone(t);
+  const { joinSQL: n, fieldAliasMap: a } = j(r, e, t), o = E(e), c = v(t, a), i = H(s?.orderBy);
+  return {
+    sql: J({ tableName: o, where: c, orderBy: i, join: n, limit: 1 }),
+    params: []
+  };
+};
+class mt extends $e {
+  constructor(e, t, s) {
+    super(e.rxdb, s), this.adapter = e, this.client$ = t, this.metadata = q(s), this.run_task$.subscribe(() => this.#e()), this.rxdb.addEventListener(be, () => {
+      this.transaction_pending = !0;
+    }), this.rxdb.addEventListener(Ne, () => {
+      this.transaction_pending = !1, this.transaction_entities.forEach((n) => this.merge_cache(n.type, n.entities)), this.transaction_entities = [];
+    }), this.rxdb.addEventListener(Te, () => {
+      this.transaction_pending = !1, this.transaction_entities = [];
+    });
+  }
+  metadata;
+  need_run_task = new ke();
+  run_task$ = this.need_run_task.asObservable().pipe(xe(16));
+  cache_query_task_map = /* @__PURE__ */ new Map();
+  cache_query_tasks = [];
+  transaction_entities = [];
+  transaction_pending = !1;
+  /**
+   * 根据 type 计算主动更新缓存策略
+   */
+  merge_cache(e, t) {
+    if (this.transaction_pending) {
+      this.transaction_entities.push({ type: e, entities: t });
+      return;
+    }
+  }
+  /**
+   * 添加缓存
+   * @param sqliteSuccessResult
+   * @param forcedUpdate 强制刷新，在数据有的情况下也会更新数据，在修改数据的情况下需要
+   */
+  add_query_cache(e, t = !1) {
+    const s = [];
+    return e.results.forEach(({ columns: n, rows: a }) => {
+      const o = n.findIndex((i) => i === "id"), c = n.findIndex((i) => i === R);
+      a.forEach((i) => {
+        const l = i[o];
+        let u;
+        if (this.hasEntityRef(l)) {
+          if (u = this.getEntityRef(l), s.push(u), t) {
+            const _ = se(this.metadata, n, i);
+            this.updateEntity(u, _);
+          }
+        } else {
+          const _ = se(this.metadata, n, i);
+          u = this.createEntityRef(_), s.push(u);
+        }
+        const h = ae(u);
+        h.local = !0, c !== -1 && (h.rowId = BigInt(i[c])), h.modified = !1;
+      });
+    }), s;
+  }
+  /**
+   * 创建查询任务
+   */
+  create_query_task(e) {
+    const { sql: t, params: s } = e, n = t + s.join(",");
+    let a;
+    if (this.cache_query_task_map.has(n) === !1) {
+      const o = new U(), c = o.asObservable(), i = new ie(0), l = i.asObservable(), u = new oe((p) => {
+        const d = this.cache_query_task_map.get(n);
+        return d.observerCount++, a = p, _(), () => {
+          if (d.observerCount--, d.observerCount <= 0) {
+            o.next(), o.complete(), this.cache_query_task_map.delete(n);
+            const x = this.cache_query_tasks.indexOf(d);
+            x >= 0 && this.cache_query_tasks.splice(x, 1);
+          }
+        };
+      }).pipe(L(1)), h = {
+        sql: t,
+        params: s,
+        observerCount: 0,
+        result$: u,
+        destroy$: c,
+        refresh$: l,
+        refresh: () => i.next(i.value + 1),
+        next: (p) => a.next(p),
+        error: (p) => a.error(p)
+      }, _ = () => {
+        this.cache_query_tasks.push(h), this.need_run_task.next();
+      };
+      return this.cache_query_task_map.set(n, h), h;
+    }
+    return this.cache_query_task_map.get(n);
+  }
+  #e() {
+    const e = this.cache_query_tasks.shift();
+    if (!e) return;
+    const { sql: t, params: s, refresh$: n } = e;
+    return n.pipe(
+      w(
+        () => this.client$.pipe(
+          Q(1),
+          K(e.destroy$),
+          w(() => this.adapter.execute(t, s))
+        )
+      )
+    ).subscribe({
+      next: (a) => e.next(a),
+      error: (a) => e.error(a)
+    });
+  }
+}
+class fe extends mt {
+  #e = /* @__PURE__ */ new Map();
+  get(e, t) {
+    const s = {
+      combinator: "and",
+      rules: [
+        {
+          field: "id",
+          operator: "=",
+          value: e
+        }
+      ]
+    }, n = V(this.adapter, this.metadata, s, t), a = this.create_query_task(n);
+    return this.#s("get", a, s, t), a.result$.pipe(
+      f((o) => this.#t(a, o)),
+      f((o) => {
+        if (o.length === 0) throw new $("not found");
+        return o[0];
+      })
+    );
+  }
+  findOne(e, t) {
+    const s = V(this.adapter, this.metadata, e, t), n = this.create_query_task(s);
+    return this.#s("findOne", n, e, t), n.result$.pipe(
+      f((a) => this.#t(n, a)),
+      f((a) => a[0])
+    );
+  }
+  findOneOrFail(e, t) {
+    const s = V(this.adapter, this.metadata, e, t), n = this.create_query_task(s);
+    return this.#s("findOneOrFail", n, e, t), n.result$.pipe(
+      f((a) => this.#t(n, a)),
+      f((a) => {
+        if (a.length === 0)
+          throw new $("not found");
+        return a[0];
+      })
+    );
+  }
+  find(e, t) {
+    const s = _t(this.adapter, this.metadata, e, t), n = this.create_query_task(s);
+    return this.#s("find", n, e, t), n.result$.pipe(f((a) => this.#t(n, a)));
+  }
+  findAll(e, t) {
+    const s = ft(this.adapter, this.metadata, e, t), n = this.create_query_task(s);
+    return this.#s("findAll", n, e, t), n.result$.pipe(f((a) => this.#t(n, a)));
+  }
+  findByCursor(e, t) {
+    throw new Error("Method not implemented.");
+  }
+  count(e, t) {
+    const s = pt(this.adapter, this.metadata, e), n = this.create_query_task(s);
+    return this.#s("count", n, e, t), n.result$.pipe(f((a) => a.results[0].rows[0][0]));
+  }
+  create(e) {
+    return I(this.#r(e));
+  }
+  update(e, t) {
+    return I(this.#i(e, t));
+  }
+  remove(e) {
+    const t = ae(e), s = () => {
+      t.origin = structuredClone({ ...e }), t.modified = !1, t.removed = !0;
+    };
+    if (t.local === !0) {
+      const { sql: a, params: o } = at(this.metadata, e, this.rxdb.context), c = this.client$.pipe(
+        Q(1),
+        w(() => this.adapter.execute(a, o)),
+        f(() => (e.removedAt = /* @__PURE__ */ new Date(), this.rxdb.context?.userId && (e.removedBy = this.rxdb.context.userId), s(), e)),
+        A(() => s()),
+        A((i) => this.merge_cache("remove", [i]))
+      );
+      return I(c);
+    } else if (t.remote === !0) {
+      const { sql: a, params: o } = ot(this.metadata, e, this.rxdb.context), c = this.#n("remove", a, o).pipe(
+        A(() => s()),
+        f((i) => i[0])
+      );
+      return I(c);
+    }
+    const n = q(e);
+    throw new $(`Remove Error${n.name}(${e.id}) not saved local.`);
+  }
+  /**
+   * 根据 type 计算主动更新缓存策略
+   */
+  merge_cache(e, t) {
+    super.merge_cache(e, t);
+    for (const s of this.cache_query_task_map.values()) {
+      if (!s.resultEntityIds) return;
+      const n = this.#e.get(s);
+      if (!n) return;
+      switch (e) {
+        case "create":
+          this.#o(n, s, t);
+          break;
+        case "update":
+          this.#c(n, s, t);
+          break;
+        case "remove":
+          this.#l(n, s, t);
+          break;
+        default:
+          throw new Error("unknown type");
+      }
+    }
+  }
+  #t(e, t) {
+    const s = this.add_query_cache(t);
+    return e.resultEntities = s, e.resultEntityIds = s.map((n) => n.id), s;
+  }
+  #r(e) {
+    const { sql: t, params: s } = it(this.metadata, e, this.rxdb.context);
+    return this.#n("create", t, s).pipe(f((n) => n[0]));
+  }
+  #i(e, t) {
+    const { sql: s, params: n } = ct(this.metadata, e, t, this.rxdb.context);
+    return this.#n("update", s, n).pipe(f((a) => a[0]));
+  }
+  #s(e, t, s, n) {
+    this.#e.set(t, {
+      type: e,
+      where: s,
+      options: n
+    }), t.destroy$.subscribe(() => this.#e.delete(t));
+  }
+  /**
+   * 执行修改语句
+   */
+  #n(e, t, s) {
+    return this.client$.pipe(
+      Q(1),
+      w(() => this.adapter.execute(t, s)),
+      f((n) => this.add_query_cache(n, !0)),
+      A((n) => this.merge_cache(e, n))
+    );
+  }
+  #o(e, t, s) {
+    const { type: n, where: a } = e;
+    switch (n) {
+      case "find":
+      case "findOne":
+      case "findOneOrFail":
+      case "findByCursor":
+      case "count":
+      case "findAll":
+        s.some((c) => S(c, a)) && t.refresh();
+        break;
+    }
+  }
+  #c(e, t, s) {
+    const n = s.map((u) => u.id), a = t.resultEntityIds.some((u) => n.includes(u)), { type: o, where: c, options: i } = e, l = s.some((u) => S(u, c));
+    switch (o) {
+      case "count":
+        l !== a && t.refresh();
+        break;
+      case "find":
+      case "findOne":
+      case "findOneOrFail":
+      case "findByCursor":
+      case "findAll":
+        (l !== a || a && l && i?.orderBy?.length && t.resultEntities && s.some((h) => we(t.resultEntities, h, i.orderBy) !== !1)) && t.refresh();
+        break;
+    }
+  }
+  #l(e, t, s) {
+    const n = s.map((i) => i.id), a = t.resultEntityIds.some((i) => n.includes(i)), { type: o, where: c } = e;
+    switch (o) {
+      case "get":
+        a && t.refresh();
+        break;
+      case "findOne":
+      case "findOneOrFail":
+      case "findByCursor":
+      case "count":
+      case "findAll":
+        (a || s.some((i) => S(i, c))) && t.refresh();
+        break;
+    }
+  }
+}
+const D = (r, e, t, s) => {
+  const n = s?.level || 0, a = E(r), o = n > 0 ? `c.level < ${n}` : "";
+  let c = "";
+  const i = [o, v(t)].filter(Boolean).join(" AND ");
+  return i && (c = `WHERE ${i}`), {
+    sql: `WITH RECURSIVE __children AS (
+  SELECT *,rowid as ${R}, 0 AS level
+  FROM ${a}
+  WHERE id = ?
+  UNION ALL
+  SELECT children.*,children.rowid as ${R}, c.level + 1
+  FROM ${a} children
+  JOIN __children c ON ${s.descendants ? "children.parentId = c.id" : "children.id = c.parentId"}
+  ${c}
+)
+SELECT ${s.count ? "count(*)-1 as count" : "*"} FROM __children
+ORDER BY level, id;`,
+    params: [e]
+  };
+}, Et = (r, e, t, s) => D(r, e, t, { ...s, descendants: !0 }), yt = (r, e, t, s) => D(r, e, t, { ...s, descendants: !1 }), $t = (r, e, t, s) => D(r, e, t, { ...s, descendants: !0, count: !0 }), bt = (r, e, t, s) => D(r, e, t, { ...s, descendants: !1, count: !0 });
+class Nt extends fe {
+  #e = /* @__PURE__ */ new Map();
+  findDescendants(e, t, s) {
+    const n = Et(this.metadata, e.id, t, s), a = this.create_query_task(n);
+    return this.#r("findDescendants", a, e.id, t, s), a.result$.pipe(f((o) => this.#t(a, o)));
+  }
+  countDescendants(e, t, s) {
+    const n = $t(this.metadata, e.id, t, s), a = this.create_query_task(n);
+    return this.#r("countDescendants", a, e.id, t, s), a.result$.pipe(f((o) => o.results[0].rows[0][0]));
+  }
+  findAncestors(e, t, s) {
+    const n = yt(this.metadata, e.id, t, s), a = this.create_query_task(n);
+    return this.#r("findAncestors", a, e.id, t, s), a.result$.pipe(f((o) => this.#t(a, o)));
+  }
+  countAncestors(e, t, s) {
+    const n = bt(this.metadata, e.id, t, s), a = this.create_query_task(n);
+    return this.#r("countAncestors", a, e.id, t, s), a.result$.pipe(f((o) => o.results[0].rows[0][0]));
+  }
+  /**
+   * 根据 type 计算主动更新缓存策略
+   */
+  merge_cache(e, t) {
+    super.merge_cache(e, t);
+    for (const s of this.cache_query_task_map.values()) {
+      if (!s.resultEntityIds) return;
+      const n = this.#e.get(s);
+      if (!n) return;
+      switch (e) {
+        case "create":
+          this.#i(n, s, t);
+          break;
+        case "update":
+          this.#s(n, s, t);
+          break;
+        case "remove":
+          this.#n(n, s, t);
+          break;
+        default:
+          throw new Error("unknown type");
+      }
+    }
+  }
+  #t(e, t) {
+    const s = this.add_query_cache(t);
+    return e.resultEntities = s, e.resultEntityIds = s.map((n) => n.id), s;
+  }
+  #r(e, t, s, n, a) {
+    this.#e.has(t) || (this.#e.set(t, {
+      type: e,
+      entityId: s,
+      where: n,
+      options: a
+    }), t.destroy$.subscribe(() => this.#e.delete(t)));
+  }
+  #i(e, t, s) {
+    const { type: n, where: a } = e, o = s.map((l) => l.parentId), c = t.resultEntityIds.some((l) => o.includes(l));
+    let i = !0;
+    switch (a.rules.length > 0 && (i = s.some((l) => S(l, a))), n) {
+      case "findDescendants":
+      case "countDescendants":
+        c && i && t.refresh();
+        break;
+    }
+  }
+  #s(e, t, s) {
+    const { type: n, where: a } = e, o = s.map((l) => l.parentId), c = t.resultEntityIds.some((l) => o.includes(l));
+    let i = !0;
+    switch (a.rules.length > 0 && (i = s.some((l) => S(l, a))), n) {
+      case "findDescendants":
+      case "countDescendants":
+      case "findAncestors":
+      case "countAncestors":
+        c && i && t.refresh();
+        break;
+    }
+  }
+  #n(e, t, s) {
+    const { type: n, where: a } = e, o = s.map((l) => l.parentId), c = t.resultEntityIds.some((l) => o.includes(l));
+    let i = !0;
+    switch (a.rules.length > 0 && (i = s.some((l) => S(l, a))), n) {
+      case "findDescendants":
+      case "countDescendants":
+      case "findAncestors":
+      case "countAncestors":
+        c && i && t.refresh();
+        break;
+    }
+  }
+}
+class vt extends Ae {
+  constructor(e, t) {
+    super(e), this.options = t;
+    const s = _e(e.options.dbName, "changes");
+    this.#r = new BroadcastChannel(s), this.#i = Ce(this.#r, "message"), this.#i.pipe(K(this.#e)).subscribe((n) => {
+      const a = n.data, { dbName: o, tableName: c, rowid: i, recordAt: l, timeStamp: u } = a;
+      if (!o || !c || !i) return;
+      const [h, _] = c.split("$"), p = this.rxdb.schema.getEntityType(_, h);
+      if (!p) return;
+      const d = {
+        rowId: i,
+        recordAt: l,
+        timeStamp: u
+      };
+      switch (a.type) {
+        case M.SQLITE_DELETE:
+          this.rxdb.dispatchEvent(new Se(p, d));
+          break;
+        case M.SQLITE_INSERT:
+          this.rxdb.dispatchEvent(new Re(p, d));
+          break;
+        case M.SQLITE_UPDATE:
+          this.rxdb.dispatchEvent(new qe(p, d));
+          break;
+      }
+    }), this.#_.pipe(K(this.#e)).subscribe();
+  }
+  #e = new U();
+  #t = /* @__PURE__ */ new Map();
+  // db change
+  #r;
+  #i;
+  // 查询缓存
+  #s = [];
+  #n = /* @__PURE__ */ new Map();
+  #o = !1;
+  #c = new ie(0);
+  #l = this.#c.asObservable();
+  // sqlite 客户端
+  #a = new oe((e) => {
+    const { vfs: t, async: s, worker: n, wasmPath: a, workerInstance: o } = this.options, c = {
+      vfs: t,
+      async: s,
+      worker: n,
+      wasmPath: a
+    };
+    he(c);
+    let i;
+    n && o ? i = ve(o) : i = new rt(), i.init(this.rxdb.options.dbName, c).then(() => e.next(i));
+  }).pipe(L(1));
+  // 已连接
+  #h = Le(() => this.rxdb.connect(this.name)).pipe(L(1));
+  // 队列
+  #_ = this.#l.pipe(
+    Z(() => this.#o === !1),
+    f(() => this.#s.shift()),
+    Z(Boolean),
+    A(() => this.#o = !0),
+    w((e) => {
+      const t = this.#n.get(e.key);
+      return this.#h.pipe(
+        w(() => this.#a),
+        w((s) => s.execute(e.sql, e.bindings)),
+        A((s) => t.next(s)),
+        A(() => setTimeout(() => this.#n.delete(e.key), 0)),
+        Me((s) => {
+          const n = s.message || "执行错误";
+          return t.error(
+            new $("${msg} ${sql} ${bindings}", {
+              msg: n,
+              sql: e.sql,
+              bindings: JSON.stringify(e.bindings)
+            })
+          ), je({ error: s });
+        })
+      );
+    }),
+    A(() => {
+      this.#o = !1, this.#u();
+    })
+  );
+  name = de;
+  /**
+   * 数据库版本
+   */
+  version$ = this.#a.pipe(
+    w((e) => ee(e.version())),
+    L(1)
+  );
+  /**
+   * 连接 wab sqlite
+   */
+  connect() {
+    return this.#a.pipe(f(() => this));
+  }
+  /**
+   * 断开连接
+   */
+  async disconnect() {
+    this.#e.next();
+  }
+  /**
+   * 获取版本
+   */
+  version() {
+    return I(this.version$);
+  }
+  /**
+   * 获取实体仓库
+   * @param entity 实体类
+   */
+  getRepository(e) {
+    if (!this.#t.has(e)) {
+      const t = q(e);
+      let s;
+      switch (t.repository) {
+        case "Repository":
+          s = new fe(this, this.#a, e);
+          break;
+        case "TreeRepository":
+          s = new Nt(this, this.#a, e);
+          break;
+        default:
+          throw new $("Unsupported repository type: " + t.repository);
+      }
+      return this.#t.set(e, s), s;
+    }
+    return this.#t.get(e);
+  }
+  /**
+   * 判断表是否存在
+   * @param EntityType
+   */
+  isTableExisted(e) {
+    return I(this.isTableExisted$(e));
+  }
+  /**
+   * 判断表是否存在
+   * @param EntityType
+   */
+  isTableExisted$(e) {
+    const t = q(e), s = E(t);
+    return this.#d(Ve(s)).pipe(f((n) => Ue(n) === !1));
+  }
+  /**
+   * 创建 table
+   * @param EntityType
+   */
+  createTable(e) {
+    const t = q(e);
+    let s = ze(this, t);
+    if (t.log !== !1) {
+      const n = Xe(this, t);
+      s += `
+` + n;
+    }
+    return I(this.#d(s).pipe(f(() => !0)));
+  }
+  /**
+   * 执行 sql
+   * @param sql
+   * @param bindings
+   */
+  execute(e, t) {
+    const s = e + t?.join(",");
+    if (!this.#n.has(s)) {
+      const n = new U();
+      this.#n.set(s, n), this.#s.push({ key: s, sql: e, bindings: t }), this.#u();
+    }
+    return this.#n.get(s).asObservable();
+  }
+  /**
+   * 处理事务
+   * @param callback
+   */
+  transaction(e) {
+    return I(this.transaction$(e));
+  }
+  transaction$(e) {
+    return this.#a.pipe(
+      w(async (t) => {
+        this.rxdb.dispatchEvent(Tt), await t.execute("BEGIN; PRAGMA defer_foreign_keys = ON;");
+        try {
+          const s = await e();
+          return await t.execute("COMMIT"), this.rxdb.dispatchEvent(wt), s;
+        } catch (s) {
+          await t.execute("ROLLBACK"), this.rxdb.dispatchEvent(gt);
+          const n = s?.message || "Transaction Error";
+          throw new $(n);
+        }
+      })
+    );
+  }
+  #u() {
+    this.#c.next(this.#c.value + 1);
+  }
+  /**
+   * 内部执行的 sql
+   * @param sql
+   * @param bindings
+   * @returns
+   */
+  #d(e, t) {
+    return this.#a.pipe(w((s) => ee(s.execute(e, t))));
+  }
+}
+const Tt = new ge(), wt = new Oe(), gt = new Ie();
+export {
+  vt as RxDBAdapterSqlite,
+  $ as RxdbAdapterSqliteError,
+  rt as SqliteClient,
+  tt as WA_SQLITE_VFS_LIST,
+  st as sqliteLoad
+};