@aiao/rxdb-client-generator 0.0.5 → 0.0.7

package/dist/RxDBClientGenerator-DmFzgpuy.js

@@ -0,0 +1,1056 @@
+import { PropertyType as d, RelationKind as f, ENTITY_BASE_METADATA_OPTIONS as S, TREE_ADJACENCY_LIST_ENTITY_BASE_OPTIONS as C, getEntityMetadata as B, transitionMetadata as N } from "@aiao/rxdb";
+import { omit as K, isObject as G, isArray as F, isNil as V, unionBy as v, capitalizeFirst as E, isFunction as U } from "@aiao/utils";
+const Y = (r, e) => {
+  const t = T(r, e), s = !!r.nullable;
+  let a = !0;
+  !s && Object.hasOwn(r, "default") && (a = !1);
+  const o = {
+    type: t,
+    name: r.name,
+    hasQuestionToken: s,
+    hasExclamationToken: a,
+    isReadonly: r.readonly
+  };
+  return V(r.default) || (o.initializer = L(r)), o;
+}, I = (r, e) => `${e.name}${r.name.charAt(0).toUpperCase() + r.name.slice(1)}KeyValue`, J = (r, e) => r.type !== d.keyValue || !("properties" in r) || !r.properties || r.properties.length === 0 ? "KeyValue" : I(r, e), H = (r, e) => r.type !== d.keyValue || !("properties" in r) || !r.properties || r.properties.length === 0 ? [] : r.properties.map((t) => ({
+  name: t.name,
+  type: T(t, e),
+  hasQuestionToken: t.nullable || !1,
+  docs: t.displayName ? [t.displayName] : void 0
+})), T = (r, e) => {
+  let t = "any";
+  switch (r.type) {
+    case d.uuid:
+      t = "UUID";
+      break;
+    case d.string:
+      t = "string";
+      break;
+    case d.number:
+      t = "number";
+      break;
+    case d.integer:
+      t = "number";
+      break;
+    case d.boolean:
+      t = "boolean";
+      break;
+    case d.date:
+      t = "Date";
+      break;
+    case d.stringArray:
+      t = "string[]";
+      break;
+    case d.numberArray:
+      t = "number[]";
+      break;
+    case d.keyValue:
+      t = J(r, e);
+      break;
+    case d.json:
+      t = "Record<string, any>";
+      break;
+  }
+  return r.nullable && (t += " | null"), t;
+}, L = (r) => {
+  switch (r.type) {
+    case d.string:
+      return `'${String(r.default)}'`;
+    case d.date:
+      if (r.default)
+        return "new Date()";
+      break;
+  }
+  return "";
+}, D = (r, e = /* @__PURE__ */ new Set()) => {
+  if (G(r))
+    for (const t in r)
+      e.add(t), Object.prototype.hasOwnProperty.call(r, t) && D(Reflect.get(r, t), e);
+  else if (F(r))
+    for (const t of r)
+      D(t, e);
+  return e;
+}, x = /* @__PURE__ */ new Map();
+Object.keys(d).forEach((r) => {
+  const e = d[r];
+  x.set(e, r);
+});
+const w = /* @__PURE__ */ new Map();
+Object.keys(f).forEach((r) => {
+  const e = f[r];
+  w.set(e, r);
+});
+function Q(r) {
+  const e = K(r, ["propertyMap", "relationMap", "indexMap"]), t = D(e);
+  let s = JSON.stringify(e, null, 2);
+  return new Set(r.properties.map((o) => o.type).filter(Boolean)).forEach((o) => {
+    const n = x.get(o);
+    s = s.replaceAll(`"type": "${o}"`, `"type": PropertyType.${n}`);
+  }), r.relations && new Set(r.relations.map((n) => n.kind)).forEach((n) => {
+    const i = w.get(n);
+    s = s.replaceAll(`"kind": "${n}"`, `"kind": RelationKind.${i}`);
+  }), t.forEach((o) => {
+    o.includes("-") || o.includes(" ") || (s = s.replaceAll(`"${o}":`, `${o}:`));
+  }), s;
+}
+const q = ({
+  classProperties: r,
+  metadata: e,
+  file: t,
+  rxdbNamedImports: s
+}) => {
+  const a = t.addInterface({
+    name: `${e.name}InitData`,
+    isExported: !0,
+    docs: ["初始化数据"]
+  }), o = (n, i = !1) => {
+    if (n.type === d.keyValue && "properties" in n && n.properties && n.properties.length > 0) {
+      const y = I(n, e), g = t.addInterface({
+        name: y,
+        isExported: !0,
+        docs: [n.displayName || `${n.name} keyValue 类型`]
+      });
+      H(n, e).forEach((m) => {
+        g.addProperty(m);
+      });
+    }
+    const c = Y(n, e), { initializer: u, ...h } = c, l = [];
+    switch (l.push(n.displayName || n.name), u && l.push(`@default ${u}`), c.type) {
+      case "UUID":
+        s.add("UUID");
+        break;
+    }
+    i || a.addProperty({
+      name: c.name,
+      type: c.type,
+      hasQuestionToken: !0,
+      docs: l
+    }), r.push({
+      ...h,
+      hasExclamationToken: !1,
+      isReadonly: n.readonly || !1,
+      docs: l
+    });
+  };
+  Array.from(e.properties.values()).forEach((n) => {
+    o(n);
+  }), Array.from(e.computedPropertyMap.values()).forEach((n) => {
+    let i = e.features || {};
+    e.repository === "GraphRepository" || e.extends.includes("GraphRepository") ? i = e.features?.graph || {} : (e.repository === "TreeRepository" || e.extends.includes("TreeRepository")) && (i = e.features?.tree || {}), i[n.name] && o(n, !0);
+  });
+}, z = (r) => {
+  const e = r.propertyMap.get("id");
+  let t = "UUID";
+  switch (e?.type) {
+    case d.uuid:
+      t = "UUID";
+      break;
+    case d.string:
+      t = "string";
+      break;
+    case d.integer:
+      t = "number";
+      break;
+  }
+  return t;
+}, W = ({
+  classProperties: r,
+  metadata: e,
+  rxdbNamedImports: t,
+  generator: s
+}) => {
+  Array.from(e.relationMap.values()).forEach((a) => {
+    switch (a.kind) {
+      // 处理一对一和多对一关系
+      // 这两种关系需要生成：
+      // 1. 关系可观察对象属性（name$）- 用于访问关联实体
+      // 2. 外键ID属性（nameId）- 存储关联实体的ID
+      case f.ONE_TO_ONE:
+      case f.MANY_TO_ONE:
+        {
+          const o = `RelationEntityObservable<typeof ${a.mappedEntity}>`, n = a.displayName || a.name;
+          r.push({
+            name: a.name + "$",
+            // 关系属性名使用$后缀，表示可观察对象
+            type: o,
+            isReadonly: !0,
+            // 关系属性是只读的，通过set/remove方法修改
+            docs: [n]
+          });
+          const i = s.getMetadata(a.mappedEntity, a.mappedNamespace), c = z(i);
+          r.push({
+            name: a.name + "Id",
+            // 外键ID属性
+            // 当关系 nullable 时，id 既可能不存在（undefined），也可能为 null（根节点），或为有效 id
+            // 使用 ?: 与 "| null" 组合表达三种状态
+            type: a.nullable ? `${c} | null` : c,
+            isReadonly: !1,
+            hasQuestionToken: a.nullable,
+            docs: [n + " id"]
+          }), t.add("RelationEntityObservable");
+        }
+        break;
+      // 处理一对多和多对多关系
+      // 这两种关系只需要生成关系可观察集合属性（name$）
+      // 不需要外键ID属性，因为外键存储在关联实体或中间表中
+      case f.ONE_TO_MANY:
+      case f.MANY_TO_MANY:
+        {
+          const o = a.displayName || a.name, n = `RelationEntitiesObservable<${a.mappedEntity}>`;
+          r.push({
+            name: a.name + "$",
+            // 关系集合属性名使用$后缀
+            isReadonly: !0,
+            // 关系属性是只读的，通过add/remove方法修改
+            type: n,
+            docs: [o]
+          }), t.add("RelationEntitiesObservable");
+        }
+        break;
+    }
+  });
+}, Z = (r, e, t) => {
+  const s = /* @__PURE__ */ new Set(), { name: a } = e, o = e.extends[0] || "", n = [];
+  o.includes("TreeAdjacencyListEntityBase") ? n.push("ITreeEntity") : o.includes("EntityBase") && n.push("IEntity"), s.add(o);
+  const i = t.addClass({
+    name: a,
+    isExported: !0,
+    extends: o,
+    implements: n.sort(),
+    decorators: [],
+    hasDeclareKeyword: !0
+  });
+  i.addJsDoc(`${e.displayName}`);
+  const c = [];
+  c.push({
+    type: `${a}StaticTypes`,
+    name: "[ENTITY_STATIC_TYPES]",
+    isStatic: !0
+  }), s.add("ENTITY_STATIC_TYPES");
+  const u = t.addInterface({
+    name: `${a}StaticTypes`,
+    docs: ["静态类型"],
+    isExported: !0
+  }), h = [];
+  q({
+    classProperties: c,
+    file: t,
+    metadata: e,
+    rxdbNamedImports: s
+  }), W({
+    classProperties: c,
+    metadata: e,
+    rxdbNamedImports: s,
+    generator: r
+  });
+  const l = e.repository || "Repository", y = r.getRepositoryGenerator(l);
+  if (y) {
+    if (l !== "Repository") {
+      const p = r.getRepositoryGenerator("Repository");
+      p && p.generate({
+        metadata: e,
+        classProperties: c,
+        classMethods: h,
+        rxdbNamedImports: s,
+        generator: r,
+        file: t,
+        staticTypesInterface: u
+      });
+    }
+    y.generate({
+      metadata: e,
+      classProperties: c,
+      classMethods: h,
+      rxdbNamedImports: s,
+      generator: r,
+      file: t,
+      staticTypesInterface: u
+    });
+  }
+  i.addProperties(
+    c.sort((p, m) => p.isStatic && !m.isStatic ? -1 : !p.isStatic && m.isStatic ? 1 : p.isReadonly && !m.isReadonly ? -1 : !p.isReadonly && m.isReadonly ? 1 : p.name.localeCompare(m.name))
+  ), i.addConstructor({
+    parameters: [
+      {
+        name: "initData",
+        type: `${a}InitData`,
+        hasQuestionToken: !0
+      }
+    ],
+    docs: ["初始化数据", "@param initData 初始化数据"]
+  });
+  const g = v(h, (p) => p.name).sort(
+    (p, m) => p.isStatic && !m.isStatic ? -1 : !p.isStatic && m.isStatic ? 1 : p.name.localeCompare(m.name)
+  );
+  return i.addMethods(g), {
+    rxdbNamedImports: s
+  };
+}, X = {
+  [d.uuid]: "UUID",
+  [d.string]: "String",
+  [d.number]: "Number",
+  [d.integer]: "Number",
+  [d.boolean]: "Boolean",
+  [d.date]: "Date",
+  [d.stringArray]: "StringArray",
+  [d.numberArray]: "NumberArray",
+  [d.keyValue]: "KeyValue"
+}, R = (r) => X[r] ?? null, O = (r, e, t) => {
+  const s = r.length > 0 ? r.map((a) => a.key).join(".") + "." : "";
+  return t ? `${s}${e}.${t}` : `${s}${e}`;
+}, ee = (r, e, t) => {
+  let s;
+  switch (r.type) {
+    case d.stringArray:
+      s = "string";
+      break;
+    case d.numberArray:
+      s = "number";
+      break;
+    case d.keyValue:
+      s = `Partial<${I(r, e)}>`;
+      break;
+    default:
+      t.length > 0 && (s = T(r, e));
+  }
+  return s;
+}, b = (r, e, t, s, a) => ({
+  rule: `${r}Rules`,
+  entity: e,
+  key: t,
+  valueType: s,
+  subRuleGroup: a
+}), te = (r, e, t, s, a) => {
+  r.type !== d.keyValue || !("properties" in r) || !r.properties || r.properties.forEach((o) => {
+    const n = R(o.type);
+    if (!n) return;
+    const i = O(t, s, o.name), c = T(o, e);
+    a.push(b(n, e.name, i, c));
+  });
+}, se = (r, e = []) => {
+  const t = [];
+  return Array.from(r.propertyMap.keys()).forEach((s) => {
+    const a = r.propertyMap.get(s), o = R(a.type);
+    if (o) {
+      const n = ee(a, r, e), i = O(e, s);
+      t.push(b(o, r.name, i, n));
+    }
+    te(a, r, e, s, t);
+  }), t;
+}, re = (r, e, t) => {
+  e.foreignKeyNames.forEach((s) => {
+    const a = s.replace(/Id$/, ""), o = e.foreignKeyRelationMap.get(a);
+    if (!o) return;
+    const i = r.getMetadata(o.mappedEntity, o.mappedNamespace)?.propertyMap.get("id")?.type, c = i && R(i) || "UUID";
+    t.push(b(c, e.name, s));
+  });
+}, ne = (r) => {
+  switch (r.kind) {
+    case f.ONE_TO_MANY:
+    case f.MANY_TO_MANY:
+      return r.mappedProperty ? [r.mappedProperty] : [];
+    default:
+      return [];
+  }
+}, oe = (r, e, t, s) => !!(r.some((o) => o.entity === s.name) || r.length > 0 && e === t), ie = (r, e, t, s, a, o) => {
+  Array.from(e.relationMap.keys()).filter((n) => !s.includes(n)).forEach((n) => {
+    const i = e.relationMap.get(n);
+    if (!i)
+      throw new Error("relation is empty");
+    const c = r.getMetadata(i.mappedEntity, i.mappedNamespace);
+    if (!c)
+      throw new Error(`generator_entity_rules: metadata "${i.mappedEntity}" not found`);
+    if (oe(o, c, t, e))
+      return;
+    if (o.length === 0) {
+      const l = `${c.name}RuleGroup`;
+      a.push(b("RelationExists", e.name, n, void 0, l));
+    }
+    if (o.length >= r.config.relationQueryDeep)
+      return;
+    const u = ne(i), h = [...o, { key: n, entity: e.name }];
+    M(r, c, t, u, a, h);
+  });
+}, M = (r, e, t, s = [], a = [], o = []) => (t = t ?? e, a.push(...se(e, o)), re(r, e, a), ie(r, e, t, s, a, o), a), _ = (r, e) => r.map(({ rule: t, entity: s, key: a, valueType: o, subRuleGroup: n }) => (e.add(t), n ? `${t}<'${a}', ${n}>` : o ? a.includes(".") ? (e.add(`Relation${t}`), `Relation${t}<'${a}', ${o}>`) : `${t}<${s}, '${a}', ${o}>` : a.includes(".") ? (e.add(`Relation${t}`), `Relation${t}<'${a}'>`) : `${t}<${s}, '${a}'>`));
+class ae {
+  generate(e) {
+    this.generateProperties(e), this.generateMethods(e);
+  }
+  /**
+   * 生成器钩子：生成特定的 Repository 属性
+   * 子类可选择性覆盖此方法，生成特定的计算属性、索引等
+   *
+   * @example
+   * ```typescript
+   * // Tree Generator 可能需要生成树级别缓存属性
+   * protected generateProperties(context: GeneratorContext): void {
+   *   context.classProperties.push({
+   *     name: 'maxDepth',
+   *     type: 'number',
+   *     isReadonly: true
+   *   });
+   * }
+   * ```
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  generateProperties(e) {
+  }
+  /**
+   * 共享工具：添加静态查询方法
+   */
+  addStaticMethod(e, t) {
+    const { classMethods: s, staticTypesInterface: a, rxdbNamedImports: o } = e, n = [t.metHodDoc || `${t.method} 查询`, "@param options 查询选项"];
+    t.example && n.push("@example", t.example), s.push({
+      name: t.method,
+      returnType: `Observable<${t.returnType}>`,
+      docs: n,
+      parameters: [
+        {
+          name: "options",
+          type: t.options,
+          hasQuestionToken: !t.optionsIsRequired
+        }
+      ],
+      isStatic: !0
+    }), a.addProperty({
+      name: `${t.method}Options`,
+      type: t.options,
+      docs: ["查询选项"]
+    });
+    const i = t.options.match(/\b([A-Z]\w+Options)\b/g);
+    i && i.forEach((c) => {
+      !/^[a-z]/.test(c) && c.match(/^(Find|Count|Get)/) && o.add(c);
+    });
+  }
+  /**
+   * 共享工具：添加实例方法
+   */
+  addInstanceMethod(e, t) {
+    e.classMethods.push({
+      name: t.name,
+      returnType: t.returnType,
+      docs: t.docs
+    });
+  }
+  /**
+   * 共享工具:获取 ID 类型
+   */
+  getIdType(e) {
+    const t = e.propertyMap.get("id");
+    if (!t) return "UUID";
+    const { type: s } = t;
+    return s === "uuid" ? "UUID" : s === "string" ? "string" : s === "number" || s === "integer" ? "number" : "UUID";
+  }
+}
+class j extends ae {
+  name = "Repository";
+  generateMethods(e) {
+    const { metadata: t, file: s, rxdbNamedImports: a, staticTypesInterface: o } = e, { name: n } = t, i = this.getIdType(t);
+    o.addProperty({
+      name: "idType",
+      type: i,
+      docs: ["id 类型"]
+    });
+    const c = M(e.generator, t), u = _(c, a), h = `
+  |` + c.map((p) => `'${p.key}'`).join(`
+  |`);
+    s.addTypeAlias({
+      name: `${n}Rule`,
+      type: Array.from(new Set(u)).join(`
+| `),
+      hasDeclareKeyword: !0,
+      docs: ["rule"]
+    }), s.addTypeAlias({
+      name: `${n}RuleGroup`,
+      // 关键：逗号后不加空格，直接换行，避免行尾空格
+      type: `RuleGroupBase<typeof ${n},${h},
+${n}Rule>`,
+      hasDeclareKeyword: !0,
+      docs: ["RuleGroupBase"],
+      isExported: !0
+    });
+    const l = `${n}OrderByField`, y = Array.from(t.propertyMap.keys());
+    s.addTypeAlias({
+      name: l,
+      type: y.map((p) => `"${p}"`).join(" | "),
+      hasDeclareKeyword: !0,
+      docs: ["OrderByField"]
+    });
+    const g = (p) => ({
+      method: p,
+      options: `${E(p)}Options<typeof ${n},${n}RuleGroup,${l}>`
+    });
+    this.addStaticMethod(e, {
+      method: "get",
+      options: `${i}`,
+      returnType: n,
+      metHodDoc: "根据 ID 获取单个实体",
+      example: `${n}.get('123').subscribe(entity => console.log(entity));`,
+      optionsIsRequired: !0
+    }), this.addStaticMethod(e, {
+      ...g("findOneOrFail"),
+      returnType: n,
+      metHodDoc: "查询单个实体,未找到时抛出错误",
+      example: `${n}.findOneOrFail({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));`,
+      optionsIsRequired: !0
+    }), this.addStaticMethod(e, {
+      ...g("find"),
+      returnType: `${n}[]`,
+      metHodDoc: "查询多个实体",
+      example: `${n}.find({ where: { combinator: 'and', rules: [] }] }).subscribe(list => console.log(list));`,
+      optionsIsRequired: !0
+    }), this.addStaticMethod(e, {
+      ...g("findOne"),
+      returnType: `${n} | undefined`,
+      metHodDoc: "查询单个实体,未找到时返回 undefined",
+      example: `${n}.findOne({ where: { combinator: 'and', rules: [] } }).subscribe(entity => console.log(entity));`,
+      optionsIsRequired: !0
+    }), this.addStaticMethod(e, {
+      ...g("findAll"),
+      returnType: `${n}[]`,
+      metHodDoc: "查询所有实体",
+      example: `${n}.findAll({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));`,
+      optionsIsRequired: !0
+    }), this.addStaticMethod(e, {
+      ...g("findByCursor"),
+      returnType: `${n}[]`,
+      metHodDoc: "游标分页查询",
+      example: `${n}.findByCursor({ where: { combinator: 'and', rules: [] } }).subscribe(list => console.log(list));`,
+      optionsIsRequired: !0
+    }), this.addStaticMethod(e, {
+      method: "count",
+      options: `${E("count")}Options<typeof ${n},${n}RuleGroup>`,
+      returnType: "number",
+      metHodDoc: "统计实体数量",
+      example: `${n}.count({ where: { combinator: 'and', rules: [] } }).subscribe(total => console.log(total));`,
+      optionsIsRequired: !0
+    }), this.addInstanceMethod(e, {
+      name: "save",
+      returnType: `Promise<${n}>`,
+      docs: ["保存"]
+    }), this.addInstanceMethod(e, {
+      name: "remove",
+      returnType: `Promise<${n}>`,
+      docs: ["删除"]
+    }), this.addInstanceMethod(e, {
+      name: "reset",
+      returnType: "void",
+      docs: ["重置数据"]
+    });
+  }
+}
+class ce extends j {
+  name = "TreeRepository";
+  generateMethods(e) {
+    const { metadata: t, rxdbNamedImports: s, generator: a, file: o, staticTypesInterface: n } = e, { name: i } = t, c = M(a, t).filter(
+      (y) => y.key.startsWith("children.") && y.key !== "children.id"
+    ), u = _(c, s), h = c.map((y) => `'${y.key}'`).join(" | ");
+    o.addTypeAlias({
+      name: `${i}TreeRule`,
+      type: Array.from(new Set(u)).join(`
+| `),
+      hasDeclareKeyword: !0,
+      docs: ["TreeRule"]
+    }), o.addTypeAlias({
+      name: `${i}TreeRuleGroup`,
+      type: `RuleGroupBase<typeof ${i}, ${h}, ${i}TreeRule>`,
+      hasDeclareKeyword: !0,
+      docs: ["TreeRuleGroup"],
+      isExported: !0
+    }), n.addProperty({
+      name: "entity",
+      type: `${i}`,
+      docs: ["查询的实体"]
+    }), s.add(E("FindTreeOptions"));
+    const l = `FindTreeOptions<typeof ${i},${i}TreeRuleGroup>`;
+    this.addStaticMethod(e, {
+      method: "findDescendants",
+      options: l,
+      returnType: `${i}[]`,
+      metHodDoc: "查询子孙实体（包含自身）",
+      example: `// 查询某节点的所有后代
+${i}.findDescendants({ entityId: root.id }).subscribe(list => console.log(list));
+
+// 仅查询直接子节点（level 1）
+${i}.findDescendants({ entityId: root.id, level: 1 }).subscribe(children => console.log(children));`
+    }), this.addStaticMethod(e, {
+      method: "countDescendants",
+      options: l,
+      returnType: "number",
+      metHodDoc: "统计子孙实体数量（不包含自身）",
+      example: `// 统计某节点下的后代数量
+${i}.countDescendants({ entityId: root.id }).subscribe(count => console.log(count));`
+    }), this.addStaticMethod(e, {
+      method: "findAncestors",
+      options: l,
+      returnType: `${i}[]`,
+      metHodDoc: "查询祖先实体（包含自身）",
+      example: `// 查询某节点的所有祖先（面包屑导航）
+${i}.findAncestors({ entityId: grand.id }).subscribe(ancestors => console.log(ancestors));
+
+// 仅查询直接父节点（level 1）
+${i}.findAncestors({ entityId: grand.id, level: 1 }).subscribe(parents => console.log(parents));`
+    }), this.addStaticMethod(e, {
+      method: "countAncestors",
+      options: l,
+      returnType: "number",
+      metHodDoc: "统计祖先实体数量（不包含自身）",
+      example: `// 统计某节点的祖先层级深度
+${i}.countAncestors({ entityId: grand.id }).subscribe(depth => console.log(depth));`
+    });
+  }
+}
+var k = /* @__PURE__ */ ((r) => (r.Var = "var", r.Let = "let", r.Const = "const", r))(k || {});
+class $ {
+  /**
+   * 渲染单个参数
+   */
+  static renderParameter(e, t) {
+    const s = [];
+    return t > 0 && s.push(", "), s.push(e.name), e.hasQuestionToken && s.push("?"), e.type && s.push(`: ${e.type}`), s.join("");
+  }
+  /**
+   * 渲染参数列表
+   */
+  static renderParameterList(e) {
+    return e?.length ? e.map((t, s) => this.renderParameter(t, s)).join("") : "";
+  }
+  /**
+   * 渲染单个变量声明
+   */
+  static renderVariableDeclaration(e, t) {
+    const s = [];
+    return t > 0 && s.push(", "), s.push(e.name), e.type && s.push(`: ${e.type}`), e.initializer && s.push(` = ${e.initializer}`), s.join("");
+  }
+  /**
+   * 渲染变量声明列表
+   */
+  static renderVariableDeclarationList(e) {
+    return e?.length ? e.map((t, s) => this.renderVariableDeclaration(t, s)).join("") : "";
+  }
+  /**
+   * 渲染 JSDoc 注释
+   */
+  static renderJsDoc(e, t = 0) {
+    if (!e?.length) return "";
+    const s = " ".repeat(t), a = e.map((o) => `${s} * ${o}`).join(`
+`);
+    return `${s}/**
+${a}
+${s} */
+`;
+  }
+  /**
+   * 渲染属性
+   */
+  static renderProperty(e, t, s = !0) {
+    const a = " ".repeat(t), o = [];
+    return e.docs?.length && o.push(this.renderJsDoc(e.docs, t)), o.push(a), e.isStatic && o.push("static "), e.isReadonly && o.push("readonly "), o.push(e.name), e.hasQuestionToken && o.push("?"), e.type && o.push(`: ${e.type}`), !s && e.initializer && o.push(` = ${e.initializer}`), o.push(`;
+`), o.join("");
+  }
+  /**
+   * 渲染接口块
+   */
+  static renderInterfaceBlock(e, t, s) {
+    const a = " ".repeat(t), o = [];
+    return e.docs?.length && o.push(this.renderJsDoc(e.docs, t)), o.push(a), s && e.isExported && o.push("export "), o.push(`interface ${e.name}`), e.extends?.length && o.push(` extends ${e.extends.join(", ")}`), o.push(` {
+`), e.properties?.length && e.properties.forEach((n) => {
+      o.push(this.renderProperty(n, t + 2));
+    }), o.push(`${a}}
+`), o.join("");
+  }
+  /**
+   * 渲染导入声明
+   */
+  static renderImports(e) {
+    if (!e.length) return "";
+    const t = e.filter((s) => s.namedImports?.length).map((s) => `import { ${s.namedImports.join(", ")} } from '${s.moduleSpecifier}';`);
+    return t.length ? t.join(`
+`) + `
+
+` : "";
+  }
+  /**
+   * 渲染类型别名
+   */
+  static renderTypeAliases(e) {
+    return e.length ? e.map((t) => {
+      const s = [];
+      return t.docs?.length && s.push(this.renderJsDoc(t.docs, 0)), t.isExported && s.push("export "), t.hasDeclareKeyword && s.push("declare "), s.push(`type ${t.name} = ${t.type};
+
+`), s.join("");
+    }).join("") : "";
+  }
+  /**
+   * 渲染模块声明
+   */
+  static renderModules(e) {
+    return e.length ? e.map((t) => {
+      const s = [];
+      return t.docs?.length && s.push(this.renderJsDoc(t.docs, 0)), t.hasDeclareKeyword && s.push("declare "), s.push(`module ${t.name} {
+`), t.interfaces?.length && t.interfaces.forEach((a) => {
+        s.push(this.renderInterfaceBlock(a, 2, !1));
+      }), s.push(`}
+
+`), s.join("");
+    }).join("") : "";
+  }
+  /**
+   * 渲染类声明
+   */
+  static renderClass(e) {
+    const t = e.getName();
+    if (!t) return "";
+    const s = [], a = e.jsDoc?.length ? e.jsDoc : [t];
+    s.push(this.renderJsDoc(a)), s.push(`export declare class ${t}`);
+    const o = e.getBaseClass();
+    if (o) {
+      const i = o.getName();
+      i && s.push(` extends ${i}`);
+    }
+    const n = e.getImplements();
+    if (n.length) {
+      const i = n.map((c) => c.getText()).join(", ");
+      s.push(` implements ${i}`);
+    }
+    if (s.push(` {
+`), e.properties?.length && e.properties.forEach((i) => {
+      s.push(this.renderProperty(i, 2, !1));
+    }), e.constructorData) {
+      const { parameters: i, docs: c } = e.constructorData;
+      c?.length && s.push(this.renderJsDoc(c, 2)), s.push(`  constructor(${this.renderParameterList(i)});
+`);
+    }
+    return e.methods?.length && e.methods.forEach((i) => {
+      i.docs?.length && s.push(this.renderJsDoc(i.docs, 2));
+      const c = ["  "];
+      i.isStatic && c.push("static "), c.push(`${i.name}(${this.renderParameterList(i.parameters)})`), i.returnType && c.push(`: ${i.returnType}`), c.push(`;
+`), s.push(c.join(""));
+    }), s.push(`}
+
+`), s.join("");
+  }
+  /**
+   * 渲染变量声明
+   */
+  static renderVariables(e) {
+    return e.length ? e.map((t) => {
+      const s = [];
+      return t.isExported && s.push("export "), t.hasDeclareKeyword && s.push("declare "), s.push(`${t.declarationKind} `), s.push(this.renderVariableDeclarationList(t.declarations)), s.push(`;
+
+`), s.join("");
+    }).join("") : "";
+  }
+}
+class de {
+  name;
+  extends;
+  docs;
+  isExported;
+  properties = [];
+  constructor(e) {
+    Object.assign(this, e), this.properties || (this.properties = []);
+  }
+  addProperty(e) {
+    this.properties.some((t) => t.name === e.name) || this.properties.push(e);
+  }
+}
+class pe {
+  structure;
+  decorators = [];
+  properties = [];
+  methods = [];
+  constructorData;
+  jsDoc = [];
+  constructor(e) {
+    this.structure = e;
+  }
+  addJsDoc(e) {
+    this.jsDoc.push(e);
+  }
+  addProperties(e) {
+    this.properties.push(...e);
+  }
+  addConstructor(e) {
+    this.constructorData = e;
+  }
+  addMethods(e) {
+    this.methods.push(...e);
+  }
+  getDecorators() {
+    return this.decorators;
+  }
+  getName() {
+    return this.structure.name;
+  }
+  getBaseClass() {
+    if (this.structure.extends)
+      return {
+        getName: () => this.structure.extends,
+        getText: () => this.structure.extends,
+        getDecorators: () => [],
+        getImplements: () => [],
+        getBaseClass: () => {
+        }
+      };
+  }
+  getImplements() {
+    return (this.structure.implements || []).map((e) => ({
+      getName: () => e,
+      getText: () => e,
+      getDecorators: () => [],
+      getImplements: () => [],
+      getBaseClass: () => {
+      }
+    }));
+  }
+  getText() {
+    return this.structure.name || "";
+  }
+}
+class A {
+  filePath;
+  classes = [];
+  interfaces = [];
+  modules = [];
+  typeAliases = [];
+  imports = [];
+  variables = [];
+  fileContent = "";
+  constructor(e) {
+    this.filePath = e;
+  }
+  addClass(e) {
+    const t = new pe(e);
+    return e.properties && t.addProperties(e.properties), e.methods && t.addMethods(e.methods), e.docs && e.docs.forEach((s) => t.addJsDoc(s)), this.classes.push(t), t;
+  }
+  addInterface(e) {
+    let t = this.interfaces.find((s) => s.name === e.name);
+    return t || (t = new de(e), this.interfaces.push(t)), t;
+  }
+  addModule(e) {
+    return this.modules.push(e), {
+      addInterface: (t) => {
+        const s = this.modules[this.modules.length - 1];
+        return s.interfaces || (s.interfaces = []), s.interfaces.push(t), {
+          addProperty: (a) => {
+            const o = this.modules[this.modules.length - 1], n = o.interfaces[o.interfaces.length - 1];
+            n.properties || (n.properties = []), n.properties.push(a);
+          }
+        };
+      }
+    };
+  }
+  addTypeAlias(e) {
+    return this.typeAliases.push(e), e;
+  }
+  addImportDeclaration(e) {
+    this.imports.push(e);
+  }
+  addVariableStatement(e) {
+    this.variables.push(e);
+  }
+  getClasses() {
+    return this.classes;
+  }
+  getFilePath() {
+    return this.filePath;
+  }
+  getText() {
+    return this.fileContent ? this.fileContent : [
+      $.renderImports(this.imports),
+      $.renderTypeAliases(this.typeAliases),
+      $.renderModules(this.modules),
+      this.interfaces.map((t) => $.renderInterfaceBlock(t, 0, !0) + `
+`).join(""),
+      this.classes.map((t) => $.renderClass(t)).join(""),
+      $.renderVariables(this.variables)
+    ].join("");
+  }
+  setContent(e) {
+    this.fileContent = e;
+  }
+  async save() {
+    console.log(`SourceFile ${this.filePath} saved`);
+  }
+  saveSync() {
+    console.log(`SourceFile ${this.filePath} saved synchronously`);
+  }
+}
+class le {
+  files = /* @__PURE__ */ new Map();
+  createSourceFile(e, t) {
+    const s = new A(e);
+    return t && s.setContent(t), this.files.set(e, s), s;
+  }
+  addSourceFileAtPath(e) {
+    const t = new A(e);
+    return this.files.set(e, t), t;
+  }
+  getSourceFiles() {
+    return Array.from(this.files.values());
+  }
+}
+const P = (r, e = "public") => `${e}_${r}`;
+class ye {
+  /**
+   * Repository 生成器注册表
+   * 用于支持可扩展的 Repository 类型
+   */
+  repositoryGenerators = /* @__PURE__ */ new Map();
+  entityMetadataOptionsMap = /* @__PURE__ */ new Map([
+    ["EntityBase", [S]],
+    ["TreeEntityBase", [C, S]]
+  ]);
+  metadataOptionsSet = /* @__PURE__ */ new Set();
+  metadataSet = /* @__PURE__ */ new Set();
+  metadataMap = /* @__PURE__ */ new Map();
+  project;
+  config = {
+    relationQueryDeep: 3
+  };
+  constructor(e) {
+    Object.assign(this.config, e), this.config.relationQueryDeep < 1 && (this.config.relationQueryDeep = 1), this.registerRepositoryGenerator(new j()), this.registerRepositoryGenerator(new ce());
+  }
+  /**
+   * 添加实体配置
+   * @param value 实体
+   */
+  addEntity(e, t) {
+    let s;
+    if (U(e))
+      s = B(e);
+    else {
+      const a = e;
+      t = t || a.extends?.length && this.entityMetadataOptionsMap.get(a.extends[0]) || [], s = N(e, t);
+    }
+    this.metadataSet.add(s), this.metadataMap.set(`${s.namespace}_${s.name}`, s);
+  }
+  getMetadata(e, t) {
+    return this.metadataMap.get(P(e, t));
+  }
+  registerAbstractMetadata(e, t) {
+    this.entityMetadataOptionsMap.set(e, t), t.forEach((s) => {
+      const a = N(s);
+      this.metadataMap.set(P(s.name, s.namespace), a);
+    });
+  }
+  /**
+   * 注册 Repository 生成器
+   * 用于扩展支持自定义 Repository 类型
+   *
+   * @param generator Repository 生成器实例
+   * @example
+   * ```typescript
+   * const generator = new RxDBClientGenerator();
+   * generator.registerRepositoryGenerator(new GeoRepositoryGenerator());
+   * ```
+   */
+  registerRepositoryGenerator(e) {
+    this.repositoryGenerators.set(e.name, e);
+  }
+  /**
+   * 获取 Repository 生成器
+   * @param name Repository 名称
+   * @returns 对应的生成器，如果不存在则返回 undefined
+   */
+  getRepositoryGenerator(e) {
+    return this.repositoryGenerators.get(e);
+  }
+  /**
+   * 执行生成器
+   */
+  exec() {
+    this.project = new le(), this.generateAllEntityDefinition(), this.generateEntityJsFile();
+  }
+  getSourceFiles() {
+    return this.project.getSourceFiles();
+  }
+  /**
+   * 生成实体的 js 文件
+   * 公开此方法以便测试使用
+   */
+  generateEntityJsFile() {
+    const { project: e, metadataSet: t } = this;
+    let s = "";
+    const a = /* @__PURE__ */ new Set(["Entity", "__decorateClass"]), o = (i) => {
+      const c = this.getMetadata(i.mappedEntity, i.mappedNamespace);
+      if (c?.relations)
+        return c.relations.find(
+          (u) => u.kind === f.MANY_TO_MANY && u.name === i.mappedProperty && u.mappedProperty === i.name
+        );
+    };
+    t.forEach((i) => {
+      i.relations.forEach((c) => {
+        if (c.kind === f.MANY_TO_MANY && !o(c))
+          throw new Error("mapped relation not found");
+      });
+    }), t.forEach((i) => {
+      const c = i.extends[0], { name: u } = i, h = u, l = Q(i);
+      c && a.add(c), i.properties.length && a.add("PropertyType"), i.relations.length && a.add("RelationKind"), s += `
+let ${h} = class ${c ? "extends " + c : ""} {};`, s += `
+${h} = __decorateClass(
+[
+  Entity(${l})
+],
+${h}
+);`;
+    }), s = `import { ${Array.from(a).sort().join(", ")} } from '@aiao/rxdb';` + s;
+    const n = Array.from(t.values()).map((i) => i.name).sort().join(", ");
+    s += `
+const ENTITIES = [ ${n} ];`, s += `
+export { ENTITIES, ${n} };`, e.createSourceFile("index.js", s);
+  }
+  /**
+   * 生成所有 entity 的定义到 index.d.ts 文件里
+   * @private
+   */
+  generateAllEntityDefinition() {
+    const { project: e, metadataSet: t } = this, s = e.createSourceFile("index.d.ts"), o = s.addModule({
+      name: '"@aiao/rxdb"',
+      hasDeclareKeyword: !0,
+      docs: ["rxdb"]
+    }).addInterface({
+      name: "RxDB",
+      docs: ["RxDB"]
+    }), n = /* @__PURE__ */ new Set(["EntityType", "IEntity", "ITreeEntity", "RuleGroupBase", "UUID"]);
+    t.forEach((i) => {
+      const { rxdbNamedImports: c } = Z(this, i, s);
+      c.forEach((l) => n.add(l));
+      const { name: u } = i, h = u;
+      i.namespace && i.namespace !== "public" ? o.addProperty({
+        name: i.namespace,
+        type: `{
+${h}: typeof ${h};
+}`,
+        docs: [i.displayName]
+      }) : o.addProperty({
+        name: h,
+        type: `typeof ${h}`,
+        docs: [i.displayName]
+      });
+    }), s.addImportDeclaration({
+      namedImports: Array.from(n).filter(Boolean).sort(),
+      isTypeOnly: !0,
+      moduleSpecifier: "@aiao/rxdb"
+    }), s.addImportDeclaration({
+      namedImports: ["Observable"],
+      isTypeOnly: !0,
+      moduleSpecifier: "rxjs"
+    }), s.addVariableStatement({
+      declarationKind: k.Const,
+      hasDeclareKeyword: !0,
+      isExported: !0,
+      declarations: [
+        {
+          name: "ENTITIES",
+          type: "EntityType[]"
+        }
+      ]
+    });
+  }
+}
+export {
+  ae as R,
+  ye as a
+};