Release 1.8.0

History.md

@@ -1,4 +1,22 @@
 
+1.8.0 / 2022-07-21
+==================
+
+**features**
+  * [[`b49a38c`](http://github.com/cnpm/cnpmcore/commit/b49a38c77e044c978e6de32a9d3e257cc90ea7c1)] - feat: use Model with inject (#269) (killa <<killa123@126.com>>)
+
+1.7.1 / 2022-07-20
+==================
+
+**fixes**
+  * [[`52fca55`](http://github.com/cnpm/cnpmcore/commit/52fca55aa883865f0ae70bfc1ff274c313b8f76a)] - fix: show package not use cache if isSync (#268) (killa <<killa123@126.com>>)
+
+1.7.0 / 2022-07-12
+==================
+
+**others**
+  * [[`4f7ce8b`](http://github.com/cnpm/cnpmcore/commit/4f7ce8b4b2a5806a225ce67228388e14388b7059)] - deps: upgrade leoric to 2.x (#262) (killa <<killa123@126.com>>)
+
 1.6.0 / 2022-07-11
 ==================
 

app/port/controller/package/ShowPackageController.ts

@@ -33,7 +33,7 @@ export class ShowPackageController extends AbstractController {
     const isFullManifests = ctx.accepts([ 'json', abbreviatedMetaType ]) !== abbreviatedMetaType;
     // handle cache
     const cacheEtag = await this.cacheService.getPackageEtag(fullname, isFullManifests);
-    if (cacheEtag) {
+    if (!isSync && cacheEtag) {
       let requestEtag = ctx.request.get('if-none-match');
       if (requestEtag.startsWith('W/')) {
         requestEtag = requestEtag.substring(2);

app/repository/BinaryRepository.ts

@@ -1,6 +1,6 @@
-import { AccessLevel, ContextProto } from '@eggjs/tegg';
+import { AccessLevel, ContextProto, Inject } from '@eggjs/tegg';
 import { ModelConvertor } from './util/ModelConvertor';
-import { Binary as BinaryModel } from './model/Binary';
+import type { Binary as BinaryModel } from './model/Binary';
 import { Binary as BinaryEntity } from '../core/entity/Binary';
 import { AbstractRepository } from './AbstractRepository';
 
@@ -8,25 +8,28 @@ import { AbstractRepository } from './AbstractRepository';
   accessLevel: AccessLevel.PUBLIC,
 })
 export class BinaryRepository extends AbstractRepository {
+  @Inject()
+  private readonly Binary: typeof BinaryModel;
+
   async saveBinary(binary: BinaryEntity): Promise<void> {
     if (binary.id) {
-      const model = await BinaryModel.findOne({ id: binary.id });
+      const model = await this.Binary.findOne({ id: binary.id });
       if (!model) return;
       await ModelConvertor.saveEntityToModel(binary, model);
     } else {
-      const model = await ModelConvertor.convertEntityToModel(binary, BinaryModel);
+      const model = await ModelConvertor.convertEntityToModel(binary, this.Binary);
       this.logger.info('[BinaryRepository:saveBinary:new] id: %s, binaryId: %s', model.id, model.binaryId);
     }
   }
 
   async findBinary(category: string, parent: string, name: string) {
-    const model = await BinaryModel.findOne({ category, parent, name });
+    const model = await this.Binary.findOne({ category, parent, name });
     if (model) return ModelConvertor.convertModelToEntity(model, BinaryEntity);
     return null;
   }
 
   async listBinaries(category: string, parent: string): Promise<BinaryEntity[]> {
-    const models = await BinaryModel.find({ category, parent });
+    const models = await this.Binary.find({ category, parent });
     return models.map(model => ModelConvertor.convertModelToEntity(model, BinaryEntity));
   }
 }

app/repository/ChangeRepository.ts

@@ -1,6 +1,6 @@
-import { AccessLevel, ContextProto } from '@eggjs/tegg';
+import { AccessLevel, ContextProto, Inject } from '@eggjs/tegg';
 import { ModelConvertor } from './util/ModelConvertor';
-import { Change as ChangeModel } from './model/Change';
+import type { Change as ChangeModel } from './model/Change';
 import { Change as ChangeEntity } from '../core/entity/Change';
 import { AbstractRepository } from './AbstractRepository';
 
@@ -8,16 +8,19 @@ import { AbstractRepository } from './AbstractRepository';
   accessLevel: AccessLevel.PUBLIC,
 })
 export class ChangeRepository extends AbstractRepository {
+  @Inject()
+  private readonly Change: typeof ChangeModel;
+
   async addChange(change: ChangeEntity) {
-    await ModelConvertor.convertEntityToModel(change, ChangeModel);
+    await ModelConvertor.convertEntityToModel(change, this.Change);
   }
 
   async query(since: number, limit: number): Promise<Array<ChangeEntity>> {
-    const models = await ChangeModel.find({ id: { $gte: since } }).order('id', 'asc').limit(limit);
+    const models = await this.Change.find({ id: { $gte: since } }).order('id', 'asc').limit(limit);
     return models.toObject() as ChangeEntity[];
   }
 
   async getLastChange() {
-    return await ChangeModel.findOne().order('id', 'desc').limit(1);
+    return await this.Change.findOne().order('id', 'desc').limit(1);
   }
 }

app/repository/PackageRepository.ts

@@ -1,17 +1,17 @@
-import { AccessLevel, ContextProto } from '@eggjs/tegg';
-import { Package as PackageModel } from './model/Package';
+import { AccessLevel, ContextProto, Inject } from '@eggjs/tegg';
+import type { Package as PackageModel } from './model/Package';
 import { Package as PackageEntity } from '../core/entity/Package';
 import { ModelConvertor } from './util/ModelConvertor';
 import { PackageVersion as PackageVersionEntity } from '../core/entity/PackageVersion';
-import { PackageVersion as PackageVersionModel } from './model/PackageVersion';
+import type { PackageVersion as PackageVersionModel } from './model/PackageVersion';
 import { PackageVersionManifest as PackageVersionManifestEntity } from '../core/entity/PackageVersionManifest';
-import { PackageVersionManifest as PackageVersionManifestModel } from './model/PackageVersionManifest';
-import { Dist as DistModel } from './model/Dist';
+import type { PackageVersionManifest as PackageVersionManifestModel } from './model/PackageVersionManifest';
+import type { Dist as DistModel } from './model/Dist';
 import { Dist as DistEntity } from '../core/entity/Dist';
 import { PackageTag as PackageTagEntity } from '../core/entity/PackageTag';
-import { PackageTag as PackageTagModel } from './model/PackageTag';
-import { Maintainer as MaintainerModel } from './model/Maintainer';
-import { User as UserModel } from './model/User';
+import type { PackageTag as PackageTagModel } from './model/PackageTag';
+import type { Maintainer as MaintainerModel } from './model/Maintainer';
+import type { User as UserModel } from './model/User';
 import { User as UserEntity } from '../core/entity/User';
 import { AbstractRepository } from './AbstractRepository';
 
@@ -19,11 +19,32 @@ import { AbstractRepository } from './AbstractRepository';
   accessLevel: AccessLevel.PUBLIC,
 })
 export class PackageRepository extends AbstractRepository {
+  @Inject()
+  private readonly Package: typeof PackageModel;
+
+  @Inject()
+  private readonly Dist: typeof DistModel;
+
+  @Inject()
+  private readonly PackageVersion: typeof PackageVersionModel;
+
+  @Inject()
+  private readonly PackageVersionManifest: typeof PackageVersionManifestModel;
+
+  @Inject()
+  private readonly PackageTag: typeof PackageTagModel;
+
+  @Inject()
+  private readonly Maintainer: typeof MaintainerModel;
+
+  @Inject()
+  private readonly User: typeof UserModel;
+
   async findPackage(scope: string, name: string): Promise<PackageEntity | null> {
-    const model = await PackageModel.findOne({ scope, name });
+    const model = await this.Package.findOne({ scope, name });
     if (!model) return null;
-    const manifestsDistModel = model.manifestsDistId ? await DistModel.findOne({ distId: model.manifestsDistId }) : null;
-    const abbreviatedsDistModel = model.abbreviatedsDistId ? await DistModel.findOne({ distId: model.abbreviatedsDistId }) : null;
+    const manifestsDistModel = model.manifestsDistId ? await this.Dist.findOne({ distId: model.manifestsDistId }) : null;
+    const abbreviatedsDistModel = model.abbreviatedsDistId ? await this.Dist.findOne({ distId: model.abbreviatedsDistId }) : null;
     const data = {
       manifestsDist: manifestsDistModel && ModelConvertor.convertModelToEntity(manifestsDistModel, DistEntity),
       abbreviatedsDist: abbreviatedsDistModel && ModelConvertor.convertModelToEntity(abbreviatedsDistModel, DistEntity),
@@ -33,18 +54,18 @@ export class PackageRepository extends AbstractRepository {
   }
 
   async findPackageId(scope: string, name: string) {
-    const model = await PackageModel.findOne({ scope, name }).select('packageId');
+    const model = await this.Package.findOne({ scope, name }).select('packageId');
     if (!model) return null;
     return model.packageId;
   }
 
   async savePackage(pkgEntity: PackageEntity): Promise<void> {
     if (pkgEntity.id) {
-      const model = await PackageModel.findOne({ id: pkgEntity.id });
+      const model = await this.Package.findOne({ id: pkgEntity.id });
       if (!model) return;
       await ModelConvertor.saveEntityToModel(pkgEntity, model);
     } else {
-      const model = await ModelConvertor.convertEntityToModel(pkgEntity, PackageModel);
+      const model = await ModelConvertor.convertEntityToModel(pkgEntity, this.Package);
       this.logger.info('[PackageRepository:savePackage:new] id: %s, packageId: %s', model.id, model.packageId);
     }
   }
@@ -53,11 +74,11 @@ export class PackageRepository extends AbstractRepository {
     const dist = isFullManifests ? pkgEntity.manifestsDist : pkgEntity.abbreviatedsDist;
     if (!dist) return;
     if (dist.id) {
-      const model = await DistModel.findOne({ id: dist.id });
+      const model = await this.Dist.findOne({ id: dist.id });
       if (!model) return;
       await ModelConvertor.saveEntityToModel(dist, model);
     } else {
-      const model = await ModelConvertor.convertEntityToModel(dist, DistModel);
+      const model = await ModelConvertor.convertEntityToModel(dist, this.Dist);
       this.logger.info('[PackageRepository:savePackageDist:new] id: %s, distId: %s, packageId: %s',
         model.id, model.distId, pkgEntity.packageId);
     }
@@ -67,7 +88,7 @@ export class PackageRepository extends AbstractRepository {
   async removePackageDist(pkgEntity: PackageEntity, isFullManifests: boolean): Promise<void> {
     const dist = isFullManifests ? pkgEntity.manifestsDist : pkgEntity.abbreviatedsDist;
     if (!dist) return;
-    const model = await DistModel.findOne({ id: dist.id });
+    const model = await this.Dist.findOne({ id: dist.id });
     if (!model) return;
     await model.remove();
     this.logger.info('[PackageRepository:removePackageDist:remove] id: %s, distId: %s, packageId: %s',
@@ -79,9 +100,9 @@ export class PackageRepository extends AbstractRepository {
   // Package Maintainers
   // return true meaning create new record
   async savePackageMaintainer(packageId: string, userId: string): Promise<undefined | true> {
-    let model = await MaintainerModel.findOne({ packageId, userId });
+    let model = await this.Maintainer.findOne({ packageId, userId });
     if (!model) {
-      model = await MaintainerModel.create({ packageId, userId });
+      model = await this.Maintainer.create({ packageId, userId });
       this.logger.info('[PackageRepository:addPackageMaintainer:new] id: %s, packageId: %s, userId: %s',
         model.id, model.packageId, model.userId);
       return true;
@@ -89,22 +110,22 @@ export class PackageRepository extends AbstractRepository {
   }
 
   async listPackageMaintainers(packageId: string): Promise<UserEntity[]> {
-    const models = await MaintainerModel.find({ packageId });
-    const userModels = await UserModel.find({ userId: models.map(m => m.userId) });
+    const models = await this.Maintainer.find({ packageId });
+    const userModels = await this.User.find({ userId: models.map(m => m.userId) });
     return userModels.map(user => ModelConvertor.convertModelToEntity(user, UserEntity));
   }
 
   async replacePackageMaintainers(packageId: string, userIds: string[]): Promise<void> {
-    await MaintainerModel.transaction(async () => {
+    await this.Maintainer.transaction(async ({ connection }) => {
       // delete exists
-      // const removeCount = await MaintainerModel.remove({ packageId }, true, { transaction });
-      const removeCount = await MaintainerModel.remove({ packageId });
+      // const removeCount = await this.Maintainer.remove({ packageId }, true, { transaction });
+      const removeCount = await this.Maintainer.remove({ packageId }, true, { connection });
       this.logger.info('[PackageRepository:replacePackageMaintainers:remove] %d rows, packageId: %s',
         removeCount, packageId);
       // add news
       for (const userId of userIds) {
-        // const model = await MaintainerModel.create({ packageId, userId }, transaction);
-        const model = await MaintainerModel.create({ packageId, userId });
+        // const model = await this.Maintainer.create({ packageId, userId }, transaction);
+        const model = await this.Maintainer.create({ packageId, userId }, { connection });
         this.logger.info('[PackageRepository:replacePackageMaintainers:new] id: %s, packageId: %s, userId: %s',
           model.id, model.packageId, model.userId);
       }
@@ -112,7 +133,7 @@ export class PackageRepository extends AbstractRepository {
   }
 
   async removePackageMaintainer(packageId: string, userId: string) {
-    const model = await MaintainerModel.findOne({ packageId, userId });
+    const model = await this.Maintainer.findOne({ packageId, userId });
     if (model) {
       await model.remove();
       this.logger.info('[PackageRepository:removePackageMaintainer:remove] id: %s, packageId: %s, userId: %s',
@@ -124,36 +145,36 @@ export class PackageRepository extends AbstractRepository {
 
   // TODO: support paging
   async listPackagesByUserId(userId: string): Promise<PackageEntity[]> {
-    const models = await MaintainerModel.find({ userId });
-    const packageModels = await PackageModel.find({ packageId: models.map(m => m.packageId) });
+    const models = await this.Maintainer.find({ userId });
+    const packageModels = await this.Package.find({ packageId: models.map(m => m.packageId) });
     return packageModels.map(pkg => ModelConvertor.convertModelToEntity(pkg, PackageEntity));
   }
 
   async createPackageVersion(pkgVersionEntity: PackageVersionEntity) {
-    await PackageVersionModel.transaction(async function(transaction) {
+    await this.PackageVersion.transaction(async transaction => {
       await Promise.all([
         // FIXME: transaction is not the options
-        ModelConvertor.convertEntityToModel(pkgVersionEntity, PackageVersionModel, transaction),
-        ModelConvertor.convertEntityToModel(pkgVersionEntity.manifestDist, DistModel, transaction),
-        ModelConvertor.convertEntityToModel(pkgVersionEntity.tarDist, DistModel, transaction),
-        ModelConvertor.convertEntityToModel(pkgVersionEntity.readmeDist, DistModel, transaction),
-        ModelConvertor.convertEntityToModel(pkgVersionEntity.abbreviatedDist, DistModel, transaction),
+        ModelConvertor.convertEntityToModel(pkgVersionEntity, this.PackageVersion, transaction),
+        ModelConvertor.convertEntityToModel(pkgVersionEntity.manifestDist, this.Dist, transaction),
+        ModelConvertor.convertEntityToModel(pkgVersionEntity.tarDist, this.Dist, transaction),
+        ModelConvertor.convertEntityToModel(pkgVersionEntity.readmeDist, this.Dist, transaction),
+        ModelConvertor.convertEntityToModel(pkgVersionEntity.abbreviatedDist, this.Dist, transaction),
       ]);
     });
   }
 
   async savePackageVersion(pkgVersionEntity: PackageVersionEntity) {
     // only abbreviatedDist and manifestDist allow to change, like `deprecated` message
-    let model = await DistModel.findOne({ id: pkgVersionEntity.manifestDist.id });
+    let model = await this.Dist.findOne({ id: pkgVersionEntity.manifestDist.id });
     if (model) {
       await ModelConvertor.saveEntityToModel(pkgVersionEntity.manifestDist, model);
     }
-    model = await DistModel.findOne({ id: pkgVersionEntity.abbreviatedDist.id });
+    model = await this.Dist.findOne({ id: pkgVersionEntity.abbreviatedDist.id });
     if (model) {
       await ModelConvertor.saveEntityToModel(pkgVersionEntity.abbreviatedDist, model);
     }
     if (pkgVersionEntity.id) {
-      const model = await PackageVersionModel.findOne({ id: pkgVersionEntity.id });
+      const model = await this.PackageVersion.findOne({ id: pkgVersionEntity.id });
       if (model) {
         await ModelConvertor.saveEntityToModel(pkgVersionEntity, model);
       }
@@ -161,14 +182,14 @@ export class PackageRepository extends AbstractRepository {
   }
 
   async findPackageVersion(packageId: string, version: string): Promise<PackageVersionEntity | null> {
-    const pkgVersionModel = await PackageVersionModel.findOne({ packageId, version });
+    const pkgVersionModel = await this.PackageVersion.findOne({ packageId, version });
     if (!pkgVersionModel) return null;
     return await this.fillPackageVersionEntitiyData(pkgVersionModel);
   }
 
   async listPackageVersions(packageId: string): Promise<PackageVersionEntity[]> {
     // FIXME: read all versions will hit the memory limit
-    const models = await PackageVersionModel.find({ packageId }).order('id desc');
+    const models = await this.PackageVersion.find({ packageId }).order('id desc');
     const entities: PackageVersionEntity[] = [];
     for (const model of models) {
       entities.push(await this.fillPackageVersionEntitiyData(model));
@@ -177,19 +198,19 @@ export class PackageRepository extends AbstractRepository {
   }
 
   async listPackageVersionNames(packageId: string): Promise<string[]> {
-    const rows = await PackageVersionModel.find({ packageId }).select('version').order('id desc');
+    const rows = await this.PackageVersion.find({ packageId }).select('version').order('id desc');
     return rows.map(row => row.version);
   }
 
   // only for unittest now
   async removePackageVersions(packageId: string): Promise<void> {
-    const removeCount = await PackageVersionModel.remove({ packageId });
+    const removeCount = await this.PackageVersion.remove({ packageId });
     this.logger.info('[PackageRepository:removePackageVersions:remove] %d rows, packageId: %s',
       removeCount, packageId);
   }
 
   async removePackageVersion(pkgVersion: PackageVersionEntity): Promise<void> {
-    const distRemoveCount = await DistModel.remove({
+    const distRemoveCount = await this.Dist.remove({
       distId: [
         pkgVersion.abbreviatedDist.distId,
         pkgVersion.manifestDist.distId,
@@ -197,32 +218,32 @@ export class PackageRepository extends AbstractRepository {
         pkgVersion.tarDist.distId,
       ],
     });
-    const removeCount = await PackageVersionModel.remove({ packageVersionId: pkgVersion.packageVersionId });
+    const removeCount = await this.PackageVersion.remove({ packageVersionId: pkgVersion.packageVersionId });
     this.logger.info('[PackageRepository:removePackageVersion:remove] %d dist rows, %d rows, packageVersionId: %s',
       distRemoveCount, removeCount, pkgVersion.packageVersionId);
   }
 
   async savePackageVersionManifest(manifestEntity: PackageVersionManifestEntity): Promise<void> {
-    let model = await PackageVersionManifestModel.findOne({ packageVersionId: manifestEntity.packageVersionId });
+    let model = await this.PackageVersionManifest.findOne({ packageVersionId: manifestEntity.packageVersionId });
     if (model) {
       model.manifest = manifestEntity.manifest;
       await model.save();
     } else {
-      model = await ModelConvertor.convertEntityToModel(manifestEntity, PackageVersionManifestModel);
+      model = await ModelConvertor.convertEntityToModel(manifestEntity, this.PackageVersionManifest);
       this.logger.info('[PackageRepository:savePackageVersionManifest:new] id: %s, packageVersionId: %s',
         model.id, model.packageVersionId);
     }
   }
 
   async findPackageVersionManifest(packageVersionId: string) {
-    const model = await PackageVersionManifestModel.findOne({ packageVersionId });
+    const model = await this.PackageVersionManifest.findOne({ packageVersionId });
     if (!model) return null;
-    return ModelConvertor.convertModelToEntity(model, PackageVersionManifestModel);
+    return ModelConvertor.convertModelToEntity(model, this.PackageVersionManifest);
   }
 
   public async queryTotal() {
-    const lastPkg = await PackageModel.findOne().order('id', 'desc');
-    const lastVersion = await PackageVersionModel.findOne().order('id', 'desc');
+    const lastPkg = await this.Package.findOne().order('id', 'desc');
+    const lastVersion = await this.PackageVersion.findOne().order('id', 'desc');
     let packageCount = 0;
     let packageVersionCount = 0;
     let lastPackage = '';
@@ -235,7 +256,7 @@ export class PackageRepository extends AbstractRepository {
     }
 
     if (lastVersion) {
-      const pkg = await PackageModel.findOne({ packageId: lastVersion.packageId });
+      const pkg = await this.Package.findOne({ packageId: lastVersion.packageId });
       if (pkg) {
         const fullname = pkg.scope ? `${pkg.scope}/${pkg.name}` : pkg.name;
         lastPackageVersion = `${fullname}@${lastVersion.version}`;
@@ -257,10 +278,10 @@ export class PackageRepository extends AbstractRepository {
       manifestDistModel,
       abbreviatedDistModel,
     ] = await Promise.all([
-      DistModel.findOne({ distId: model.tarDistId }),
-      DistModel.findOne({ distId: model.readmeDistId }),
-      DistModel.findOne({ distId: model.manifestDistId }),
-      DistModel.findOne({ distId: model.abbreviatedDistId }),
+      this.Dist.findOne({ distId: model.tarDistId }),
+      this.Dist.findOne({ distId: model.readmeDistId }),
+      this.Dist.findOne({ distId: model.manifestDistId }),
+      this.Dist.findOne({ distId: model.abbreviatedDistId }),
     ]);
     const data = {
       tarDist: tarDistModel && ModelConvertor.convertModelToEntity(tarDistModel, DistEntity),
@@ -272,7 +293,7 @@ export class PackageRepository extends AbstractRepository {
   }
 
   async findPackageTag(packageId: string, tag: string): Promise<PackageTagEntity | null> {
-    const model = await PackageTagModel.findOne({ packageId, tag });
+    const model = await this.PackageTag.findOne({ packageId, tag });
     if (!model) return null;
     const entity = ModelConvertor.convertModelToEntity(model, PackageTagEntity);
     return entity;
@@ -280,18 +301,18 @@ export class PackageRepository extends AbstractRepository {
 
   async savePackageTag(packageTagEntity: PackageTagEntity) {
     if (packageTagEntity.id) {
-      const model = await PackageTagModel.findOne({ id: packageTagEntity.id });
+      const model = await this.PackageTag.findOne({ id: packageTagEntity.id });
       if (!model) return;
       await ModelConvertor.saveEntityToModel(packageTagEntity, model);
     } else {
-      const model = await ModelConvertor.convertEntityToModel(packageTagEntity, PackageTagModel);
+      const model = await ModelConvertor.convertEntityToModel(packageTagEntity, this.PackageTag);
       this.logger.info('[PackageRepository:savePackageTag:new] id: %s, packageTagId: %s, tags: %s => %s',
         model.id, model.packageTagId, model.tag, model.version);
     }
   }
 
   async removePackageTag(packageTagEntity: PackageTagEntity) {
-    const model = await PackageTagModel.findOne({ id: packageTagEntity.id });
+    const model = await this.PackageTag.findOne({ id: packageTagEntity.id });
     if (!model) return;
     await model.remove();
     this.logger.info('[PackageRepository:removePackageTag:remove] id: %s, packageTagId: %s, packageId: %s',
@@ -299,7 +320,7 @@ export class PackageRepository extends AbstractRepository {
   }
 
   async listPackageTags(packageId: string): Promise<PackageTagEntity[]> {
-    const models = await PackageTagModel.find({ packageId });
+    const models = await this.PackageTag.find({ packageId });
     const entities: PackageTagEntity[] = [];
     for (const model of models) {
       entities.push(ModelConvertor.convertModelToEntity(model, PackageTagEntity));

app/repository/PackageVersionBlockRepository.ts

@@ -1,6 +1,6 @@
-import { AccessLevel, ContextProto } from '@eggjs/tegg';
+import { AccessLevel, ContextProto, Inject } from '@eggjs/tegg';
 import { ModelConvertor } from './util/ModelConvertor';
-import { PackageVersionBlock as PackageVersionBlockModel } from './model/PackageVersionBlock';
+import type { PackageVersionBlock as PackageVersionBlockModel } from './model/PackageVersionBlock';
 import { PackageVersionBlock as PackageVersionBlockEntity } from '../core/entity/PackageVersionBlock';
 import { AbstractRepository } from './AbstractRepository';
 
@@ -8,13 +8,16 @@ import { AbstractRepository } from './AbstractRepository';
   accessLevel: AccessLevel.PUBLIC,
 })
 export class PackageVersionBlockRepository extends AbstractRepository {
+  @Inject()
+  private readonly PackageVersionBlock: typeof PackageVersionBlockModel;
+
   async savePackageVersionBlock(block: PackageVersionBlockEntity) {
     if (block.id) {
-      const model = await PackageVersionBlockModel.findOne({ id: block.id });
+      const model = await this.PackageVersionBlock.findOne({ id: block.id });
       if (!model) return;
       await ModelConvertor.saveEntityToModel(block, model);
     } else {
-      const model = await ModelConvertor.convertEntityToModel(block, PackageVersionBlockModel);
+      const model = await ModelConvertor.convertEntityToModel(block, this.PackageVersionBlock);
       this.logger.info('[PackageVersionBlockRepository:savePackageVersionBlock:new] id: %s, packageVersionBlockId: %s',
         model.id, model.packageVersionBlockId);
     }
@@ -25,17 +28,17 @@ export class PackageVersionBlockRepository extends AbstractRepository {
   }
 
   async findPackageVersionBlock(packageId: string, version: string) {
-    const model = await PackageVersionBlockModel.findOne({ packageId, version });
+    const model = await this.PackageVersionBlock.findOne({ packageId, version });
     if (model) return ModelConvertor.convertModelToEntity(model, PackageVersionBlockEntity);
     return null;
   }
 
   async listPackageVersionBlocks(packageId: string) {
-    return await PackageVersionBlockModel.find({ packageId });
+    return await this.PackageVersionBlock.find({ packageId });
   }
 
   async removePackageVersionBlock(packageVersionBlockId: string) {
-    const removeCount = await PackageVersionBlockModel.remove({ packageVersionBlockId });
+    const removeCount = await this.PackageVersionBlock.remove({ packageVersionBlockId });
     this.logger.info('[PackageVersionBlockRepository:removePackageVersionBlock:remove] %d rows, packageVersionBlockId: %s',
       removeCount, packageVersionBlockId);
   }

app/repository/PackageVersionDownloadRepository.ts

@@ -1,17 +1,20 @@
-import { AccessLevel, ContextProto } from '@eggjs/tegg';
+import { AccessLevel, ContextProto, Inject } from '@eggjs/tegg';
 import { AbstractRepository } from './AbstractRepository';
-import { PackageVersionDownload as PackageVersionDownloadModel } from './model/PackageVersionDownload';
+import type { PackageVersionDownload as PackageVersionDownloadModel } from './model/PackageVersionDownload';
 
 @ContextProto({
   accessLevel: AccessLevel.PUBLIC,
 })
 export class PackageVersionDownloadRepository extends AbstractRepository {
+  @Inject()
+  private readonly PackageVersionDownload: typeof PackageVersionDownloadModel;
+
   async plus(packageId: string, version: string, counter: number): Promise<void> {
     const now = new Date();
     const yearMonth = now.getFullYear() * 100 + now.getMonth() + 1;
     const date = new Date().getDate();
     const field = date < 10 ? `d0${date}` : `d${date}`;
-    let model = await PackageVersionDownloadModel.findOne({
+    let model = await this.PackageVersionDownload.findOne({
       packageId,
       version,
       yearMonth,
@@ -23,11 +26,11 @@ export class PackageVersionDownloadRepository extends AbstractRepository {
         version,
         yearMonth,
       };
-      model = await PackageVersionDownloadModel.create(attributes);
+      model = await this.PackageVersionDownload.create(attributes);
       this.logger.info('[PackageVersionDownloadRepository:plus:new] id: %s, packageId: %s, version: %s, yearMonth: %s',
         model.id, model.packageId, model.version, model.yearMonth);
     }
-    await PackageVersionDownloadModel
+    await this.PackageVersionDownload
       .where({ id: model.id })
       .increment(field, counter);
     this.logger.info('[PackageVersionDownloadRepository:plus:increment] id: %s, packageId: %s, version: %s, field: %s%s, plus: %d',
@@ -37,7 +40,7 @@ export class PackageVersionDownloadRepository extends AbstractRepository {
   async query(packageId: string, start: Date, end: Date) {
     const startYearMonth = start.getFullYear() * 100 + start.getMonth() + 1;
     const endYearMonth = end.getFullYear() * 100 + end.getMonth() + 1;
-    const models = await PackageVersionDownloadModel.find({
+    const models = await this.PackageVersionDownload.find({
       packageId,
       yearMonth: { $gte: startYearMonth, $lte: endYearMonth },
     });
@@ -46,7 +49,7 @@ export class PackageVersionDownloadRepository extends AbstractRepository {
 
   async saveSyncDataByMonth(packageId: string, yearMonth: number, counters: [string, number][]): Promise<void> {
     const version = '*';
-    let model = await PackageVersionDownloadModel.findOne({
+    let model = await this.PackageVersionDownload.findOne({
       packageId,
       version,
       yearMonth,
@@ -58,7 +61,7 @@ export class PackageVersionDownloadRepository extends AbstractRepository {
         version,
         yearMonth,
       };
-      model = await PackageVersionDownloadModel.create(attributes);
+      model = await this.PackageVersionDownload.create(attributes);
     }
     for (const [ date, counter ] of counters) {
       const field = `d${date}`;

app/repository/TaskRepository.ts

@@ -1,7 +1,7 @@
-import { AccessLevel, ContextProto } from '@eggjs/tegg';
+import { AccessLevel, ContextProto, Inject } from '@eggjs/tegg';
 import { ModelConvertor } from './util/ModelConvertor';
-import { Task as TaskModel } from './model/Task';
-import { HistoryTask as HistoryTaskModel } from './model/HistoryTask';
+import type { Task as TaskModel } from './model/Task';
+import type { HistoryTask as HistoryTaskModel } from './model/HistoryTask';
 import { Task as TaskEntity } from '../core/entity/Task';
 import { AbstractRepository } from './AbstractRepository';
 import { TaskType, TaskState } from '../../app/common/enum/Task';
@@ -10,35 +10,41 @@ import { TaskType, TaskState } from '../../app/common/enum/Task';
   accessLevel: AccessLevel.PUBLIC,
 })
 export class TaskRepository extends AbstractRepository {
+  @Inject()
+  private readonly Task: typeof TaskModel;
+
+  @Inject()
+  private readonly HistoryTask: typeof HistoryTaskModel;
+
   async saveTask(task: TaskEntity): Promise<void> {
     if (task.id) {
-      const model = await TaskModel.findOne({ id: task.id });
+      const model = await this.Task.findOne({ id: task.id });
       if (!model) return;
       await ModelConvertor.saveEntityToModel(task, model);
     } else {
-      await ModelConvertor.convertEntityToModel(task, TaskModel);
+      await ModelConvertor.convertEntityToModel(task, this.Task);
     }
   }
 
   async saveTaskToHistory(task: TaskEntity): Promise<void> {
-    const model = await TaskModel.findOne({ id: task.id });
+    const model = await this.Task.findOne({ id: task.id });
     if (!model) return;
-    const history = await HistoryTaskModel.findOne({ taskId: task.taskId });
+    const history = await this.HistoryTask.findOne({ taskId: task.taskId });
     if (history) {
       await ModelConvertor.saveEntityToModel(task, history);
     } else {
-      await ModelConvertor.convertEntityToModel(task, HistoryTaskModel);
+      await ModelConvertor.convertEntityToModel(task, this.HistoryTask);
     }
     await model.remove();
   }
 
   async findTask(taskId: string) {
-    const task = await TaskModel.findOne({ taskId });
+    const task = await this.Task.findOne({ taskId });
     if (task) {
       return ModelConvertor.convertModelToEntity(task, TaskEntity);
     }
     // try to read from history
-    const history = await HistoryTaskModel.findOne({ taskId });
+    const history = await this.HistoryTask.findOne({ taskId });
     if (history) {
       return ModelConvertor.convertModelToEntity(history, TaskEntity);
     }
@@ -50,7 +56,7 @@ export class TaskRepository extends AbstractRepository {
     if (state) {
       where.state = state;
     }
-    const task = await TaskModel.findOne(where);
+    const task = await this.Task.findOne(where);
     if (task) {
       return ModelConvertor.convertModelToEntity(task, TaskEntity);
     }
@@ -60,7 +66,7 @@ export class TaskRepository extends AbstractRepository {
   async findTimeoutTasks(taskState: TaskState, timeout: number) {
     const timeoutDate = new Date();
     timeoutDate.setTime(timeoutDate.getTime() - timeout);
-    const models = await TaskModel.find({
+    const models = await this.Task.find({
       state: taskState,
       updatedAt: {
         $lt: timeoutDate,

app/repository/UserRepository.ts

@@ -1,7 +1,7 @@
-import { AccessLevel, ContextProto } from '@eggjs/tegg';
+import { AccessLevel, ContextProto, Inject } from '@eggjs/tegg';
 import { ModelConvertor } from './util/ModelConvertor';
-import { User as UserModel } from './model/User';
-import { Token as TokenModel } from './model/Token';
+import type { User as UserModel } from './model/User';
+import type { Token as TokenModel } from './model/Token';
 import { User as UserEntity } from '../core/entity/User';
 import { Token as TokenEntity } from '../core/entity/Token';
 import { AbstractRepository } from './AbstractRepository';
@@ -10,19 +10,25 @@ import { AbstractRepository } from './AbstractRepository';
   accessLevel: AccessLevel.PUBLIC,
 })
 export class UserRepository extends AbstractRepository {
+  @Inject()
+  private readonly User: typeof UserModel;
+
+  @Inject()
+  private readonly Token: typeof TokenModel;
+
   async saveUser(user: UserEntity): Promise<void> {
     if (user.id) {
-      const model = await UserModel.findOne({ id: user.id });
+      const model = await this.User.findOne({ id: user.id });
       if (!model) return;
       await ModelConvertor.saveEntityToModel(user, model);
     } else {
-      const model = await ModelConvertor.convertEntityToModel(user, UserModel);
+      const model = await ModelConvertor.convertEntityToModel(user, this.User);
       this.logger.info('[UserRepository:saveUser:new] id: %s, userId: %s', model.id, model.userId);
     }
   }
 
   async findUserByName(name: string) {
-    const model = await UserModel.findOne({ name });
+    const model = await this.User.findOne({ name });
     if (!model) return null;
     return ModelConvertor.convertModelToEntity(model, UserEntity);
   }
@@ -30,7 +36,7 @@ export class UserRepository extends AbstractRepository {
   async findUserAndTokenByTokenKey(tokenKey: string) {
     const token = await this.findTokenByTokenKey(tokenKey);
     if (!token) return null;
-    const userModel = await UserModel.findOne({ userId: token.userId });
+    const userModel = await this.User.findOne({ userId: token.userId });
     if (!userModel) return null;
     return {
       token,
@@ -39,30 +45,30 @@ export class UserRepository extends AbstractRepository {
   }
 
   async findTokenByTokenKey(tokenKey: string) {
-    const model = await TokenModel.findOne({ tokenKey });
+    const model = await this.Token.findOne({ tokenKey });
     if (!model) return null;
     return ModelConvertor.convertModelToEntity(model, TokenEntity);
   }
 
   async saveToken(token: TokenEntity): Promise<void> {
     if (token.id) {
-      const model = await TokenModel.findOne({ id: token.id });
+      const model = await this.Token.findOne({ id: token.id });
       if (!model) return;
       await ModelConvertor.saveEntityToModel(token, model);
     } else {
-      const model = await ModelConvertor.convertEntityToModel(token, TokenModel);
+      const model = await ModelConvertor.convertEntityToModel(token, this.Token);
       this.logger.info('[UserRepository:saveToken:new] id: %s, tokenId: %s', model.id, model.tokenId);
     }
   }
 
   async removeToken(tokenId: string) {
-    const removeCount = await TokenModel.remove({ tokenId });
+    const removeCount = await this.Token.remove({ tokenId });
     this.logger.info('[UserRepository:removeToken:remove] %d rows, tokenId: %s',
       removeCount, tokenId);
   }
 
   async listTokens(userId: string): Promise<TokenEntity[]> {
-    const models = await TokenModel.find({ userId });
+    const models = await this.Token.find({ userId });
     return models.map(model => ModelConvertor.convertModelToEntity(model, TokenEntity));
   }
 }

app/repository/util/ModelConvertor.ts

@@ -10,7 +10,7 @@ const ID = 'id';
 
 export class ModelConvertor {
   static async convertEntityToModel<T extends Bone>(entity: object, ModelClazz: EggProtoImplClass<T>, options?): Promise<T> {
-    const metadata = ModelMetadataUtil.getControllerMetadata(ModelClazz);
+    const metadata = ModelMetadataUtil.getModelMetadata(ModelClazz);
     if (!metadata) {
       throw new Error(`Model ${ModelClazz.name} has no metadata`);
     }
@@ -35,7 +35,7 @@ export class ModelConvertor {
   // Find out which attributes changed and set `updatedAt` to now
   static async saveEntityToModel<T extends Bone>(entity: object, model: T, options?): Promise<boolean> {
     const ModelClazz = model.constructor as EggProtoImplClass<T>;
-    const metadata = ModelMetadataUtil.getControllerMetadata(ModelClazz);
+    const metadata = ModelMetadataUtil.getModelMetadata(ModelClazz);
     if (!metadata) {
       throw new Error(`Model ${ModelClazz.name} has no metadata`);
     }
@@ -57,7 +57,7 @@ export class ModelConvertor {
   static convertModelToEntity<T>(bone: Bone, entityClazz: EggProtoImplClass<T>, data?: object): T {
     data = data || {};
     const ModelClazz = bone.constructor;
-    const metadata = ModelMetadataUtil.getControllerMetadata(ModelClazz);
+    const metadata = ModelMetadataUtil.getModelMetadata(ModelClazz);
     if (!metadata) {
       throw new Error(`Model ${ModelClazz.name} has no metadata`);
     }

app/repository/util/ModelConvertorUtil.ts

@@ -12,7 +12,7 @@ export class ModelConvertorUtil {
    * If has no entity property info, use modelProperty as default value
    */
   static getEntityPropertyName(clazz: EggProtoImplClass, modelProperty: string): string {
-    const propertyMap: Map<string, string> | undefined = MetadataUtil.getOwnMetaData(ENTITY_PROPERTY_MAP_ATTRIBUTE, clazz);
+    const propertyMap: Map<string, string> | undefined = MetadataUtil.getMetaData(ENTITY_PROPERTY_MAP_ATTRIBUTE, clazz);
     return propertyMap?.get(modelProperty) ?? modelProperty;
   }
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cnpmcore",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "npm core",
   "files": [
     "dist/**/*"
@@ -70,14 +70,14 @@
     "npm"
   ],
   "dependencies": {
-    "@eggjs/tegg": "^1.2.0",
-    "@eggjs/tegg-aop-plugin": "^1.0.5",
+    "@eggjs/tegg": "^1.3.2",
+    "@eggjs/tegg-aop-plugin": "^1.3.2",
     "@eggjs/tegg-config": "^1.0.0",
-    "@eggjs/tegg-controller-plugin": "^1.0.5",
-    "@eggjs/tegg-eventbus-plugin": "^1.0.5",
-    "@eggjs/tegg-orm-decorator": "^1.0.1",
-    "@eggjs/tegg-orm-plugin": "^1.0.5",
-    "@eggjs/tegg-plugin": "^1.0.5",
+    "@eggjs/tegg-controller-plugin": "^1.3.2",
+    "@eggjs/tegg-eventbus-plugin": "^1.3.2",
+    "@eggjs/tegg-orm-decorator": "^1.4.0",
+    "@eggjs/tegg-orm-plugin": "^2.1.0",
+    "@eggjs/tegg-plugin": "^1.3.2",
     "@eggjs/tsconfig": "^1.0.0",
     "@node-rs/crc32": "^1.2.2",
     "@sinclair/typebox": "^0.23.0",
@@ -93,7 +93,7 @@
     "egg-typebox-validate": "^2.0.0",
     "fs-cnpm": "^2.4.0",
     "ioredis": "^4.28.3",
-    "leoric": "^1.15.0",
+    "leoric": "^2.6.2",
     "lodash": "^4.17.21",
     "mysql": "^2.18.1",
     "mysql2": "^2.3.0",