@diyaner/egg-typeorm 2.2.0 → 2.3.1

package/index.d.ts

@@ -41,9 +41,13 @@ declare module "egg" {
 			/** 绑定实体类列表 */
 			entites: {
 				all: any[];
-				// 第一层中直接定义的实体，直接附加给第一个连接。（因为把第一个连接作为默认主连接数据库）
+				/**
+				 * 第一层中直接定义的实体，直接附加给第一个连接。（因为把第一个连接作为默认主连接数据库）
+				 */
 				level1: any[];
-				// 按第一层文件夹区分的实体，是要对应到数据库连接name属性的。也就是不同name对应不同实体目录
+				/** 按第一层文件夹区分的实体，是要对应到数据库连接name属性的。也就是不同name对应不同实体目录
+				 * - 目录名转为大写，如abc -> ABC
+				 */
 				dirs: {
 					[key: string]: any[];
 				};

package/lib/EggDataSource.d.ts

@@ -3,19 +3,34 @@ import { DataSource, QueryRunner } from "typeorm";
  * custom extend typeorm's DataSource class
  */
 export declare class EggDataSource extends DataSource {
-    private customAddEntityCacheMap;
+    private eggCustomAddEntityCacheMap;
+    /** 分表添加实体缓存map */
+    private eggCustomAddSplitEntityCacheMap;
     /**
-     * 在一个typeorm连接datasource实例上动态添加一个实体及其metadata
+     * 在一个typeorm连接datasource实例上动态添加一个实体类及其metadata
+     * - 可以实现动态分表，同一实体类的子类，改表名就能对应多个db表等场景
+     * - 注意：不能在每个请求之中重复添加相同功能的类，否则可能造成OOM；应该在app全局上统一获取单例类
+     * - 类上可定义属性name2,处理源码被压缩情况下类名丢失问题
+     */
+    addEntity<T extends Function>(classes: T): Promise<this>;
+    /**
+     * 在一个typeorm连接datasource实例上动态添加一个或多个实体类及其metadata
      *
-     * - 可以实现动态分表
+     * - 可以实现动态分表，同一实体类的子类，改表名就能对应多个db表等场景
      *
      * - 注意：不能在每个请求之中重复添加相同功能的类，否则可能造成OOM；应该在app全局上统一获取单例类
      */
-    addEntity<T extends Function>(classes: T): Promise<this>;
+    addEntities<T extends Function>(...classess: T[]): Promise<this>;
     /** 一个实体类来构建元数据，这个只适合无关联关系的单个类，表 */
     private buildMetaData2;
     /** 移除一个ds上的某个类实体 */
     removeEntity<T extends Function>(clz: T): void;
     /** query方法，支持查询语句转义 :params */
     query2<T = any>(query: string, parameters: Record<string, any>, queryRunner?: QueryRunner): Promise<T>;
+    /** 使用一个现有entity进行模型分表
+     * - 注意，同一个分表entity不应反复调用，否则产生多个相同class，造成OOM
+     * - 原始实体必须已经存在在datasource中，否则会报错
+     * - 与原始实体不同的是，它关联的toOne实体身上并未关联本实体（还是关联的原始实体），因此查询时不能使用oneToMany关系关联本实体的数据。只能本实体为主查询
+     */
+    getSplitTableEntity<T extends Function>(clz: T, tableName: string, isSubfix?: boolean): Promise<T>;
 }

package/lib/EggDataSource.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EggDataSource = void 0;
+const tslib_1 = require("tslib");
 const typeorm_1 = require("typeorm");
 const ConnectionMetadataBuilder_1 = require("typeorm/connection/ConnectionMetadataBuilder");
 const EntityMetadataValidator_1 = require("typeorm/metadata-builder/EntityMetadataValidator");
@@ -11,20 +12,29 @@ const EntityMetadataValidator_1 = require("typeorm/metadata-builder/EntityMetada
 class EggDataSource extends typeorm_1.DataSource {
     constructor() {
         super(...arguments);
-        this.customAddEntityCacheMap = new Map();
+        this.eggCustomAddEntityCacheMap = new Map();
+        /** 分表添加实体缓存map */
+        this.eggCustomAddSplitEntityCacheMap = new Map();
     }
     /**
-     * 在一个typeorm连接datasource实例上动态添加一个实体及其metadata
-     *
-     * - 可以实现动态分表
-     *
+     * 在一个typeorm连接datasource实例上动态添加一个实体类及其metadata
+     * - 可以实现动态分表，同一实体类的子类，改表名就能对应多个db表等场景
      * - 注意：不能在每个请求之中重复添加相同功能的类，否则可能造成OOM；应该在app全局上统一获取单例类
+     * - 类上可定义属性name2,处理源码被压缩情况下类名丢失问题
      */
     async addEntity(classes) {
-        const entityCacheClz = this.customAddEntityCacheMap.get(classes);
+        const entityCacheClz = this.eggCustomAddEntityCacheMap.get(classes);
         if (entityCacheClz) {
             return this;
         }
+        // @ts-ignore name2 for 源码压缩场景，可重新定义类名
+        if (classes.name2) {
+            Object.defineProperty(classes, "name", {
+                writable: true,
+            });
+            // @ts-ignore
+            classes.name = classes.name2;
+        }
         // 因typeorm底层实现需要所有entities一起解析实现关联关系。因此只能全部entities重新build
         let existedEntities = this.options.entities;
         if (!existedEntities) {
@@ -39,7 +49,22 @@ class EggDataSource extends typeorm_1.DataSource {
         await this.buildMetadatas(); // 与连接初始化时一致，根据所有实体类构建元数据。添加单个实体这里调用，将会很费性能，且可能由于关联关系问题报错。
         // 不全部重新build，只单个类，但又无法实现关联关系
         // await this.buildMetaData2(classes);
-        this.customAddEntityCacheMap.set(classes, true);
+        this.eggCustomAddEntityCacheMap.set(classes, true);
+        return this;
+    }
+    /**
+     * 在一个typeorm连接datasource实例上动态添加一个或多个实体类及其metadata
+     *
+     * - 可以实现动态分表，同一实体类的子类，改表名就能对应多个db表等场景
+     *
+     * - 注意：不能在每个请求之中重复添加相同功能的类，否则可能造成OOM；应该在app全局上统一获取单例类
+     */
+    async addEntities(...classess) {
+        for (const classes of classess) {
+            await this.addEntity(classes);
+        }
+        // 不全部重新build，只单个类，但又无法实现关联关系
+        // await this.buildMetaData2(classes);
         return this;
     }
     /** 一个实体类来构建元数据，这个只适合无关联关系的单个类，表 */
@@ -63,7 +88,7 @@ class EggDataSource extends typeorm_1.DataSource {
     }
     /** 移除一个ds上的某个类实体 */
     removeEntity(clz) {
-        this.customAddEntityCacheMap.delete(clz);
+        this.eggCustomAddEntityCacheMap.delete(clz);
         const metadata = this.entityMetadatasMap.get(clz);
         if (metadata && typeorm_1.InstanceChecker.isBaseEntityConstructor(metadata.target)) {
             // @ts-ignore
@@ -78,6 +103,30 @@ class EggDataSource extends typeorm_1.DataSource {
         const result = this.driver.escapeQueryWithParameters(query, parameters, {});
         return await super.query(result[0], result[1], queryRunner);
     }
+    /** 使用一个现有entity进行模型分表
+     * - 注意，同一个分表entity不应反复调用，否则产生多个相同class，造成OOM
+     * - 原始实体必须已经存在在datasource中，否则会报错
+     * - 与原始实体不同的是，它关联的toOne实体身上并未关联本实体（还是关联的原始实体），因此查询时不能使用oneToMany关系关联本实体的数据。只能本实体为主查询
+     */
+    async getSplitTableEntity(clz, tableName, isSubfix = false) {
+        const meta = this.getMetadata(clz);
+        if (!meta)
+            throw new Error(`entity ${clz.name} not found in datasource ${this.name}`);
+        const name = isSubfix ? `${meta.givenTableName || meta.name || clz.name}_${tableName}` : tableName;
+        const CacheClasses = this.eggCustomAddSplitEntityCacheMap.get(name);
+        if (CacheClasses) {
+            return CacheClasses;
+        }
+        let Classes = class Classes extends clz {
+        };
+        Classes = tslib_1.__decorate([
+            (0, typeorm_1.Entity)({ name, comment: meta.comment || "" })
+        ], Classes);
+        Classes.name2 = name;
+        await this.addEntity(Classes);
+        this.eggCustomAddSplitEntityCacheMap.set(name, Classes);
+        return Classes;
+    }
 }
 exports.EggDataSource = EggDataSource;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/Logger.js

@@ -10,13 +10,13 @@ class EggTypeORMLogger {
         };
     }
     logQuery(query, parameters, _queryRunner) {
-        this.app.coreLogger.debug(`[egg-typeorm Logger] %s \r\n%j`, query, parameters);
+        this.app.coreLogger.debug(`[Egg-TypeORM logQuery] %s \r\n%j`, query, parameters);
     }
     logQueryError(error, query, parameters, _queryRunner) {
-        this.app.coreLogger.error(`%s\r\n%s\r\n%j`, query, error, parameters);
+        this.app.coreLogger.error(`[Egg-TypeORM logQueryError] %s\r\n%s\r\n%j`, query, error, parameters);
     }
     logQuerySlow(time, query, parameters, _queryRunner) {
-        this.app.coreLogger.warn(`[egg-typeorm Logger slow sql] %s \r\n%s \r\n%j`, time, query, parameters);
+        this.app.coreLogger.warn(`[Egg-TypeORM SLOW SQL] %s \r\n%s \r\n%j`, time, query, parameters);
     }
     // @ts-ignore
     logSchemaBuild(message, queryRunner) {
@@ -26,11 +26,9 @@ class EggTypeORMLogger {
     logMigration(message, queryRunner) {
         // throw new Error("Method not implemented.");
     }
-    // @ts-ignore
     log(level, message, queryRunner) {
-        // throw new Error("Method not implemented.");
         this.app.logger[this.loggerMap[level]](message);
     }
 }
 exports.default = EggTypeORMLogger;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9nZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiTG9nZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0EsTUFBcUIsZ0JBQWdCO0lBQ3BDLFlBQW9CLEdBQXdCO1FBQXhCLFFBQUcsR0FBSCxHQUFHLENBQXFCO1FBb0I1QyxjQUFTLEdBQUc7WUFDWCxHQUFHLEVBQUUsTUFBTTtZQUNYLElBQUksRUFBRSxNQUFNO1lBQ1osSUFBSSxFQUFFLE1BQU07U0FDWixDQUFDO0lBeEI2QyxDQUFDO0lBQ2hELFFBQVEsQ0FBQyxLQUFhLEVBQUUsVUFBOEIsRUFBRSxZQUFzQztRQUM3RixJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsZ0NBQWdDLEVBQUUsS0FBSyxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ2hGLENBQUM7SUFDRCxhQUFhLENBQUMsS0FBcUIsRUFBRSxLQUFhLEVBQUUsVUFBOEIsRUFBRSxZQUFzQztRQUN6SCxJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsZ0JBQWdCLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxVQUFVLENBQUMsQ0FBQztJQUN2RSxDQUFDO0lBQ0QsWUFBWSxDQUFDLElBQVksRUFBRSxLQUFhLEVBQUUsVUFBOEIsRUFBRSxZQUFzQztRQUMvRyxJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsZ0RBQWdELEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxVQUFVLENBQUMsQ0FBQztJQUNyRyxDQUFDO0lBRUQsYUFBYTtJQUNiLGNBQWMsQ0FBQyxPQUFlLEVBQUUsV0FBcUM7UUFDcEUsOENBQThDO0lBQy9DLENBQUM7SUFDRCxhQUFhO0lBQ2IsWUFBWSxDQUFDLE9BQWUsRUFBRSxXQUFxQztRQUNsRSw4Q0FBOEM7SUFDL0MsQ0FBQztJQVFELGFBQWE7SUFDYixHQUFHLENBQUMsS0FBOEIsRUFBRSxPQUFZLEVBQUUsV0FBcUM7UUFDdEYsOENBQThDO1FBQzlDLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNqRCxDQUFDO0NBQ0Q7QUFoQ0QsbUNBZ0NDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9nZ2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiTG9nZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0EsTUFBcUIsZ0JBQWdCO0lBQ3BDLFlBQW9CLEdBQXdCO1FBQXhCLFFBQUcsR0FBSCxHQUFHLENBQXFCO1FBb0I1QyxjQUFTLEdBQUc7WUFDWCxHQUFHLEVBQUUsTUFBTTtZQUNYLElBQUksRUFBRSxNQUFNO1lBQ1osSUFBSSxFQUFFLE1BQU07U0FDWixDQUFDO0lBeEI2QyxDQUFDO0lBQ2hELFFBQVEsQ0FBQyxLQUFhLEVBQUUsVUFBOEIsRUFBRSxZQUFzQztRQUM3RixJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsa0NBQWtDLEVBQUUsS0FBSyxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBQ2xGLENBQUM7SUFDRCxhQUFhLENBQUMsS0FBcUIsRUFBRSxLQUFhLEVBQUUsVUFBOEIsRUFBRSxZQUFzQztRQUN6SCxJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsNENBQTRDLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxVQUFVLENBQUMsQ0FBQztJQUNuRyxDQUFDO0lBQ0QsWUFBWSxDQUFDLElBQVksRUFBRSxLQUFhLEVBQUUsVUFBOEIsRUFBRSxZQUFzQztRQUMvRyxJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMseUNBQXlDLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxVQUFVLENBQUMsQ0FBQztJQUM5RixDQUFDO0lBRUQsYUFBYTtJQUNiLGNBQWMsQ0FBQyxPQUFlLEVBQUUsV0FBcUM7UUFDcEUsOENBQThDO0lBQy9DLENBQUM7SUFDRCxhQUFhO0lBQ2IsWUFBWSxDQUFDLE9BQWUsRUFBRSxXQUFxQztRQUNsRSw4Q0FBOEM7SUFDL0MsQ0FBQztJQVFELEdBQUcsQ0FBQyxLQUE4QixFQUFFLE9BQVksRUFBRSxXQUFxQztRQUN0RixJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDakQsQ0FBQztDQUNEO0FBOUJELG1DQThCQyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diyaner/egg-typeorm",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "description": "egg plugin for nodejs orm freamwork typeorm.",
   "eggPlugin": {
     "name": "typeorm"