cabloy 5.1.112 → 5.1.114

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

@@ -2,35 +2,78 @@ import type { EntityStockReservation } from 'vona-module-commerce-trade';
 
 import { catchError } from '@cabloy/utils';
 import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
 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', {
+interface IStockFixture {
+  categoryId: number;
+  productId: number;
+  skuId: number;
+}
+
+type IStockFixturePartial = Partial<IStockFixture>;
+
+function createTestId() {
+  return randomUUID().slice(0, 12);
+}
+
+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 },
   });
-  const productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
-    body: { categoryId, title: `reservation-product-${suffix}`, published: true },
+  fixture.productId = await app.bean.executor.performAction('post', '/commerce/catalog/product', {
+    body: {
+      categoryId: fixture.categoryId,
+      title: `reservation-product-${suffix}`,
+      published: true,
+    },
   });
-  return await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
+  fixture.skuId = await app.bean.executor.performAction('post', '/commerce/catalog/sku', {
     body: {
-      productId,
+      productId: fixture.productId,
       code: `reservation-sku-${suffix}`,
       priceCents: 100,
       lifecycle: 'active',
     },
   });
+  return fixture as IStockFixture;
 }
 
-async function prepareStock(suffix: string, quantity = 3): Promise<number> {
-  const skuId = await createSku(suffix);
+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,
+    skuId: fixture.skuId,
     delta: quantity,
     reason: 'reservation test setup',
     correlationId: `reservation-setup-${suffix}`,
   });
-  return skuId;
+  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(
@@ -59,17 +102,18 @@ async function assertReservationRejected(skuId: number, suffix: string, expected
   );
 }
 
