cabloy 5.1.111 → 5.1.113

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

@@ -0,0 +1,457 @@
+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';
+
+interface IStockFixture {
+  categoryId: number;
+  productId: number;
+  skuId: number;
+}
+
+type IStockFixturePartial = Partial<IStockFixture>;
+
+async function createSku(suffix: string, fixtures: IStockFixturePartial[]): Promise<IStockFixture> {
+  const fixture: IStockFixturePartial = {};
+  fixtures.push(fixture);
+  fixture.categoryId = await app.bean.executor.performAction('post', '/commerce/catalog/category', {
+    body: { name: `reservation-category-${suffix}`, published: true },
+  });
+  fixture.productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
+    body: {
+      categoryId: fixture.categoryId,
+      title: `reservation-product-${suffix}`,
+      published: true,
+    },
+  });
+  fixture.skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+    body: {
+      productId: fixture.productId,
+      code: `reservation-sku-${suffix}`,
+      priceCents: 100,
+      lifecycle: 'active',
+    },
+  });
+  return fixture as IStockFixture;
+}
+
+async function prepareStock(
+  suffix: string,
+  fixtures: IStockFixturePartial[],
+  quantity = 3,
+): Promise<IStockFixture> {
+  const fixture = await createSku(suffix, fixtures);
+  await app.scope('commerce-trade').service.stockBalance.adjustStock({
+    skuId: fixture.skuId,
+    delta: quantity,
+    reason: 'reservation test setup',
+    correlationId: `reservation-setup-${suffix}`,
+  });
+  return fixture;
+}
+
+async function dropStockFixtures(fixtures: IStockFixturePartial[]) {
+  const scopeTrade = app.scope('commerce-trade');
+  const scopeCatalog = app.scope('commerce-catalog');
+  for (const fixture of fixtures.toReversed()) {
+    if (fixture.skuId !== undefined) {
+      await scopeTrade.model.stockAudit.delete({ skuId: fixture.skuId });
+      await scopeTrade.model.stockReservation.delete({ skuId: fixture.skuId });
+      await scopeTrade.model.stockBalance.delete({ skuId: fixture.skuId });
+      await scopeCatalog.model.sku.delete({ id: fixture.skuId });
+    }
+    if (fixture.productId !== undefined) {
+      await scopeCatalog.model.product.delete({ id: fixture.productId });
+    }
+    if (fixture.categoryId !== undefined) {
+      await scopeCatalog.model.category.delete({ id: fixture.categoryId });
+    }
+  }
+}
+
+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 fixtures: IStockFixturePartial[] = [];
+      await app.bean.passport.signinMock();
+      try {
+        const suffix = `${Date.now()}`;
+        const fixture = await prepareStock(suffix, fixtures);
+        const reservation = await reserve(fixture.skuId, suffix);
+        const balanceAfterReserve = await app
+          .scope('commerce-trade')
+          .model.stockBalance.get({ skuId: fixture.skuId });
+        assert.deepEqual(
+          [
+            balanceAfterReserve?.onHand,
+            balanceAfterReserve?.reserved,
+            balanceAfterReserve?.available,
+          ],
+          [3, 2, 1],
+        );
+
+        const duplicate = await reserve(fixture.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: fixture.skuId });
+        assert.deepEqual(
+          [
+            balanceAfterConsume?.onHand,
+            balanceAfterConsume?.reserved,
+            balanceAfterConsume?.available,
+          ],
+          [1, 0, 1],
+        );
+        const audits = await app.scope('commerce-trade').model.stockAudit.select({
+          where: { skuId: fixture.skuId },
+        });
+        assert.deepEqual(
+          audits.map(audit => audit.operation),
+          ['adjust', 'reserve', 'consume'],
+        );
+        assert.equal(audits[1].stockReservationId, reservation.id);
+      } finally {
+        await dropStockFixtures(fixtures);
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('rejects reservations for inactive or unpublished catalog data without writes', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixtures: IStockFixturePartial[] = [];
+      await app.bean.passport.signinMock();
+      try {
+        const suffix = `${Date.now()}`;
+        const inactiveSku = await prepareStock(`${suffix}-inactive`, fixtures);
+        await app.scope('commerce-catalog').model.sku.updateById(inactiveSku.skuId, {
+          lifecycle: 'inactive',
+        });
+        await assertReservationRejected(inactiveSku.skuId, `${suffix}-inactive`, 404);
+
+        const unpublishedProductSku = await prepareStock(`${suffix}-product`, fixtures);
+        await app
+          .scope('commerce-catalog')
+          .model.product.updateById(unpublishedProductSku.productId, { published: false });
+        await assertReservationRejected(unpublishedProductSku.skuId, `${suffix}-product`, 409);
+
+        const unpublishedCategorySku = await prepareStock(`${suffix}-category`, fixtures);
+        await app
+          .scope('commerce-catalog')
+          .model.category.updateById(unpublishedCategorySku.categoryId, { published: false });
+        await assertReservationRejected(unpublishedCategorySku.skuId, `${suffix}-category`, 409);
+      } finally {
+        await dropStockFixtures(fixtures);
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('releases and restores stock only from legal reservation states', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixtures: IStockFixturePartial[] = [];
+      await app.bean.passport.signinMock();
+      try {
+        const suffix = `${Date.now()}`;
+        const fixture = await prepareStock(suffix, fixtures);
+        const releasedReservation = await reserve(fixture.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(fixture.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 duplicateRestore = await app.scope('commerce-trade').service.stockBalance.restore({
+          reservationId: consumedReservation.id,
+          reason: 'refund success retry',
+        });
+        assert.equal(duplicateRestore.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: fixture.skuId });
+        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [3, 0, 3]);
+        const audits = await app.scope('commerce-trade').model.stockAudit.select({
+          where: { skuId: fixture.skuId },
+        });
+        assert.equal(audits.length, 6);
+        assert.deepEqual(
+          audits.map(audit => audit.operation),
+          ['adjust', 'reserve', 'release', 'reserve', 'consume', 'restore'],
+        );
+        assert.deepEqual(
+          audits.map(audit => audit.stockBalanceId),
+          audits.map(() => balance?.id),
+        );
+        assert.deepEqual(
+          audits.map(audit => audit.stockReservationId),
+          [
+            null,
+            releasedReservation.id,
+            releasedReservation.id,
+            consumedReservation.id,
+            consumedReservation.id,
+            consumedReservation.id,
+          ],
+        );
+        assert.deepEqual(
+          audits.map(audit => audit.correlationId),
+          [
+            `reservation-setup-${suffix}`,
+            `reservation-${suffix}-release`,
+            `reservation-${suffix}-release`,
+            `reservation-${suffix}-restore`,
+            `reservation-${suffix}-restore`,
+            `reservation-${suffix}-restore`,
+          ],
+        );
+        assert.deepEqual(
+          audits.map(audit => audit.reason),
+          [
+            'reservation test setup',
+            'reservation test',
+            'payment failed',
+            'reservation test',
+            'payment success',
+            'refund success',
+          ],
+        );
+        assert.deepEqual(
+          audits.map(audit => [
+            audit.delta,
+            audit.priorOnHand,
+            audit.priorReserved,
+            audit.priorAvailable,
+            audit.onHand,
+            audit.reserved,
+            audit.available,
+          ]),
+          [
+            [3, 0, 0, 0, 3, 0, 3],
+            [-2, 3, 0, 3, 3, 2, 1],
+            [0, 3, 2, 1, 3, 0, 3],
+            [-1, 3, 0, 3, 3, 1, 2],
+            [-1, 3, 1, 2, 2, 0, 2],
+            [1, 2, 0, 2, 3, 0, 3],
+          ],
+        );
+      } finally {
+        await dropStockFixtures(fixtures);
+        await app.bean.passport.signout();
+      }
+    });
+  });
+
+  it('allows exactly one independent reservation for the final unit', async t => {
+    if (process.env.DATABASE_DEFAULT_CLIENT !== 'pg') {
+      t.skip('requires PostgreSQL row-lock contention');
+      return;
+    }
+    const fixtures: IStockFixturePartial[] = [];
+    const suffix = `${Date.now()}`;
+    let fixture!: IStockFixture;
+    try {
+      await app.bean.executor.mockCtx(async () => {
+        await app.bean.passport.signinMock();
+        try {
+          fixture = await prepareStock(suffix, fixtures, 1);
+        } finally {
+          await app.bean.passport.signout();
+        }
+      });
+
+      const reserveInContext = async (correlationSuffix: string) => {
+        return await app.bean.executor.mockCtx(async () => {
+          await app.bean.passport.signinMock();
+          try {
+            return await reserve(fixture.skuId, correlationSuffix, 1);
+          } finally {
+            await app.bean.passport.signout();
+          }
+        });
+      };
+      const results = await Promise.allSettled([
+        reserveInContext(`${suffix}-first`),
+        reserveInContext(`${suffix}-second`),
+      ]);
+      assert.equal(
+        results.filter(result => result.status === 'fulfilled').length,
+        1,
+        JSON.stringify(results),
+      );
+      assert.equal(
+        results.filter(result => result.status === 'rejected').length,
+        1,
+        JSON.stringify(results),
+      );
+      const rejected = results.find(result => result.status === 'rejected');
+      assert.equal(
+        (rejected as PromiseRejectedResult | undefined)?.reason?.code,
+        409,
+        String((rejected as PromiseRejectedResult | undefined)?.reason),
+      );
+
+      await app.bean.executor.mockCtx(async () => {
+        const balance = await app
+          .scope('commerce-trade')
+          .model.stockBalance.get({ skuId: fixture.skuId });
+        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [1, 1, 0]);
+        const reservations = await app.scope('commerce-trade').model.stockReservation.select({
+          where: { skuId: fixture.skuId },
+        });
+        const audits = await app.scope('commerce-trade').model.stockAudit.select({
+          where: { skuId: fixture.skuId },
+        });
+        assert.equal(reservations.length, 1);
+        assert.deepEqual(
+          audits.map(audit => audit.operation),
+          ['adjust', 'reserve'],
+        );
+        assert.equal(audits.filter(audit => audit.operation === 'reserve').length, 1);
+        assert.equal(
+          audits.some(audit => audit.correlationId === `reservation-${suffix}-first`) ||
+            audits.some(audit => audit.correlationId === `reservation-${suffix}-second`),
+          true,
+        );
+      });
+    } finally {
+      await app.bean.executor.mockCtx(async () => {
+        await dropStockFixtures(fixtures);
+      });
+    }
+  });
+
+  it('rolls back reservation, balance, and audit writes in one transaction', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixtures: IStockFixturePartial[] = [];
+      await app.bean.passport.signinMock();
+      try {
+        const suffix = `${Date.now()}`;
+        const fixture = await prepareStock(suffix, fixtures);
+        const balance = await app.scope('commerce-trade').model.stockBalance.get({
+          skuId: fixture.skuId,
+        });
+        const db = app.ctx.db;
+        const [_, err] = await catchError(async () => {
+          await db.transaction.begin(async () => {
+            const modelStockBalance = app
+              .scope('commerce-trade')
+              .model.stockBalance.newInstance(db);
+            const modelStockReservation = app
+              .scope('commerce-trade')
+              .model.stockReservation.newInstance(db);
+            const modelStockAudit = app.scope('commerce-trade').model.stockAudit.newInstance(db);
+            const reservation = await modelStockReservation.insert({
+              stockBalanceId: balance!.id,
+              skuId: fixture.skuId,
+              quantity: 2,
+              state: 'reserved',
+              correlationId: `reservation-${suffix}-rollback`,
+            });
+            await modelStockBalance.updateById(balance!.id, {
+              onHand: 3,
+              reserved: 2,
+              available: 1,
+            });
+            await modelStockAudit.insert({
+              stockBalanceId: balance!.id,
+              skuId: fixture.skuId,
+              stockReservationId: reservation.id,
+              actorId: app.bean.passport.currentUser!.id,
+              operation: 'reserve',
+              delta: -2,
+              reason: 'transaction rollback proof',
+              correlationId: reservation.correlationId,
+              priorOnHand: 3,
+              priorReserved: 0,
+              priorAvailable: 3,
+              onHand: 3,
+              reserved: 2,
+              available: 1,
+            });
+            throw new Error('transaction rollback proof');
+          });
+        });
+        assert.match(err?.message ?? '', /transaction rollback proof/);
+
+        const unchanged = await app
+          .scope('commerce-trade')
+          .model.stockBalance.get({ skuId: fixture.skuId });
+        assert.deepEqual([unchanged?.onHand, unchanged?.reserved, unchanged?.available], [3, 0, 3]);
+        assert.equal(
+          await app.scope('commerce-trade').model.stockReservation.get({ skuId: fixture.skuId }),
+          undefined,
+        );
+        const audits = await app.scope('commerce-trade').model.stockAudit.select({
+          where: { skuId: fixture.skuId },
+        });
+        assert.equal(audits.length, 1);
+      } finally {
+        await dropStockFixtures(fixtures);
+        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": [