@aiao/rxdb-client-generator 0.0.1

package/README.md

@@ -0,0 +1 @@
+# rxdb-client-generator

package/RxDBClientGenerator.d.ts

@@ -0,0 +1,35 @@
+import { EntityMetadataOptions, EntityType } from '@aiao/rxdb';
+import { Project } from 'ts-morph-browser';
+export interface RxDBClientGeneratorOptions {
+    /**
+     * 关系查询深度
+     * 最小为 1
+     * @default 2
+     * @example 1 允许查询自己的基本属性 + 自己的关系的基本属性
+     * @example 2 允许查询自己的基本属性 + 自己的关系的基本属性 + 自己关系的关系的基本属性
+     */
+    relationQueryDeep?: number;
+}
+/**
+ * RxDB Client 生成器
+ */
+export declare class RxDBClientGenerator {
+    project: Project;
+    metadataSet: Set<import('type-fest/source/readonly-deep').ReadonlyObjectDeep<import('@aiao/rxdb').EntityMetadataType>>;
+    metadataMap: Map<string, import('type-fest/source/readonly-deep').ReadonlyObjectDeep<import('@aiao/rxdb').EntityMetadataType>>;
+    config: Required<RxDBClientGeneratorOptions>;
+    constructor(options?: RxDBClientGeneratorOptions);
+    /**
+     * 添加实体配置
+     * @param value 实体
+     */
+    addEntity(value: EntityMetadataOptions | EntityType): void;
+    /**
+     * 执行生成器
+     */
+    execSync(): void;
+    /**
+     * 执行生成器
+     */
+    exec(): void;
+}

package/RxDBClientGenerator.utils.d.ts

@@ -0,0 +1,19 @@
+import { EntityMetadata, EntityPropertyMetadata } from '@aiao/rxdb';
+import { OptionalKind, PropertyDeclarationStructure } from 'ts-morph-browser';
+/**
+ * 获取属性配置
+ */
+export declare const getPropertyTypeConfig: (property: EntityPropertyMetadata) => Partial<OptionalKind<PropertyDeclarationStructure>> & {
+    type: string;
+    name: string;
+};
+export declare const getEntityPropertyTsType: (property: EntityPropertyMetadata) => string;
+export declare const getGeneratorEntityConfig: (metadata: EntityMetadata) => {
+    entityPath: string;
+    fileName: string;
+};
+export declare const getGeneratorEntityDefinitionConfig: (metadata: EntityMetadata) => {
+    entityPath: string;
+    fileName: string;
+};
+export declare function transitionMetadata(metadata: EntityMetadata): string;

package/generator_all_entity_definition.d.ts

@@ -0,0 +1,6 @@
+import { RxDBClientGenerator } from './RxDBClientGenerator';
+/**
+ * 生成所有 entity 的定义到 types.d.ts 文件里
+ */
+declare const _default: (generator: RxDBClientGenerator) => void;
+export default _default;

package/generator_entity_definition.d.ts

@@ -0,0 +1,10 @@
+import { EntityMetadata } from '@aiao/rxdb';
+import { SourceFile } from 'ts-morph-browser';
+import { RxDBClientGenerator } from './RxDBClientGenerator';
+/**
+ * 生成一个实体的类型文件
+ */
+declare const _default: (generator: RxDBClientGenerator, metadata: EntityMetadata, file: SourceFile) => {
+    rxdbNamedImports: Set<string>;
+};
+export default _default;

package/generator_entity_js_file.d.ts

@@ -0,0 +1,6 @@
+import { RxDBClientGenerator } from './RxDBClientGenerator';
+/**
+ * 生成实体的 js 文件
+ */
+declare const _default: (generator: RxDBClientGenerator) => void;
+export default _default;

package/generator_entity_properties.d.ts

@@ -0,0 +1,11 @@
+import { EntityMetadata } from '@aiao/rxdb';
+import { OptionalKind, PropertyDeclarationStructure, SourceFile } from 'ts-morph-browser';
+/**
+ * 生成实体的属性
+ */
+declare const _default: ({ classProperties, metadata, file }: {
+    metadata: EntityMetadata;
+    file: SourceFile;
+    classProperties: OptionalKind<PropertyDeclarationStructure>[];
+}) => void;
+export default _default;

