@aiao/rxdb-client-generator 0.0.3 → 0.0.4

package/dist/RxDBClientGenerator-HeMQrLeK.js

@@ -0,0 +1,860 @@
+import { PropertyType as u, RelationKind as h, getEntityMetadata as A, getEntityMetadataOptions as k, transitionMetadata as b, ENTITY_METADATA_MAP as C } from "@aiao/rxdb";
+import { isNil as j, omit as v, isObject as F, isArray as B, capitalizeFirst as g, unionBy as K, isFunction as Y } from "@aiao/utils";
+const U = (n) => {
+  const e = N(n), t = !!n.nullable;
+  let r = !0;
+  !t && Object.hasOwn(n, "default") && (r = !1);
+  const s = {
+    type: e,
+    name: n.name,
+    hasQuestionToken: t,
+    hasExclamationToken: r,
+    isReadonly: n.readonly
+  };
+  return j(n.default) || (s.initializer = G(n)), s;
+}, N = (n) => {
+  let e = "any";
+  switch (n.type) {
+    case u.uuid:
+      e = "UUID";
+      break;
+    case u.string:
+      e = "string";
+      break;
+    case u.number:
+      e = "number";
+      break;
+    case u.boolean:
+      e = "boolean";
+      break;
+    case u.date:
+      e = "Date";
+      break;
+  }
+  return n.nullable && (e += " | null"), e;
+}, G = (n) => {
+  switch (n.type) {
+    case u.string:
+      return `'${String(n.default)}'`;
+    case u.date:
+      if (n.default)
+        return "new Date()";
+      break;
+  }
+  return "";
+}, D = (n, e = /* @__PURE__ */ new Set()) => {
+  if (F(n))
+    for (const t in n)
+      e.add(t), Object.prototype.hasOwnProperty.call(n, t) && D(Reflect.get(n, t), e);
+  else if (B(n))
+    for (const t of n)
+      D(t, e);
+  return e;
+}, x = /* @__PURE__ */ new Map();
+Object.keys(u).forEach((n) => {
+  const e = u[n];
+  x.set(e, n);
+});
+const I = /* @__PURE__ */ new Map();
+Object.keys(h).forEach((n) => {
+  const e = h[n];
+  I.set(e, n);
+});
+function J(n) {
+  const e = v(n, ["propertyMap", "relationMap", "indexMap"]), t = D(e);
+  let r = JSON.stringify(e, null, 2);
+  return new Set(n.properties.map((i) => i.type)).forEach((i) => {
+    const o = x.get(i);
+    r = r.replaceAll(`"type": "${i}"`, `"type": PropertyType.${o}`);
+  }), n.relations && new Set(n.relations.map((o) => o.kind)).forEach((o) => {
+    const a = I.get(o);
+    r = r.replaceAll(`"kind": "${o}"`, `"kind": RelationKind.${a}`);
+  }), t.forEach((i) => {
+    i.includes("-") || i.includes(" ") || (r = r.replaceAll(`"${i}":`, `${i}:`));
+  }), r;
+}
+const Q = ({
+  classProperties: n,
+  metadata: e,
+  file: t,
+  rxdbNamedImports: r
+}) => {
+  const { name: s } = e, i = t.addInterface({
+    name: `${s}InitData`,
+    isExported: !0,
+    docs: ["初始化数据"]
+  });
+  Array.from(e.properties.values()).forEach((o) => {
+    const a = U(o), { initializer: c, ...l } = a, d = [];
+    switch (d.push(o.displayName || o.name), c && d.push(`@default ${c}`), a.type) {
+      case "UUID":
+        r.add("UUID");
+        break;
+    }
+    i.addProperty({
+      name: a.name,
+      type: a.type,
+      hasQuestionToken: !0,
+      docs: d
+    }), n.push({
+      ...l,
+      hasExclamationToken: !1,
+      docs: d
+    });
+  });
+}, S = (n) => {
+  let e = "UUID";
+  switch (n.propertyMap.get("id").type) {
+    case u.uuid:
+      e = "UUID";
+      break;
+    case u.string:
+      e = "string";
+      break;
+    case u.integer:
+      e = "number";
+      break;
+  }
+  return e;
+}, L = ({
+  classProperties: n,
+  metadata: e,
+  rxdbNamedImports: t,
+  generator: r
+}) => {
+  Array.from(e.relationMap.values()).forEach((s) => {
+    switch (s.kind) {
+      // 处理一对一和多对一关系
+      // 这两种关系需要生成：
+      // 1. 关系可观察对象属性（name$）- 用于访问关联实体
+      // 2. 外键ID属性（nameId）- 存储关联实体的ID
+      case h.ONE_TO_ONE:
+      case h.MANY_TO_ONE:
+        {
+          const i = s.nullable ? `RelationEntityObservable<${s.mappedEntity} | null>` : `RelationEntityObservable<${s.mappedEntity}>`, o = s.displayName || s.name;
+          n.push({
+            name: s.name + "$",
+            // 关系属性名使用$后缀，表示可观察对象
+            type: i,
+            isReadonly: !0,
+            // 关系属性是只读的，通过set/remove方法修改
+            docs: [o]
+          });
+          const a = r.getMetadata(s.mappedEntity, s.mappedNamespace), c = S(a);
+          n.push({
+            name: s.name + "Id",
+            // 外键ID属性
+            type: c,
+            isReadonly: !0,
+            hasQuestionToken: s.nullable,
+            docs: [o + " id"]
+          }), t.add("RelationEntityObservable");
+        }
+        break;
+      // 处理一对多和多对多关系
+      // 这两种关系只需要生成关系可观察集合属性（name$）
+      // 不需要外键ID属性，因为外键存储在关联实体或中间表中
+      case h.ONE_TO_MANY:
+      case h.MANY_TO_MANY:
+        {
+          const i = s.displayName || s.name, o = `RelationEntitiesObservable<${s.mappedEntity}>`;
+          n.push({
+            name: s.name + "$",
+            // 关系集合属性名使用$后缀
+            isReadonly: !0,
+            // 关系属性是只读的，通过add/remove方法修改
+            type: o,
+            docs: [i]
+          }), t.add("RelationEntitiesObservable");
+        }
+        break;
+    }
+  });
+}, H = (n) => {
+  const e = [];
+  return Array.from(n.propertyMap.keys()).forEach((t) => {
+    const r = n.propertyMap.get(t);
+    let s = "";
+    switch (r.type) {
+      case u.uuid:
+        s = "UUID";
+        break;
+      case u.string:
+        s = "String";
+        break;
+      case u.number:
+      case u.integer:
+        s = "Number";
+        break;
+      case u.boolean:
+        s = "Boolean";
+        break;
+      case u.date:
+        s = "Date";
+        break;
+    }
+    if (s) {
+      s += "Rules";
+      const i = N(r);
+      e.push({
+        rule: s,
+        entity: n.name,
+        key: t,
+        valueType: i
+      });
+    }
+  }), e;
+}, _ = (n, e, t, r = [], s = [], i = []) => (t = t ?? e, H(e).forEach(({ rule: o, entity: a, key: c, valueType: l }) => {
+  i.length > 0 ? c = i.map((d) => d.key).join(".") + "." + c : l = void 0, s.push({
+    rule: o,
+    entity: a,
+    key: c,
+    valueType: l
+  });
+}), e.foreignKeyNames.forEach((o) => {
+  s.push({
+    rule: "UUIDRules",
+    entity: e.name,
+    key: o
+  });
+}), Array.from(e.relationMap.keys()).filter((o) => !r.includes(o)).forEach((o) => {
+  const a = e.relationMap.get(o);
+  if (!a)
+    throw new Error("relation is empty");
+  const c = [];
+  switch (a.kind) {
+    case h.ONE_TO_ONE:
+      break;
+    case h.ONE_TO_MANY:
+      c.push(a.mappedProperty);
+      break;
+    case h.MANY_TO_ONE:
+      break;
+    case h.MANY_TO_MANY:
+      c.push(a.mappedProperty);
+      break;
+  }
+  const l = n.getMetadata(a.mappedEntity, a.mappedNamespace);
+  if (!l)
+    throw new Error(`generator_entity_rules: metadata "${a.mappedEntity}" not found`);
+  if (i.find(($) => $.entity === e.name) || i.length && l === t) return;
+  const y = [...i, { key: o, entity: e.name }];
+  i.length < n.config.relationQueryDeep && _(n, l, t, c, s, y);
+}), s), M = (n, e) => n.map(({ rule: t, entity: r, key: s, valueType: i }) => (e.add(t), i ? s.includes(".") ? (e.add(`Relation${t}`), `Relation${t}<'${s}', ${i}>`) : `${t}<${r}, '${s}', ${i}>` : s.includes(".") ? (e.add(`Relation${t}`), `Relation${t}<'${s}'>`) : `${t}<${r}, '${s}'>`)), V = ({
+  classMethods: n,
+  rxdbNamedImports: e,
+  generator: t,
+  metadata: r,
+  file: s,
+  staticTypesInterface: i,
+  idType: o
+}) => {
+  const { name: a } = r, c = _(t, r), l = M(c, e), d = `
+  |` + c.map((f) => `'${f.key}'`).join(`
+  |`);
+  s.addTypeAlias({
+    name: `${a}Rule`,
+    type: Array.from(new Set(l)).join(`
+| `),
+    hasDeclareKeyword: !0,
+    docs: ["rule"]
+  }), s.addTypeAlias({
+    name: `${a}RuleGroup`,
+    type: `RuleGroupCustom<typeof ${a}, ${d},
+${a}Rule>`,
+    hasDeclareKeyword: !0,
+    docs: ["RuleGroupCustom"],
+    isExported: !0
+  });
+  const y = `${a}OrderByField`, $ = Array.from(r.propertyMap.keys());
+  s.addTypeAlias({
+    name: y,
+    type: $.map((f) => `"${f}"`).join(" | "),
+    hasDeclareKeyword: !0,
+    docs: ["OrderByField"]
+  });
+  const p = ({
+    method: f,
+    options: T,
+    returnType: E,
+    metHodDoc: P
+  }) => {
+    n.push({
+      name: f,
+      returnType: `Observable<${E}>`,
+      docs: [P || `${f} 查询`, "@param options 查询选项"],
+      parameters: [
+        {
+          name: "options",
+          type: T
+        }
+      ],
+      isStatic: !0
+    }), i.addProperty({
+      name: `${f}Options`,
+      type: T,
+      docs: ["查询选项"]
+    }), e.add(g(`${f}Options`));
+  };
+  p({
+    method: "get",
+    options: `${o}`,
+    returnType: a
+  });
+  const m = (f) => ({
+    method: f,
+    options: `${g(f)}Options<typeof ${a},${a}RuleGroup,${y}>`
+  });
+  p({
+    ...m("findOneOrFail"),
+    returnType: a
+  }), p({
+    ...m("find"),
+    returnType: `${a}[]`
+  }), p({
+    ...m("findOne"),
+    returnType: `${a} | undefined`
+  }), p({
+    ...m("findAll"),
+    returnType: `${a}[]`
+  }), p({
+    method: "count",
+    options: `${g("count")}Options<typeof ${a},${a}RuleGroup>`,
+    returnType: "number"
+  }), n.push({
+    name: "save",
+    returnType: `Promise<${a}>`,
+    docs: ["保存"]
+  }), n.push({
+    name: "remove",
+    returnType: `Promise<${a}>`,
+    docs: ["删除"]
+  }), n.push({
+    name: "reset",
+    returnType: "void",
+    docs: ["重置数据"]
+  });
+}, z = ({
+  metadata: n,
+  classMethods: e,
+  rxdbNamedImports: t,
+  generator: r,
+  file: s,
+  staticTypesInterface: i
+}) => {
+  const { name: o } = n, a = _(r, n).filter(
+    (p) => p.key.startsWith("children.") && p.key !== "children.id"
+  ), c = M(a, t), l = a.map((p) => `'${p.key}'`).join(" | ");
+  s.addTypeAlias({
+    name: `${o}TreeRule`,
+    type: Array.from(new Set(c)).join(`
+| `),
+    hasDeclareKeyword: !0,
+    docs: ["TreeRule"]
+  }), s.addTypeAlias({
+    name: `${o}TreeRuleGroup`,
+    type: `RuleGroupCustom<typeof ${o}, ${l}, ${o}TreeRule>`,
+    hasDeclareKeyword: !0,
+    docs: ["TreeRuleGroup"],
+    isExported: !0
+  });
+  const d = ({
+    method: p,
+    options: m,
+    returnType: f,
+    metHodDoc: T,
+    optionsIsRequired: E
+  }) => {
+    e.push({
+      name: p,
+      returnType: `Observable<${f}>`,
+      docs: [T || `${p} 查询`, "@param options 查询选项"],
+      parameters: [
+        {
+          name: "options",
+          type: m,
+          hasQuestionToken: !E
+        }
+      ],
+      isStatic: !0
+    }), i.addProperty({
+      name: "entity",
+      type: `${o}`,
+      docs: ["查询的实体"]
+    }), i.addProperty({
+      name: `${p}Options`,
+      type: m,
+      docs: ["查询选项"]
+    });
+  };
+  t.add(g("FindTreeRootOptions")), t.add(g("FindTreeOptions"));
+  const y = `FindTreeRootOptions<typeof ${o},${o}TreeRuleGroup>`;
+  d({
+    method: "findRoot",
+    options: y,
+    returnType: `${o}[]`,
+    metHodDoc: "查询子孙实体",
+    optionsIsRequired: !1
+  }), d({
+    method: "countRoot",
+    options: y,
+    returnType: "number",
+    metHodDoc: "查询子孙实体数量"
+  });
+  const $ = `FindTreeOptions<typeof ${o},${o}TreeRuleGroup>`;
+  d({
+    method: "findDescendants",
+    options: $,
+    returnType: `${o}[]`,
+    metHodDoc: "查询子孙实体"
+  }), d({
+    method: "countDescendants",
+    options: $,
+    returnType: "number",
+    metHodDoc: "查询子孙实体数量"
+  }), d({
+    method: "findAncestors",
+    options: $,
+    returnType: `${o}[]`,
+    metHodDoc: "查询祖先实体"
+  }), d({
+    method: "countAncestors",
+    options: $,
+    returnType: "number",
+    metHodDoc: "查询祖先实体数量"
+  });
+}, q = (n, e, t) => {
+  const r = /* @__PURE__ */ new Set(), { name: s } = e, i = e.extends[0] || "", o = ["IEntityStaticType"];
+  i.includes("TreeAdjacencyListEntityBase") ? o.push("ITreeEntity") : i.includes("EntityBase") && o.push("IEntity"), r.add(i);
+  const a = t.addClass({
+    name: s,
+    isExported: !0,
+    extends: i,
+    implements: o.sort(),
+    decorators: [],
+    hasDeclareKeyword: !0
+  });
+  a.addJsDoc(`${e.displayName}`);
+  const c = [];
+  c.push({
+    type: `${s}StaticTypes`,
+    name: "[ENTITY_STATIC_TYPES]",
+    isStatic: !1
+  }), r.add("ENTITY_STATIC_TYPES");
+  const l = t.addInterface({
+    name: `${s}StaticTypes`,
+    docs: ["静态类型"],
+    isExported: !0
+  }), d = S(e);
+  l.addProperty({
+    name: "idType",
+    type: d,
+    docs: ["id 类型"]
+  });
+  const y = [];
+  Q({
+    classProperties: c,
+    file: t,
+    metadata: e,
+    rxdbNamedImports: r
+  }), L({
+    classProperties: c,
+    metadata: e,
+    rxdbNamedImports: r,
+    generator: n
+  }), V({
+    classMethods: y,
+    file: t,
+    generator: n,
+    metadata: e,
+    rxdbNamedImports: r,
+    staticTypesInterface: l,
+    idType: d
+  }), e.repository === "TreeRepository" && z({
+    classMethods: y,
+    metadata: e,
+    file: t,
+    generator: n,
+    rxdbNamedImports: r,
+    staticTypesInterface: l
+  }), a.addProperties(
+    c.sort((p, m) => p.isReadonly && !m.isReadonly ? -1 : !p.isReadonly && m.isReadonly ? 1 : p.name.localeCompare(m.name))
+  ), a.addConstructor({
+    parameters: [
+      {
+        name: "initData",
+        type: `${s}InitData`,
+        hasQuestionToken: !0
+      }
+    ],
+    docs: ["初始化数据", "@param initData 初始化数据"]
+  });
+  const $ = K(y, (p) => p.name).sort(
+    (p, m) => p.isStatic && !m.isStatic ? -1 : !p.isStatic && m.isStatic ? 1 : p.name.localeCompare(m.name)
+  );
+  return a.addMethods($), {
+    rxdbNamedImports: r
+  };
+};
+var w = /* @__PURE__ */ ((n) => (n.Var = "var", n.Let = "let", n.Const = "const", n))(w || {});
+class W {
+  files = /* @__PURE__ */ new Map();
+  createSourceFile(e, t) {
+    const r = new O(e);
+    return t && r.setContent(t), this.files.set(e, r), r;
+  }
+  addSourceFileAtPath(e) {
+    const t = new O(e);
+    return this.files.set(e, t), t;
+  }
+  getSourceFiles() {
+    return Array.from(this.files.values());
+  }
+}
+class O {
+  filePath;
+  classes = [];
+  interfaces = [];
+  modules = [];
+  typeAliases = [];
+  imports = [];
+  variables = [];
+  fileContent = "";
+  constructor(e) {
+    this.filePath = e;
+  }
+  addClass(e) {
+    const t = new Z(e);
+    return this.classes.push(t), t;
+  }
+  addInterface(e) {
+    let t = this.interfaces.find((r) => r.name === e.name);
+    return t || (t = new X(e), this.interfaces.push(t)), t;
+  }
+  addModule(e) {
+    return this.modules.push(e), {
+      addInterface: (t) => {
+        const r = this.modules[this.modules.length - 1];
+        return r.interfaces || (r.interfaces = []), r.interfaces.push(t), {
+          addProperty: (s) => {
+            const i = this.modules[this.modules.length - 1], o = i.interfaces[i.interfaces.length - 1];
+            o.properties || (o.properties = []), o.properties.push(s);
+          }
+        };
+      }
+    };
+  }
+  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() {
+    if (this.fileContent)
+      return this.fileContent;
+    let e = "";
+    return this.imports.forEach((t) => {
+      t.namedImports && t.namedImports.length > 0 && (e += `import { ${t.namedImports.join(", ")} } from '${t.moduleSpecifier}';
+`);
+    }), this.imports.length > 0 && (e += `
+`), this.typeAliases.forEach((t) => {
+      t.docs && t.docs.length > 0 && (e += this.renderJsDoc(t.docs, 0)), t.isExported && (e += "export "), t.hasDeclareKeyword && (e += "declare "), e += `type ${t.name} = ${t.type};
+
+`;
+    }), this.modules.forEach((t) => {
+      t.docs && t.docs.length > 0 && (e += this.renderJsDoc(t.docs, 0)), t.hasDeclareKeyword && (e += "declare "), e += `module ${t.name} {
+`, t.interfaces && t.interfaces.length > 0 && t.interfaces.forEach((r) => {
+        e += this.renderInterfaceBlock(r, 2, !1);
+      }), e += `}
+
+`;
+    }), this.interfaces.forEach((t) => {
+      e += this.renderInterfaceBlock(t, 0, !0) + `
+`;
+    }), this.classes.forEach((t) => {
+      const r = t.getName();
+      if (r) {
+        t.jsDoc && t.jsDoc.length > 0 ? e += this.renderJsDoc(t.jsDoc) : e += this.renderJsDoc([r]), e += `export declare class ${r}`;
+        const s = t.getBaseClass();
+        if (s) {
+          const o = s.getName();
+          o && (e += ` extends ${o}`);
+        }
+        const i = t.getImplements();
+        if (i.length > 0 && (e += ` implements ${i.map((o) => o.getText()).join(", ")}`), e += ` {
+`, t.properties && t.properties.length > 0 && t.properties.forEach((o) => {
+          e += this.renderProperty(o, 2, !1);
+        }), t.constructorData) {
+          const o = t.constructorData;
+          o.docs && o.docs.length > 0 && (e += this.renderJsDoc(o.docs, 2)), e += `  constructor(${this.renderParameterList(o.parameters)});
+`;
+        }
+        t.methods && t.methods.length > 0 && t.methods.forEach((o) => {
+          o.docs && o.docs.length > 0 && (e += this.renderJsDoc(o.docs, 2)), e += "  ", o.isStatic && (e += "static "), e += `${o.name}(${this.renderParameterList(o.parameters)})`, o.returnType && (e += `: ${o.returnType}`), e += `;
+`;
+        }), e += `}
+
+`;
+      }
+    }), this.variables.forEach((t) => {
+      t.isExported && (e += "export "), t.hasDeclareKeyword && (e += "declare "), e += `${t.declarationKind} ${this.renderVariableDeclarationList(t.declarations)};
+
+`;
+    }), e;
+  }
+  setContent(e) {
+    this.fileContent = e;
+  }
+  async save() {
+    console.log(`SourceFile ${this.filePath} saved`);
+  }
+  saveSync() {
+    console.log(`SourceFile ${this.filePath} saved synchronously`);
+  }
+  // Helpers: rendering
+  // 通用参数渲染函数
+  renderParameter(e, t) {
+    let r = "";
+    return t > 0 && (r += ", "), r += e.name, e.hasQuestionToken && (r += "?"), e.type && (r += `: ${e.type}`), r;
+  }
+  // 通用参数列表渲染函数
+  renderParameterList(e) {
+    return !e || e.length === 0 ? "" : e.map((t, r) => this.renderParameter(t, r)).join("");
+  }
+  // 通用变量声明渲染函数
+  renderVariableDeclaration(e, t) {
+    let r = "";
+    return t > 0 && (r += ", "), r += e.name, e.type && (r += `: ${e.type}`), e.initializer && (r += ` = ${e.initializer}`), r;
+  }
+  // 通用变量声明列表渲染函数
+  renderVariableDeclarationList(e) {
+    return !e || e.length === 0 ? "" : e.map((t, r) => this.renderVariableDeclaration(t, r)).join("");
+  }
+  // 通用JSDoc渲染函数
+  renderJsDoc(e, t = 0) {
+    if (!e || e.length === 0) return "";
+    const r = " ".repeat(t);
+    return `${r}/**
+${r} * ${e.join(`
+${r} * `)}
+${r} */
+`;
+  }
+  // 通用属性渲染函数
+  renderProperty(e, t, r = !0) {
+    let s = "";
+    return e.docs && e.docs.length > 0 && (s += this.renderJsDoc(e.docs, t)), s += " ".repeat(t), e.isStatic && (s += "static "), s += e.name, e.hasQuestionToken && (s += "?"), e.type && (s += `: ${e.type}`), !r && e.initializer && (s += ` = ${e.initializer}`), s += `;
+`, s;
+  }
+  // 接口属性渲染（调用通用函数）
+  renderInterfaceProperty(e, t) {
+    return this.renderProperty(e, t);
+  }
+  renderInterfaceBlock(e, t, r) {
+    const s = " ".repeat(t);
+    let i = "";
+    return e.docs && e.docs.length > 0 && (i += this.renderJsDoc(e.docs, t)), r && e.isExported ? i += `${s}export ` : i += s, i += `interface ${e.name}`, e.extends && e.extends.length > 0 && (i += ` extends ${e.extends.join(", ")}`), i += ` {
+`, e.properties && e.properties.length > 0 && e.properties.forEach((o) => {
+      i += this.renderInterfaceProperty(o, t + 2);
+    }), i += `${s}}
+`, i;
+  }
+}
+class X {
+  name;
+  extends;
+  docs;
+  isExported;
+  properties = [];
+  constructor(e) {
+    Object.assign(this, e);
+  }
+  addProperty(e) {
+    this.properties.some((t) => t.name === e.name) || this.properties.push(e);
+  }
+}
+class Z {
+  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() {
+    return this.structure.extends ? {
+      getName: () => this.structure.extends,
+      getText: () => this.structure.extends,
+      getDecorators: () => [],
+      getImplements: () => [],
+      getBaseClass: () => {
+      }
+    } : void 0;
+  }
+  getImplements() {
+    return (this.structure.implements || []).map((e) => ({
+      getName: () => e,
+      getText: () => e,
+      getDecorators: () => [],
+      getImplements: () => [],
+      getBaseClass: () => {
+      }
+    }));
+  }
+  getText() {
+    return this.structure.name || "";
+  }
+}
+const ee = (n) => {
+  const { project: e, metadataSet: t } = n, r = e.createSourceFile("index.d.ts"), i = r.addModule({
+    name: '"@aiao/rxdb"',
+    hasDeclareKeyword: !0,
+    docs: ["rxdb"]
+  }).addInterface({
+    name: "RxDB",
+    docs: ["RxDB"]
+  }), o = /* @__PURE__ */ new Set([
+    "UUID",
+    "EntityType",
+    "RuleGroupCustom",
+    "IEntityStaticType",
+    "ITreeEntity"
+  ]);
+  t.forEach((a) => {
+    const { rxdbNamedImports: c } = q(n, a, r);
+    c.forEach((y) => o.add(y));
+    const { name: l } = a, d = l;
+    a.namespace && a.namespace !== "public" ? i.addProperty({
+      name: a.namespace,
+      type: `{
+${d}: typeof ${d};
+}`,
+      docs: [a.displayName]
+    }) : i.addProperty({
+      name: d,
+      type: `typeof ${d}`,
+      docs: [a.displayName]
+    });
+  }), r.addImportDeclaration({
+    namedImports: Array.from(o).filter(Boolean).sort(),
+    isTypeOnly: !0,
+    moduleSpecifier: "@aiao/rxdb"
+  }), r.addImportDeclaration({
+    namedImports: ["Observable"],
+    isTypeOnly: !0,
+    moduleSpecifier: "rxjs"
+  }), r.addVariableStatement({
+    declarationKind: w.Const,
+    hasDeclareKeyword: !0,
+    isExported: !0,
+    declarations: [
+      {
+        name: "ENTITIES",
+        type: "EntityType[]"
+      }
+    ]
+  });
+}, te = (n) => {
+  const { project: e, metadataSet: t } = n;
+  let r = "";
+  const s = /* @__PURE__ */ new Set(["Entity", "__decorateClass"]), i = (a) => {
+    for (const c of t.values())
+      if (c.relations && c.namespace === a.mappedNamespace && c.name === a.mappedEntity)
+        return c.relations.find((l) => l.kind === h.MANY_TO_MANY && l.mappedProperty === a.name);
+  };
+  t.forEach((a) => {
+    a.relations.forEach((c) => {
+      if (c.kind === h.MANY_TO_MANY && !i(c))
+        throw new Error("mapped relation not found");
+    });
+  }), t.forEach((a) => {
+    const c = a.extends[0], { name: l } = a, d = l, y = J(a);
+    c && s.add(c), a.properties.length && s.add("PropertyType"), a.relations.length && s.add("RelationKind"), r += `
+let ${d} = class ${c ? "extends " + c : ""} {};`, r += `
+${d} = __decorateClass(
+[
+  Entity(${y})
+],
+${d}
+);`;
+  }), r = `import { ${Array.from(s).sort().join(", ")} } from '@aiao/rxdb';` + r;
+  const o = Array.from(t.values()).map((a) => a.name).sort().join(", ");
+  r += `
+const ENTITIES = [ ${o} ];`, r += `
+export { ENTITIES, ${o} };`, e.createSourceFile("index.js", r);
+}, R = (n, e = "public") => `${e}_${n}`;
+class ne {
+  metadataMap = /* @__PURE__ */ new Map();
+  project;
+  metadataSet = /* @__PURE__ */ new Set();
+  config = {
+    relationQueryDeep: 3
+  };
+  constructor(e) {
+    Object.assign(this.config, e), this.config.relationQueryDeep < 1 && (this.config.relationQueryDeep = 1);
+  }
+  /**
+   * 添加实体配置
+   * @param value 实体
+   */
+  addEntity(e, t) {
+    let r;
+    if (Y(e))
+      r = A(e);
+    else {
+      const s = e;
+      t = t || s.extends?.length && k(s.extends[0]) || [], r = b(e, t);
+    }
+    this.metadataSet.add(r), this.metadataMap.set(`${r.namespace}_${r.name}`, r);
+  }
+  getMetadata(e, t) {
+    return this.metadataMap.get(R(e, t));
+  }
+  /**
+   * 执行生成器
+   */
+  exec() {
+    this.project = new W(), Object.values(C).forEach(
+      (e) => e.forEach((t) => {
+        const r = b(t);
+        this.metadataMap.set(R(t.name, t.namespace), r);
+      })
+    ), ee(this), te(this);
+  }
+  getSourceFiles() {
+    return this.project.getSourceFiles();
+  }
+}
+export {
+  ne as R
+};