cabloy 5.1.125 → 5.1.127

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

@@ -1,7 +1,7 @@
 import assert from 'node:assert';
 import { createHmac, randomUUID } from 'node:crypto';
-import { describe, it } from 'node:test';
-import { app } from 'vona-mock';
+import { after, before, describe, it } from 'node:test';
+import { acquireTestLock, app } from 'vona-mock';
 
 interface IFixture {
   categoryId?: number;
@@ -166,6 +166,23 @@ async function createCheckoutFixture(suffix: string, withCoupon = true): Promise
 }
 
 describe('paymentOutcome.test.ts', { concurrency: false, sequential: true }, () => {
+  const releaseTestLocks: Array<() => void> = [];
+
+  before(async () => {
+    try {
+      for (const scene of ['a-commerce', 'a-pay']) {
+        releaseTestLocks.push(await acquireTestLock(scene));
+      }
+    } catch (error) {
+      for (const release of releaseTestLocks.reverse()) release();
+      throw error;
+    }
+  });
+
+  after(() => {
+    for (const release of releaseTestLocks.reverse()) release();
+  });
+
   it('delivers a signed webhook through the durable outbox to Commerce exactly once', async () => {
     await app.bean.executor.mockCtx(async () => {
       const fixture: IFixture = {};

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

@@ -16,6 +16,7 @@ interface IFixture {
   customerName?: string;
   orderId?: number;
   paymentAttemptId?: number;
+  paymentSessionId?: number;
 }
 
 async function cleanup(fixture: IFixture) {
@@ -24,6 +25,21 @@ async function cleanup(fixture: IFixture) {
   const promotion = app.scope('commerce-promotion');
   const catalog = app.scope('commerce-catalog');
   const member = app.scope('commerce-member');
+  const pay = app.scope('a-pay');
+  if (fixture.paymentSessionId !== undefined) {
+    const refundOperations = await pay.model.refundOperation.select({
+      where: { paymentSessionId: fixture.paymentSessionId },
+    });
+    for (const refundOperation of refundOperations) {
+      await pay.model.providerOperation.delete({ refundOperationId: refundOperation.id });
+      await pay.model.outboxEvent.delete({ refundOperationId: refundOperation.id });
+      await pay.model.webhookInbox.delete({ refundOperationId: refundOperation.id });
+      await pay.model.refundOperation.delete({ id: refundOperation.id });
+    }
+    await pay.model.outboxEvent.delete({ paymentSessionId: fixture.paymentSessionId });
+    await pay.model.webhookInbox.delete({ paymentSessionId: fixture.paymentSessionId });
+    await pay.model.providerOperation.delete({ paymentSessionId: fixture.paymentSessionId });
+  }
   if (fixture.orderId !== undefined) {
     const requests = await payment.model.refundRequest.select({
       where: { orderId: fixture.orderId },
@@ -39,6 +55,8 @@ async function cleanup(fixture: IFixture) {
     await payment.model.paymentAudit.delete({ paymentAttemptId: fixture.paymentAttemptId });
     await payment.model.paymentAttempt.delete({ id: fixture.paymentAttemptId });
   }
+  if (fixture.paymentSessionId !== undefined)
+    await pay.model.paymentSession.delete({ id: fixture.paymentSessionId });
   if (fixture.orderId !== undefined)
     await trade.model.orderAudit.delete({ orderId: fixture.orderId });
   if (fixture.skuId !== undefined) await trade.model.stockAudit.delete({ skuId: fixture.skuId });
@@ -152,10 +170,17 @@ async function createPaidOrder(suffix: string): Promise<IFixture> {
   });
   fixture.orderId = checkout.orderId as number;
   fixture.paymentAttemptId = checkout.paymentAttemptId as number;
-  await app.scope('commerce-trade').service.order.applyPaymentOutcome(fixture.paymentAttemptId, {
-    outcome: 'succeeded',
-    idempotencyKey: `refund-payment-${suffix}`,
+  fixture.paymentSessionId = checkout.paymentSessionId as number;
+  const pay = app.scope('a-pay');
+  await pay.service.paymentSession.start(fixture.paymentSessionId);
+  await app
+    .scope('pay-mock')
+    .service.payMock.completePaymentSession(fixture.paymentSessionId, 'succeeded');
+  const outbox = await pay.model.outboxEvent.get({
+    paymentSessionId: fixture.paymentSessionId,
+    eventType: 'payment.outcome.v1',
   });
+  await pay.queue.outboxDispatch.pushAsync({ outboxEventId: outbox!.id });
   return fixture;
 }
 
@@ -310,6 +335,89 @@ describe('refundLifecycle.test.ts', { concurrency: false, sequential: true }, ()
     });
   });
 
+  it('settles an executed mock-provider refund through the durable outbox', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const fixture: IFixture = {};
+      try {
+        Object.assign(fixture, await createPaidOrder(randomUUID().slice(0, 12)));
+        const order = app.scope('commerce-trade').service.order;
+        await order.requestRefund(fixture.orderId!, {
+          reason: 'provider-backed refund',
+          idempotencyKey: 'provider-backed-request-1',
+        });
+        await app.bean.passport.signout();
+        await app.bean.passport.signinMock();
+        await order.approveRefund(fixture.orderId!, {
+          reason: 'provider-backed approval',
+          idempotencyKey: 'provider-backed-approve-1',
+        });
+        const executed = await order.executeRefund(fixture.orderId!);
+        assert.ok(executed.refundAttemptId);
+        assert.ok(executed.refundOperationId);
+        assert.deepEqual(
+          [executed.orderState, executed.refundState, executed.refundAttemptState],
+          ['refund_approved', 'approved', 'created'],
+        );
+        const pay = app.scope('a-pay');
+        const refundOperation = await pay.model.refundOperation.getById(executed.refundOperationId);
+        const refundAttempt = await app
+          .scope('commerce-payment')
+          .model.refundAttempt.getById(executed.refundAttemptId);
+        assert.equal(String(refundAttempt?.refundOperationId), String(executed.refundOperationId));
+        assert.equal(refundOperation?.state, 'pending');
+        const receipt = await app
+          .scope('pay-mock')
+          .service.payMock.completeRefundOperation(executed.refundOperationId, 'succeeded');
+        assert.deepEqual(receipt, {
+          refundOperationId: executed.refundOperationId,
+          accepted: true,
+        });
+        const outbox = await pay.model.outboxEvent.get({
+          refundOperationId: executed.refundOperationId,
+          eventType: 'refund.outcome.v1',
+        });
+        assert.ok(outbox);
+        await pay.queue.outboxDispatch.pushAsync({ outboxEventId: outbox.id });
+        await pay.queue.outboxDispatch.pushAsync({ outboxEventId: outbox.id });
+        const [
+          dispatched,
+          settledOrder,
+          settledRequest,
+          settledAttempt,
+          line,
+          balance,
+          grant,
+          audits,
+        ] = await Promise.all([
+          pay.model.outboxEvent.getById(outbox.id),
+          app.scope('commerce-trade').model.order.getById(fixture.orderId!),
+          app.scope('commerce-payment').model.refundRequest.getById(executed.refundRequestId),
+          app.scope('commerce-payment').model.refundAttempt.getById(executed.refundAttemptId),
+          app.scope('commerce-trade').model.orderLine.get({ orderId: fixture.orderId }),
+          app.scope('commerce-trade').model.stockBalance.getById(fixture.balanceId!),
+          app.scope('commerce-promotion').model.couponGrant.getById(fixture.grantId!),
+          app
+            .scope('commerce-payment')
+            .model.refundAudit.select({ where: { orderId: fixture.orderId } }),
+        ]);
+        const reservation = await app
+          .scope('commerce-trade')
+          .model.stockReservation.get({ orderLineId: line?.id });
+        assert.deepEqual([dispatched?.state, dispatched?.attemptCount], ['dispatched', 1]);
+        assert.deepEqual(
+          [settledOrder?.state, settledRequest?.state, settledAttempt?.state, reservation?.state],
+          ['refunded', 'refunded', 'succeeded', 'restored'],
+        );
+        assert.deepEqual([balance?.onHand, balance?.reserved, balance?.available], [1, 0, 1]);
+        assert.equal(grant?.state, 'redeemed');
+        assert.equal(audits.filter(audit => audit.toRefundState === 'refunded').length, 1);
+      } finally {
+        await app.bean.passport.signout();
+        await cleanup(fixture);
+      }
+    });
+  });
+
   it('preserves rejected and failed cycles while permitting a fresh request', async () => {
     await app.bean.executor.mockCtx(async () => {
       const fixture: IFixture = {};

package/vona/src/suite/a-training/modules/training-record/src/dto/detailRecordSubjectResItem.tsx

@@ -38,7 +38,12 @@ export interface IDtoOptionsDetailRecordSubjectResItem extends IDecoratorDtoOpti
 export class DtoDetailRecordSubjectResItem extends $Dto.get(() => ModelSubject, {
   dtoClass: DtoDetailRecordSubjectBase,
 }) {
-  @Api.field(v.title('#'), ZovaRender.order(1, 'core'), ZovaRender.cell('basic-details:lineNumber'))
+  @Api.field(
+    v.title('#'),
+    ZovaRender.order(1, 'core'),
+    ZovaRender.cell('basic-details:lineNumber'),
+    v.optional(),
+  )
   _lineNumber?: number;
 
   @Api.field(

package/vona/src/suite/a-training/modules/training-record/src/dto/recordSelectResItem.tsx

@@ -49,7 +49,9 @@ export interface IDtoOptionsRecordSelectResItem extends IDecoratorDtoOptions {}
     }),
   ],
 })
-export class DtoRecordSelectResItem extends $Dto.get(() => ModelRecord) {
+export class DtoRecordSelectResItem extends $Dto.get(() => ModelRecord, {
+  include: { student: true },
+}) {
   @Api.field(
     ZovaRender.visible(false),
     v.optional(),

package/vona/src/suite/a-training/modules/training-record/src/dto/recordView.tsx

@@ -37,7 +37,10 @@ export interface IDtoOptionsRecordView extends IDecoratorDtoOptions {}
   },
 })
 export class DtoRecordView extends $Dto.get(() => ModelRecord, {
-  include: { trainingRecordSubjects: { dtoClass: DtoDetailRecordSubjectView } },
+  include: {
+    student: true,
+    trainingRecordSubjects: { dtoClass: DtoDetailRecordSubjectView },
+  },
 }) {
   @Api.field(
     ZovaRender.visible(false),

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

@@ -8,10 +8,51 @@ import path from 'node:path';
 import { describe, it } from 'node:test';
 import { app } from 'vona-mock';
 
+import { DtoDetailRecordSubjectResItem } from '../src/dto/detailRecordSubjectResItem.tsx';
+import { DtoRecordSelectResItem } from '../src/dto/recordSelectResItem.tsx';
+import { DtoRecordView } from '../src/dto/recordView.tsx';
+
 const dossierTextAttendance = Buffer.from('attendance dossier file');
 const dossierTextAssessment = Buffer.from('assessment dossier file');
 
 describe('record.test.ts', () => {
+  it('action:record:emittedDtoSchemas', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const subjectApiJson = await app.bean.openapi.generateJsonOfClass(
+        DtoDetailRecordSubjectResItem,
+      );
+      const subjectComponent = Object.values(subjectApiJson.components!.schemas as any).find(
+        item => (item as any).properties?._lineNumber,
+      ) as any;
+      assert.ok(subjectComponent?.properties?._lineNumber);
+      assert.equal(subjectComponent.required?.includes('_lineNumber'), false);
+
+      for (const [DtoClass, hasTrainingRecordSubjects] of [
+        [DtoRecordSelectResItem, false],
+        [DtoRecordView, true],
+      ] as const) {
+        const apiJson = await app.bean.openapi.generateJsonOfClass(DtoClass);
+        const component = Object.values(apiJson.components!.schemas as any).find(item => {
+          const properties = (item as any).properties;
+          return (
+            properties?.student &&
+            Boolean(properties?.trainingRecordSubjects) === hasTrainingRecordSubjects
+          );
+        }) as any;
+        assert.ok(component);
+        assert.ok(component.properties.student);
+        assert.equal(
+          Boolean(component.properties.trainingRecordSubjects),
+          hasTrainingRecordSubjects,
+        );
+        assert.deepEqual(Object.keys(component.properties.student.properties).sort(), [
+          'id',
+          'name',
+        ]);
+      }
+    });
+  });
+
   it('action:record', async () => {
     await app.bean.executor.mockCtx(async () => {
       const studentData: DtoStudentCreate = {
@@ -80,6 +121,8 @@ describe('record.test.ts', () => {
         assert.equal(!!recordItem, true);
         assert.equal(recordItem!.name, recordData.name);
         assert.equal(String(recordItem!.studentId), String(studentId));
+        assert.equal(String(recordItem!.student?.id), String(studentId));
+        assert.equal(recordItem!.student?.name, studentData.name);
         assert.equal(recordItem!.dossierFiles?.length, 1);
         assert.equal(recordItem!.dossierFiles?.[0]?.filename, 'attendance.txt');
 
@@ -90,6 +133,8 @@ describe('record.test.ts', () => {
         const recordDossierFile = record.dossierFiles?.[0];
         assert.equal(record.name, recordData.name);
         assert.equal(String(record.studentId), String(studentId));
+        assert.equal(String(record.student?.id), String(studentId));
+        assert.equal(record.student?.name, studentData.name);
         assert.equal(record.subjectCount, recordData.subjectCount);
         assert.equal(record.totalScore, recordData.totalScore);
         assert.equal(Number(record.averageScore), recordData.averageScore);

package/vona/src/suite/a-training/modules/training-student/src/dto/detailRecordResItem.tsx

@@ -39,7 +39,12 @@ export class DtoDetailRecordResItem extends $Dto.get(() => ModelRecord, {
   dtoClass: DtoDetailRecordBase,
   include: { trainingRecordSubjects: false },
 }) {
-  @Api.field(v.title('#'), ZovaRender.order(1, 'core'), ZovaRender.cell('basic-details:lineNumber'))
+  @Api.field(
+    v.title('#'),
+    ZovaRender.order(1, 'core'),
+    ZovaRender.cell('basic-details:lineNumber'),
+    v.optional(),
+  )
   _lineNumber?: number;
 
   @Api.field(

package/vona/src/suite/a-training/modules/training-student/src/dto/studentSummary.tsx

@@ -1,39 +1,21 @@
-import type { TableIdentity } from 'table-identity';
 import type { IDecoratorDtoOptions } from 'vona-module-a-web';
 
 import { Api, v } from 'vona-module-a-openapiutils';
+import { $Dto } from 'vona-module-a-orm';
 import { Dto } from 'vona-module-a-web';
 
 import { $locale } from '../.metadata/locales.ts';
+import { ModelStudent } from '../model/student.ts';
 
 export interface IDtoOptionsStudentSummary extends IDecoratorDtoOptions {}
 
 @Dto<IDtoOptionsStudentSummary>()
-export class DtoStudentSummary {
-  @Api.field(v.tableIdentity())
-  id: TableIdentity;
-
-  @Api.field(v.title($locale('StudentName')))
-  name: string;
-
-  @Api.field(
-    v.title($locale('Mobile')),
-    v.serializerReplace({
-      patternFrom: /^(\d{3})\d{4}(\d+)$/,
-      patternTo: '$1****$2',
-    }),
-  )
-  mobile: string;
-
-  @Api.field(v.title($locale('Level')))
-  level: number;
-
+export class DtoStudentSummary extends $Dto.get(() => ModelStudent, {
+  columns: ['id', 'name', 'mobile', 'level', 'description'],
+}) {
   @Api.field(v.title($locale('LevelTitle')))
   levelTitle: string;
 
-  @Api.field(v.title($locale('Description')), v.optional())
-  description?: string;
-
   @Api.field(v.title($locale('DescriptionLength')))
   descriptionLength: number;
 

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

@@ -1,8 +1,4 @@
-import type {
-  DtoStudentSelectRes,
-  DtoStudentSummary,
-  EntityStudent,
-} from 'vona-module-training-student';
+import type { DtoStudentSelectRes, EntityStudent } from 'vona-module-training-student';
 
 import assert from 'node:assert';
 import { describe, it } from 'node:test';
@@ -14,6 +10,9 @@ import {
   DtoStudentView,
 } from 'vona-module-training-student';
 
+import { DtoDetailRecordResItem } from '../src/dto/detailRecordResItem.tsx';
+import { DtoStudentSummary } from '../src/dto/studentSummary.tsx';
+
 describe('student.test.ts', () => {
   it('action:student:formLayoutMetadata', async () => {
     await app.bean.executor.mockCtx(async () => {
@@ -77,6 +76,39 @@ describe('student.test.ts', () => {
     });
   });
 
+  it('action:student:emittedDtoSchemas', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const summaryApiJson = await app.bean.openapi.generateJsonOfClass(DtoStudentSummary);
+      const summaryComponent = Object.values(summaryApiJson.components!.schemas as any).find(
+        item => {
+          return (item as any).properties?.summaryText;
+        },
+      ) as any;
+      assert.ok(summaryComponent);
+      assert.deepEqual(
+        Object.keys(summaryComponent.properties).sort(),
+        [
+          'id',
+          'name',
+          'mobile',
+          'level',
+          'description',
+          'levelTitle',
+          'descriptionLength',
+          'summaryText',
+        ].sort(),
+      );
+
+      const detailRecordApiJson =
+        await app.bean.openapi.generateJsonOfClass(DtoDetailRecordResItem);
+      const detailRecordComponent = Object.values(
+        detailRecordApiJson.components!.schemas as any,
+      ).find(item => (item as any).properties?._lineNumber) as any;
+      assert.ok(detailRecordComponent?.properties?._lineNumber);
+      assert.equal(detailRecordComponent.required?.includes('_lineNumber'), false);
+    });
+  });
+
   it('action:student', async () => {
     await app.bean.executor.mockCtx(async () => {
       // data

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-pay",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "description": "",
   "keywords": [
     "Vona Module"

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

@@ -501,6 +501,7 @@ declare module 'vona' {
 export * from '../service/outbox.ts';
 export * from '../service/paymentSession.ts';
 export * from '../service/providerOperation.ts';
+export * from '../service/refundOperation.ts';
 export * from '../service/webhook.ts';
 
 import 'vona-module-a-bean';
@@ -510,6 +511,7 @@ declare module 'vona-module-a-bean' {
       'a-pay:outbox': never;
 'a-pay:paymentSession': never;
 'a-pay:providerOperation': never;
+'a-pay:refundOperation': never;
 'a-pay:webhook': never;
     }
 
@@ -550,6 +552,17 @@ declare module 'vona-module-a-pay' {
             
           }
 
+        export interface ServiceRefundOperation {
+          /** @internal */
+          get scope(): ScopeModuleAPay;
+        }
+
+          export interface ServiceRefundOperation {
+            get $beanFullName(): 'a-pay.service.refundOperation';
+            get $onionName(): 'a-pay:refundOperation';
+            
+          }
+
         export interface ServiceWebhook {
           /** @internal */
           get scope(): ScopeModuleAPay;
@@ -566,11 +579,13 @@ declare module 'vona-module-a-pay' {
 import type { ServiceOutbox } from '../service/outbox.ts';
 import type { ServicePaymentSession } from '../service/paymentSession.ts';
 import type { ServiceProviderOperation } from '../service/providerOperation.ts';
+import type { ServiceRefundOperation } from '../service/refundOperation.ts';
 import type { ServiceWebhook } from '../service/webhook.ts';
 export interface IModuleService {
   'outbox': ServiceOutbox;
 'paymentSession': ServicePaymentSession;
 'providerOperation': ServiceProviderOperation;
+'refundOperation': ServiceRefundOperation;
 'webhook': ServiceWebhook;
 }
 /** service: end */
@@ -582,6 +597,7 @@ declare module 'vona' {
     'a-pay.service.outbox': ServiceOutbox;
 'a-pay.service.paymentSession': ServicePaymentSession;
 'a-pay.service.providerOperation': ServiceProviderOperation;
+'a-pay.service.refundOperation': ServiceRefundOperation;
 'a-pay.service.webhook': ServiceWebhook;
   }
 }
@@ -675,12 +691,14 @@ export interface IModuleQueue {
 /** queue: end */
 /** schedule: begin */
 export * from '../bean/schedule.outboxDispatch.ts';
+export * from '../bean/schedule.providerOperationDispatch.ts';
 
 import { type IDecoratorScheduleOptions } from 'vona-module-a-schedule';
 declare module 'vona-module-a-schedule' {
   
     export interface IScheduleRecord {
       'a-pay:outboxDispatch': IDecoratorScheduleOptions;
+'a-pay:providerOperationDispatch': IDecoratorScheduleOptions;
     }
 
   
@@ -696,6 +714,17 @@ declare module 'vona-module-a-pay' {
             get $beanFullName(): 'a-pay.schedule.outboxDispatch';
             get $onionName(): 'a-pay:outboxDispatch';
             get $onionOptions(): IDecoratorScheduleOptions;
+          }
+
+        export interface ScheduleProviderOperationDispatch {
+          /** @internal */
+          get scope(): ScopeModuleAPay;
+        }
+
+          export interface ScheduleProviderOperationDispatch {
+            get $beanFullName(): 'a-pay.schedule.providerOperationDispatch';
+            get $onionName(): 'a-pay:providerOperationDispatch';
+            get $onionOptions(): IDecoratorScheduleOptions;
           } 
 }
 /** schedule: end */

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/bean/meta.index.ts

@@ -12,7 +12,9 @@ import { $tableColumns } from 'vona-module-a-ormutils';
     ...$tableColumns('payPaymentSession', 'providerOrderId'),
     ...$tableColumns('payPaymentSession', 'providerCaptureId'),
     ...$tableColumns('payProviderOperation', 'paymentSessionId+kind'),
+    ...$tableColumns('payProviderOperation', 'refundOperationId'),
     ...$tableColumns('payProviderOperation', 'state+nextAttemptAt'),
+    ...$tableColumns('payProviderOperation', 'state+claimExpiresAt'),
     ...$tableColumns('payProviderOperation', 'idempotencyKey'),
     ...$tableColumns('payRefundOperation', 'paymentSessionId'),
     ...$tableColumns('payRefundOperation', 'state'),
@@ -21,6 +23,7 @@ import { $tableColumns } from 'vona-module-a-ormutils';
     ...$tableColumns('payWebhookInbox', 'paymentSessionId'),
     ...$tableColumns('payWebhookInbox', 'state'),
     ...$tableColumns('payPaymentAudit', 'paymentSessionId'),
+    ...$tableColumns('payOutboxEvent', 'refundOperationId'),
     ...$tableColumns('payOutboxEvent', 'state+nextAttemptAt'),
     ...$tableColumns('payOutboxEvent', 'state+claimExpiresAt'),
   },

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/bean/meta.redlock.ts

@@ -1,7 +1,9 @@
 import { Meta } from 'vona-module-a-meta';
 import { BeanRedlockBase } from 'vona-module-a-redlock';
 
-export type TypeRedlockLockResource = `pay.webhook.${string}`;
+export type TypeRedlockLockResource =
+  | `pay.providerOperation.start.${string}`
+  | `pay.webhook.${string}`;
 export type TypeRedlockLockIsolateResource = never;
 
 @Meta()

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/bean/meta.version.ts

@@ -33,6 +33,7 @@ export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
     await this.bean.model.createTable(providerOperation.$table, table => {
       table.basicFields();
       table.tableIdentity(providerOperation.paymentSessionId);
+      table.tableIdentity(providerOperation.refundOperationId);
       table.string(providerOperation.kind, 32);
       table.string(providerOperation.state, 32);
       table.string(providerOperation.idempotencyKey, 100);
@@ -41,6 +42,9 @@ export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
       table.string(providerOperation.providerResourceId, 255);
       table.integer(providerOperation.attemptCount);
       table.dateTime(providerOperation.claimedAt);
+      table.string(providerOperation.claimToken, 100);
+      table.dateTime(providerOperation.claimExpiresAt);
+      table.dateTime(providerOperation.submittedAt);
       table.dateTime(providerOperation.nextAttemptAt);
       table.string(providerOperation.errorCode, 100);
       table.string(providerOperation.errorSummary, 255);
@@ -71,9 +75,11 @@ export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
       table.tableIdentity(webhookInbox.paymentSessionId);
       table.tableIdentity(webhookInbox.refundOperationId);
       table.string(webhookInbox.paymentState, 32);
+      table.string(webhookInbox.refundState, 32);
       table.integer(webhookInbox.amountMinor);
       table.string(webhookInbox.currency, 3);
       table.string(webhookInbox.providerCaptureId, 255);
+      table.string(webhookInbox.providerRefundId, 255);
       table.string(webhookInbox.payloadHash, 64);
       table.string(webhookInbox.state, 32);
       table.integer(webhookInbox.retryCount);
@@ -99,6 +105,7 @@ export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
       table.basicFields();
       table.string(outboxEvent.eventType, 100);
       table.tableIdentity(outboxEvent.paymentSessionId);
+      table.tableIdentity(outboxEvent.refundOperationId);
       table.json(outboxEvent.payload);
       table.string(outboxEvent.state, 32);
       table.integer(outboxEvent.attemptCount);

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/bean/queue.outboxDispatch.ts

@@ -3,6 +3,8 @@ import type { IQueueExecute, IQueuePushOptions } from 'vona-module-a-queue';
 
 import { BeanQueueBase, Queue } from 'vona-module-a-queue';
 
+import type { IPaymentOutcomeEvent, IRefundOutcomeEvent } from '../types/payment.ts';
+
 export interface IOutboxDispatchJobData {
   outboxEventId: TableIdentity;
 }
@@ -16,13 +18,16 @@ export class QueueOutboxDispatch
     const event = await this.scope.service.outbox.claim(data.outboxEventId);
     if (!event) return;
     try {
-      if (event.eventType !== 'payment.outcome.v1') {
-        this.app.throw(409, `unsupported payment outbox event: ${event.eventType}`);
-      }
       const session = await this.scope.model.paymentSession.getById(event.paymentSessionId);
       if (!session) this.app.throw(404, 'payment session not found');
       const payScene = this.bean.payScene.get(session.payScene as never);
-      await payScene.onPaymentOutcome(event.payload);
+      if (event.eventType === 'payment.outcome.v1') {
+        await payScene.onPaymentOutcome(event.payload as IPaymentOutcomeEvent);
+      } else if (event.eventType === 'refund.outcome.v1') {
+        await payScene.onRefundOutcome(event.payload as IRefundOutcomeEvent);
+      } else {
+        this.app.throw(409, `unsupported payment outbox event: ${event.eventType}`);
+      }
       await this.scope.service.outbox.markDispatched(event.id, event.claimToken!);
     } catch (error) {
       await this.scope.service.outbox.release(event.id, event.claimToken!, error);

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/bean/schedule.providerOperationDispatch.ts

@@ -0,0 +1,11 @@
+import type { IScheduleExecute } from 'vona-module-a-schedule';
+
+import { BeanBase } from 'vona';
+import { Schedule } from 'vona-module-a-schedule';
+
+@Schedule({ repeat: { every: 60 * 1000 } })
+export class ScheduleProviderOperationDispatch extends BeanBase implements IScheduleExecute {
+  async execute() {
+    await this.scope.service.providerOperation.queueDue();
+  }
+}

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/entity/outboxEvent.tsx

@@ -5,20 +5,27 @@ import { Api, v } from 'vona-module-a-openapiutils';
 import { Entity, EntityBase } from 'vona-module-a-orm';
 import { z } from 'zod';
 
-import type { IPaymentOutcomeEvent, TypeOutboxEventState } from '../types/payment.ts';
+import type {
+  IPaymentOutcomeEvent,
+  IRefundOutcomeEvent,
+  TypeOutboxEventState,
+} from '../types/payment.ts';
 
 export interface IEntityOptionsOutboxEvent extends IDecoratorEntityOptions {}
 
 @Entity<IEntityOptionsOutboxEvent>('payOutboxEvent')
 export class EntityOutboxEvent extends EntityBase {
-  @Api.field(z.literal('payment.outcome.v1'))
-  eventType: 'payment.outcome.v1';
+  @Api.field(z.enum(['payment.outcome.v1', 'refund.outcome.v1']))
+  eventType: 'payment.outcome.v1' | 'refund.outcome.v1';
 
   @Api.field(v.tableIdentity())
   paymentSessionId: TableIdentity;
 
+  @Api.field(v.optional(), v.tableIdentity())
+  refundOperationId?: TableIdentity;
+
   @Api.field(v.required())
-  payload: IPaymentOutcomeEvent;
+  payload: IPaymentOutcomeEvent | IRefundOutcomeEvent;
 
   @Api.field(z.enum(['pending', 'claimed', 'dispatched', 'failed']))
   state: TypeOutboxEventState;