-describe('stockReservation.test.ts', () => {
+describe('stockReservation.test.ts', { concurrency: false }, () => {
   it('reserves and consumes stock exactly once with traceable audits', async () => {
     await app.bean.executor.mockCtx(async () => {
-      const suffix = `${Date.now()}`;
+      const fixtures: IStockFixturePartial[] = [];
       await app.bean.passport.signinMock();
       try {
-        const skuId = await prepareStock(suffix);
-        const reservation = await reserve(skuId, suffix);
+        const suffix = createTestId();
+        const fixture = await prepareStock(suffix, fixtures);
+        const reservation = await reserve(fixture.skuId, suffix);
         const balanceAfterReserve = await app
           .scope('commerce-trade')
-          .model.stockBalance.get({ skuId });
+          .model.stockBalance.get({ skuId: fixture.skuId });
         assert.deepEqual(
           [
             balanceAfterReserve?.onHand,
@@ -79,7 +123,7 @@ describe('stockReservation.test.ts', () => {
           [3, 2, 1],
         );
 
-        const duplicate = await reserve(skuId, suffix);
+        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,
@@ -94,7 +138,7 @@ describe('stockReservation.test.ts', () => {
 
         const balanceAfterConsume = await app
           .scope('commerce-trade')
-          .model.stockBalance.get({ skuId });
+          .model.stockBalance.get({ skuId: fixture.skuId });
         assert.deepEqual(
           [
             balanceAfterConsume?.onHand,
@@ -103,15 +147,16 @@ describe('stockReservation.test.ts', () => {
           ],
           [1, 0, 1],
         );
-        const audits = await app
-          .scope('commerce-trade')
-          .model.stockAudit.select({ where: { skuId } });
+        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();
       }
     });
@@ -119,36 +164,29 @@ describe('stockReservation.test.ts', () => {
 
   it('rejects reservations for inactive or unpublished catalog data without writes', async () => {
     await app.bean.executor.mockCtx(async () => {
-      const suffix = `${Date.now()}`;
+      const fixtures: IStockFixturePartial[] = [];
       await app.bean.passport.signinMock();
       try {
-        const inactiveSkuId = await prepareStock(`${suffix}-inactive`);
-        await app.scope('commerce-catalog').model.sku.updateById(inactiveSkuId, {
+        const suffix = createTestId();
+        const inactiveSku = await prepareStock(`${suffix}-inactive`, fixtures);
+        await app.scope('commerce-catalog').model.sku.updateById(inactiveSku.skuId, {
           lifecycle: 'inactive',
         });
-        await assertReservationRejected(inactiveSkuId, `${suffix}-inactive`, 404);
+        await assertReservationRejected(inactiveSku.skuId, `${suffix}-inactive`, 404);
 
-        const unpublishedProductSkuId = await prepareStock(`${suffix}-product`);
-        const unpublishedProductSku = await app
-          .scope('commerce-catalog')
-          .model.sku.getById(unpublishedProductSkuId);
+        const unpublishedProductSku = await prepareStock(`${suffix}-product`, fixtures);
         await app
           .scope('commerce-catalog')
-          .model.product.updateById(unpublishedProductSku!.productId, { published: false });
-        await assertReservationRejected(unpublishedProductSkuId, `${suffix}-product`, 409);
+          .model.product.updateById(unpublishedProductSku.productId, { published: false });
+        await assertReservationRejected(unpublishedProductSku.skuId, `${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);
+        const unpublishedCategorySku = await prepareStock(`${suffix}-category`, fixtures);
         await app
           .scope('commerce-catalog')
-          .model.category.updateById(unpublishedCategoryProduct!.categoryId, { published: false });
-        await assertReservationRejected(unpublishedCategorySkuId, `${suffix}-category`, 409);
+          .model.category.updateById(unpublishedCategorySku.categoryId, { published: false });
+        await assertReservationRejected(unpublishedCategorySku.skuId, `${suffix}-category`, 409);
       } finally {
+        await dropStockFixtures(fixtures);
         await app.bean.passport.signout();
       }
     });
@@ -156,11 +194,12 @@ describe('stockReservation.test.ts', () => {
 
   it('releases and restores stock only from legal reservation states', async () => {
     await app.bean.executor.mockCtx(async () => {
-      const suffix = `${Date.now()}`;
+      const fixtures: IStockFixturePartial[] = [];
       await app.bean.passport.signinMock();
       try {
-        const skuId = await prepareStock(suffix);
-        const releasedReservation = await reserve(skuId, `${suffix}-release`);
+        const suffix = createTestId();
+        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',
@@ -172,7 +211,7 @@ describe('stockReservation.test.ts', () => {
         });
         assert.equal(duplicateRelease.state, 'released');
 
-        const consumedReservation = await reserve(skuId, `${suffix}-restore`, 1);
+        const consumedReservation = await reserve(fixture.skuId, `${suffix}-restore`, 1);
         await app.scope('commerce-trade').service.stockBalance.consume({
           reservationId: consumedReservation.id,
           reason: 'payment success',
@@ -182,6 +221,11 @@ describe('stockReservation.test.ts', () => {
           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({
@@ -190,71 +234,227 @@ describe('stockReservation.test.ts', () => {
           }),
         );
         assert.equal(err?.code, 409);
-        const balance = await app.scope('commerce-trade').model.stockBalance.get({ skuId });
+        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 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);
+  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 = createTestId();
+    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),
+      );
 
-        const balance = await app.scope('commerce-trade').model.stockBalance.get({ skuId });
+      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 },
+          where: { skuId: fixture.skuId },
+        });
+        const audits = await app.scope('commerce-trade').model.stockAudit.select({
+          where: { skuId: fixture.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();
-      }
-    });
+        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 and balance when audit persistence fails', async () => {
+  it('rolls back reservation, balance, and audit writes in one transaction', async () => {
     await app.bean.executor.mockCtx(async () => {
-      const suffix = `${Date.now()}`;
+      const fixtures: IStockFixturePartial[] = [];
       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 suffix = createTestId();
+        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 balance = await app.scope('commerce-trade').model.stockBalance.get({ skuId });
-        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [3, 0, 3]);
+        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 }),
+          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-vendor/a-image/modules/image-cloudflare/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-image-cloudflare",
-  "version": "5.0.6",
+  "version": "5.0.7",
   "description": "",
   "keywords": [
     "Vona Module"

package/vona/src/suite-vendor/a-image/modules/image-cloudflare/src/service/imageCloudflare.ts

@@ -162,7 +162,7 @@ export class ServiceImageCloudflare extends BeanBase {
     options: IImageProviderCloudflareClientOptions,
   ) {
     const normalized = this._normalizeClientOptions(options);
-    const response = await fetch(
+    const response = await this.bean.core.fetch(
       `${normalized.apiBaseUrl}/accounts/${normalized.accountId}/images/v1/${encodeURIComponent(image.resourceId)}`,
       {
         method: 'DELETE',
@@ -247,13 +247,16 @@ export class ServiceImageCloudflare extends BeanBase {
     apiPath: string,
     init: RequestInit,
   ) {
-    const response = await fetch(`${options.apiBaseUrl}/accounts/${options.accountId}${apiPath}`, {
-      ...init,
-      headers: {
-        ...this._createHeaders(options),
-        ...(init.headers ?? {}),
+    const response = await this.bean.core.fetch(
+      `${options.apiBaseUrl}/accounts/${options.accountId}${apiPath}`,
+      {
+        ...init,
+        headers: {
+          ...this._createHeaders(options),
+          ...(init.headers ?? {}),
+        },
       },
-    });
+    );
     return await this._parseEnvelope<T>(response);
   }
 

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-image",
-  "version": "5.0.7",
+  "version": "5.0.8",
   "description": "",
   "author": "",
   "files": [],

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

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

package/vona/src/suite-vendor/a-vona/modules/a-aspect/src/types/aopMethod.ts

@@ -15,15 +15,28 @@ export interface IUseAopMethodPropMetadataInner<T extends keyof IAopMethodRecord
 
 export interface IAopMethodRecord {}
 
+export type AopMethodNext = Next & {
+  replay: Next;
+};
+
+export type AopMethodNextSync = NextSync & {
+  replay: NextSync;
+};
+
 export interface IAopMethodGet {
-  get(options: IDecoratorAopMethodOptions, next: NextSync, receiver: any, prop: string): any;
+  get(
+    options: IDecoratorAopMethodOptions,
+    next: AopMethodNextSync,
+    receiver: any,
+    prop: string,
+  ): any;
 }
 
 export interface IAopMethodSet {
   set(
     options: IDecoratorAopMethodOptions,
     value: any,
-    next: NextSync,
+    next: AopMethodNextSync,
     receiver: any,
     prop: string,
   ): boolean;
@@ -33,7 +46,7 @@ export interface IAopMethodExecute {
   execute(
     options: IDecoratorAopMethodOptions,
     args: [],
-    next: Next | NextSync,
+    next: AopMethodNext | AopMethodNextSync,
     receiver: any,
     prop: string,
   ): Promise<any> | any;

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-core",
-  "version": "5.1.44",
+  "version": "5.1.45",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [
@@ -84,7 +84,9 @@
   },
   "title": "a-core",
   "vonaModule": {
-    "dependencies": {},
+    "dependencies": {
+      "a-retryable": "5.0.0"
+    },
     "globalDependencies": {
       "@babel/core": true,
       "@babel/traverse": true,

package/vona/src/suite-vendor/a-vona/modules/a-core/src/bean/bean.core.ts

@@ -1,6 +1,8 @@
 import { BeanBase } from 'vona';
 import { Bean } from 'vona-module-a-bean';
 
+import type { TypeContextFetch } from '../types/fetch.ts';
+
 @Bean()
 export class BeanCore extends BeanBase {
   get protocol() {
@@ -11,6 +13,10 @@ export class BeanCore extends BeanBase {
     return this.app.util.host;
   }
 
+  get fetch(): TypeContextFetch {
+    return this.ctx.state.fetch ?? globalThis.fetch;
+  }
+
   getAbsoluteUrl(path?: string) {
     return this.app.util.getAbsoluteUrl(path);
   }

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

@@ -1,2 +1,3 @@
 export * from './.metadata/index.ts';
 export * from './lib/index.ts';
+export * from './types/index.ts';

package/vona/src/suite-vendor/a-vona/modules/a-core/src/lib/core.ts

@@ -3,6 +3,7 @@ import type { IFilterOptionsError } from 'vona-module-a-error';
 import type { IAopMethodOptionsLog } from 'vona-module-a-logger';
 import type { TypeUseOnionOmitOptionsGlobal } from 'vona-module-a-onion';
 import type { IAopMethodOptionsTransaction } from 'vona-module-a-orm';
+import type { IAopMethodOptionsRetryable } from 'vona-module-a-retryable';
 import type { IInterceptorOptionsUpload } from 'vona-module-a-upload';
 
 import { Aspect } from 'vona-module-a-aspect';
@@ -29,6 +30,10 @@ function Transaction(options?: Partial<IAopMethodOptionsTransaction>): MethodDec
   return Aspect.aopMethod('a-orm:transaction', options);
 }
 
+function Retryable(options: IAopMethodOptionsRetryable): MethodDecorator {
+  return Aspect.aopMethod('a-retryable:retryable', options);
+}
+
 function CaptchaVerify(options?: Partial<IInterceptorOptionsCaptchaVerify>): MethodDecorator {
   return Aspect.interceptor('a-captcha:captchaVerify', options);
 }
@@ -46,6 +51,7 @@ export const Core = {
   error: Error,
   log: Log,
   transaction: Transaction,
+  retryable: Retryable,
   captchaVerify: CaptchaVerify,
   fileUpload: FileUpload,
   serializer: Serializer,