@aiao/rxdb-client-generator 0.0.2 → 0.0.3

package/build_rxdb_client_lib-BPIw_COZ.js

@@ -0,0 +1,961 @@
+import { mkdirSync as k, writeFileSync as P } from "node:fs";
+import { resolve as A, join as F, dirname as M } from "node:path";
+import { Project as w, Node as T } from "ts-morph";
+import { PropertyType as d, RelationKind as u, getEntityMetadata as C, transitionMetadata as E, ENTITY_METADATA_MAP as I, getEntityMetadataOptions as v } from "@aiao/rxdb";
+import { glob as j } from "glob";
+import { isNil as B, omit as K, isObject as G, isArray as Q, isFunction as U } from "@aiao/utils";
+const Y = (s) => {
+  const e = D(s), t = !!s.nullable;
+  let r = !0;
+  !t && Object.hasOwn(s, "default") && (r = !1);
+  const o = {
+    type: e,
+    name: s.name,
+    hasQuestionToken: t,
+    hasExclamationToken: r,
+    isReadonly: s.readonly
+  };
+  return B(s.default) || (o.initializer = J(s)), o;
+}, D = (s) => {
+  let e = "any";
+  switch (s.type) {
+    case d.uuid:
+      e = "UUID";
+      break;
+    case d.string:
+      e = "string";
+      break;
+    case d.number:
+      e = "number";
+      break;
+    case d.boolean:
+      e = "boolean";
+      break;
+    case d.date:
+      e = "Date";
+      break;
+  }
+  return s.nullable && (e += " | null"), e;
+}, J = (s) => {
+  switch (s.type) {
+    case d.string:
+      return `'${String(s.default)}'`;
+    case d.date:
+      return `new Date(${s.default.getTime()})`;
+    default:
+      return `${String(s.default)}`;
+  }
+}, y = (s, e = /* @__PURE__ */ new Set()) => {
+  if (G(s))
+    for (const t in s)
+      e.add(t), Object.prototype.hasOwnProperty.call(s, t) && y(Reflect.get(s, t), e);
+  else if (Q(s))
+    for (const t of s)
+      y(t, e);
+  return e;
+}, _ = /* @__PURE__ */ new Map();
+Object.keys(d).forEach((s) => {
+  const e = d[s];
+  _.set(e, s);
+});
+const R = /* @__PURE__ */ new Map();
+Object.keys(u).forEach((s) => {
+  const e = u[s];
+  R.set(e, s);
+});
+function L(s) {
+  const e = K(s, ["propertyMap", "relationMap", "indexMap"]), t = y(e);
+  let r = JSON.stringify(e, null, 2);
+  return new Set(s.properties.map((n) => n.type)).forEach((n) => {
+    const a = _.get(n);
+    r = r.replaceAll(`"type": "${n}"`, `"type": PropertyType.${a}`);
+  }), s.relations && new Set(s.relations.map((a) => a.kind)).forEach((a) => {
+    const i = R.get(a);
+    r = r.replaceAll(`"kind": "${a}"`, `"kind": RelationKind.${i}`);
+  }), t.forEach((n) => {
+    n.includes("-") || n.includes(" ") || (r = r.replaceAll(`"${n}":`, `${n}:`));
+  }), r;
+}
+function V(s) {
+  return s.startsWith("_") || s === "id" || s === "createdAt" || s === "updatedAt" || s === "removedAt";
+}
+const z = ({
+  classProperties: s,
+  metadata: e,
+  file: t,
+  rxdbNamedImports: r
+}) => {
+  const { name: o } = e, n = t.addInterface({
+    name: `${o}InitData`,
+    isExported: !0,
+    docs: ["初始化数据"]
+  });
+  e.properties.values().filter((a) => V(a.name) === !1).forEach((a) => {
+    const i = Y(a), { initializer: c, ...p } = i;
+    let l = a.displayName || a.name;
+    switch (c && (l += `
+@default ${c}`), i.type) {
+      case "UUID":
+        r.add("UUID");
+        break;
+    }
+    n.addProperty({
+      name: i.name,
+      type: i.type,
+      hasQuestionToken: !0,
+      docs: [l]
+    }), s.push({
+      ...p,
+      hasExclamationToken: !1,
+      docs: [l]
+    });
+  });
+}, W = ({
+  classProperties: s,
+  metadata: e,
+  rxdbNamedImports: t
+}) => {
+  e.relationMap.values().forEach((r) => {
+    switch (r.kind) {
+      // 处理一对一和多对一关系
+      // 这两种关系需要生成：
+      // 1. 关系可观察对象属性（name$）- 用于访问关联实体
+      // 2. 外键ID属性（nameId）- 存储关联实体的ID
+      case u.ONE_TO_ONE:
+      case u.MANY_TO_ONE:
+        {
+          const o = r.nullable ? `RelationEntityObservable<${r.mappedEntity} | null>` : `RelationEntityObservable<${r.mappedEntity}>`, n = r.displayName || r.name;
+          s.push({
+            name: r.name + "$",
+            // 关系属性名使用$后缀，表示可观察对象
+            type: o,
+            isReadonly: !0,
+            // 关系属性是只读的，通过set/remove方法修改
+            docs: [n]
+          }), s.push({
+            name: r.name + "Id",
+            // 外键ID属性
+            type: "UUID",
+            isReadonly: !0,
+            docs: [n + " id"]
+          }), t.add("RelationEntityObservable");
+        }
+        break;
+      // 处理一对多和多对多关系
+      // 这两种关系只需要生成关系可观察集合属性（name$）
+      // 不需要外键ID属性，因为外键存储在关联实体或中间表中
+      case u.ONE_TO_MANY:
+      case u.MANY_TO_MANY:
+        {
+          const o = r.displayName || r.name, n = `RelationEntitiesObservable<${r.mappedEntity}>`;
+          s.push({
+            name: r.name + "$",
+            // 关系集合属性名使用$后缀
+            isReadonly: !0,
+            // 关系属性是只读的，通过add/remove方法修改
+            type: n,
+            docs: [o]
+          }), t.add("RelationEntitiesObservable");
+        }
+        break;
+    }
+  });
+}, q = (s) => Array.from(s.propertyMap.keys()).map((e) => {
+  const t = s.propertyMap.get(e);
+  let r = "";
+  switch (t.type) {
+    case d.uuid:
+      r = "UUID";
+      break;
+    case d.string:
+      r = "String";
+      break;
+    case d.number:
+    case d.integer:
+      r = "Number";
+      break;
+    case d.boolean:
+      r = "Boolean";
+      break;
+    case d.date:
+      r = "Date";
+      break;
+    default:
+      throw new Error("Unknown property type: " + t.type);
+  }
+  if (!r) throw new Error("ruleName is empty");
+  r += "Rules";
+  const o = D(t);
+  return {
+    rule: r,
+    entity: s.name,
+    key: e,
+    valueType: o
+  };
+}), $ = (s, e, t, r = [], o = [], n = []) => (t = t ?? e, q(e).forEach(({ rule: a, entity: i, key: c, valueType: p }) => {
+  n.length > 0 ? c = n.map((l) => l.key).join(".") + "." + c : p = void 0, o.push({
+    rule: a,
+    entity: i,
+    key: c,
+    valueType: p
+  });
+}), e.foreignKeyNames.forEach((a) => {
+  o.push({
+    rule: "UUIDRules",
+    entity: e.name,
+    key: a
+  });
+}), e.relationMap.keys().filter((a) => !r.includes(a)).forEach((a) => {
+  const i = e.relationMap.get(a);
+  if (!i)
+    throw new Error("relation is empty");
+  const c = [];
+  switch (i.kind) {
+    case u.ONE_TO_ONE:
+      break;
+    case u.ONE_TO_MANY:
+      c.push(i.mappedProperty);
+      break;
+    case u.MANY_TO_ONE:
+      break;
+    case u.MANY_TO_MANY:
+      c.push(i.mappedProperty);
+      break;
+  }
+  const p = s.getMetadata(i.mappedEntity, i.mappedNamespace);
+  if (!p)
+    throw new Error(`generator_entity_rules: metadata "${i.mappedEntity}" not found`);
+  if (n.find((g) => g.entity === e.name) || n.length && p === t) return;
+  const m = [...n, { key: a, entity: e.name }];
+  n.length < s.config.relationQueryDeep && $(s, p, t, c, o, m);
+}), o), S = (s, e) => s.map(({ rule: t, entity: r, key: o, valueType: n }) => (e.add(t), n ? (n === "UUID" && e.add("UUID"), o.includes(".") ? (e.add(`Relation${t}`), `Relation${t}<'${o}', ${n}>`) : `${t}<${r}, '${o}', ${n}>`) : o.includes(".") ? (e.add(`Relation${t}`), `Relation${t}<'${o}'>`) : `${t}<${r}, '${o}'>`)), H = ({
+  classMethods: s,
+  rxdbNamedImports: e,
+  generator: t,
+  metadata: r,
+  file: o
+}) => {
+  const { name: n } = r, a = $(t, r), i = S(a, e);
+  o.addTypeAlias({
+    name: `${n}Rule`,
+    type: `
+| ` + Array.from(new Set(i)).join(`
+| `),
+    hasDeclareKeyword: !0,
+    docs: ["rule"]
+  }), o.addTypeAlias({
+    name: `${n}RuleGroup`,
+    type: `RuleGroup<${n}, keyof ${n}, ${n}Rule>`,
+    hasDeclareKeyword: !0,
+    docs: ["RuleGroup"],
+    isExported: !0
+  });
+  const c = `${n}OrderByField`, p = Array.from(r.propertyMap.keys());
+  o.addTypeAlias({
+    name: c,
+    type: p.map((l) => `"${l}"`).join(" | "),
+    hasDeclareKeyword: !0,
+    docs: ["OrderByField"]
+  }), s.push({
+    name: "get",
+    returnType: `Observable<${n}>`,
+    docs: ["查询", "@param id 实体的 id", "@param options 查询选项"],
+    parameters: [
+      {
+        name: "id",
+        type: "string"
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: "GetOptions"
+      }
+    ],
+    isStatic: !0
+  }), e.add("GetOptions"), s.push({
+    name: "findOneOrFail",
+    returnType: `Observable<${n}>`,
+    docs: ["查询", "@param where 查询条件", "@param options 查询选项"],
+    parameters: [
+      {
+        name: "where",
+        type: `${n}RuleGroup`
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: `FindOneOrFailOptions<${c}>`
+      }
+    ],
+    isStatic: !0
+  }), e.add("FindOneOrFailOptions"), s.push({
+    name: "find",
+    returnType: `Observable<${n}[]>`,
+    docs: ["查询", "@param where 查询条件", "@param options 查询选项"],
+    parameters: [
+      {
+        name: "where",
+        type: `${n}RuleGroup`
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: `FindOptions<${c}>`
+      }
+    ],
+    isStatic: !0
+  }), e.add("FindOptions"), s.push({
+    name: "findOne",
+    returnType: `Observable<${n} | undefined>`,
+    docs: ["查询", "@param where 查询条件", "@param options 查询选项"],
+    parameters: [
+      {
+        name: "where",
+        type: `${n}RuleGroup`
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: `FindOneOptions<${c}>`
+      }
+    ],
+    isStatic: !0
+  }), e.add("FindOneOptions"), s.push({
+    name: "findAll",
+    returnType: `Observable<${n}[]>`,
+    docs: ["查询", "@param where 查询条件", "@param options 查询选项"],
+    parameters: [
+      {
+        name: "where",
+        type: `${n}RuleGroup`
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: `FindAllOptions<${c}>`
+      }
+    ],
+    isStatic: !0
+  }), e.add("FindAllOptions"), s.push({
+    name: "findByCursor",
+    returnType: `Observable<${n}[]>`,
+    docs: ["查询", "@param where 查询条件", "@param options 查询选项"],
+    parameters: [
+      {
+        name: "where",
+        type: `${n}RuleGroup`
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: `FindByCursorOptions<${c}>`
+      }
+    ],
+    isStatic: !0
+  }), e.add("FindByCursorOptions"), s.push({
+    name: "count",
+    returnType: "Observable<number>",
+    docs: ["查询", "@param where 查询条件", "@param options 查询选项"],
+    parameters: [
+      {
+        name: "where",
+        type: `${n}RuleGroup`
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: "CountOptions"
+      }
+    ],
+    isStatic: !0
+  }), e.add("CountOptions"), s.push({
+    name: "save",
+    returnType: `Promise<${n}>`,
+    docs: ["保存"]
+  }), s.push({
+    name: "remove",
+    returnType: `Promise<${n}>`,
+    docs: ["删除"]
+  });
+}, X = ({
+  metadata: s,
+  classMethods: e,
+  rxdbNamedImports: t,
+  generator: r,
+  file: o
+}) => {
+  const { name: n } = s, a = $(r, s).filter(
+    (c) => c.key.startsWith("children.") && c.key !== "children.id"
+  ), i = S(a, t);
+  o.addTypeAlias({
+    name: `${n}TreeRule`,
+    type: `
+| ` + Array.from(new Set(i)).join(`
+| `),
+    hasDeclareKeyword: !0,
+    docs: ["TreeRule"]
+  }), o.addTypeAlias({
+    name: `${n}TreeRuleGroup`,
+    type: `RuleGroup<${n}, keyof ${n}, ${n}TreeRule>`,
+    hasDeclareKeyword: !0,
+    docs: ["TreeRuleGroup"],
+    isExported: !0
+  }), e.push({
+    name: "findDescendants",
+    returnType: `Observable<${n}[]>`,
+    docs: ["查询子孙实体", "@param options 查询选项"],
+    parameters: [
+      {
+        name: "entity",
+        type: `${n}`
+      },
+      {
+        name: "where",
+        type: `${n}TreeRuleGroup`
+      },
+      {
+        name: "options",
+        type: "FindTreeOptions",
+        hasQuestionToken: !0
+      }
+    ],
+    isStatic: !0
+  }), e.push({
+    name: "countDescendants",
+    returnType: "Observable<number>",
+    docs: ["查询子孙实体数量", "@param options 查询选项"],
+    parameters: [
+      {
+        name: "entity",
+        type: `${n}`
+      },
+      {
+        name: "where",
+        type: `${n}TreeRuleGroup`
+      },
+      {
+        name: "options",
+        type: "FindTreeOptions",
+        hasQuestionToken: !0
+      }
+    ],
+    isStatic: !0
+  }), e.push({
+    name: "findAncestors",
+    returnType: `Observable<${n}[]>`,
+    docs: ["查询祖先实体", "@param options 查询选项"],
+    parameters: [
+      {
+        name: "entity",
+        type: `${n}`
+      },
+      {
+        name: "where",
+        type: `${n}TreeRuleGroup`
+      },
+      {
+        name: "options",
+        type: "FindTreeOptions",
+        hasQuestionToken: !0
+      }
+    ],
+    isStatic: !0
+  }), e.push({
+    name: "countAncestors",
+    returnType: "Observable<number>",
+    docs: ["查询祖先实体数量", "@param options 查询选项"],
+    parameters: [
+      {
+        name: "entity",
+        type: `${n}`
+      },
+      {
+        name: "where",
+        type: `${n}TreeRuleGroup`
+      },
+      {
+        name: "options",
+        type: "FindTreeOptions",
+        hasQuestionToken: !0
+      }
+    ],
+    isStatic: !0
+  }), t.add("FindTreeOptions");
+}, Z = (s, e, t) => {
+  const r = /* @__PURE__ */ new Set(), { name: o } = e, n = e.extends[0];
+  r.add(n);
+  const a = t.addClass({
+    name: o,
+    isExported: !0,
+    extends: n,
+    decorators: [],
+    hasDeclareKeyword: !0
+  });
+  a.addJsDoc(`${e.displayName}`);
+  const i = [], c = [];
+  return z({
+    classProperties: i,
+    file: t,
+    metadata: e,
+    rxdbNamedImports: r
+  }), W({
+    classProperties: i,
+    metadata: e,
+    rxdbNamedImports: r
+  }), H({
+    classMethods: c,
+    file: t,
+    generator: s,
+    metadata: e,
+    rxdbNamedImports: r
+  }), e.repository === "TreeRepository" && X({
+    classMethods: c,
+    metadata: e,
+    file: t,
+    generator: s,
+    rxdbNamedImports: r
+  }), a.addProperties(
+    i.sort((p, l) => p.isReadonly && !l.isReadonly ? -1 : !p.isReadonly && l.isReadonly ? 1 : p.name.localeCompare(l.name))
+  ), a.addConstructor({
+    parameters: [
+      {
+        name: "initData",
+        type: `${o}InitData`,
+        hasQuestionToken: !0
+      }
+    ],
+    docs: ["初始化数据", "@param initData 初始化数据"]
+  }), a.addMethods(
+    c.sort((p, l) => p.isStatic && !l.isStatic ? -1 : !p.isStatic && l.isStatic ? 1 : p.name.localeCompare(l.name))
+  ), {
+    rxdbNamedImports: r
+  };
+};
+var x = /* @__PURE__ */ ((s) => (s.Var = "var", s.Let = "let", s.Const = "const", s))(x || {});
+class ee {
+  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 te(e);
+    return this.classes.push(t), t;
+  }
+  addInterface(e) {
+    return this.interfaces.push(e), e.properties = e.properties || [], {
+      addProperty: (t) => {
+        e.properties.push(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: (o) => {
+            const n = this.modules[this.modules.length - 1], a = n.interfaces[n.interfaces.length - 1];
+            a.properties || (a.properties = []), a.properties.push(o);
+          }
+        };
+      }
+    };
+  }
+  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, !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, !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 o = t.getBaseClass();
+        if (o) {
+          const a = o.getName();
+          a && (e += ` extends ${a}`);
+        }
+        const n = t.getImplements();
+        if (n.length > 0 && (e += ` implements ${n.map((a) => a.getText()).join(", ")}`), e += ` {
+`, t.properties && t.properties.length > 0 && t.properties.forEach((a) => {
+          e += this.renderProperty(a, 2, !1);
+        }), t.constructorData) {
+          const a = t.constructorData;
+          a.docs && a.docs.length > 0 && (e += this.renderJsDoc(a.docs, 2)), e += `  constructor(${this.renderParameterList(a.parameters)});
+`;
+        }
+        t.methods && t.methods.length > 0 && t.methods.forEach((a) => {
+          a.docs && a.docs.length > 0 && (e += this.renderJsDoc(a.docs, 2)), e += "  ", a.isStatic && (e += "static "), e += `${a.name}(${this.renderParameterList(a.parameters)})`, a.returnType && (e += `: ${a.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, r = !1) {
+    if (!e || e.length === 0) return "";
+    const o = " ".repeat(t);
+    return r ? `${o}/** ${e.join(`
+`)} */
+` : `${o}/**
+${o} * ${e.join(`
+${o} * `)}
+${o} */
+`;
+  }
+  // 通用属性渲染函数
+  renderProperty(e, t, r = !0) {
+    const o = " ".repeat(t);
+    let n = "";
+    return e.docs && e.docs.length > 0 && (n += this.renderJsDoc(e.docs, t, !0)), n += `${o}${e.name}`, e.hasQuestionToken && (n += "?"), e.type && (n += `: ${e.type}`), !r && e.initializer && (n += ` = ${e.initializer}`), n += `;
+`, n;
+  }
+  // 接口属性渲染（调用通用函数）
+  renderInterfaceProperty(e, t) {
+    return this.renderProperty(e, t, !0);
+  }
+  renderInterfaceBlock(e, t, r) {
+    const o = " ".repeat(t);
+    let n = "";
+    return e.docs && e.docs.length > 0 && (n += this.renderJsDoc(e.docs, t, !0)), r && e.isExported ? n += `${o}export ` : n += o, n += `interface ${e.name}`, e.extends && e.extends.length > 0 && (n += ` extends ${e.extends.join(", ")}`), n += ` {
+`, e.properties && e.properties.length > 0 && e.properties.forEach((a) => {
+      n += this.renderInterfaceProperty(a, t + 2);
+    }), n += `${o}}
+`, n;
+  }
+}
+class te {
+  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 re = (s) => {
+  const { project: e, metadataSet: t } = s, r = e.createSourceFile("index.d.ts"), n = r.addModule({
+    name: '"@aiao/rxdb"',
+    hasDeclareKeyword: !0,
+    docs: ["rxdb"]
+  }).addInterface({
+    name: "RxDB",
+    docs: ["RxDB"]
+  }), a = /* @__PURE__ */ new Set(["EntityType", "RuleGroup"]);
+  t.forEach((i) => {
+    const { rxdbNamedImports: c } = Z(s, i, r);
+    c.forEach((m) => a.add(m));
+    const { name: p } = i, l = p;
+    i.namespace && i.namespace !== "public" ? n.addProperty({
+      name: i.namespace,
+      type: `{
+${l}: typeof ${l};
+}`,
+      docs: [i.displayName]
+    }) : n.addProperty({
+      name: l,
+      type: `typeof ${l}`,
+      docs: [i.displayName]
+    });
+  }), r.addImportDeclaration({
+    namedImports: Array.from(a).sort(),
+    isTypeOnly: !0,
+    moduleSpecifier: "@aiao/rxdb"
+  }), r.addImportDeclaration({
+    namedImports: ["Observable"],
+    isTypeOnly: !0,
+    moduleSpecifier: "rxjs"
+  }), r.addVariableStatement({
+    declarationKind: x.Const,
+    hasDeclareKeyword: !0,
+    isExported: !0,
+    declarations: [
+      {
+        name: "ENTITIES",
+        type: "EntityType[]"
+      }
+    ]
+  });
+}, ne = (s) => {
+  const { project: e, metadataSet: t } = s;
+  let r = "";
+  const o = /* @__PURE__ */ new Set(["Entity", "__decorateClass"]), n = (i) => {
+    for (const c of t.values())
+      if (c.relations && c.namespace === i.mappedNamespace && c.name === i.mappedEntity)
+        return c.relations.find((p) => p.kind === u.MANY_TO_MANY && p.mappedProperty === i.name);
+  };
+  t.forEach((i) => {
+    i.relations.forEach((c) => {
+      if (c.kind === u.MANY_TO_MANY && !n(c))
+        throw new Error("mapped relation not found");
+    });
+  }), t.forEach((i) => {
+    const c = i.extends[0], { name: p } = i, l = p, m = L(i);
+    c && o.add(c), i.properties.length && o.add("PropertyType"), i.relations.length && o.add("RelationKind"), r += `
+let ${l} = class ${c ? "extends " + c : ""} {};`, r += `
+${l} = __decorateClass(
+[
+  Entity(${m})
+],
+${l}
+);`;
+  }), r = `import { ${Array.from(o).sort().join(", ")} } from '@aiao/rxdb';` + r;
+  const a = Array.from(t.values()).map((i) => i.name).sort().join(", ");
+  r += `
+const ENTITIES = [ ${a} ];`, r += `
+export { ENTITIES, ${a} };`, e.createSourceFile("index.js", r);
+}, b = (s, e = "public") => `${e}_${s}`;
+class se {
+  metadataMap = /* @__PURE__ */ new Map();
+  project;
+  metadataSet = /* @__PURE__ */ new Set();
+  config = {
+    relationQueryDeep: 2
+  };
+  constructor(e) {
+    Object.assign(this.config, e), this.config.relationQueryDeep < 1 && (this.config.relationQueryDeep = 1);
+  }
+  /**
+   * 添加实体配置
+   * @param value 实体
+   */
+  addEntity(e, t) {
+    let r;
+    U(e) ? r = C(e) : r = E(e, t), this.metadataSet.add(r), this.metadataMap.set(`${r.namespace}_${r.name}`, r);
+  }
+  getMetadata(e, t) {
+    return this.metadataMap.get(b(e, t));
+  }
+  /**
+   * 执行生成器
+   */
+  exec() {
+    this.project = new ee(), Object.values(I).forEach(
+      (e) => e.forEach((t) => {
+        const r = E(t);
+        this.metadataMap.set(b(t.name, t.namespace), r);
+      })
+    ), re(this), ne(this);
+  }
+  getSourceFiles() {
+    return this.project.getSourceFiles();
+  }
+}
+const ae = (s, e = new w()) => {
+  const r = e.addSourceFileAtPath(s).getClasses(), o = /* @__PURE__ */ new Map();
+  r.forEach((a) => {
+    const i = a.getName();
+    if (!i) return;
+    const c = { decoratorName: "", extends: "", implements: [] };
+    o.set(i, c);
+    const p = oe(a);
+    if (p.length === 1) {
+      const { args: h, metadataOptions: f, name: N } = p[0];
+      h.length === 1 && (c.metadataOptions = f, c.decoratorName = N);
+    }
+    const m = a.getBaseClass()?.getName();
+    m && (c.extends = m), a.getImplements().forEach((h) => {
+      const f = h.getText();
+      c.implements.push(f);
+    });
+  });
+  const n = [];
+  for (const a of o.values()) {
+    const { metadataOptions: i, decoratorName: c } = a;
+    if (i) {
+      switch (c) {
+        case "Entity":
+          i.repository = "Repository";
+          break;
+        case "TreeEntity":
+          i.repository = "TreeRepository";
+          break;
+      }
+      n.push({
+        decoratorName: c,
+        metadataOptions: i,
+        implements: a.implements,
+        extendMetadataOptions: v(a.extends)
+      });
+    }
+  }
+  return n;
+}, oe = (s) => T.isDecoratable(s) ? s.getDecorators().map((e) => {
+  const t = e.getName(), r = e.getExpression(), o = T.isCallExpression(r);
+  let n = [], a;
+  return o && (n = r.getArguments().map((i) => i.getText()), n.length && (a = ie(n[0]))), {
+    name: t,
+    args: n,
+    metadataOptions: a
+  };
+}) : [], ie = (s) => {
+  try {
+    return new Function("PropertyType", "RelationKind", `return ${s}`)(d, u);
+  } catch (e) {
+    console.error(e);
+  }
+}, ce = async (s) => {
+  const e = [];
+  for (const t of s)
+    try {
+      if (t.includes("*") || t.includes("?")) {
+        const r = await j(t, {
+          absolute: !0,
+          ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"]
+        });
+        e.push(...r);
+      } else {
+        const r = A(t);
+        e.push(r);
+      }
+    } catch (r) {
+      console.error(`处理路径 ${t} 时出错:`, r);
+    }
+  return [...new Set(e)];
+}, fe = async (s) => {
+  const { entities: e, outDir: t } = s, r = await ce(e), o = new w(), n = new se();
+  for (let a = 0; a < r.length; a++) {
+    const i = r[a];
+    ae(i, o).forEach(({ metadataOptions: p, extendMetadataOptions: l }) => {
+      n.addEntity(p, l);
+    });
+  }
+  n.exec(), n.getSourceFiles().forEach((a) => {
+    const i = F(t, a.getFilePath());
+    k(M(i), { recursive: !0 }), P(i, a.getText());
+  });
+};
+export {
+  se as R,
+  fe as b
+};