@aiao/rxdb 0.0.2 → 0.0.4

package/index.js

@@ -1,1779 +0,0 @@
-import { isFunction as oe, startCase as ce, get as le, isEqual as J, isSymbol as de, omitBy as he, deepFreeze as pe, isPromise as ue } from "@aiao/utils";
-import { v7 as fe } from "uuid";
-import { BehaviorSubject as N, filter as Y, distinctUntilChanged as I, switchMap as f, shareReplay as A, map as D, tap as b, firstValueFrom as S, of as j, defer as q } from "rxjs";
-class v extends Error {
-}
-class T {
-  constructor(e) {
-    this.entity = e;
-  }
-}
-class U extends T {
-  constructor(e, t) {
-    super(e), this.error = t;
-  }
-}
-const Ee = "ENTITY_NEW";
-class ye extends T {
-  type = Ee;
-}
-const V = "ENTITY_CREATE", me = `${V}_SUCCESS`, _e = `${V}_ERROR`;
-class ge extends T {
-  type = V;
-}
-class be extends T {
-  type = me;
-}
-class ve extends U {
-  type = _e;
-}
-const K = "ENTITY_UPDATE", Te = `${K}_SUCCESS`, Ae = `${K}_ERROR`;
-class Oe extends T {
-  type = K;
-}
-class Re extends T {
-  type = Te;
-}
-class we extends U {
-  type = Ae;
-}
-const W = "ENTITY_REMOVE", Ne = `${W}_SUCCESS`, xe = `${W}_ERROR`;
-class Me extends T {
-  type = W;
-}
-class Se extends T {
-  type = Ne;
-}
-class Ce extends U {
-  type = xe;
-}
-const Ie = "ENTITY_PATCH";
-class De extends T {
-  constructor(e, t, s, n, i, a) {
-    super(e), this.patch = t, this.inversePatch = s, this.recordAt = n, this.timeStamp = i, this.updatedBy = a;
-  }
-  type = Ie;
-}
-const F = "TRANSACTION_BEGIN", z = "TRANSACTION_COMMIT", H = "TRANSACTION_ROLLBACK";
-class mt {
-  type = F;
-}
-class _t {
-  type = z;
-}
-class gt {
-  type = H;
-}
-const ee = "DATABASE_DELETE", Be = "DATABASE_INSERT", $e = "DATABASE_UPDATE";
-class G {
-  constructor(e, t) {
-    this.EntityType = e, this.data = t;
-  }
-}
-class bt extends G {
-  type = ee;
-}
-class vt extends G {
-  type = Be;
-}
-class Tt extends G {
-  type = $e;
-}
-const te = Symbol("ɵProxy"), L = Symbol("ɵMetadata"), se = Symbol("ɵStatus"), B = Symbol("ɵStatusCheck"), ne = Symbol("ɵEntityManager"), re = Symbol("ɵEntityDeleteCheck"), x = Symbol("ɵUpdateBy"), Pe = "SYSTEM", Ye = "USER", je = (r, e) => e.sync.local?.adapter === r, Le = (r) => [F, z, H].includes(r.type), O = (r) => r[L] || r.constructor[L], m = (r) => r[se], At = (r, e, t, s) => {
-  let n = s > 1 ? void 0 : s ? Object.getOwnPropertyDescriptor(e, t) : e;
-  for (let i = r.length - 1, a; i >= 0; i--)
-    (a = r[i]) && (n = a(n) || n);
-  return n;
-}, ke = () => fe(), Ue = [
-  "id",
-  "createdAt",
-  "updatedAt",
-  "removedAt",
-  "createdBy",
-  "updatedBy",
-  "removedBy"
-], Ve = ["rev"], Ot = (r) => !!(Ue.includes(r) || Ve.includes(r) || r.startsWith("_")), u = (r, e, t) => Object.defineProperty(r, e, {
-  value: t,
-  enumerable: !1,
-  configurable: !1,
-  writable: !1
-}), Q = (r, e, t) => Object.defineProperty(r, e, {
-  value: t,
-  enumerable: !1,
-  configurable: !1,
-  writable: !0
-}), w = (r, e, t) => {
-  let s;
-  const n = {
-    get: () => (s = t(), n.get = () => s, s),
-    enumerable: !1,
-    configurable: !1
-  };
-  return Object.defineProperty(r, e, n);
-}, Ke = (r, e) => {
-  const t = {};
-  let s = !1;
-  r.defaultValueProperties.forEach((n) => {
-    e[n.name] === void 0 && (s = !0, oe(n.default) ? t[n.name] = n.default() : t[n.name] = n.default);
-  }), s && Object.assign(e, t);
-}, We = (r, e, t) => {
-  const { propertyMap: s, foreignKeyNames: n } = O(e);
-  Object.keys(t).forEach((i) => {
-    s.has(i) ? r.propertyMap.get(i)?.readonly !== !0 && (e[i] = t[i]) : n.includes(i) && (e[i] = t[i]);
-  });
-};
-var E = /* @__PURE__ */ ((r) => (r.uuid = "uuid", r.string = "string", r.number = "number", r.integer = "integer", r.boolean = "boolean", r.date = "date", r.json = "json", r))(E || {}), p = /* @__PURE__ */ ((r) => (r.ONE_TO_ONE = "1:1", r.ONE_TO_MANY = "1:m", r.MANY_TO_ONE = "m:1", r.MANY_TO_MANY = "m:n", r))(p || {}), Fe = /* @__PURE__ */ ((r) => (r.Full = "full", r.Filter = "filter", r.None = "None", r))(Fe || {});
-const ze = (r, e) => {
-  const t = [];
-  t.push(r);
-  const s = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = { ...r };
-  if (a.repository = a.repository || "Repository", a.namespace = a.namespace || "public", a.properties = a.properties || [], a.relations = a.relations || [], a.indexes = a.indexes || [], e) {
-    let o = e, c = r;
-    for (; o !== Object.prototype && c; )
-      o = Object.getPrototypeOf(o), c = O(o), c && t.push(c);
-    const l = t.map((d) => d.name);
-    l.shift(), a.extends = l;
-  } else
-    a.extends = r.extends || [];
-  return a.displayName || (a.displayName = ce(a.name).replace(" ", "")), a.relations.forEach((o) => {
-    o.mappedNamespace = o.mappedNamespace || "public";
-  }), t.reverse().forEach((o) => {
-    o.properties?.forEach((c) => {
-      s.set(c.name, c);
-    }), o.relations?.forEach((c) => {
-      if (c.mappedNamespace = c.mappedNamespace || "public", c.mappedEntity === o.name && c.mappedNamespace === o.namespace) {
-        const l = { ...c };
-        l.mappedEntity = a.name, l.mappedNamespace = a.namespace, n.set(c.name, l);
-      } else
-        n.set(c.name, c);
-    }), o.indexes?.forEach((c) => i.set(c.name, c));
-  }), u(a, "propertyMap", s), u(a, "relationMap", n), u(a, "indexMap", i), w(
-    a,
-    "defaultValueProperties",
-    () => Array.from(s.values()).filter((o) => o.default !== void 0)
-  ), w(
-    a,
-    "foreignKeyRelations",
-    () => Array.from(a.relationMap.values()).filter(
-      (o) => o.kind === p.MANY_TO_ONE || o.kind === p.ONE_TO_ONE
-    )
-  ), w(a, "foreignKeyRelationMap", () => {
-    const o = /* @__PURE__ */ new Map();
-    return a.foreignKeyRelations.forEach((c) => o.set(c.name, c)), o;
-  }), w(a, "foreignKeyNames", () => a.foreignKeyRelations.map((o) => `${o.name}Id`)), u(
-    a,
-    "isForeignKey",
-    (o) => o && o.endsWith("Id") && a.foreignKeyNames.includes(o)
-  ), a;
-}, R = (r) => (e) => {
-  const t = ze(r, e);
-  if (u(e, L, t), r.abstract) return e;
-  const s = e;
-  return class extends s {
-    /**
-     * 实体构造函数
-     * 处理实体初始化、默认值填充和代理包装
-     *
-     * 构造函数执行以下步骤：
-     * 1. 调用原始类的构造函数
-     * 2. 获取实体管理器
-     * 3. 填充默认值（基于元数据中定义的默认值）
-     * 4. 填充初始值（如果提供了初始化数据）
-     * 5. 创建并返回实体代理（用于变更跟踪）
-     */
-    constructor(n) {
-      super(n);
-      const i = this[ne];
-      if (!i) throw new v("need init rxdb");
-      return Ke(t, this), n && We(t, this, n), i[te](this);
-    }
-  };
-}, Rt = (r) => {
-  const e = r.features || {};
-  return R({
-    ...r,
-    features: {
-      ...e,
-      treeType: e.treeType || "adjacency-list"
-    },
-    repository: r.repository || "TreeRepository"
-  });
-};
-var He = Object.getOwnPropertyDescriptor, Ge = (r, e, t, s) => {
-  for (var n = s > 1 ? void 0 : s ? He(e, t) : e, i = r.length - 1, a; i >= 0; i--)
-    (a = r[i]) && (n = a(n) || n);
-  return n;
-};
-let $ = class {
-  /**
-   * 实体唯一标识符
-   * 自动生成的UUID，作为主键
-   */
-  id;
-  /**
-   * 创建时间
-   * 实体创建时自动设置为当前时间
-   */
-  createdAt;
-  /**
-   * 更新时间
-   * 实体创建或更新时自动设置为当前时间
-   */
-  updatedAt;
-  /**
-   * 删除时间
-   * 实体被软删除时设置为当前时间，否则为null
-   */
-  removedAt;
-  /**
-   * 创建者ID
-   * 记录创建此实体的用户ID
-   */
-  createdBy;
-  /**
-   * 更新者ID
-   * 记录最后更新此实体的用户ID
-   */
-  updatedBy;
-  /**
-   * 删除者ID
-   * 记录删除此实体的用户ID
-   */
-  removedBy;
-  /**
-   * 实体基类构造函数
-   * 子类会通过 Entity 装饰器增强此构造函数
-   *
-   * @param initData - 可选的初始化数据
-   */
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  constructor(r) {
-  }
-};
-$ = Ge([
-  R({
-    name: "EntityBase",
-    abstract: !0,
-    // 标记为抽象类，不会直接创建此类的实例
-    properties: [
-      {
-        name: "id",
-        type: E.uuid,
-        primary: !0,
-        // 主键
-        unique: !0,
-        // 唯一索引
-        readonly: !0,
-        // 创建后不可修改
-        default: () => ke()
-        // 默认生成UUID
-      },
-      {
-        name: "createdAt",
-        type: E.date,
-        readonly: !0,
-        default: () => /* @__PURE__ */ new Date()
-      },
-      {
-        name: "updatedAt",
-        type: E.date,
-        readonly: !0,
-        default: () => /* @__PURE__ */ new Date()
-      },
-      {
-        name: "removedAt",
-        type: E.date,
-        readonly: !0,
-        nullable: !0
-      },
-      {
-        name: "createdBy",
-        type: E.string,
-        readonly: !0,
-        nullable: !0
-      },
-      {
-        name: "updatedBy",
-        type: E.string,
-        readonly: !0,
-        nullable: !0
-      },
-      {
-        name: "removedBy",
-        type: E.string,
-        readonly: !0,
-        nullable: !0
-      }
-    ]
-  })
-], $);
-var Je = Object.getOwnPropertyDescriptor, qe = (r, e, t, s) => {
-  for (var n = s > 1 ? void 0 : s ? Je(e, t) : e, i = r.length - 1, a; i >= 0; i--)
-    (a = r[i]) && (n = a(n) || n);
-  return n;
-};
-let X = class extends $ {
-};
-X = qe([
-  R({
-    name: "TreeAdjacencyListEntityBase",
-    abstract: !0,
-    // 标记为抽象类，不会直接创建此类的实例
-    relations: [
-      {
-        name: "children",
-        // 子节点关系名称
-        kind: p.ONE_TO_MANY,
-        // 一对多关系
-        mappedEntity: "TreeAdjacencyListEntityBase",
-        // 关联到同一实体类型
-        mappedProperty: "parent"
-        // 映射到子实体的 parent 属性
-      },
-      {
-        name: "parent",
-        // 父节点关系名称
-        kind: p.MANY_TO_ONE,
-        // 多对一关系
-        mappedEntity: "TreeAdjacencyListEntityBase",
-        // 关联到同一实体类型
-        nullable: !0
-        // 允许根节点没有父节点
-      }
-    ]
-  })
-], X);
-const Qe = (r) => !!r.combinator, Xe = (r, e) => {
-  const t = e[r.field], { operator: s, value: n } = r;
-  switch (s) {
-    case "in":
-      return n.includes(t);
-    case "notIn":
-      return n.includes(t) === !1;
-    case "between":
-      return t >= n[0] && t <= n[1];
-    case "notBetween":
-      return t < n[0] || t > n[1];
-    case "contains":
-      return `${t}`.includes(`${n}`);
-    case "notContain":
-      return `${t}`.includes(`${n}`) === !1;
-    case "beginWith":
-      return `${t}`.startsWith(`${n}`);
-    case "notBeginWith":
-      return `${t}`.startsWith(`${n}`) === !1;
-    case "endWith":
-      return `${t}`.endsWith(`${n}`);
-    case "notEndWith":
-      return `${t}`.endsWith(`${n}`) === !1;
-    case "=":
-      return J(n, t);
-    case "!=":
-      return J(n, t) === !1;
-    case ">":
-      return t > n;
-    case ">=":
-      return t >= n;
-    case "<":
-      return t < n;
-    case "<=":
-      return t <= n;
-    default:
-      throw new v(`Unknown operator: ${s}`);
-  }
-}, k = (r, e) => {
-  if (Qe(r)) {
-    const { combinator: t, rules: s } = r;
-    return t === "and" ? s.every((n) => k(n, e)) : s.some((n) => k(n, e));
-  } else
-    return Xe(r, e);
-}, wt = (r, e) => k(e, r), Ze = (r, e, t) => {
-  const { field: s, order: n } = t, i = le(e, s);
-  if (n === "asc") {
-    if (r.some((c) => i < Reflect.get(c, s))) return !0;
-    if (r.every((c) => i > Reflect.get(c, s))) return !1;
-  } else {
-    if (r.some((c) => i > Reflect.get(c, s))) return !0;
-    if (r.every((c) => i < Reflect.get(c, s))) return !1;
-  }
-}, Nt = (r, e, t) => {
-  if (t.length === 0) return !1;
-  for (let s = 0; s < t.length; s++) {
-    const n = t[s], i = Ze(r, e, n);
-    if (i === void 0) {
-      if (s < t.length - 1) {
-        const { field: a } = n, o = Reflect.get(e, a);
-        r = r.filter((c) => Reflect.get(c, a) === o);
-      }
-    } else
-      return i;
-  }
-};
-var et = /* @__PURE__ */ ((r) => (r.Synced = "Synced", r.Syncing = "Syncing", r.Never = "Never", r))(et || {});
-class xt {
-  constructor(e, t) {
-    this.rxdb = e, this.EntityClass = t;
-  }
-  /**
-   * 获取实体实例
-   * @param data 实体数据
-   */
-  createEntityRef(e) {
-    return this.rxdb.em.createEntityRef(this.EntityClass, e);
-  }
-  /**
-   * 获取实体实例
-   * @param id 实体的 ID
-   */
-  getEntityRef(e) {
-    return this.rxdb.em.getEntityRef(this.EntityClass, e);
-  }
-  /**
-   * 获取实体实例
-   * @param id 实体的 ID
-   */
-  hasEntityRef(e) {
-    return this.rxdb.em.hasEntityRef(this.EntityClass, e);
-  }
-  /**
-   * 更新实体
-   */
-  updateEntity(e, t) {
-    e[x] = Pe;
-    const s = m(e);
-    s.origin = { ...t }, Object.assign(e, t), e[x] = null;
-  }
-}
-class ae {
-  constructor(e, t) {
-    this.rxdb = e, this.EntityType = t;
-    const s = O(t);
-    this.sync = s.sync || e.options.sync;
-    const { local: n, remote: i } = this.sync;
-    n && this.localAdapterSub.next(n.adapter), i && this.remoteAdapterSub.next(i.adapter);
-  }
-  /**
-   * 本地适配器
-   */
-  localAdapterSub = new N("");
-  localAdapter$ = this.localAdapterSub.asObservable().pipe(
-    Y(Boolean),
-    I(),
-    f((e) => this.rxdb.getAdapter(e)),
-    A(1)
-  );
-  /**
-   * 本地仓库
-   */
-  local$ = this.localAdapter$.pipe(
-    D((e) => e.getRepository(this.EntityType)),
-    A(1)
-  );
-  /**
-   * 远程适配器
-   */
-  remoteAdapterSub = new N("");
-  remoteAdapter$ = this.remoteAdapterSub.asObservable().pipe(
-    Y(Boolean),
-    I(),
-    f((e) => this.rxdb.getAdapter(e)),
-    A(1)
-  );
-  /**
-   * 远程仓库
-   */
-  remote$ = this.remoteAdapter$.pipe(
-    D((e) => e.getRepository(this.EntityType)),
-    A(1)
-  );
-  /**
-   * 同步配置
-   * TODO: 待实现同步功能
-   */
-  sync;
-  /**
-   * 根据 id 获取实体
-   * @param id
-   * @param options
-   */
-  get(e, t) {
-    return this.local$.pipe(
-      f((s) => s.get(e, t)),
-      b(this._setLocalEntityStatus)
-    );
-  }
-  /**
-   * 查找一个实体
-   * @param where
-   * @param options
-   */
-  findOne(e, t) {
-    return this.local$.pipe(
-      f((s) => s.findOne(e, t)),
-      b((s) => s && this._setLocalEntityStatus(s))
-    );
-  }
-  /**
-   * 查找一个实体，查不到就抛出错误
-   * @param where
-   * @param options
-   */
-  findOneOrFail(e, t) {
-    return this.local$.pipe(
-      f((s) => s.findOneOrFail(e, t)),
-      b(this._setLocalEntityStatus)
-    );
-  }
-  /**
-   * 查询多个实体
-   * @param where
-   * @param options
-   */
-  find(e, t) {
-    return this.local$.pipe(
-      f((s) => s.find(e, t)),
-      b(this._setLocalEntitiesStatus)
-    );
-  }
-  /**
-   * 查询所有实体
-   * @param where
-   * @param options
-   */
-  findAll(e, t) {
-    return this.local$.pipe(
-      f((s) => s.findAll(e, t)),
-      b(this._setLocalEntitiesStatus)
-    );
-  }
-  /**
-   * 通过指针查询实体
-   * @param where
-   * @param options
-   */
-  findByCursor(e, t) {
-    return this.local$.pipe(
-      f((s) => s.findByCursor(e, t)),
-      b(this._setLocalEntitiesStatus)
-    );
-  }
-  /**
-   * 查询实体数量
-   * @param where
-   * @param options
-   */
-  count(e, t) {
-    return this.local$.pipe(f((s) => s.count(e, t)));
-  }
-  /**
-   * 事务保存
-   * @param entities 需要保存的实体
-   */
-  async transactionSave(e) {
-    return e = Array.from(new Set(e)), (await S(this.localAdapter$)).transaction(async () => {
-      let s;
-      for (let n = 0; n < e.length; n++) {
-        const i = e[n], a = m(i);
-        a.modified && (a.local ? s = await this.rxdb.em.update(i) : s = await this.rxdb.em.create(i));
-      }
-      return s;
-    });
-  }
-  /**
-   * 创建实体
-   * @param entity
-   */
-  create(e) {
-    const t = this.local$.pipe(
-      f((s) => s.create(e)),
-      b(this._setLocalEntityStatus)
-    );
-    return S(t);
-  }
-  /**
-   * 更新实体
-   * @param entity
-   * @param patch
-   */
-  update(e, t) {
-    const s = this.local$.pipe(
-      f((n) => n.update(e, t)),
-      b(this._setLocalEntityStatus)
-    );
-    return S(s);
-  }
-  /**
-   * 删除实体
-   * @param entity
-   */
-  remove(e) {
-    const t = this.local$.pipe(f((s) => s.remove(e)));
-    return S(t);
-  }
-  /**
-   * 设置状态 local
-   */
-  _setLocalEntityStatus = (e) => m(e).local = !0;
-  _setLocalEntitiesStatus = (e) => e.forEach(this._setLocalEntityStatus);
-}
-class tt extends ae {
-  /**
-   * 查询子孙
-   */
-  findDescendants(e, t, s) {
-    return this.local$.pipe(
-      f((n) => n.findDescendants(e, t, s)),
-      b(this._setLocalEntitiesStatus)
-    );
-  }
-  /**
-   * 查询子孙数量
-   */
-  countDescendants(e, t, s) {
-    return this.local$.pipe(f((n) => n.countDescendants(e, t, s)));
-  }
-  /**
-   * 查询祖先
-   */
-  findAncestors(e, t, s) {
-    return this.local$.pipe(
-      f((n) => n.findAncestors(e, t, s)),
-      b(this._setLocalEntitiesStatus)
-    );
-  }
-  /**
-   * 查询祖先数量
-   */
-  countAncestors(e, t, s) {
-    return this.local$.pipe(f((n) => n.countAncestors(e, t, s)));
-  }
-}
-const st = (r) => {
-  const e = m(r), t = r;
-  let s = [];
-  const n = () => {
-    let o = {}, c = {}, l = null;
-    const d = () => {
-      l && (e.addEntityPatch(c, o, l), l = null, o = {}, c = {});
-    };
-    s.forEach(({ prop: h, value: y, oldValue: _, updatedBy: g }) => {
-      o[h] = o[h] ?? _, c[h] = y, l === null ? l = g : l !== g && d();
-    }), d(), e[B] = !1, s = [], t[x] = null;
-  };
-  let i;
-  const a = {
-    // get: (target, prop, receiver) => {
-    //   const value = Reflect.get(target, prop, receiver);
-    //   return value;
-    // },
-    /**
-     * 拦截属性设置操作
-     * 当属性值发生变化时，记录变更并安排检查
-     */
-    set: (o, c, l, d) => {
-      if (o[c] === l) return !0;
-      if (de(c) === !1) {
-        const h = o[x] || Ye;
-        s.push({ updatedBy: h, prop: c, value: l, oldValue: o[c] }), e[B] = !0, e.modified = !0, clearTimeout(i), i = setTimeout(() => n(), 0);
-      }
-      return Reflect.set(o, c, l, d);
-    }
-  };
-  return new Proxy(r, a);
-}, nt = (r, e, t) => {
-  const s = t.rxdb.schema.getEntityType(r.mappedEntity, r.mappedNamespace);
-  if (!s) throw new v(`mapped entity not found: ${r.mappedEntity}`);
-  const n = r.name + "Id", i = r.name + "$";
-  let a;
-  switch (r.kind) {
-    /**
-     * 多对一, 一对一关系处理
-     * 创建一个可观察对象，通过外键ID获取关联实体
-     * 提供set和remove方法操作关系
-     */
-    case p.MANY_TO_ONE:
-    case p.ONE_TO_ONE:
-      a = function() {
-        const o = this, c = m(o), l = new N(o[n]), d = l.asObservable().pipe(
-          f((h) => h ? t.getRepository(s).get(h) : j(null)),
-          A(1)
-        );
-        return u(d, "set", (h) => {
-          h || d.remove(), Reflect.get(o, n) != h.id && (c.addRelationEntity(r, h), l.next(h.id), Reflect.set(o, n, h.id));
-        }), u(d, "remove", () => {
-          Reflect.get(o, n) != null && (l.next(null), c.removeRelationEntity(r, e), Reflect.set(o, n, null));
-        }), Object.freeze(d);
-      };
-      break;
-    /**
-     * 一对多关系处理
-     * 创建一个可观察对象，查询所有关联到当前实体的实体集合
-     * 提供add和remove方法操作关系集合
-     */
-    case p.ONE_TO_MANY:
-      a = function() {
-        const o = r.mappedProperty + "Id", c = r.mappedProperty + "$", l = this, d = m(l), h = t.getRepository(s).findAll({
-          combinator: "and",
-          rules: [
-            {
-              field: o,
-              operator: "=",
-              value: l.id
-            }
-          ]
-        }), y = t.getRepository(s).count({
-          combinator: "and",
-          rules: [
-            {
-              field: o,
-              operator: "=",
-              value: l.id
-            }
-          ]
-        });
-        return u(h, "count$", y), u(h, "add", (..._) => {
-          _.forEach((g) => {
-            d.addRelationEntity(r, g), g[c].set(l);
-          });
-        }), u(h, "remove", (..._) => {
-          _.forEach((g) => {
-            d.removeRelationEntity(r, g), g[c].remove();
-          });
-        }), Object.freeze(h);
-      };
-      break;
-    /**
-     * 多对多关系处理
-     * 通过中间表（junction entity）实现多对多关系
-     * 创建一个可观察对象，查询通过中间表关联到当前实体的实体集合
-     * 提供add和remove方法操作关系集合
-     */
-    case p.MANY_TO_MANY:
-      a = function() {
-        const o = this, c = m(o), l = r.name + "Id";
-        if (!r.junctionEntityType) throw new v("junction entity not found");
-        const d = t.getRepository(r.junctionEntityType).findAll({
-          combinator: "and",
-          rules: [
-            {
-              field: r.mappedProperty + "Id",
-              operator: "=",
-              value: o.id
-            }
-          ]
-        }).pipe(
-          f((y) => {
-            const _ = y.map((g) => g[l]);
-            return t.getRepository(s).findAll({
-              combinator: "and",
-              rules: [
-                {
-                  field: "id",
-                  operator: "in",
-                  value: _
-                }
-              ]
-            });
-          })
-        ), h = t.getRepository(r.junctionEntityType).count({
-          combinator: "and",
-          rules: [
-            {
-              field: r.mappedProperty + "Id",
-              operator: "=",
-              value: o.id
-            }
-          ]
-        });
-        return u(d, "count$", h), u(d, "add", (...y) => {
-          y.forEach((_) => c.addRelationEntity(r, _));
-        }), u(d, "remove", (...y) => {
-          y.forEach((_) => {
-            c.removeRelationEntity(r, _);
-          });
-        }), Object.freeze(d);
-      };
-      break;
-  }
-  Object.defineProperty(e.prototype, i, {
-    get: a,
-    enumerable: !1,
-    configurable: !1
-  });
-};
-class rt {
-  /**
-   * 创建实体状态实例
-   *
-   * @constructor
-   * @param rxdb - RxDB 实例
-   * @param data - 实体状态初始数据
-   */
-  constructor(e, t) {
-    this.rxdb = e, u(this, "target", t.target), this._local = t.local || !1, this._remote = t.remote || !1, this._modified = t.modified || !1, this._origin = { ...t.target }, this._patches = t.patches || [], [
-      "_rowId",
-      "_local",
-      "_modified",
-      "_origin",
-      "_patches",
-      "_remote",
-      "_removed",
-      "_snapshots",
-      "patches$",
-      "rxdb",
-      B
-    ].forEach(
-      (s) => Object.defineProperty(this, s, {
-        enumerable: !1,
-        configurable: !1
-      })
-    );
-  }
-  /**
-   * 按关系类型存储关联实体
-   * 用于跟踪和管理实体的各种关系
-   */
-  #e = /* @__PURE__ */ new Map();
-  /**
-   * 实体变更记录的可观察对象
-   * 用于发布实体变更通知
-   */
-  #t = new N([]);
-  /**
-   * 实体状态快照数组
-   * 用于存储实体在不同时间点的完整状态
-   */
-  #s = [];
-  /**
-   * 标识实体是否存在于远程数据库
-   */
-  _remote;
-  /**
-   * 标识实体是否存在于本地数据库
-   */
-  _local;
-  /**
-   * 标识实体是否已被修改
-   */
-  _modified;
-  /**
-   * 标识实体是否已被删除
-   */
-  _removed = !1;
-  /**
-   * 实体在数据库中的行ID
-   */
-  _rowId;
-  /**
-   * 实体变更记录数组
-   */
-  _patches;
-  /**
-   * 实体原始对象
-   */
-  target;
-  /**
-   * 实体代理对象
-   * 用于拦截属性访问和修改
-   */
-  proxyTarget;
-  /**
-   * 实体变更记录的可观察流
-   * 用于订阅实体变更
-   */
-  patches$ = this.#t.asObservable();
-  /**
-   * 状态检查标记
-   * 用于内部状态验证
-   */
-  [B] = !1;
-  /**
-   * 实体原始数据
-   * 用于比较变更和恢复
-   */
-  _origin;
-  /**
-   * 是否已修改
-   */
-  get modified() {
-    return this._modified;
-  }
-  set modified(e) {
-    this._modified !== e && (this._modified = e);
-  }
-  /**
-   * 是否已删除
-   */
-  get removed() {
-    return this._removed;
-  }
-  set removed(e) {
-    this._removed !== e && (this._removed = e);
-  }
-  /**
-   * 是否是远程数据
-   */
-  get remote() {
-    return this._remote;
-  }
-  set remote(e) {
-    this._remote !== e && (this._remote = e);
-  }
-  /**
-   * 是否是本地数据
-   */
-  get local() {
-    return this._local;
-  }
-  set local(e) {
-    this._local !== e && (this._local = e);
-  }
-  /**
-   * 获取变化
-   */
-  get patches() {
-    return this._patches;
-  }
-  /**
-   * 设置原始值
-   */
-  set origin(e) {
-    this._origin = e;
-  }
-  get origin() {
-    return this._origin;
-  }
-  /**
-   * 设置 rowId
-   */
-  set rowId(e) {
-    this._rowId !== e && (this._rowId = e, this.rxdb.em.updateEntityRowId(this.proxyTarget, e));
-  }
-  get rowId() {
-    return this._rowId;
-  }
-  /**
-   * 添加实体变更记录
-   * 记录实体的变更并发布变更事件
-   *
-   * @param patch - 变更内容
-   * @param inversePatch - 逆向变更内容，用于撤销操作
-   * @param updatedBy - 更新者信息
-   * @param [recordAt=Date.now()] - 记录时间戳
-   */
-  addEntityPatch(e, t, s, n = Date.now()) {
-    const i = performance.now(), a = { patch: e, inversePatch: t, recordAt: n, timeStamp: i, updatedBy: s };
-    this._patches.length === 0 && this.#s.push(Object.freeze(structuredClone(this.origin))), w(a, "snapshot", () => {
-      const c = this._patches.findIndex((h) => h === a), l = this.#s[c];
-      if (l) return l;
-      let d;
-      for (let h = 0; h <= c; h++) {
-        const y = this.#s[h];
-        y ? d = y : (d = Object.freeze({ ...d, ...a.patch }), this.#s[h] = d);
-      }
-      return d;
-    }), this._patches.push(a), this.#t.next(this._patches);
-    const o = new De(this.proxyTarget, e, t, n, i, s);
-    this.rxdb.dispatchEvent(o);
-  }
-  /**
-   * 获取需要保存的关联实体
-   * 根据关系类型的优先级排序，返回需要保存的实体数组
-   *
-   * @returns 需要保存的实体数组
-   */
-  getNeedSaveRelationEntities() {
-    const e = /* @__PURE__ */ new Set([this.proxyTarget]);
-    return this.#e.forEach(
-      (t) => t.forEach((s) => {
-        m(s).modified === !0 && e.add(s);
-      })
-    ), Array.from(e);
-  }
-  /**
-   * 添加关系实体
-   * 根据关系类型处理实体间的关联
-   *
-   * @param relation - 关系元数据
-   * @param entity - 要关联的实体
-   */
-  addRelationEntity(e, t) {
-    const s = this.getRelationCache(e.kind);
-    switch (e.kind) {
-      case p.MANY_TO_MANY:
-        {
-          const n = e.junctionEntityType, i = e.name + "Id", a = e.mappedProperty + "Id", o = (h) => h instanceof n && h[i] === t.id && h[a] === this.target.id;
-          if (s.values().find(o)) return;
-          const l = m(t).getRelationCache(p.MANY_TO_MANY);
-          let d = l.values().find(o);
-          d || (d = new n({
-            [i]: t.id,
-            [a]: this.target.id
-          })), s.add(t), s.add(d), l.add(this.proxyTarget), l.add(d);
-        }
-        break;
-      default:
-        s.add(t);
-    }
-  }
-  /**
-   * 删除关系实体
-   * 根据关系类型移除实体间的关联
-   *
-   * @param relation - 关系元数据
-   * @param entity - 要移除关联的实体
-   */
-  removeRelationEntity(e, t) {
-    const s = this.getRelationCache(e.kind);
-    switch (e.kind) {
-      case p.MANY_TO_MANY:
-        {
-          const n = e.junctionEntityType, i = e.name + "Id", a = e.mappedProperty + "Id", o = s.values().find((c) => c instanceof n && c[i] === this.target.id && c[a] === t.id);
-          o && s.delete(o);
-        }
-        break;
-    }
-    s.delete(t);
-  }
-  /**
-   * 获取指定关系类型的实体缓存
-   * 如果缓存不存在则创建新的缓存
-   *
-   * @param kind - 关系类型
-   */
-  getRelationCache(e) {
-    let t = this.#e.get(e);
-    return t ? this.#e.get(e) : (t = /* @__PURE__ */ new Set(), this.#e.set(e, t), t);
-  }
-}
-class at {
-  /**
-   * 创建实体管理器实例
-   *
-   * 构造函数会：
-   * 1. 为所有注册的实体类型添加静态和实例方法
-   * 2. 设置实体关系处理
-   * 3. 配置实体代理和删除检查
-   *
-   * @param rxdb - RxDB实例，提供数据库访问和事件分发
-   */
-  constructor(e) {
-    this.rxdb = e, this.rxdb.options.entities.forEach((t) => {
-      const s = O(t);
-      u(t.prototype, ne, this), ["get", "findOneOrFail", "find", "findOne", "findAll", "findByCursor", "count"].forEach((n) => {
-        u(t, n, (i, a) => this.#n(t)[n](i, a));
-      }), s.repository === "TreeRepository" && ["findDescendants", "countDescendants", "findAncestors", "countAncestors"].forEach((n) => {
-        u(
-          t,
-          n,
-          (i, a, o) => this.#n(t)[n](i, a, o)
-        );
-      }), Object.keys(Z).forEach(
-        (n) => u(t.prototype, n, Z[n](this, t))
-      ), s.relationMap.forEach((n) => nt(n, t, this));
-    }), u(this, te, (t) => {
-      const s = this.#i(t, { local: !1, remote: !1, modified: !0 });
-      this.addEntityCache(s);
-      const n = new ye(s);
-      return this.rxdb.dispatchEvent(n), s;
-    }), u(this, re, (t) => {
-      const { EntityType: s, data: n } = t;
-      if (n.rowId) {
-        const a = this.#a(s).get(n.rowId), o = a && this.#r(s).get(a);
-        if (o) {
-          const c = m(o);
-          c.removed = !0;
-        }
-      }
-    });
-  }
-  /**
-   * 实体仓库映射
-   * 存储每个实体类型对应的仓库实例
-   */
-  #e = /* @__PURE__ */ new Map();
-  /**
-   * 实体缓存映射
-   * 按实体类型存储实体实例，键为实体ID
-   * 用于实现实体标识映射和缓存
-   */
-  #t = /* @__PURE__ */ new Map();
-  /**
-   * 行ID映射
-   * 存储数据库行ID到实体UUID的映射关系
-   * 用于在数据库操作中快速查找实体
-   */
-  #s = /* @__PURE__ */ new Map();
-  /**
-   * 创建实体引用
-   * 根据提供的数据创建或获取实体实例，并设置其状态
-   * 如果实体已存在于缓存中，则返回缓存的实例
-   *
-   * @template T 实体类型
-   * @param EntityType - 实体类型
-   * @param data - 实体数据，必须包含id
-   * @param [status] - 可选的实体状态配置
-   * @returns 创建或获取的实体实例
-   */
-  createEntityRef(e, t, s) {
-    const n = this.#r(e);
-    if (n.has(t.id) === !1) {
-      const i = Object.create(e.prototype);
-      Object.assign(i, t);
-      const a = this.#i(i, s);
-      n.set(i.id, a);
-    }
-    return n.get(t.id);
-  }
-  /**
-   * 获取实体引用
-   * 从缓存中获取指定ID的实体实例
-   *
-   * @template T 实体类型
-   * @param EntityType - 实体类型
-   * @param id - 实体ID
-   * @returns 实体实例，如果不存在则返回undefined
-   */
-  getEntityRef(e, t) {
-    return this.#r(e)?.get(t);
-  }
-  /**
-   * 检查实体是否在缓存中
-   * 判断指定ID的实体是否已在缓存中初始化
-   *
-   * @template T 实体类型
-   * @param EntityType - 实体类型
-   * @param id - 实体ID
-   * @returns 如果实体在缓存中存在则返回true
-   */
-  hasEntityRef(e, t) {
-    return this.#r(e)?.has(t) === !0;
-  }
-  /**
-   * 添加实体到缓存
-   * 将实体实例添加到对应类型的缓存映射中
-   *
-   * @template T 实体类型
-   * @param entity - 要缓存的实体实例
-   */
-  addEntityCache(e) {
-    this.#r(e.constructor)?.set(e.id, e);
-  }
-  /**
-   * 从缓存中删除实体
-   * 将实体实例从缓存映射中移除
-   *
-   * @template T 实体类型
-   * @param entity - 要移除的实体实例
-   */
-  removeEntityCache(e) {
-    this.#r(e.constructor)?.delete(e.id);
-  }
-  /**
-   * 更新实体的行ID映射
-   * 建立数据库行ID到实体UUID的映射关系
-   *
-   * @template T 实体类型
-   * @param entity - 实体实例
-   * @param rowId - 数据库行ID
-   */
-  updateEntityRowId(e, t) {
-    this.#a(e.constructor).set(t, e.id);
-  }
-  /**
-   * 保存实体
-   * 根据实体状态决定是创建新实体还是更新现有实体
-   * 如果有关联实体需要保存，会使用事务进行批量保存
-   *
-   * @template T 实体类型
-   * @param data - 要保存的实体实例
-   * @returns 保存后的实体实例
-   */
-  async save(e) {
-    const t = e.constructor, s = m(e), n = s.getNeedSaveRelationEntities();
-    return n.length > 1 ? this.#n(t).transactionSave(n) : s.modified ? s.local ? this.update(e) : this.create(e) : e;
-  }
-  /**
-   * 删除实体
-   * 从数据库中删除实体，并分发相关事件
-   *
-   * @template T 实体类型
-   * @param data - 要删除的实体实例
-   * @returns 删除后的实体实例
-   * @throws 如果删除失败，抛出错误
-   */
-  async remove(e) {
-    const t = e.constructor;
-    this.rxdb.dispatchEvent(new Me(e));
-    try {
-      const s = await this.#n(t).remove(e);
-      return this.rxdb.dispatchEvent(new Se(s)), s;
-    } catch (s) {
-      throw this.rxdb.dispatchEvent(new Ce(e, s)), s;
-    }
-  }
-  /**
-   * 创建实体
-   * 在数据库中创建新实体，并分发相关事件
-   *
-   * @template T 实体类型
-   * @param data - 要创建的实体实例
-   * @returns 创建后的实体实例
-   * @throws 如果创建失败，抛出错误
-   */
-  async create(e) {
-    const t = e.constructor;
-    this.rxdb.dispatchEvent(new ge(e));
-    try {
-      const s = await this.#n(t).create(e);
-      return this.rxdb.dispatchEvent(new be(s)), s;
-    } catch (s) {
-      throw this.rxdb.dispatchEvent(new ve(e, s)), s;
-    }
-  }
-  /**
-   * 更新实体
-   * 在数据库中更新实体，只更新已修改的属性，并分发相关事件
-   *
-   * @template T 实体类型
-   * @param data - 要更新的实体实例
-   * @returns 更新后的实体实例
-   * @throws 如果更新失败，抛出错误
-   */
-  async update(e) {
-    const t = e.constructor, s = m(e);
-    if (s.modified) {
-      const n = he(s.target, (i, a) => i === s.origin[a]);
-      this.rxdb.dispatchEvent(new Oe(e));
-      try {
-        const i = await this.#n(t).update(e, n);
-        return this.rxdb.dispatchEvent(new Re(i)), i;
-      } catch (i) {
-        throw this.rxdb.dispatchEvent(new we(e, i)), i;
-      }
-    }
-    return e;
-  }
-  /**
-   * 获取实体仓库
-   * 获取指定实体类型的仓库实例
-   *
-   * @template T 实体类型
-   * @param EntityType - 实体类型
-   * @returns 实体仓库实例
-   */
-  getRepository(e) {
-    return this.#n(e);
-  }
-  /**
-   * 获取或创建实体仓库
-   * 根据实体元数据中的repository配置创建对应类型的仓库
-   *
-   * @template T 实体类型
-   * @template RT 仓库类型
-   * @param EntityType - 实体类型
-   * @returns 实体仓库实例
-   * @throws {RxDBError} 如果仓库类型无效
-   */
-  #n(e) {
-    if (!this.#e.has(e)) {
-      const t = O(e);
-      let s;
-      switch (t.repository) {
-        case "Repository":
-          s = new ae(this.rxdb, e);
-          break;
-        case "TreeRepository":
-          s = new tt(this.rxdb, e);
-          break;
-        default:
-          throw new v("repository must be 'Repository' or 'TreeRepository'");
-      }
-      return this.#e.set(e, s), s;
-    }
-    return this.#e.get(e);
-  }
-  /**
-   * 获取实体缓存映射
-   * 获取指定实体类型的缓存映射，如果不存在则创建
-   *
-   * @template T 实体类型
-   * @param EntityType - 实体类型
-   * @returns 实体缓存映射
-   */
-  #r(e) {
-    return this.#t.has(e) === !1 && this.#t.set(e, /* @__PURE__ */ new Map()), this.#t.get(e);
-  }
-  /**
-   * 获取行ID缓存映射
-   * 获取指定实体类型的行ID映射，如果不存在则创建
-   *
-   * @template T 实体类型
-   * @param EntityType - 实体类型
-   * @returns 行ID到UUID的映射
-   */
-  #a(e) {
-    return this.#s.has(e) === !1 && this.#s.set(e, /* @__PURE__ */ new Map()), this.#s.get(e);
-  }
-  /**
-   * 初始化实体
-   * 设置实体的状态和代理，使其可以跟踪变更
-   *
-   * @template T 实体类型
-   * @param entity - 要初始化的实体实例
-   * @param [status] - 可选的实体状态配置
-   * @returns 初始化后的代理实体实例
-   */
-  #i(e, t) {
-    Q(e, x, "");
-    const s = new rt(this.rxdb, { target: e, ...t });
-    Q(e, se, s);
-    const n = st(e);
-    return u(s, "proxyTarget", n), n;
-  }
-}
-const Z = {
-  save: (r) => function() {
-    return r.save(this);
-  },
-  remove: (r) => function() {
-    return r.remove(this);
-  }
-}, it = (r) => {
-  const [{ metadata: e, relation: t }, { metadata: s, relation: n }] = r, i = Array.from(/* @__PURE__ */ new Set([e.namespace, s.namespace])).sort().join("_") || void 0;
-  return {
-    name: Array.from(/* @__PURE__ */ new Set([e.name, s.name])).sort().join("_"),
-    namespace: i,
-    relations: [
-      {
-        name: t.name,
-        kind: p.MANY_TO_ONE,
-        mappedNamespace: s.namespace,
-        mappedEntity: s.name
-      },
-      {
-        name: n.name,
-        kind: p.MANY_TO_ONE,
-        mappedNamespace: e.namespace,
-        mappedEntity: e.name
-      }
-    ]
-  };
-};
-var ot = Object.getOwnPropertyDescriptor, ct = (r, e, t, s) => {
-  for (var n = s > 1 ? void 0 : s ? ot(e, t) : e, i = r.length - 1, a; i >= 0; i--)
-    (a = r[i]) && (n = a(n) || n);
-  return n;
-};
-let P = class {
-  id;
-  namespace;
-  entity;
-  entityId;
-  type;
-  inversePatch;
-  patch;
-  changedAt;
-};
-P = ct([
-  R({
-    name: "RxDBChange",
-    log: !1,
-    properties: [
-      {
-        name: "id",
-        type: E.integer,
-        primary: !0
-      },
-      {
-        name: "namespace",
-        type: E.string,
-        readonly: !0,
-        nullable: !0
-      },
-      {
-        name: "entity",
-        type: E.string,
-        readonly: !0
-      },
-      {
-        name: "entityId",
-        type: E.uuid,
-        readonly: !0
-      },
-      {
-        name: "type",
-        type: E.string,
-        readonly: !0
-      },
-      {
-        name: "inversePatch",
-        type: E.json,
-        readonly: !0,
-        nullable: !0
-      },
-      {
-        name: "patch",
-        type: E.json,
-        readonly: !0,
-        nullable: !0
-      },
-      {
-        name: "changedAt",
-        type: E.date,
-        default: "CURRENT_TIMESTAMP",
-        readonly: !0,
-        nullable: !0
-      }
-    ]
-  })
-], P);
-var lt = Object.getOwnPropertyDescriptor, dt = (r, e, t, s) => {
-  for (var n = s > 1 ? void 0 : s ? lt(e, t) : e, i = r.length - 1, a; i >= 0; i--)
-    (a = r[i]) && (n = a(n) || n);
-  return n;
-};
-let M = class {
-  id;
-  name;
-  executedAt;
-};
-M = dt([
-  R({
-    name: "RxDBMigration",
-    log: !1,
-    properties: [
-      {
-        name: "id",
-        type: E.integer,
-        primary: !0
-      },
-      {
-        name: "name",
-        type: E.string,
-        readonly: !0
-      },
-      {
-        name: "executedAt",
-        type: E.date,
-        readonly: !0,
-        default: () => /* @__PURE__ */ new Date()
-      }
-    ]
-  })
-], M);
-var ht = Object.getOwnPropertyDescriptor, pt = (r, e, t, s) => {
-  for (var n = s > 1 ? void 0 : s ? ht(e, t) : e, i = r.length - 1, a; i >= 0; i--)
-    (a = r[i]) && (n = a(n) || n);
-  return n;
-};
-const C = (r, e) => e + ":" + r;
-class ut {
-  constructor(e) {
-    this.rxdb = e;
-    const { entities: t } = this.rxdb.options;
-    [P, M, ...t].forEach((s) => {
-      const n = O(s), { name: i, namespace: a } = n, o = C(i, a);
-      this.#e.set(o, n), this.#t.set(o, s);
-    }), this.#e.forEach((s) => {
-      const { relations: n } = s;
-      n.forEach((i) => {
-        if (i.kind === p.MANY_TO_MANY) {
-          const a = this.findMappedRelation(s, i);
-          if (!a) throw new v("mapped relation not found");
-          const o = it([{ metadata: s, relation: i }, a]), c = C(o.name, o.namespace);
-          if (this.#e.has(c) === !1) {
-            let l = class extends $ {
-            };
-            l = pt([
-              R(o)
-            ], l);
-            const d = O(l);
-            this.#e.set(c, d), this.#t.set(c, l), this.rxdb.options.entities.push(l);
-          }
-          i.junctionEntityType = this.#t.get(c);
-        }
-      });
-    }), this.#e.forEach((s, n) => {
-      const { name: i, namespace: a } = s;
-      let o = e;
-      a && Object.hasOwn(o, a) === !1 && (u(o, a, {}), o = o[a]), u(o, i, this.#t.get(n));
-    }), Object.freeze(this);
-  }
-  #e = /* @__PURE__ */ new Map();
-  #t = /* @__PURE__ */ new Map();
-  /**
-   * 查找当前关系属性的映射关系
-   * @param relation 当前关系属性
-   */
-  findMappedRelation(e, t) {
-    for (const s of this.#e.values())
-      if (s.relations && s.name === t.mappedEntity && s.namespace === t.mappedNamespace) {
-        let n;
-        switch (t.kind) {
-          case p.MANY_TO_MANY:
-            n = (a) => a.kind === p.MANY_TO_MANY && a.name === t.mappedProperty && a.mappedProperty === t.name;
-            break;
-          case p.ONE_TO_MANY:
-            n = (a) => a.kind === p.MANY_TO_ONE && a.name === t.mappedProperty;
-            break;
-          case p.MANY_TO_ONE:
-            n = (a) => a.kind === p.ONE_TO_MANY && a.mappedProperty === t.name;
-            break;
-          case p.ONE_TO_ONE:
-            n = (a) => a.kind === p.ONE_TO_ONE && a.mappedEntity === e.name;
-            break;
-        }
-        const i = s.relations.find(n);
-        if (i)
-          return {
-            metadata: s,
-            relation: i
-          };
-      }
-  }
-  /**
-   * 通过查询条件的字段找出关系数组
-   * @param field 查询条件的字段
-   */
-  getFieldRelations(e, t) {
-    if (t.includes(".") === !1) throw new v(`field '${t}' 必须是关属性查询`);
-    const s = [], n = t.split("."), i = n.length - 1;
-    let a = e, o, c = !1, l = "";
-    return n.length === 2 && n[1] == "id" && (c = a.foreignKeyRelationMap.has(n[0]), l = n[0] + "Id"), n.forEach((d, h) => {
-      if (h === i) {
-        if (a.propertyMap.has(d) === !1) throw new v(`property '${d}' not found`);
-        o = a.propertyMap.get(d);
-      } else {
-        if (a.relationMap.has(d) === !1) throw new v(`relation '${d}' not found`);
-        const y = a.relationMap.get(d);
-        s.push({ relation: y, metadata: a }), a = this.getEntityMetadata(y.mappedEntity, y.mappedNamespace);
-      }
-    }), {
-      property: o,
-      propertyName: l || o.name,
-      isForeignKey: c,
-      relations: s
-    };
-  }
-  /**
-   * 获取实体元数据
-   */
-  getEntityMetadata(e, t) {
-    const s = C(e, t);
-    return this.#e.get(s);
-  }
-  /**
-   * 获取实体元数据
-   */
-  getEntityType(e, t) {
-    const s = C(e, t);
-    return this.#t.get(s);
-  }
-}
-class Mt {
-  // 插件
-  #e = /* @__PURE__ */ new WeakSet();
-  // events
-  #t = /* @__PURE__ */ new Map();
-  #s = [];
-  #n = !1;
-  // 适配器
-  #r = /* @__PURE__ */ new Map();
-  #a = /* @__PURE__ */ new Map();
-  #i = new N(0);
-  #l = this.#i.asObservable().pipe(I(), A(1));
-  // 上下文
-  #c = {};
-  /**
-   * Schema 管理
-   */
-  schema;
-  /**
-   * Entity 管理
-   */
-  em;
-  /**
-   * 设置环境上下文
-   */
-  get context() {
-    return this.#c;
-  }
-  set context(e) {
-    this.#c = e;
-  }
-  options;
-  constructor(e) {
-    this.options = Object.freeze(
-      Object.assign(
-        {
-          relationQueryDeep: 2
-        },
-        e
-      )
-    ), this.schema = new ut(this), this.em = new at(this), this.context = { ...this.options.context }, this.addEventListener(F, () => {
-      this.#n = !0;
-    }), this.addEventListener(z, () => {
-      this.#n = !1, this.#s.forEach((s) => this.dispatchEvent(s)), this.#s = [];
-    }), this.addEventListener(H, () => {
-      this.#n = !1, this.#s = [];
-    });
-    const t = this.em;
-    this.addEventListener(ee, (s) => t[re](s)), pe(this.options);
-  }
-  /**
-   * 注册适配器
-   */
-  adapter(e, t) {
-    return this.#r.set(e, t), this.#i.next(this.#r.size), this;
-  }
-  /**
-   * 获取适配器
-   */
-  getAdapter(e) {
-    return this.#a.has(e) ? this.#a.get(e) : this.#l.pipe(
-      D(() => this.#r.get(e)),
-      Y(Boolean),
-      I(),
-      f((t) => {
-        if (!this.#a.has(e)) {
-          const s = t(this);
-          ue(s) ? this.#a.set(e, q(() => s).pipe(A(1))) : this.#a.set(e, j(s).pipe(A(1)));
-        }
-        return this.#a.get(e);
-      })
-    );
-  }
-  /**
-   * 安装插件
-   */
-  use(e, t) {
-    if (this.#e.has(e))
-      console.warn("plugin already installed");
-    else {
-      this.#e.add(e);
-      const s = e(this, t);
-      this[s.name] = s;
-    }
-    return this;
-  }
-  /**
-   * 连接适配器
-   */
-  connect(e) {
-    return this.getAdapter(e).pipe(
-      f((t) => t.connect()),
-      f((t) => je(e, this.options) ? q(async () => {
-        if (!await t.isTableExisted(M)) {
-          await t.createTable(M), await t.createTable(P);
-          for (let n = 0; n < this.options.entities.length; n++) {
-            const i = this.options.entities[n];
-            try {
-              await t.createTable(i);
-            } catch (a) {
-              console.error(a);
-            }
-          }
-        }
-      }).pipe(D(() => t)) : j(t))
-    );
-  }
-  addEventListener(e, t) {
-    this.#o(e).add(t);
-  }
-  removeEventListener(e, t) {
-    this.#o(e).delete(t);
-  }
-  dispatchEvent(e) {
-    this.#n && Le(e) === !1 ? this.#s.push(e) : this.#o(e.type).forEach((t) => t.call(this, e));
-  }
-  #o(e) {
-    if (this.#t.has(e))
-      return this.#t.get(e);
-    {
-      const s = /* @__PURE__ */ new Set();
-      return this.#t.set(e, s), s;
-    }
-  }
-}
-class ie {
-  constructor(e) {
-    this.rxdb = e;
-  }
-}
-class St extends ie {
-}
-class Ct extends ie {
-}
-class It {
-  constructor(e) {
-    this.rxdb = e;
-  }
-}
-export {
-  ee as DATABASE_DELETE,
-  Be as DATABASE_INSERT,
-  $e as DATABASE_UPDATE,
-  _e as ENTITY_CREATE_ERROR_EVENT,
-  V as ENTITY_CREATE_EVENT,
-  me as ENTITY_CREATE_SUCCESS_EVENT,
-  Ee as ENTITY_NEW_EVENT,
-  Ie as ENTITY_PATCH_EVENT,
-  xe as ENTITY_REMOVE_ERROR_EVENT,
-  W as ENTITY_REMOVE_EVENT,
-  Ne as ENTITY_REMOVE_SUCCESS_EVENT,
-  Ae as ENTITY_UPDATE_ERROR_EVENT,
-  K as ENTITY_UPDATE_EVENT,
-  Te as ENTITY_UPDATE_SUCCESS_EVENT,
-  R as Entity,
-  $ as EntityBase,
-  ve as EntityCreateErrorEvent,
-  ge as EntityCreateEvent,
-  be as EntityCreateSuccessEvent,
-  ye as EntityNewEvent,
-  De as EntityPatchEvent,
-  Ce as EntityRemoveErrorEvent,
-  Me as EntityRemoveEvent,
-  Se as EntityRemoveSuccessEvent,
-  we as EntityUpdateErrorEvent,
-  Oe as EntityUpdateEvent,
-  Re as EntityUpdateSuccessEvent,
-  E as PropertyType,
-  p as RelationKind,
-  xt as RepositoryBase,
-  Mt as RxDB,
-  ie as RxDBAdapterBase,
-  bt as RxDBAdapterDeleteChangeEvent,
-  vt as RxDBAdapterInsertChangeEvent,
-  St as RxDBAdapterLocalBase,
-  Ct as RxDBAdapterRemoteBase,
-  Tt as RxDBAdapterUpdateChangeEvent,
-  P as RxDBChange,
-  v as RxDBError,
-  M as RxDBMigration,
-  It as RxDBPluginBase,
-  et as SyncStatus,
-  Fe as SyncType,
-  F as TRANSACTION_BEGIN,
-  z as TRANSACTION_COMMIT,
-  H as TRANSACTION_ROLLBACK,
-  mt as TransactionBeginEvent,
-  _t as TransactionCommitEvent,
-  gt as TransactionRollbackEvent,
-  X as TreeAdjacencyListEntityBase,
-  Rt as TreeEntity,
-  At as __decorateClass,
-  Ke as fillDefaultValue,
-  We as fillInitValue,
-  O as getEntityMetadata,
-  m as getEntityStatus,
-  Nt as isEntityEffectOrderBy,
-  Ot as isEntityInternalName,
-  wt as isEntityMatchRuleGroup,
-  Qe as isRuleGroup,
-  u as setSafeObjectKey,
-  w as setSafeObjectKeyLazyInitOnce,
-  Q as setSafeObjectWritableKey,
-  ze as transitionMetadata,
-  ke as uuid
-};