@aiao/rxdb-query-builder 0.0.10

package/dist/index.js

@@ -0,0 +1,1224 @@
+import { v4 as V } from "uuid";
+import { BehaviorSubject as L, map as M, distinctUntilChanged as w } from "rxjs";
+import { RelationKind as B, PropertyType as g } from "@aiao/rxdb";
+function b(n) {
+  return "combinator" in n && "rules" in n;
+}
+function S(n) {
+  return "field" in n && "operator" in n;
+}
+const k = [
+  // 相等操作符
+  {
+    key: "=",
+    label: "等于",
+    valueType: "single",
+    applicableTypes: ["string", "number", "boolean", "date"]
+  },
+  {
+    key: "!=",
+    label: "不等于",
+    valueType: "single",
+    applicableTypes: ["string", "number", "boolean", "date"]
+  },
+  // 比较操作符
+  {
+    key: "<",
+    label: "小于",
+    valueType: "single",
+    applicableTypes: ["number", "date", "string"]
+  },
+  {
+    key: ">",
+    label: "大于",
+    valueType: "single",
+    applicableTypes: ["number", "date", "string"]
+  },
+  {
+    key: "<=",
+    label: "小于等于",
+    valueType: "single",
+    applicableTypes: ["number", "date", "string"]
+  },
+  {
+    key: ">=",
+    label: "大于等于",
+    valueType: "single",
+    applicableTypes: ["number", "date", "string"]
+  },
+  // 字符串操作符
+  {
+    key: "contains",
+    label: "包含",
+    valueType: "single",
+    applicableTypes: ["string", "array"]
+  },
+  {
+    key: "notContains",
+    label: "不包含",
+    valueType: "single",
+    applicableTypes: ["string", "array"]
+  },
+  {
+    key: "startsWith",
+    label: "开头是",
+    valueType: "single",
+    applicableTypes: ["string"]
+  },
+  {
+    key: "notStartsWith",
+    label: "开头不是",
+    valueType: "single",
+    applicableTypes: ["string"]
+  },
+  {
+    key: "endsWith",
+    label: "结尾是",
+    valueType: "single",
+    applicableTypes: ["string"]
+  },
+  {
+    key: "notEndsWith",
+    label: "结尾不是",
+    valueType: "single",
+    applicableTypes: ["string"]
+  },
+  // 空值操作符（仅在 nullable 字段时通过 getForField() 动态添加）
+  {
+    key: "null",
+    label: "为空",
+    valueType: "none",
+    applicableTypes: []
+  },
+  {
+    key: "notNull",
+    label: "不为空",
+    valueType: "none",
+    applicableTypes: []
+  },
+  // 集合操作符
+  {
+    key: "in",
+    label: "在列表中",
+    valueType: "array",
+    applicableTypes: ["string", "number"]
+  },
+  {
+    key: "notIn",
+    label: "不在列表中",
+    valueType: "array",
+    applicableTypes: ["string", "number"]
+  },
+  // 范围操作符
+  {
+    key: "between",
+    label: "在范围内",
+    valueType: "range",
+    applicableTypes: ["number", "date"]
+  },
+  {
+    key: "notBetween",
+    label: "不在范围内",
+    valueType: "range",
+    applicableTypes: ["number", "date"]
+  },
+  // 关系操作符
+  {
+    key: "exists",
+    label: "存在",
+    valueType: "subquery",
+    applicableTypes: ["relation"]
+  },
+  {
+    key: "notExists",
+    label: "不存在",
+    valueType: "subquery",
+    applicableTypes: ["relation"]
+  }
+];
+function ce(n, e = k) {
+  return e.filter((r) => r.applicableTypes.includes(n));
+}
+const K = [
+  {
+    name: "stringType",
+    appliesTo: ["string"],
+    message: "值必须是字符串类型",
+    validate: (n) => n.value === void 0 || n.value === null || Array.isArray(n.value) ? !0 : typeof n.value == "string"
+  },
+  {
+    name: "numberType",
+    appliesTo: ["number"],
+    message: "值必须是数字类型",
+    validate: (n) => n.value === void 0 || n.value === null || Array.isArray(n.value) ? !0 : typeof n.value == "number" && !isNaN(n.value)
+  },
+  {
+    name: "booleanType",
+    appliesTo: ["boolean"],
+    message: "值必须是布尔类型",
+    validate: (n) => n.value === void 0 || n.value === null || Array.isArray(n.value) ? !0 : typeof n.value == "boolean"
+  },
+  {
+    name: "dateType",
+    appliesTo: ["date"],
+    message: "值必须是有效日期",
+    validate: (n) => {
+      if (n.value === void 0 || n.value === null || Array.isArray(n.value))
+        return !0;
+      if (n.value instanceof Date)
+        return !isNaN(n.value.getTime());
+      if (typeof n.value == "string") {
+        const e = new Date(n.value);
+        return !isNaN(e.getTime());
+      }
+      return !1;
+    }
+  }
+], U = {
+  uuid: "string",
+  string: "string",
+  number: "number",
+  integer: "number",
+  boolean: "boolean",
+  date: "date",
+  stringArray: "array",
+  numberArray: "array",
+  keyValue: "object",
+  json: "object"
+};
+function W(n, e) {
+  return e?.displayName ? e.displayName : n.replace(/([A-Z])/g, " $1").replace(/^./, (r) => r.toUpperCase()).trim();
+}
+class P {
+  options;
+  constructor(e = {}) {
+    this.options = {
+      includeForeignKeys: e.includeForeignKeys ?? !1,
+      includeComputedProperties: e.includeComputedProperties ?? !1,
+      includeRelations: e.includeRelations ?? !1,
+      entityMetadataMap: e.entityMetadataMap,
+      fieldFilter: e.fieldFilter ?? (() => !0),
+      displayNameGenerator: e.displayNameGenerator ?? W
+    };
+  }
+  /**
+   * 从 EntityMetadata 解析字段元数据
+   *
+   * @param metadata - RxDB 实体元数据
+   * @returns 字段元数据数组
+   *
+   * @example
+   * ```typescript
+   * const parser = new SchemaParser();
+   * const fields = parser.parse(userMetadata);
+   * // [{ name: 'id', displayName: 'ID', type: 'string' }, ...]
+   * ```
+   */
+  parse(e) {
+    const r = [];
+    for (const t of e.properties) {
+      if (!this.options.includeForeignKeys && e.isForeignKey(t.name))
+        continue;
+      const s = this.parseProperty(t);
+      s && this.options.fieldFilter(s) && r.push(s);
+    }
+    if (this.options.includeComputedProperties)
+      for (const t of e.computedProperties) {
+        const s = this.parseProperty(t);
+        s && this.options.fieldFilter(s) && r.push(s);
+      }
+    if (this.options.includeRelations && e.relations)
+      for (const t of e.relations) {
+        const s = this.parseRelation(t);
+        s && this.options.fieldFilter(s) && r.push(s);
+      }
+    return r;
+  }
+  /**
+   * 从多个 EntityMetadata 批量解析
+   *
+   * @param metadataMap - 实体名称到元数据的映射
+   * @returns 实体名称到字段数组的映射
+   */
+  parseMany(e) {
+    const r = /* @__PURE__ */ new Map();
+    for (const [t, s] of e)
+      r.set(t, this.parse(s));
+    return r;
+  }
+  /**
+   * 解析单个属性
+   */
+  parseProperty(e) {
+    const r = this.mapPropertyType(e.type);
+    if (!r)
+      return null;
+    const t = {
+      name: e.name,
+      displayName: this.options.displayNameGenerator(e.name, e),
+      type: r
+    };
+    return e.nullable !== void 0 && (t.required = !e.nullable), e.description && (t.description = e.description), e.enum && Array.isArray(e.enum) && (t.enum = e.enum), e.pattern && (t.pattern = e.pattern), t;
+  }
+  /**
+   * 将 RxDB PropertyType 映射到 QueryBuilder 类型
+   */
+  mapPropertyType(e) {
+    const r = typeof e == "string" ? e : String(e);
+    return U[r] ?? null;
+  }
+  /**
+   * 解析关系字段
+   */
+  parseRelation(e) {
+    const r = {
+      name: e.name,
+      displayName: this.options.displayNameGenerator(e.name, e),
+      type: "relation",
+      isRelation: !0,
+      relationTarget: e.mappedEntity,
+      relationKind: e.kind
+    };
+    if (this.options.entityMetadataMap) {
+      const t = e.mappedEntity, s = this.options.entityMetadataMap.get(t);
+      if (s) {
+        const a = new P({
+          ...this.options,
+          includeRelations: !1
+          // 防止无限递归
+        });
+        r.relationFields = a.parse(s);
+      }
+    }
+    return r;
+  }
+}
+function j(n) {
+  return new P(n);
+}
+function A() {
+  return V();
+}
+class Y {
+  idGenerator;
+  constructor(e = {}) {
+    this.idGenerator = e.idGenerator ?? A;
+  }
+  /**
+   * 将 QueryBuilder 状态转换为 RxDB Query
+   *
+   * @param state - QueryBuilder 状态
+   * @returns RxDB RuleGroup 查询对象
+   *
+   * @example
+   * ```typescript
+   * const converter = new QueryConverter<User>();
+   * const query = converter.toRxDBQuery(queryBuilderState);
+   * // { combinator: 'and', rules: [...] }
+   * ```
+   */
+  toRxDBQuery(e) {
+    return this.convertGroupToRxDB(e.rootGroup);
+  }
+  /**
+   * 将 RxDB Query 转换为 QueryBuilder 状态
+   *
+   * @param query - RxDB RuleGroup 查询对象
+   * @returns QueryBuilder 状态
+   *
+   * @example
+   * ```typescript
+   * const converter = new QueryConverter<User>();
+   * const state = converter.fromRxDBQuery(rxdbQuery);
+   * ```
+   */
+  fromRxDBQuery(e) {
+    return {
+      rootGroup: this.convertGroupFromRxDB(e)
+    };
+  }
+  /**
+   * 转换单个规则组到 RxDB 格式
+   */
+  convertGroupToRxDB(e) {
+    const r = [];
+    for (const t of e.rules)
+      b(t) ? r.push(this.convertGroupToRxDB(t)) : S(t) && r.push(this.convertRuleToRxDB(t));
+    return {
+      combinator: e.combinator,
+      rules: r
+    };
+  }
+  /**
+   * 转换单条规则到 RxDB 格式
+   * 移除 QueryBuilder 特有的 id 字段
+   */
+  convertRuleToRxDB(e) {
+    const { id: r, ...t } = e;
+    return t;
+  }
+  /**
+   * 从 RxDB 格式转换规则组
+   */
+  convertGroupFromRxDB(e) {
+    const r = [];
+    for (const t of e.rules)
+      this.isRxDBRuleGroup(t) ? r.push(this.convertGroupFromRxDB(t)) : r.push(this.convertRuleFromRxDB(t));
+    return {
+      id: this.idGenerator(),
+      combinator: e.combinator,
+      rules: r
+    };
+  }
+  /**
+   * 从 RxDB 格式转换单条规则
+   * 添加 QueryBuilder 需要的 id 字段
+   */
+  convertRuleFromRxDB(e) {
+    return {
+      id: this.idGenerator(),
+      ...e
+    };
+  }
+  /**
+   * 判断是否为 RxDB RuleGroup
+   */
+  isRxDBRuleGroup(e) {
+    return typeof e == "object" && e !== null && "combinator" in e && "rules" in e && Array.isArray(e.rules);
+  }
+}
+function X(n) {
+  return new Y(n);
+}
+class q {
+  operators;
+  /**
+   * 获取操作符数量
+   */
+  get size() {
+    return this.operators.size;
+  }
+  constructor(e = {}) {
+    if (this.operators = /* @__PURE__ */ new Map(), e.useDefaultOperators !== !1)
+      for (const r of k)
+        this.operators.set(r.key, r);
+    if (e.operators)
+      for (const r of e.operators)
+        this.operators.set(r.key, r);
+  }
+  /**
+   * 注册新操作符
+   *
+   * @param operator - 操作符定义
+   *
+   * @example
+   * ```typescript
+   * registry.register({
+   *   key: 'contains',
+   *   label: '包含',
+   *   applicableTypes: ['string'],
+   *   valueType: 'single'
+   * });
+   * ```
+   */
+  register(e) {
+    this.operators.set(e.key, e);
+  }
+  /**
+   * 批量注册操作符
+   *
+   * @param operators - 操作符定义数组
+   */
+  registerMany(e) {
+    for (const r of e)
+      this.register(r);
+  }
+  /**
+   * 移除操作符
+   *
+   * @param key - 操作符键值
+   * @returns 是否成功移除
+   */
+  unregister(e) {
+    return this.operators.delete(e);
+  }
+  /**
+   * 获取操作符定义
+   *
+   * @param key - 操作符键值
+   * @returns 操作符定义或 undefined
+   */
+  get(e) {
+    return this.operators.get(e);
+  }
+  /**
+   * 获取所有操作符
+   *
+   * @returns 所有操作符定义数组
+   */
+  getAll() {
+    return Array.from(this.operators.values());
+  }
+  /**
+   * 根据字段类型获取适用的操作符
+   *
+   * @param fieldType - 字段类型
+   * @returns 适用的操作符数组
+   *
+   * @example
+   * ```typescript
+   * const stringOperators = registry.getForType('string');
+   * // [{ key: '=', ... }, { key: 'contains', ... }, ...]
+   * ```
+   */
+  getForType(e) {
+    return Array.from(this.operators.values()).filter((r) => r.applicableTypes.includes(e));
+  }
+  /**
+   * 根据字段元数据获取适用的操作符
+   *
+   * @param field - 字段元数据
+   * @returns 适用的操作符数组
+   */
+  getForField(e) {
+    const r = this.getForType(e.type);
+    if (e.nullable) {
+      const t = r.some((o) => o.key === "null"), s = r.some((o) => o.key === "notNull"), a = this.operators.get("null"), l = this.operators.get("notNull"), i = [...r];
+      return !t && a && i.push(a), !s && l && i.push(l), i;
+    }
+    return r;
+  }
+  /**
+   * 检查操作符是否支持指定类型
+   *
+   * @param operatorKey - 操作符键值
+   * @param fieldType - 字段类型
+   * @returns 是否支持
+   */
+  isOperatorSupportedForType(e, r) {
+    const t = this.operators.get(e);
+    return t ? t.applicableTypes.includes(r) : !1;
+  }
+  /**
+   * 检查操作符是否支持指定字段
+   *
+   * @param operatorKey - 操作符键值
+   * @param field - 字段元数据
+   * @returns 是否支持
+   */
+  isOperatorSupportedForField(e, r) {
+    const t = this.operators.get(e);
+    return t ? (e === "null" || e === "notNull") && r.nullable ? !0 : t.applicableTypes.includes(r.type) : !1;
+  }
+  /**
+   * 获取操作符的值类型
+   *
+   * @param operatorKey - 操作符键值
+   * @returns 值类型
+   */
+  getValueType(e) {
+    return this.operators.get(e)?.valueType;
+  }
+  /**
+   * 清空所有操作符
+   */
+  clear() {
+    this.operators.clear();
+  }
+  /**
+   * 重置为默认操作符
+   */
+  reset() {
+    this.clear();
+    for (const e of k)
+      this.operators.set(e.key, e);
+  }
+}
+function J(n) {
+  return new q(n);
+}
+let $ = null;
+function z() {
+  return $ || ($ = new q()), $;
+}
+function Z(n) {
+  return typeof n == "object" && n !== null && "where" in n;
+}
+function O(n) {
+  if ("value" in n)
+    return n.value;
+}
+class H {
+  rules;
+  operatorRegistry;
+  constructor(e = {}) {
+    if (this.rules = /* @__PURE__ */ new Map(), this.operatorRegistry = e.operatorRegistry ?? z(), e.useBuiltinRules !== !1)
+      for (const r of K)
+        this.rules.set(r.name, r);
+    if (e.customRules)
+      for (const r of e.customRules)
+        this.rules.set(r.name, r);
+  }
+  /**
+   * 校验单条规则
+   */
+  validateRule(e, r) {
+    const t = [], s = O(e), a = {
+      fieldType: r.type,
+      operator: e.operator,
+      value: s
+    };
+    this.operatorRegistry.isOperatorSupportedForField(e.operator, r) || t.push({
+      field: e.field,
+      rule: "operatorTypeMatch",
+      message: `操作符 "${e.operator}" 不支持字段 "${r.name}"`
+    });
+    const l = this.operatorRegistry.getValueType(e.operator);
+    if (l === "subquery") {
+      if (Z(e) && e.where !== void 0 && e.where !== null) {
+        const i = e.where;
+        if (typeof i == "object" && "combinator" in i && "rules" in i)
+          if (!i.rules || i.rules.length === 0)
+            t.push({
+              field: e.field,
+              rule: "valueType",
+              message: "EXISTS 子查询条件不能为空"
+            });
+          else {
+            const o = this.validateSubqueryRules(i);
+            o.length > 0 && t.push(
+              ...o.map((f) => ({
+                ...f,
+                field: `${e.field}.${f.field}`
+                // 添加父字段前缀
+              }))
+            );
+          }
+        else
+          t.push({
+            field: e.field,
+            rule: "valueType",
+            message: "EXISTS 子查询格式无效"
+          });
+      }
+    } else {
+      const i = this.validateValueType(s, l, e.field, r.displayName);
+      i && t.push(i);
+    }
+    for (const i of this.rules.values()) {
+      if (i.appliesTo && !i.appliesTo.includes(r.type))
+        continue;
+      i.validate(a) || t.push({
+        field: e.field,
+        rule: i.name,
+        message: i.message
+      });
+    }
+    return {
+      valid: t.length === 0,
+      errors: t.length > 0 ? t : void 0
+    };
+  }
+  /**
+   * 校验整个规则组
+   */
+  validateGroup(e, r) {
+    const t = [];
+    for (const s of e.rules)
+      if (b(s)) {
+        const a = this.validateGroup(s, r);
+        !a.valid && a.errors && t.push(...a.errors);
+      } else if (S(s)) {
+        const a = r.get(s.field);
+        if (!a) {
+          t.push({
+            field: s.field,
+            rule: "fieldExists",
+            message: `字段 "${s.field}" 不存在`
+          });
+          continue;
+        }
+        const l = this.validateRule(s, a);
+        !l.valid && l.errors && t.push(...l.errors);
+      }
+    return {
+      valid: t.length === 0,
+      errors: t.length > 0 ? t : void 0
+    };
+  }
+  /**
+   * 注册自定义校验规则
+   */
+  registerRule(e) {
+    this.rules.set(e.name, e);
+  }
+  /**
+   * 移除校验规则
+   */
+  unregisterRule(e) {
+    return this.rules.delete(e);
+  }
+  /**
+   * 获取所有校验规则
+   */
+  getRules() {
+    return Array.from(this.rules.values());
+  }
+  /**
+   * 校验值类型
+   */
+  validateValueType(e, r, t, s) {
+    return r === "none" || r === "subquery" ? null : r === "array" ? !Array.isArray(e) || e.length === 0 ? {
+      field: t,
+      rule: "valueType",
+      message: `${s || t}需要提供一个或多个值`
+    } : null : r === "range" ? !Array.isArray(e) || e.length !== 2 ? {
+      field: t,
+      rule: "valueType",
+      message: `${s || t}需要提供两个值（范围）`
+    } : null : e == null || e === "" ? {
+      field: t,
+      rule: "valueType",
+      message: `${s || t}需要提供一个值`
+    } : null;
+  }
+  /**
+   * 验证子查询规则的基本有效性（不依赖字段元数据）
+   *
+   * @description
+   * 子查询可能引用关系实体的字段，我们无法获取其 FieldMetadata。
+   * 因此只验证规则的基本结构和值类型，不验证字段是否存在或操作符是否匹配。
+   */
+  validateSubqueryRules(e) {
+    const r = [];
+    for (const t of e.rules)
+      if (b(t)) {
+        const s = this.validateSubqueryRules(t);
+        r.push(...s);
+      } else if (S(t)) {
+        const s = O(t), a = this.operatorRegistry.getValueType(t.operator), l = this.validateValueType(s, a, t.field);
+        if (l && r.push(l), a === "subquery") {
+          const i = t;
+          if ("where" in i && i.where) {
+            const o = i.where;
+            if (typeof o == "object" && "combinator" in o && "rules" in o)
+              if (!o.rules || o.rules.length === 0)
+                r.push({
+                  field: t.field,
+                  rule: "valueType",
+                  message: "EXISTS 子查询条件不能为空"
+                });
+              else {
+                const f = this.validateSubqueryRules(o);
+                r.push(...f);
+              }
+            else
+              r.push({
+                field: t.field,
+                rule: "valueType",
+                message: "EXISTS 子查询格式无效"
+              });
+          }
+        }
+      }
+    return r;
+  }
+}
+function ee(n) {
+  return new H(n);
+}
+const te = 5, _ = "and";
+function I() {
+  return {
+    id: A(),
+    combinator: _,
+    rules: []
+  };
+}
+class re {
+  stateSubject;
+  fieldsMap;
+  config;
+  operatorRegistry;
+  validationService;
+  queryConverter;
+  /**
+   * 状态变更的 Observable 流
+   */
+  state$;
+  /**
+   * 根规则组的 Observable
+   */
+  rootGroup$;
+  /**
+   * 校验结果的 Observable
+   */
+  validation$;
+  /**
+   * RxDB Query 格式的 Observable
+   */
+  query$;
+  constructor(e = {}) {
+    if (this.operatorRegistry = e.operatorRegistry ?? J(), this.validationService = e.validationService ?? ee({
+      operatorRegistry: this.operatorRegistry
+    }), this.queryConverter = e.queryConverter ?? X(), this.fieldsMap = /* @__PURE__ */ new Map(), e.fields)
+      for (const t of e.fields)
+        this.fieldsMap.set(t.name, t);
+    this.config = e.config ?? {};
+    let r;
+    e.initialState ? r = e.initialState : e.initialQuery ? r = this.queryConverter.fromRxDBQuery(e.initialQuery) : e.config?.initialQuery ? r = { rootGroup: e.config.initialQuery } : r = { rootGroup: I() }, this.stateSubject = new L(r), this.state$ = this.stateSubject.asObservable(), this.rootGroup$ = this.state$.pipe(
+      M((t) => t.rootGroup),
+      w()
+    ), this.validation$ = this.state$.pipe(
+      M((t) => this.validationService.validateGroup(t.rootGroup, this.fieldsMap)),
+      w((t, s) => t.valid === s.valid && JSON.stringify(t.errors) === JSON.stringify(s.errors))
+    ), this.query$ = this.state$.pipe(
+      M((t) => this.queryConverter.toRxDBQuery(t)),
+      w((t, s) => JSON.stringify(t) === JSON.stringify(s))
+    );
+  }
+  /**
+   * 获取当前状态快照
+   */
+  getState() {
+    return this.stateSubject.getValue();
+  }
+  /**
+   * 获取当前配置
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * 获取最大嵌套层级
+   */
+  getMaxNestingLevel() {
+    return this.config.maxNestingLevel ?? te;
+  }
+  /**
+   * 获取字段列表
+   */
+  getFields() {
+    return Array.from(this.fieldsMap.values());
+  }
+  /**
+   * 设置字段列表
+   */
+  setFields(e) {
+    this.fieldsMap.clear();
+    for (const r of e)
+      this.fieldsMap.set(r.name, r);
+  }
+  /**
+   * 获取操作符注册表
+   */
+  getOperatorRegistry() {
+    return this.operatorRegistry;
+  }
+  // ==================== 规则操作 ====================
+  /**
+   * 添加规则
+   */
+  addRule(e = null, r) {
+    const t = {
+      id: A(),
+      field: r?.field ?? "",
+      operator: r?.operator ?? "=",
+      value: "value" in (r ?? {}) ? r.value : ""
+    }, s = this.getState(), a = this.addItemToGroup(s.rootGroup, e ?? s.rootGroup.id, t);
+    return this.stateSubject.next({ rootGroup: a }), t.id;
+  }
+  /**
+   * 添加规则组
+   */
+  addGroup(e = null, r = _) {
+    const t = this.getState(), s = e ?? t.rootGroup.id, a = this.getGroupDepth(t.rootGroup, s), l = this.getMaxNestingLevel();
+    if (a >= l)
+      throw new Error(`已达到最大嵌套深度 ${l}`);
+    const i = {
+      id: A(),
+      combinator: r,
+      rules: []
+    }, o = this.addItemToGroup(t.rootGroup, s, i);
+    return this.stateSubject.next({ rootGroup: o }), i.id;
+  }
+  /**
+   * 更新规则
+   */
+  updateRule(e, r) {
+    const t = this.getState(), s = this.updateItemInGroup(t.rootGroup, e, r);
+    this.stateSubject.next({ rootGroup: s });
+  }
+  /**
+   * 更新组的组合器
+   */
+  updateGroupCombinator(e, r) {
+    const t = this.getState(), s = this.updateItemInGroup(t.rootGroup, e, { combinator: r });
+    this.stateSubject.next({ rootGroup: s });
+  }
+  /**
+   * 删除规则或组
+   */
+  remove(e) {
+    const r = this.getState();
+    if (e === r.rootGroup.id)
+      throw new Error("不能删除根组");
+    const t = this.removeItemFromGroup(r.rootGroup, e);
+    this.stateSubject.next({ rootGroup: t });
+  }
+  /**
+   * 清空所有规则
+   */
+  clear() {
+    this.stateSubject.next({ rootGroup: I() });
+  }
+  /**
+   * 销毁服务
+   */
+  destroy() {
+    this.stateSubject.complete();
+  }
+  // ==================== 转换方法 ====================
+  /**
+   * 获取 RxDB Query 格式
+   */
+  toRxDBQuery() {
+    return this.queryConverter.toRxDBQuery(this.getState());
+  }
+  /**
+   * 从 RxDB Query 加载
+   */
+  fromRxDBQuery(e) {
+    const r = this.queryConverter.fromRxDBQuery(e);
+    this.stateSubject.next(r);
+  }
+  // ==================== 校验方法 ====================
+  /**
+   * 执行校验并返回结果
+   */
+  validate() {
+    return this.validationService.validateGroup(this.getState().rootGroup, this.fieldsMap);
+  }
+  /**
+   * 检查当前状态是否有效
+   */
+  isValid() {
+    return this.validate().valid;
+  }
+  // ==================== 私有辅助方法 ====================
+  addItemToGroup(e, r, t) {
+    return e.id === r ? {
+      ...e,
+      rules: [...e.rules, t]
+    } : {
+      ...e,
+      rules: e.rules.map((s) => b(s) ? this.addItemToGroup(s, r, t) : s)
+    };
+  }
+  updateItemInGroup(e, r, t) {
+    return e.id === r ? { ...e, ...t } : {
+      ...e,
+      rules: e.rules.map((s) => b(s) ? s.id === r ? { ...s, ...t } : this.updateItemInGroup(s, r, t) : S(s) && s.id === r ? { ...s, ...t } : s)
+    };
+  }
+  removeItemFromGroup(e, r) {
+    return {
+      ...e,
+      rules: e.rules.filter((t) => b(t) || S(t) ? t.id !== r : !0).map((t) => b(t) ? this.removeItemFromGroup(t, r) : t)
+    };
+  }
+  getGroupDepth(e, r, t = 1) {
+    if (e.id === r)
+      return t;
+    for (const s of e.rules)
+      if (b(s)) {
+        const a = this.getGroupDepth(s, r, t + 1);
+        if (a > 0)
+          return a;
+      }
+    return 0;
+  }
+}
+function fe(n) {
+  return new re(n);
+}
+const x = "__exists__";
+function ye(n) {
+  const e = /* @__PURE__ */ new Set(), r = n.filter((i) => e.has(i.name) ? !1 : (e.add(i.name), !0)), t = [], s = /* @__PURE__ */ new Map(), a = [...r].sort((i, o) => {
+    const f = (i.name.match(/\./g) || []).length, y = (o.name.match(/\./g) || []).length;
+    return f - y;
+  }), l = /* @__PURE__ */ new Map();
+  for (const i of r)
+    if (i.displayName) {
+      const o = i.name.split("."), f = i.displayName.split(".");
+      let y = "";
+      for (let u = 0; u < o.length - 1; u++)
+        y = y ? `${y}.${o[u]}` : o[u], f[u] && !l.has(y) && l.set(y, f[u]);
+    }
+  for (const i of a) {
+    const o = i.name.split("."), f = o[o.length - 1], y = i.type === "relation" || !!i.isRelation, u = (i.displayName ?? f).split("."), c = u[u.length - 1] || f, p = {
+      label: f,
+      value: i.name,
+      displayName: c,
+      type: i.type,
+      isRelation: y,
+      description: i.description,
+      required: i.required,
+      enum: i.enum,
+      // 关系字段复制 relationFields 用于子查询
+      ...i.relationFields && { relationFields: i.relationFields }
+    };
+    if (s.set(i.name, p), o.length === 1)
+      t.push(p);
+    else {
+      const m = o.slice(0, -1).join("."), v = s.get(m);
+      if (v)
+        v.children = v.children ?? [], v.children.push(p);
+      else {
+        let d = "", N = t;
+        for (let T = 0; T < o.length - 1; T++) {
+          const R = o[T];
+          d = d ? `${d}.${R}` : R;
+          let h = s.get(d);
+          if (!h) {
+            const F = l.get(d) ?? R;
+            h = {
+              label: R,
+              value: d,
+              displayName: F,
+              type: "relation",
+              isRelation: !0,
+              children: []
+            }, s.set(d, h), N.push(h);
+          }
+          h.children = h.children ?? [], N = h.children;
+        }
+        N.push(p);
+      }
+    }
+  }
+  return C(t, r), t;
+}
+function C(n, e) {
+  const r = new Map(e.map((t) => [t.name, t]));
+  for (const t of n) {
+    if (t.isRelation && t.children && t.children.length > 0 && !t.children.some((a) => a.label === x)) {
+      const l = r.get(t.value)?.relationFields;
+      t.children.unshift({
+        label: x,
+        value: t.value,
+        // 使用父节点的值，这样选择它就等于选择关系字段本身
+        displayName: "(存在性检查)",
+        type: "relation",
+        isRelation: !0,
+        description: `检查 ${t.displayName} 是否存在`,
+        relationFields: l
+        // 复制 relationFields，确保 EXISTS 查询可以访问关联实体字段
+      });
+    }
+    t.children && C(t.children, e);
+  }
+}
+function se(n, e) {
+  for (const r of n) {
+    if (r.value === e)
+      return r;
+    if (r.children) {
+      const t = se(r.children, e);
+      if (t) return t;
+    }
+  }
+}
+function de(n) {
+  const e = /* @__PURE__ */ new Map(), r = (t) => {
+    for (const s of t)
+      e.set(s.value, s), s.children && r(s.children);
+  };
+  return r(n), e;
+}
+function he(n = 10) {
+  return Array(n).fill("children");
+}
+function me(n, e) {
+  const r = e.split("."), t = [];
+  let s = n;
+  for (let a = 0; a < r.length; a++) {
+    const l = r.slice(0, a + 1).join("."), i = s.find((o) => o.value === l);
+    i ? (t.push(i.displayName || i.label), s = i.children ?? []) : t.push(r[a]);
+  }
+  return t.join(".");
+}
+const ne = 4, Q = ["id", "createdAt", "updatedAt", "createdBy", "updatedBy"];
+function G(n) {
+  switch (n) {
+    case g.uuid:
+      return "string";
+    case g.string:
+      return "string";
+    case g.number:
+    case g.integer:
+      return "number";
+    case g.boolean:
+      return "boolean";
+    case g.date:
+      return "date";
+    case g.stringArray:
+    case g.numberArray:
+      return "array";
+    case g.json:
+    case g.keyValue:
+      return "object";
+    default:
+      return "string";
+  }
+}
+function ie(n) {
+  return n.kind === B.ONE_TO_MANY || n.kind === B.MANY_TO_MANY ? "mappedProperty" in n && n.mappedProperty ? [n.mappedProperty] : [] : [];
+}
+function ae(n, e, r = {}, t, s = [], a = "", l = /* @__PURE__ */ new Set(), i = 0) {
+  const o = [], f = r.relationQueryDeep ?? ne, y = r.systemFields ?? Q;
+  if (t = t ?? n, l.has(n.name))
+    return o;
+  if (!a)
+    for (const u of y) {
+      const c = n.properties.find((p) => p.name === u);
+      c && o.push({
+        name: u,
+        displayName: c.displayName ?? u,
+        type: G(c.type),
+        nullable: c.nullable ?? !1
+      });
+    }
+  for (const [u, c] of n.propertyMap) {
+    const p = a ? `${a}.${u}` : u;
+    o.push({
+      name: p,
+      displayName: c.displayName ?? u,
+      type: G(c.type),
+      nullable: c.nullable ?? !1
+    });
+  }
+  for (const u of n.foreignKeyNames) {
+    const c = a ? `${a}.${u}` : u;
+    if (!o.some((p) => p.name === c)) {
+      const p = u.slice(0, -2), m = n.foreignKeyRelationMap.get(p), v = m?.displayName ?? p, d = m && "nullable" in m ? m.nullable ?? !1 : !1;
+      o.push({
+        name: c,
+        displayName: `${v}ID`,
+        type: "string",
+        nullable: d
+      });
+    }
+  }
+  if (i < f)
+    for (const [u, c] of n.relationMap) {
+      if (s.includes(u)) continue;
+      const p = e.get(c.mappedEntity);
+      if (!p || i > 0 && p.metadata === t || l.has(p.metadata.name)) continue;
+      const m = a ? `${a}.${u}` : u, v = c.displayName || u, d = oe(p.metadata, r);
+      o.push({
+        name: m,
+        displayName: `${v} (${c.kind})`,
+        type: "relation",
+        isRelation: !0,
+        relationTarget: c.mappedEntity,
+        relationFields: d
+      });
+      const N = ie(c), T = new Set(l);
+      T.add(n.name);
+      const R = ae(
+        p.metadata,
+        e,
+        r,
+        t,
+        N,
+        m,
+        T,
+        i + 1
+      );
+      for (const h of y) {
+        const F = `${m}.${h}`, D = p.metadata.properties.find((E) => E.name === h);
+        D && !o.some((E) => E.name === F) && o.push({
+          name: F,
+          displayName: `${v}.${D.displayName ?? h}`,
+          type: G(D.type),
+          nullable: D.nullable ?? !1
+        });
+      }
+      o.push(...R);
+    }
+  return o;
+}
+function oe(n, e = {}) {
+  const r = [], t = e.systemFields ?? Q;
+  for (const s of t) {
+    const a = n.properties.find((l) => l.name === s);
+    a && r.push({
+      name: s,
+      displayName: a.displayName ?? s,
+      type: G(a.type),
+      nullable: a.nullable ?? !1
+    });
+  }
+  for (const [s, a] of n.propertyMap)
+    r.push({
+      name: s,
+      displayName: a.displayName ?? s,
+      type: G(a.type),
+      nullable: a.nullable ?? !1
+    });
+  for (const s of n.foreignKeyNames)
+    if (!r.some((a) => a.name === s)) {
+      const a = s.slice(0, -2), l = n.foreignKeyRelationMap.get(a), i = l?.displayName ?? a, o = l && "nullable" in l ? l.nullable ?? !1 : !1;
+      r.push({
+        name: s,
+        displayName: `${i}ID`,
+        type: "string",
+        nullable: o
+      });
+    }
+  return r;
+}
+function ge(n) {
+  return n.sort((e, r) => {
+    const t = (e.name.match(/\./g) || []).length, s = (r.name.match(/\./g) || []).length;
+    return t !== s ? t - s : e.name.localeCompare(r.name);
+  });
+}
+function ve(n, e) {
+  return j(e).parse(n);
+}
+function be(n, e) {
+  return j(e).parseMany(n);
+}
+export {
+  K as BUILTIN_VALIDATION_RULES,
+  k as DEFAULT_OPERATORS,
+  q as OperatorRegistry,
+  re as QueryBuilderService,
+  Y as QueryConverter,
+  P as SchemaParser,
+  H as ValidationService,
+  ye as buildFieldTree,
+  de as createFieldNodeMap,
+  J as createOperatorRegistry,
+  fe as createQueryBuilderService,
+  X as createQueryConverter,
+  be as createSchemaFromEntities,
+  ve as createSchemaFromEntity,
+  j as createSchemaParser,
+  ee as createValidationService,
+  ae as extractFieldsFromMetadata,
+  oe as extractRelationTargetFields,
+  se as findNodeByValue,
+  A as generateId,
+  z as getDefaultOperatorRegistry,
+  me as getDisplayNamePath,
+  ce as getOperatorsForType,
+  he as getOptionGroupChildren,
+  ie as getRelationIgnoreKeys,
+  S as isRule,
+  b as isRuleGroup,
+  G as mapPropertyType,
+  ge as organizeFields
+};