package/generator_entity_relations.d.ts

@@ -0,0 +1,22 @@
+import { EntityMetadata } from '@aiao/rxdb';
+import { OptionalKind, PropertyDeclarationStructure } from 'ts-morph-browser';
+/**
+ * 生成实体的关系属性
+ *
+ * 根据实体元数据中的关系定义，生成相应的TypeScript属性声明：
+ * - 对于一对一和多对一关系：生成关系可观察对象属性和ID属性
+ * - 对于一对多和多对多关系：生成关系可观察集合属性
+ *
+ * 生成的属性会添加到类属性数组中，并将所需的导入添加到导入集合中
+ *
+ * @param options - 生成选项
+ * @param options.metadata - 实体元数据，包含关系定义
+ * @param options.classProperties - 类属性数组，生成的属性会添加到这里
+ * @param options.rxdbNamedImports - rxdb导入集合，用于收集所需的导入
+ */
+declare const _default: ({ classProperties, metadata, rxdbNamedImports }: {
+    metadata: EntityMetadata;
+    classProperties: OptionalKind<PropertyDeclarationStructure>[];
+    rxdbNamedImports: Set<string>;
+}) => void;
+export default _default;

package/generator_entity_rules.d.ts

@@ -0,0 +1,13 @@
+import { EntityMetadata } from '@aiao/rxdb';
+import { RxDBClientGenerator } from './RxDBClientGenerator';
+interface RuleTypeData {
+    rule: string;
+    entity: string;
+    key: string;
+    valueType?: string;
+}
+declare const generator_entity_rules: (generator: RxDBClientGenerator, metadata: EntityMetadata, firstMetadata?: EntityMetadata, ignoreKeys?: string[], result?: RuleTypeData[], patch?: {
+    key: string;
+    entity: string;
+}[]) => RuleTypeData[];
+export default generator_entity_rules;

package/generator_repository_methods.d.ts

@@ -0,0 +1,14 @@
+import { EntityMetadata } from '@aiao/rxdb';
+import { MethodDeclarationStructure, OptionalKind, SourceFile } from 'ts-morph-browser';
+import { RxDBClientGenerator } from './RxDBClientGenerator';
+/**
+ * 生成 repository 方法
+ */
+declare const _default: ({ classMethods, rxdbNamedImports, generator, metadata, file }: {
+    classMethods: OptionalKind<MethodDeclarationStructure>[];
+    rxdbNamedImports: Set<string>;
+    generator: RxDBClientGenerator;
+    metadata: EntityMetadata;
+    file: SourceFile;
+}) => void;
+export default _default;

package/generator_tree_repository_methods.d.ts

@@ -0,0 +1,14 @@
+import { EntityMetadata } from '@aiao/rxdb';
+import { MethodDeclarationStructure, OptionalKind, SourceFile } from 'ts-morph-browser';
+import { RxDBClientGenerator } from './RxDBClientGenerator';
+/**
+ * 生成 tree repository 方法
+ */
+declare const _default: ({ metadata, classMethods, rxdbNamedImports, generator, file }: {
+    generator: RxDBClientGenerator;
+    metadata: EntityMetadata;
+    classMethods: OptionalKind<MethodDeclarationStructure>[];
+    rxdbNamedImports: Set<string>;
+    file: SourceFile;
+}) => void;
+export default _default;

package/index.d.ts

@@ -0,0 +1 @@
+export * from './RxDBClientGenerator';

package/index.js

