cabloy 5.1.111 → 5.1.112

package/vona/src/suite/a-commerce/modules/commerce-trade/test/stockReservation.test.ts

@@ -0,0 +1,262 @@
+import type { EntityStockReservation } from 'vona-module-commerce-trade';
+
+import { catchError } from '@cabloy/utils';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+async function createSku(suffix: string): Promise<number> {
+  const categoryId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
+    body: { name: `reservation-category-${suffix}`, published: true },
+  });
+  const productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
+    body: { categoryId, title: `reservation-product-${suffix}`, published: true },
+  });
+  return await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+    body: {
+      productId,
+      code: `reservation-sku-${suffix}`,
+      priceCents: 100,
+      lifecycle: 'active',
+    },
+  });
+}
+
+async function prepareStock(suffix: string, quantity = 3): Promise<number> {
+  const skuId = await createSku(suffix);
+  await app.scope('commerce-trade').service.stockBalance.adjustStock({
+    skuId,
+    delta: quantity,
+    reason: 'reservation test setup',
+    correlationId: `reservation-setup-${suffix}`,
+  });
+  return skuId;
+}
+
+async function reserve(
+  skuId: number,
+  suffix: string,
+  quantity = 2,
+): Promise<EntityStockReservation> {
+  return await app.scope('commerce-trade').service.stockBalance.reserve({
+    skuId,
+    quantity,
+    reason: 'reservation test',
+    correlationId: `reservation-${suffix}`,
+  });
+}
+
+async function assertReservationRejected(skuId: number, suffix: string, expectedCode: number) {
+  const [_, err] = await catchError(() => reserve(skuId, suffix));
+  assert.equal(err?.code, expectedCode);
+  const balance = await app.scope('commerce-trade').model.stockBalance.get({ skuId });
+  assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [3, 0, 3]);
+  assert.equal(await app.scope('commerce-trade').model.stockReservation.get({ skuId }), undefined);
+  const audits = await app.scope('commerce-trade').model.stockAudit.select({ where: { skuId } });
+  assert.deepEqual(
+    audits.map(audit => audit.operation),
+    ['adjust'],
+  );
+}
+
+describe('stockReservation.test.ts', () => {
+  it('reserves and consumes stock exactly once with traceable audits', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const suffix = `${Date.now()}`;
+      await app.bean.passport.signinMock();
+      try {
+        const skuId = await prepareStock(suffix);
+        const reservation = await reserve(skuId, suffix);
+        const balanceAfterReserve = await app
+          .scope('commerce-trade')
+          .model.stockBalance.get({ skuId });
+        assert.deepEqual(
+          [
+            balanceAfterReserve?.onHand,
+            balanceAfterReserve?.reserved,
+            balanceAfterReserve?.available,
+          ],
+          [3, 2, 1],
+        );
+
+        const duplicate = await reserve(skuId, suffix);
+        assert.equal(duplicate.id, reservation.id);
+        const consumed = await app.scope('commerce-trade').service.stockBalance.consume({
+          reservationId: reservation.id,
+          reason: 'payment success',
+        });
+        assert.equal(consumed.state, 'consumed');
+        const duplicateConsume = await app.scope('commerce-trade').service.stockBalance.consume({
+          reservationId: reservation.id,
+          reason: 'payment success retry',
+        });
+        assert.equal(duplicateConsume.state, 'consumed');
+
+        const balanceAfterConsume = await app
+          .scope('commerce-trade')
+          .model.stockBalance.get({ skuId });
+        assert.deepEqual(
+          [
+            balanceAfterConsume?.onHand,
+            balanceAfterConsume?.reserved,
+            balanceAfterConsume?.available,
+          ],
+          [1, 0, 1],
+        );
+        const audits = await app
+          .scope('commerce-trade')
+          .model.stockAudit.select({ where: { skuId } });
+        assert.deepEqual(
+          audits.map(audit => audit.operation),
+          ['adjust', 'reserve', 'consume'],
+        );
+        assert.equal(audits[1].stockReservationId, reservation.id);
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('rejects reservations for inactive or unpublished catalog data without writes', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const suffix = `${Date.now()}`;
+      await app.bean.passport.signinMock();
+      try {
+        const inactiveSkuId = await prepareStock(`${suffix}-inactive`);
+        await app.scope('commerce-catalog').model.sku.updateById(inactiveSkuId, {
+          lifecycle: 'inactive',
+        });
+        await assertReservationRejected(inactiveSkuId, `${suffix}-inactive`, 404);
+
+        const unpublishedProductSkuId = await prepareStock(`${suffix}-product`);
+        const unpublishedProductSku = await app
+          .scope('commerce-catalog')
+          .model.sku.getById(unpublishedProductSkuId);
+        await app
+          .scope('commerce-catalog')
+          .model.product.updateById(unpublishedProductSku!.productId, { published: false });
+        await assertReservationRejected(unpublishedProductSkuId, `${suffix}-product`, 409);
+
+        const unpublishedCategorySkuId = await prepareStock(`${suffix}-category`);
+        const unpublishedCategorySku = await app
+          .scope('commerce-catalog')
+          .model.sku.getById(unpublishedCategorySkuId);
+        const unpublishedCategoryProduct = await app
+          .scope('commerce-catalog')
+          .model.product.getById(unpublishedCategorySku!.productId);
+        await app
+          .scope('commerce-catalog')
+          .model.category.updateById(unpublishedCategoryProduct!.categoryId, { published: false });
+        await assertReservationRejected(unpublishedCategorySkuId, `${suffix}-category`, 409);
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('releases and restores stock only from legal reservation states', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const suffix = `${Date.now()}`;
+      await app.bean.passport.signinMock();
+      try {
+        const skuId = await prepareStock(suffix);
+        const releasedReservation = await reserve(skuId, `${suffix}-release`);
+        const released = await app.scope('commerce-trade').service.stockBalance.release({
+          reservationId: releasedReservation.id,
+          reason: 'payment failed',
+        });
+        assert.equal(released.state, 'released');
+        const duplicateRelease = await app.scope('commerce-trade').service.stockBalance.release({
+          reservationId: releasedReservation.id,
+          reason: 'payment failed retry',
+        });
+        assert.equal(duplicateRelease.state, 'released');
+
+        const consumedReservation = await reserve(skuId, `${suffix}-restore`, 1);
+        await app.scope('commerce-trade').service.stockBalance.consume({
+          reservationId: consumedReservation.id,
+          reason: 'payment success',
+        });
+        const restored = await app.scope('commerce-trade').service.stockBalance.restore({
+          reservationId: consumedReservation.id,
+          reason: 'refund success',
+        });
+        assert.equal(restored.state, 'restored');
+
+        const [_, err] = await catchError(() =>
+          app.scope('commerce-trade').service.stockBalance.consume({
+            reservationId: releasedReservation.id,
+            reason: 'invalid replay',
+          }),
+        );
+        assert.equal(err?.code, 409);
+        const balance = await app.scope('commerce-trade').model.stockBalance.get({ skuId });
+        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [3, 0, 3]);
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('allows exactly one competing reservation for the final unit', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const suffix = `${Date.now()}`;
+      await app.bean.passport.signinMock();
+      try {
+        const skuId = await prepareStock(suffix, 1);
+        const results = await Promise.allSettled([
+          reserve(skuId, `${suffix}-first`, 1),
+          reserve(skuId, `${suffix}-second`, 1),
+        ]);
+        assert.equal(results.filter(result => result.status === 'fulfilled').length, 1);
+        assert.equal(results.filter(result => result.status === 'rejected').length, 1);
+
+        const balance = await app.scope('commerce-trade').model.stockBalance.get({ skuId });
+        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [1, 1, 0]);
+        const reservations = await app.scope('commerce-trade').model.stockReservation.select({
+          where: { skuId },
+        });
+        const audits = await app
+          .scope('commerce-trade')
+          .model.stockAudit.select({ where: { skuId } });
+        assert.equal(reservations.length, 1);
+        assert.deepEqual(
+          audits.map(audit => audit.operation),
+          ['adjust', 'reserve'],
+        );
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('rolls back reservation and balance when audit persistence fails', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const suffix = `${Date.now()}`;
+      await app.bean.passport.signinMock();
+      try {
+        const skuId = await prepareStock(suffix);
+        const modelStockAudit = app.scope('commerce-trade').model.stockAudit;
+        const insert = modelStockAudit.insert.bind(modelStockAudit);
+        (modelStockAudit as any).insert = async () => {
+          throw new Error('reservation audit insert failure');
+        };
+        try {
+          const [_, err] = await catchError(() => reserve(skuId, suffix));
+          assert.match(err?.message ?? '', /reservation audit insert failure/);
+        } finally {
+          (modelStockAudit as any).insert = insert;
+        }
+
+        const balance = await app.scope('commerce-trade').model.stockBalance.get({ skuId });
+        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [3, 0, 3]);
+        assert.equal(
+          await app.scope('commerce-trade').model.stockReservation.get({ skuId }),
+          undefined,
+        );
+      } finally {
+        await app.bean.passport.signout();
+      }
+    });
+  });
+});

package/vona/src/suite/a-commerce/package.json

@@ -10,6 +10,7 @@
     "vona-module-commerce-member": "^5.0.0",
     "vona-module-commerce-payment": "^5.0.0",
     "vona-module-commerce-promotion": "^5.0.0",
+    "vona-module-commerce-seed": "^5.0.0",
     "vona-module-commerce-siteadmin": "^5.0.0",
     "vona-module-commerce-siteweb": "^5.0.0",
     "vona-module-commerce-trade": "^5.0.0"

package/vona/src/suite/a-commerce/tsconfig.json

@@ -22,6 +22,9 @@
     },
     {
       "path": "modules/commerce-siteadmin/tsconfig.build.json"
+    },
+    {
+      "path": "modules/commerce-seed/tsconfig.build.json"
     }
   ],
   "exclude": ["modules"]