@@ -0,0 +1,652 @@
+import { PropertyType as l, RelationKind as y, isEntityInternalName as R, getEntityMetadata as S, transitionMetadata as g } from "@aiao/rxdb";
+import { isNil as _, omit as D, isObject as N, isArray as k, isFunction as A } from "@aiao/utils";
+import { VariableDeclarationKind as j, ScriptTarget as M, Project as x, QuoteKind as F, IndentationText as v } from "ts-morph-browser";
+const K = (n) => {
+  const e = E(n), a = !!n.nullable;
+  let r = !0;
+  !a && Object.hasOwn(n, "default") && (r = !1);
+  const i = {
+    type: e,
+    name: n.name,
+    hasQuestionToken: a,
+    hasExclamationToken: r,
+    isReadonly: n.readonly
+  };
+  return _(n.default) || (i.initializer = P(n)), i;
+}, E = (n) => {
+  let e = "any";
+  switch (n.type) {
+    case l.uuid:
+      e = "UUID";
+      break;
+    case l.string:
+      e = "string";
+      break;
+    case l.number:
+      e = "number";
+      break;
+    case l.boolean:
+      e = "boolean";
+      break;
+    case l.date:
+      e = "Date";
+      break;
+  }
+  return n.nullable && (e += " | null"), e;
+}, P = (n) => {
+  switch (n.type) {
+    case l.string:
+      return `'${String(n.default)}'`;
+    case l.date:
+      return `new Date(${n.default.getTime()})`;
+    default:
+      return `${String(n.default)}`;
+  }
+}, h = (n, e = /* @__PURE__ */ new Set()) => {
+  if (N(n))
+    for (const a in n)
+      e.add(a), Object.prototype.hasOwnProperty.call(n, a) && h(Reflect.get(n, a), e);
+  else if (k(n))
+    for (const a of n)
+      h(a, e);
+  return e;
+}, b = /* @__PURE__ */ new Map();
+Object.keys(l).forEach((n) => {
+  const e = l[n];
+  b.set(e, n);
+});
+const w = /* @__PURE__ */ new Map();
+Object.keys(y).forEach((n) => {
+  const e = y[n];
+  w.set(e, n);
+});
+function G(n) {
+  const e = D(n, ["propertyMap", "relationMap", "indexMap"]), a = h(e);
+  let r = JSON.stringify(e, null, 2);
+  return new Set(n.properties.map((t) => t.type)).forEach((t) => {
+    const p = b.get(t);
+    r = r.replaceAll(`"type": "${t}"`, `"type": PropertyType.${p}`);
+  }), n.relations && new Set(n.relations.map((p) => p.kind)).forEach((p) => {
+    const o = w.get(p);
+    r = r.replaceAll(`"kind": "${p}"`, `"kind": RelationKind.${o}`);
+  }), a.forEach((t) => {
+    t.includes("-") || t.includes(" ") || (r = r.replaceAll(`"${t}":`, `${t}:`));
+  }), r;
+}
+const I = ({
+  classProperties: n,
+  metadata: e,
+  file: a
+}) => {
+  const { name: r } = e, i = a.addInterface({
+    name: `${r}InitData`,
+    isExported: !0,
+    docs: ["初始化数据"]
+  });
+  e.propertyMap.values().filter((t) => R(t.name) === !1).forEach((t) => {
+    const p = K(t), { initializer: o, ...s } = p;
+    let c = t.displayName || t.name;
+    o && (c += `
+@default ${o}`), i.addProperty({
+      name: p.name,
+      type: p.type,
+      hasQuestionToken: !0,
+      docs: [c]
+    }), n.push({
+      ...s,
+      hasExclamationToken: !1,
+      docs: [c]
+    });
+  });
+}, Q = ({
+  classProperties: n,
+  metadata: e,
+  rxdbNamedImports: a
+}) => {
+  e.relationMap.values().forEach((r) => {
+    switch (r.kind) {
+      // 处理一对一和多对一关系
+      // 这两种关系需要生成：
+      // 1. 关系可观察对象属性（name$）- 用于访问关联实体
+      // 2. 外键ID属性（nameId）- 存储关联实体的ID
+      case y.ONE_TO_ONE:
+      case y.MANY_TO_ONE:
+        {
+          const i = r.nullable ? `RelationEntityObservable<${r.mappedEntity} | null>` : `RelationEntityObservable<${r.mappedEntity}>`, t = r.displayName || r.name;
+          n.push({
+            name: r.name + "$",
+            // 关系属性名使用$后缀，表示可观察对象
+            type: i,
+            isReadonly: !0,
+            // 关系属性是只读的，通过set/remove方法修改
+            docs: [t]
+          }), n.push({
+            name: r.name + "Id",
+            // 外键ID属性
+            type: "UUID",
+            isReadonly: !0,
+            docs: [t + " id"]
+          }), a.add("RelationEntityObservable");
+        }
+        break;
+      // 处理一对多和多对多关系
+      // 这两种关系只需要生成关系可观察集合属性（name$）
+      // 不需要外键ID属性，因为外键存储在关联实体或中间表中
+      case y.ONE_TO_MANY:
+      case y.MANY_TO_MANY:
+        {
+          const i = r.displayName || r.name, t = `RelationEntitiesObservable<${r.mappedEntity}>`;
+          n.push({
+            name: r.name + "$",
+            // 关系集合属性名使用$后缀
+            isReadonly: !0,
+            // 关系属性是只读的，通过add/remove方法修改
+            type: t,
+            docs: [i]
+          }), a.add("RelationEntitiesObservable");
+        }
+        break;
+    }
+  });
+}, C = (n) => Array.from(n.propertyMap.keys()).map((e) => {
+  const a = n.propertyMap.get(e);
+  let r = "";
+  switch (a.type) {
+    case l.uuid:
+      r = "UUID";
+      break;
+    case l.string:
+      r = "String";
+      break;
+    case l.number:
+    case l.integer:
+      r = "Number";
+      break;
+    case l.boolean:
+      r = "Boolean";
+      break;
+    case l.date:
+      r = "Date";
+      break;
+    default:
+      throw new Error("Unknown property type: " + a.type);
+  }
+  if (!r) throw new Error("ruleName is empty");
+  r += "Rules";
+  const i = E(a);
+  return {
+    rule: r,
+    entity: n.name,
+    key: e,
+    valueType: i
+  };
+}), $ = (n, e, a, r = [], i = [], t = []) => (a = a ?? e, C(e).forEach(({ rule: p, entity: o, key: s, valueType: c }) => {
+  t.length > 0 ? s = t.map((u) => u.key).join(".") + "." + s : c = void 0, i.push({
+    rule: p,
+    entity: o,
+    key: s,
+    valueType: c
+  });
+}), e.foreignKeyNames.forEach((p) => {
+  i.push({
+    rule: "UUIDRules",
+    entity: e.name,
+    key: p
+  });
+}), e.relationMap.keys().filter((p) => !r.includes(p)).forEach((p) => {
+  const o = e.relationMap.get(p);
+  if (!o)
+    throw new Error("relation is empty");
+  const s = [];
+  switch (o.kind) {
+    case y.ONE_TO_ONE:
+      break;
+    case y.ONE_TO_MANY:
+      s.push(o.mappedProperty);
+      break;
+    case y.MANY_TO_ONE:
+      break;
+    case y.MANY_TO_MANY:
+      s.push(o.mappedProperty);
+      break;
+  }
+  const c = n.metadataMap.get(`${o.mappedNamespace}_${o.mappedEntity}`);
+  if (!c)
+    throw new Error(`generator_entity_rules: metadata "${o.mappedEntity}" not found`);
+  if (t.find((m) => m.entity === e.name) || t.length && c === a) return;
+  const d = [...t, { key: p, entity: e.name }];
+  t.length < n.config.relationQueryDeep && $(n, c, a, s, i, d);
+}), i), U = ({
+  classMethods: n,
+  rxdbNamedImports: e,
+  generator: a,
+  metadata: r,
+  file: i
+}) => {
+  const { name: t } = r, o = $(a, r).map(({ rule: u, entity: d, key: m, valueType: f }) => (e.add(u), f ? (f === "UUID" && e.add("UUID"), `${u}<${d}, '${m}', ${f}>`) : `${u}<${d}, '${m}'>`));
+  i.addTypeAlias({
+    name: `${t}Rule`,
+    type: `
+| ` + Array.from(new Set(o)).join(`
+| `),
+    hasDeclareKeyword: !0,
+    docs: ["rule"]
+  }), i.addTypeAlias({
+    name: `${t}RuleGroup`,
+    type: `RuleGroup<${t}, keyof ${t}, ${t}Rule>`,
+    hasDeclareKeyword: !0,
+    docs: ["RuleGroup"],
+    isExported: !0
+  });
+  const s = `${t}OrderByField`, c = Array.from(r.propertyMap.keys());
+  i.addTypeAlias({
+    name: s,
+    type: c.map((u) => `"${u}"`).join(" | "),
+    hasDeclareKeyword: !0,
+    docs: ["OrderByField"]
+  }), n.push({
+    name: "get",
+    returnType: `Observable<${t}>`,
+    docs: [["查询", "@param id 实体的 id", "@param options 查询选项"].join(`
+`)],
+    parameters: [
+      {
+        name: "id",
+        type: "string"
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: "GetOptions"
+      }
+    ],
+    isStatic: !0
+  }), e.add("GetOptions"), n.push({
+    name: "findOneOrFail",
+    returnType: `Observable<${t}>`,
+    docs: [["查询", "@param where 查询条件", "@param options 查询选项"].join(`
+`)],
+    parameters: [
+      {
+        name: "where",
+        type: `${t}RuleGroup`
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: `FindOneOrFailOptions<${s}>`
+      }
+    ],
+    isStatic: !0
+  }), e.add("FindOneOrFailOptions"), n.push({
+    name: "find",
+    returnType: `Observable<${t}[]>`,
+    docs: [["查询", "@param where 查询条件", "@param options 查询选项"].join(`
+`)],
+    parameters: [
+      {
+        name: "where",
+        type: `${t}RuleGroup`
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: `FindOptions<${s}>`
+      }
+    ],
+    isStatic: !0
+  }), e.add("FindOptions"), n.push({
+    name: "findOne",
+    returnType: `Observable<${t} | undefined>`,
+    docs: [["查询", "@param where 查询条件", "@param options 查询选项"].join(`
+`)],
+    parameters: [
+      {
+        name: "where",
+        type: `${t}RuleGroup`
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: `FindOneOptions<${s}>`
+      }
+    ],
+    isStatic: !0
+  }), e.add("FindOneOptions"), n.push({
+    name: "findAll",
+    returnType: `Observable<${t}[]>`,
+    docs: [["查询", "@param where 查询条件", "@param options 查询选项"].join(`
+`)],
+    parameters: [
+      {
+        name: "where",
+        type: `${t}RuleGroup`
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: `FindAllOptions<${s}>`
+      }
+    ],
+    isStatic: !0
+  }), e.add("FindAllOptions"), n.push({
+    name: "findByCursor",
+    returnType: `Observable<${t}[]>`,
+    docs: [["查询", "@param where 查询条件", "@param options 查询选项"].join(`
+`)],
+    parameters: [
+      {
+        name: "where",
+        type: `${t}RuleGroup`
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: `FindByCursorOptions<${s}>`
+      }
+    ],
+    isStatic: !0
+  }), e.add("FindByCursorOptions"), n.push({
+    name: "count",
+    returnType: "Observable<number>",
+    docs: [["查询", "@param where 查询条件", "@param options 查询选项"].join(`
+`)],
+    parameters: [
+      {
+        name: "where",
+        type: `${t}RuleGroup`
+      },
+      {
+        name: "options",
+        hasQuestionToken: !0,
+        type: "CountOptions"
+      }
+    ],
+    isStatic: !0
+  }), e.add("CountOptions"), n.push({
+    name: "save",
+    returnType: `Promise<${t}>`,
+    docs: [["保存"].join(`
+`)]
+  }), n.push({
+    name: "remove",
+    returnType: `Promise<${t}>`,
+    docs: [["删除"].join(`
+`)]
+  });
+}, B = ({
+  metadata: n,
+  classMethods: e,
+  rxdbNamedImports: a,
+  generator: r,
+  file: i
+}) => {
+  const { name: t } = n, o = $(r, n).filter(
+    (s) => s.key.startsWith("children.") && s.key !== "children.id"
+  ).map(({ rule: s, entity: c, key: u, valueType: d }) => (a.add(s), d ? (d === "UUID" && a.add("UUID"), `${s}<${c}, '${u}', ${d}>`) : `${s}<${c}, '${u}'>`));
+  i.addTypeAlias({
+    name: `${t}TreeRule`,
+    type: `
+| ` + Array.from(new Set(o)).join(`
+| `),
+    hasDeclareKeyword: !0,
+    docs: ["TreeRule"]
+  }), i.addTypeAlias({
+    name: `${t}TreeRuleGroup`,
+    type: `RuleGroup<${t}, keyof ${t}, ${t}TreeRule>`,
+    hasDeclareKeyword: !0,
+    docs: ["TreeRuleGroup"],
+    isExported: !0
+  }), e.push({
+    name: "findDescendants",
+    returnType: `Observable<${t}[]>`,
+    docs: [["查询子孙实体", "@param options 查询选项"].join(`
+`)],
+    parameters: [
+      {
+        name: "entity",
+        type: `${t}`
+      },
+      {
+        name: "where",
+        type: `${t}TreeRuleGroup`
+      },
+      {
+        name: "options",
+        type: "FindTreeOptions",
+        hasQuestionToken: !0
+      }
+    ],
+    isStatic: !0
+  }), e.push({
+    name: "countDescendants",
+    returnType: "Observable<number>",
+    docs: [["查询子孙实体数量", "@param options 查询选项"].join(`
+`)],
+    parameters: [
+      {
+        name: "entity",
+        type: `${t}`
+      },
+      {
+        name: "where",
+        type: `${t}TreeRuleGroup`
+      },
+      {
+        name: "options",
+        type: "FindTreeOptions",
+        hasQuestionToken: !0
+      }
+    ],
+    isStatic: !0
+  }), e.push({
+    name: "findAncestors",
+    returnType: `Observable<${t}[]>`,
+    docs: [["查询祖先实体", "@param options 查询选项"].join(`
+`)],
+    parameters: [
+      {
+        name: "entity",
+        type: `${t}`
+      },
+      {
+        name: "where",
+        type: `${t}TreeRuleGroup`
+      },
+      {
+        name: "options",
+        type: "FindTreeOptions",
+        hasQuestionToken: !0
+      }
+    ],
+    isStatic: !0
+  }), e.push({
+    name: "countAncestors",
+    returnType: "Observable<number>",
+    docs: [["查询祖先实体数量", "@param options 查询选项"].join(`
+`)],
+    parameters: [
+      {
+        name: "entity",
+        type: `${t}`
+      },
+      {
+        name: "where",
+        type: `${t}TreeRuleGroup`
+      },
+      {
+        name: "options",
+        type: "FindTreeOptions",
+        hasQuestionToken: !0
+      }
+    ],
+    isStatic: !0
+  }), a.add("FindTreeOptions");
+}, Y = (n, e, a) => {
+  const r = /* @__PURE__ */ new Set(), { name: i } = e, t = e.extends[0];
+  r.add(t);
+  const p = a.addClass({
+    name: i,
+    isExported: !0,
+    extends: t,
+    decorators: [],
+    hasDeclareKeyword: !0
+  });
+  p.addJsDoc(`
+${e.displayName}`);
+  const o = [], s = [];
+  return I({
+    classProperties: o,
+    file: a,
+    metadata: e
+  }), Q({
+    classProperties: o,
+    metadata: e,
+    rxdbNamedImports: r
+  }), U({
+    classMethods: s,
+    file: a,
+    generator: n,
+    metadata: e,
+    rxdbNamedImports: r
+  }), e.repository === "TreeRepository" && B({
+    classMethods: s,
+    metadata: e,
+    file: a,
+    generator: n,
+    rxdbNamedImports: r
+  }), p.addProperties(
+    o.sort((c, u) => c.isReadonly && !u.isReadonly ? -1 : !c.isReadonly && u.isReadonly ? 1 : c.name.localeCompare(u.name))
+  ), p.addConstructor({
+    parameters: [
+      {
+        name: "initData",
+        type: `${i}InitData`,
+        hasQuestionToken: !0
+      }
+    ],
+    docs: [["初始化数据", "@param initData 初始化数据"].join(`
+`)]
+  }), p.addMethods(
+    s.sort((c, u) => c.isStatic && !u.isStatic ? -1 : !c.isStatic && u.isStatic ? 1 : c.name.localeCompare(u.name))
+  ), {
+    rxdbNamedImports: r
+  };
+}, T = (n) => {
+  const { project: e, metadataSet: a } = n, r = e.createSourceFile("types.d.ts"), t = r.addModule({
+    name: '"@aiao/rxdb"',
+    hasDeclareKeyword: !0,
+    docs: ["rxdb"]
+  }).addInterface({
+    name: "RxDB",
+    docs: ["RxDB"]
+  }), p = /* @__PURE__ */ new Set(["EntityType", "RuleGroup"]);
+  a.forEach((o) => {
+    const { rxdbNamedImports: s } = Y(n, o, r);
+    s.forEach((d) => p.add(d));
+    const { name: c } = o, u = c;
+    o.namespace && o.namespace !== "public" ? t.addProperty({
+      name: o.namespace,
+      type: `{
+${u}: typeof ${u};
+}`,
+      docs: [o.displayName]
+    }) : t.addProperty({
+      name: u,
+      type: `typeof ${u}`,
+      docs: [o.displayName]
+    });
+  }), r.addImportDeclaration({
+    namedImports: Array.from(p).sort(),
+    isTypeOnly: !0,
+    moduleSpecifier: "@aiao/rxdb"
+  }), r.addImportDeclaration({
+    namedImports: ["Observable"],
+    isTypeOnly: !0,
+    moduleSpecifier: "rxjs"
+  }), r.addVariableStatement({
+    declarationKind: j.Const,
+    hasDeclareKeyword: !0,
+    isExported: !0,
+    declarations: [
+      {
+        name: "ENTITIES",
+        type: "EntityType[]"
+      }
+    ]
+  });
+}, O = (n) => {
+  const { project: e, metadataSet: a } = n;
+  let r = "";
+  const i = /* @__PURE__ */ new Set(["Entity", "__decorateClass"]), t = (o) => {
+    for (const s of a.values())
+      if (s.relations && s.namespace === o.mappedNamespace && s.name === o.mappedEntity)
+        return s.relations.find((c) => c.kind === y.MANY_TO_MANY && c.mappedProperty === o.name);
+  };
+  a.forEach((o) => {
+    o.relations.forEach((s) => {
+      if (s.kind === y.MANY_TO_MANY && !t(s))
+        throw new Error("mapped relation not found");
+    });
+  }), a.forEach((o) => {
+    const s = o.extends[0], { name: c } = o, u = c, d = G(o);
+    s && i.add(s), o.properties.length && i.add("PropertyType"), o.relations.length && i.add("RelationKind"), r += `
+let ${u} = class ${s ? "extends " + s : ""} {};`, r += `
+${u} = __decorateClass(
+[
+  Entity(${d})
+],
+${u}
+);`;
+  }), r = `import { ${Array.from(i).sort().join(", ")} } from '@aiao/rxdb';` + r;
+  const p = Array.from(a.values()).map((o) => o.name).sort().join(", ");
+  r += `
+const ENTITIES = [ ${p} ];`, r += `
+export { ENTITIES, ${p} };`, e.createSourceFile("index.js", r);
+};
+class q {
+  project;
+  metadataSet = /* @__PURE__ */ new Set();
+  metadataMap = /* @__PURE__ */ new Map();
+  config = {
+    relationQueryDeep: 2
+  };
+  constructor(e) {
+    Object.assign(this.config, e), this.config.relationQueryDeep < 1 && (this.config.relationQueryDeep = 1);
+    const a = {
+      target: M.ESNext
+    };
+    this.project = new x({
+      useInMemoryFileSystem: !0,
+      skipAddingFilesFromTsConfig: !0,
+      compilerOptions: a,
+      manipulationSettings: {
+        indentationText: v.TwoSpaces,
+        quoteKind: F.Single
+      }
+    });
+  }
+  /**
+   * 添加实体配置
+   * @param value 实体
+   */
+  addEntity(e) {
+    let a = e;
+    A(e) ? a = S(e) : a = g(e), this.metadataSet.add(a), this.metadataMap.set(`${a.namespace}_${a.name}`, a);
+  }
+  /**
+   * 执行生成器
+   */
+  execSync() {
+    T(this), O(this), this.project.saveSync();
+  }
+  /**
+   * 执行生成器
+   */
+  exec() {
+    T(this), O(this), this.project.save();
+  }
+}
+export {
+  q as RxDBClientGenerator
+};

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@aiao/rxdb-client-generator",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./index.js",
+  "dependencies": {
+    "@aiao/utils": "0.0.1",
+    "@aiao/rxdb": "0.0.1",
+    "ts-morph-browser": "^25.0.3"
+  },
+  ".": {
+    "import": "./index.js",
+    "types": "./index.d.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}