package/vona/src/suite/a-home/modules/home-user/src/.metadata/index.ts

@@ -144,7 +144,7 @@ import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'von
 declare module 'vona-module-home-user' {
   export interface IModelOptionsUser {
         relations: {
-          roles: IModelRelationBelongsToMany<'home-user:roleUser', 'home-user:role', false, undefined,undefined,undefined,undefined>;
+          roles: IModelRelationBelongsToMany<'home-user:roleUser', 'home-user:role', false, '*',undefined,undefined,undefined>;
         };
       }
   export interface ModelRole {
@@ -152,6 +152,8 @@ declare module 'vona-module-home-user' {
       [SymbolKeyEntityMeta]: EntityRoleMeta;
       [SymbolKeyModelOptions]: IModelOptionsRole;
       get<T extends IModelGetOptions<EntityRole,ModelRole>>(where: TypeModelWhere<EntityRole>, options?: T): Promise<TypeModelRelationResult<EntityRole, ModelRole, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityRole,ModelRole>>(where: TypeModelWhere<EntityRole>, options?: T): Promise<TypeModelRelationResult<EntityRole, ModelRole, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityRole,ModelRole>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityRole, ModelRole, T> | undefined>;
       mget<T extends IModelGetOptions<EntityRole,ModelRole>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityRole, ModelRole, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntityRole,ModelRole,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityRole, ModelRole, T>>;
       select<T extends IModelSelectParams<EntityRole,ModelRole,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityRole, ModelRole, T>[]>;
@@ -181,6 +183,8 @@ export interface ModelRoleUser {
       [SymbolKeyEntityMeta]: EntityRoleUserMeta;
       [SymbolKeyModelOptions]: IModelOptionsRoleUser;
       get<T extends IModelGetOptions<EntityRoleUser,ModelRoleUser>>(where: TypeModelWhere<EntityRoleUser>, options?: T): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityRoleUser,ModelRoleUser>>(where: TypeModelWhere<EntityRoleUser>, options?: T): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityRoleUser,ModelRoleUser>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T> | undefined>;
       mget<T extends IModelGetOptions<EntityRoleUser,ModelRoleUser>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntityRoleUser,ModelRoleUser,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityRoleUser, ModelRoleUser, T>>;
       select<T extends IModelSelectParams<EntityRoleUser,ModelRoleUser,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityRoleUser, ModelRoleUser, T>[]>;
@@ -206,6 +210,8 @@ export interface ModelUser {
       [SymbolKeyEntityMeta]: EntityUserMeta;
       [SymbolKeyModelOptions]: IModelOptionsUser;
       get<T extends IModelGetOptions<EntityUser,ModelUser>>(where: TypeModelWhere<EntityUser>, options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUser, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityUser,ModelUser>>(where: TypeModelWhere<EntityUser>, options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUser, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityUser,ModelUser>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUser, T> | undefined>;
       mget<T extends IModelGetOptions<EntityUser,ModelUser>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityUser, ModelUser, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntityUser,ModelUser,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityUser, ModelUser, T>>;
       select<T extends IModelSelectParams<EntityUser,ModelUser,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityUser, ModelUser, T>[]>;

package/vona/src/suite/a-home/modules/home-user/test/role.test.ts

@@ -9,37 +9,28 @@ describe('role.test.ts', () => {
       const roleRegisteredUser = await scope.model.role.getByName('registeredUser');
       assert.equal(roleRegisteredUser?.title, 'Registered User');
       assert.deepEqual(roleRegisteredUser?.locales, { 'zh-cn': '注册用户' });
-      assert.deepEqual(roleRegisteredUser?.siteIds, ['web']);
+      assert.ok(roleRegisteredUser?.siteIds.includes('web'));
 
       const roleSystemAdmin = await scope.model.role.getByName('systemAdmin');
       assert.equal(roleSystemAdmin?.title, 'System Administrator');
       assert.deepEqual(roleSystemAdmin?.locales, { 'zh-cn': '系统管理员' });
-      assert.deepEqual(roleSystemAdmin?.siteIds, ['web', 'admin']);
+      assert.ok(roleSystemAdmin?.siteIds.includes('web'));
+      assert.ok(roleSystemAdmin?.siteIds.includes('admin'));
 
       await app.bean.passport.signinMock();
       const passport = await app.bean.executor.performAction('get', '/home/user/passport/current');
-      assert.deepEqual(
-        passport.roles.map(role => ({
-          name: role.name,
-          title: role.title,
-          locales: role.locales,
-          siteIds: role.siteIds,
-        })),
-        [
-          {
-            name: 'registeredUser',
-            title: 'Registered User',
-            locales: { 'zh-cn': '注册用户' },
-            siteIds: ['web'],
-          },
-          {
-            name: 'systemAdmin',
-            title: 'System Administrator',
-            locales: { 'zh-cn': '系统管理员' },
-            siteIds: ['web', 'admin'],
-          },
-        ],
+      const passportRegisteredUser = passport.roles.find(
+        (role: any) => role.name === 'registeredUser',
       );
+      assert.equal(passportRegisteredUser?.title, 'Registered User');
+      assert.deepEqual(passportRegisteredUser?.locales, { 'zh-cn': '注册用户' });
+      assert.ok(passportRegisteredUser?.siteIds.includes('web'));
+
+      const passportSystemAdmin = passport.roles.find((role: any) => role.name === 'systemAdmin');
+      assert.equal(passportSystemAdmin?.title, 'System Administrator');
+      assert.deepEqual(passportSystemAdmin?.locales, { 'zh-cn': '系统管理员' });
+      assert.ok(passportSystemAdmin?.siteIds.includes('web'));
+      assert.ok(passportSystemAdmin?.siteIds.includes('admin'));
     });
   });
 });

package/vona/src/suite/a-training/modules/training-record/src/.metadata/index.ts

@@ -95,6 +95,8 @@ trainingRecordSubjects: IModelRelationHasMany<'training-recordsubject:subject',
       [SymbolKeyEntityMeta]: EntityRecordMeta;
       [SymbolKeyModelOptions]: IModelOptionsRecord;
       get<T extends IModelGetOptions<EntityRecord,ModelRecord>>(where: TypeModelWhere<EntityRecord>, options?: T): Promise<TypeModelRelationResult<EntityRecord, ModelRecord, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityRecord,ModelRecord>>(where: TypeModelWhere<EntityRecord>, options?: T): Promise<TypeModelRelationResult<EntityRecord, ModelRecord, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityRecord,ModelRecord>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityRecord, ModelRecord, T> | undefined>;
       mget<T extends IModelGetOptions<EntityRecord,ModelRecord>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityRecord, ModelRecord, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntityRecord,ModelRecord,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityRecord, ModelRecord, T>>;
       select<T extends IModelSelectParams<EntityRecord,ModelRecord,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityRecord, ModelRecord, T>[]>;
@@ -393,15 +395,15 @@ export * from '../bean/fileScene.dossierFile.ts';
 
 import { type IDecoratorFileSceneOptions } from 'vona-module-a-file';
 declare module 'vona-module-a-file' {
-
+  
     export interface IFileSceneRecord {
       'training-record:dossierFile': IDecoratorFileSceneOptions;
     }
 
-
+  
 }
 declare module 'vona-module-training-record' {
-
+  
         export interface FileSceneDossierFile {
           /** @internal */
           get scope(): ScopeModuleTrainingRecord;
@@ -411,7 +413,7 @@ declare module 'vona-module-training-record' {
             get $beanFullName(): 'training-record.fileScene.dossierFile';
             get $onionName(): 'training-record:dossierFile';
             get $onionOptions(): IDecoratorFileSceneOptions;
-          }
+          } 
 }
 /** fileScene: end */
 /** imageScene: begin */
@@ -419,15 +421,15 @@ export * from '../bean/imageScene.sceneImage.ts';
 
 import { type IDecoratorImageSceneOptions } from 'vona-module-a-image';
 declare module 'vona-module-a-image' {
-
+  
     export interface IImageSceneRecord {
       'training-record:sceneImage': IDecoratorImageSceneOptions;
     }
 
-
+  
 }
 declare module 'vona-module-training-record' {
-
+  
         export interface ImageSceneSceneImage {
           /** @internal */
           get scope(): ScopeModuleTrainingRecord;
@@ -437,7 +439,7 @@ declare module 'vona-module-training-record' {
             get $beanFullName(): 'training-record.imageScene.sceneImage';
             get $onionName(): 'training-record:sceneImage';
             get $onionOptions(): IDecoratorImageSceneOptions;
-          }
+          } 
 }
 /** imageScene: end */
 /** locale: begin */

package/vona/src/suite/a-training/modules/training-recordsubject/src/.metadata/index.ts

@@ -90,6 +90,8 @@ declare module 'vona-module-training-recordsubject' {
       [SymbolKeyEntityMeta]: EntitySubjectMeta;
       [SymbolKeyModelOptions]: IModelOptionsSubject;
       get<T extends IModelGetOptions<EntitySubject,ModelSubject>>(where: TypeModelWhere<EntitySubject>, options?: T): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntitySubject,ModelSubject>>(where: TypeModelWhere<EntitySubject>, options?: T): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntitySubject,ModelSubject>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T> | undefined>;
       mget<T extends IModelGetOptions<EntitySubject,ModelSubject>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntitySubject,ModelSubject,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntitySubject, ModelSubject, T>>;
       select<T extends IModelSelectParams<EntitySubject,ModelSubject,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntitySubject, ModelSubject, T>[]>;

package/vona/src/suite/a-training/modules/training-student/src/.metadata/index.ts

@@ -86,7 +86,7 @@ import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'von
 declare module 'vona-module-training-student' {
   export interface IModelOptionsStudent {
         relations: {
-          trainingRecords: IModelRelationHasMany<'training-record:record', 'studentId', false, 'id'|'name'|'subjectCount'|'totalScore'|'averageScore'|'trainingTime'|'sceneImageIds'|'description', undefined, undefined, undefined>;
+          trainingRecords: IModelRelationHasMany<'training-record:record', 'studentId', false, 'id'|'name'|'subjectCount'|'totalScore'|'averageScore'|'trainingTime'|'sceneImageIds'|'dossierFileIds'|'description', undefined, undefined, undefined>;
         };
       }
   export interface ModelStudent {
@@ -94,6 +94,8 @@ declare module 'vona-module-training-student' {
       [SymbolKeyEntityMeta]: EntityStudentMeta;
       [SymbolKeyModelOptions]: IModelOptionsStudent;
       get<T extends IModelGetOptions<EntityStudent,ModelStudent>>(where: TypeModelWhere<EntityStudent>, options?: T): Promise<TypeModelRelationResult<EntityStudent, ModelStudent, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityStudent,ModelStudent>>(where: TypeModelWhere<EntityStudent>, options?: T): Promise<TypeModelRelationResult<EntityStudent, ModelStudent, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityStudent,ModelStudent>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityStudent, ModelStudent, T> | undefined>;
       mget<T extends IModelGetOptions<EntityStudent,ModelStudent>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityStudent, ModelStudent, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntityStudent,ModelStudent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityStudent, ModelStudent, T>>;
       select<T extends IModelSelectParams<EntityStudent,ModelStudent,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityStudent, ModelStudent, T>[]>;

package/vona/src/suite-vendor/a-auth/modules/a-auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-auth",
-  "version": "5.1.20",
+  "version": "5.1.21",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-auth/modules/a-auth/src/.metadata/index.ts

@@ -115,7 +115,7 @@ import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'von
 declare module 'vona-module-a-auth' {
   export interface IModelOptionsAuth {
         relations: {
-          authProvider: IModelRelationBelongsTo<ModelAuth, ModelAuthProvider, false, 'id'|'providerName'|'clientName'>;
+          authProvider: IModelRelationBelongsTo<'a-auth:auth', 'a-auth:authProvider', false, 'id'|'providerName'|'clientName'>;
         };
       }
   export interface ModelAuth {
@@ -123,6 +123,8 @@ declare module 'vona-module-a-auth' {
       [SymbolKeyEntityMeta]: EntityAuthMeta;
       [SymbolKeyModelOptions]: IModelOptionsAuth;
       get<T extends IModelGetOptions<EntityAuth,ModelAuth>>(where: TypeModelWhere<EntityAuth>, options?: T): Promise<TypeModelRelationResult<EntityAuth, ModelAuth, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityAuth,ModelAuth>>(where: TypeModelWhere<EntityAuth>, options?: T): Promise<TypeModelRelationResult<EntityAuth, ModelAuth, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityAuth,ModelAuth>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityAuth, ModelAuth, T> | undefined>;
       mget<T extends IModelGetOptions<EntityAuth,ModelAuth>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityAuth, ModelAuth, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntityAuth,ModelAuth,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityAuth, ModelAuth, T>>;
       select<T extends IModelSelectParams<EntityAuth,ModelAuth,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityAuth, ModelAuth, T>[]>;
@@ -148,6 +150,8 @@ export interface ModelAuthProvider {
       [SymbolKeyEntityMeta]: EntityAuthProviderMeta;
       [SymbolKeyModelOptions]: IModelOptionsAuthProvider;
       get<T extends IModelGetOptions<EntityAuthProvider,ModelAuthProvider>>(where: TypeModelWhere<EntityAuthProvider>, options?: T): Promise<TypeModelRelationResult<EntityAuthProvider, ModelAuthProvider, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityAuthProvider,ModelAuthProvider>>(where: TypeModelWhere<EntityAuthProvider>, options?: T): Promise<TypeModelRelationResult<EntityAuthProvider, ModelAuthProvider, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityAuthProvider,ModelAuthProvider>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityAuthProvider, ModelAuthProvider, T> | undefined>;
       mget<T extends IModelGetOptions<EntityAuthProvider,ModelAuthProvider>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityAuthProvider, ModelAuthProvider, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntityAuthProvider,ModelAuthProvider,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityAuthProvider, ModelAuthProvider, T>>;
       select<T extends IModelSelectParams<EntityAuthProvider,ModelAuthProvider,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityAuthProvider, ModelAuthProvider, T>[]>;
@@ -203,11 +207,11 @@ declare module 'vona-module-a-auth' {
 /** bean: begin */
 import type { BeanAuth } from '../bean/bean.auth.ts';
 import type { BeanAuthProvider } from '../bean/bean.authProvider.ts';
-import 'vona';  
+import 'vona';
 declare module 'vona' {
   export interface IBeanRecordGlobal {
     'auth': BeanAuth;
-'authProvider': BeanAuthProvider;
+    'authProvider': BeanAuthProvider;
   }
 }
 /** bean: end */

package/vona/src/suite-vendor/a-auth/modules/auth-simple/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-auth-simple",
-  "version": "5.1.13",
+  "version": "5.1.14",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-auth/modules/auth-simple/src/.metadata/index.ts

@@ -90,6 +90,8 @@ declare module 'vona-module-auth-simple' {
       [SymbolKeyEntityMeta]: EntityAuthSimpleMeta;
       [SymbolKeyModelOptions]: IModelOptionsAuthSimple;
       get<T extends IModelGetOptions<EntityAuthSimple,ModelAuthSimple>>(where: TypeModelWhere<EntityAuthSimple>, options?: T): Promise<TypeModelRelationResult<EntityAuthSimple, ModelAuthSimple, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityAuthSimple,ModelAuthSimple>>(where: TypeModelWhere<EntityAuthSimple>, options?: T): Promise<TypeModelRelationResult<EntityAuthSimple, ModelAuthSimple, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityAuthSimple,ModelAuthSimple>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityAuthSimple, ModelAuthSimple, T> | undefined>;
       mget<T extends IModelGetOptions<EntityAuthSimple,ModelAuthSimple>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityAuthSimple, ModelAuthSimple, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntityAuthSimple,ModelAuthSimple,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityAuthSimple, ModelAuthSimple, T>>;
       select<T extends IModelSelectParams<EntityAuthSimple,ModelAuthSimple,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityAuthSimple, ModelAuthSimple, T>[]>;

package/vona/src/suite-vendor/a-auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-auth",
-  "version": "5.1.22",
+  "version": "5.1.23",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "",

package/vona/src/suite-vendor/a-cabloy/modules/a-datasharding/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-datasharding",
-  "version": "5.1.12",
+  "version": "5.1.13",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-cabloy/modules/a-datasharding/src/.metadata/index.ts

@@ -43,7 +43,7 @@ declare module 'vona-module-a-datasharding' {
 /** bean: end */
 /** bean: begin */
 import type { BeanDatasharding } from '../bean/bean.datasharding.ts';
-import 'vona';  
+import 'vona';
 declare module 'vona' {
   export interface IBeanRecordGlobal {
     'datasharding': BeanDatasharding;

package/vona/src/suite-vendor/a-cabloy/modules/a-datasource/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-datasource",
-  "version": "5.1.11",
+  "version": "5.1.12",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-cabloy/modules/a-datasource/src/.metadata/index.ts

@@ -90,6 +90,8 @@ declare module 'vona-module-a-datasource' {
       [SymbolKeyEntityMeta]: EntityDatasourceMeta;
       [SymbolKeyModelOptions]: IModelOptionsDatasource;
       get<T extends IModelGetOptions<EntityDatasource,ModelDatasource>>(where: TypeModelWhere<EntityDatasource>, options?: T): Promise<TypeModelRelationResult<EntityDatasource, ModelDatasource, T> | undefined>;
+      getForUpdate<T extends IModelGetOptions<EntityDatasource,ModelDatasource>>(where: TypeModelWhere<EntityDatasource>, options?: T): Promise<TypeModelRelationResult<EntityDatasource, ModelDatasource, T> | undefined>;
+      getByIdForUpdate<T extends IModelGetOptions<EntityDatasource,ModelDatasource>>(id: TableIdentity, options?: T): Promise<TypeModelRelationResult<EntityDatasource, ModelDatasource, T> | undefined>;
       mget<T extends IModelGetOptions<EntityDatasource,ModelDatasource>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityDatasource, ModelDatasource, T>[]>;
       selectAndCount<T extends IModelSelectParams<EntityDatasource,ModelDatasource,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<EntityDatasource, ModelDatasource, T>>;
       select<T extends IModelSelectParams<EntityDatasource,ModelDatasource,ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityDatasource, ModelDatasource, T>[]>;
@@ -139,7 +141,7 @@ declare module 'vona-module-a-datasource' {
 /** bean: end */
 /** bean: begin */
 import type { BeanDatasource } from '../bean/bean.datasource.ts';
-import 'vona';  
+import 'vona';
 declare module 'vona' {
   export interface IBeanRecordGlobal {
     'datasource': BeanDatasource;

package/vona/src/suite-vendor/a-cabloy/modules/a-socket/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-socket",
-  "version": "5.1.14",
+  "version": "5.1.15",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-cabloy/modules/a-socket/src/.metadata/index.ts

@@ -17,7 +17,7 @@ declare module 'vona-module-a-socket' {
 /** bean: end */
 /** bean: begin */
 import type { BeanSocket } from '../bean/bean.socket.ts';
-import 'vona';  
+import 'vona';
 declare module 'vona' {
   export interface IBeanRecordGlobal {
     'socket': BeanSocket;

package/vona/src/suite-vendor/a-cabloy/modules/a-ssr/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-ssr",
-  "version": "5.1.26",
+  "version": "5.1.27",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [