cabloy 5.1.115 → 5.1.117

package/vona/src/suite/a-commerce/modules/commerce-payment/src/entity/paymentAudit.tsx

@@ -0,0 +1,54 @@
+import type { TableIdentity } from 'table-identity';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+import { z } from 'zod';
+
+import type { TypePaymentAttemptState } from './paymentAttempt.tsx';
+
+export type TypePaymentOutcome = Extract<
+  TypePaymentAttemptState,
+  'succeeded' | 'failed' | 'cancelled'
+>;
+
+export interface IEntityOptionsPaymentAudit extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsPaymentAudit>('commercePaymentAudit')
+export class EntityPaymentAudit extends EntityBase {
+  @Api.field(v.tableIdentity())
+  paymentAttemptId: TableIdentity;
+
+  @Api.field(v.tableIdentity())
+  orderId: TableIdentity;
+
+  @Api.field(v.tableIdentity())
+  userId: TableIdentity;
+
+  @Api.field(z.literal('mock'))
+  provider: 'mock';
+
+  @Api.field(z.enum(['succeeded', 'failed', 'cancelled']))
+  outcome: TypePaymentOutcome;
+
+  @Api.field(z.enum(['created', 'succeeded', 'failed', 'cancelled']))
+  fromAttemptState: TypePaymentAttemptState;
+
+  @Api.field(z.enum(['paid', 'cancelled', 'expired']))
+  toOrderState: 'paid' | 'cancelled' | 'expired';
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  idempotencyKey: string;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  correlationId: string;
+
+  @Api.field(v.required(), v.min(1), v.max(255))
+  reason: string;
+
+  @Api.field(v.optional(), v.tableIdentity())
+  actorId?: TableIdentity;
+
+  @Api.field(v.required())
+  processedAt: Date;
+}

package/vona/src/suite/a-commerce/modules/commerce-payment/src/model/paymentAudit.ts

@@ -0,0 +1,10 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+
+import { EntityPaymentAudit } from '../entity/paymentAudit.tsx';
+
+export interface IModelOptionsPaymentAudit extends IDecoratorModelOptions<EntityPaymentAudit> {}
+
+@Model<IModelOptionsPaymentAudit>({ entity: EntityPaymentAudit })
+export class ModelPaymentAudit extends BeanModelBase<EntityPaymentAudit> {}

package/vona/src/suite/a-commerce/modules/commerce-payment/src/service/mockPaymentAdapter.ts

@@ -0,0 +1,18 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { TypePaymentOutcome } from '../entity/paymentAudit.tsx';
+
+export interface IPaymentProviderAdapter {
+  readonly provider: 'mock';
+  normalizeOutcome(outcome: TypePaymentOutcome): TypePaymentOutcome;
+}
+
+@Service()
+export class ServiceMockPaymentAdapter extends BeanBase implements IPaymentProviderAdapter {
+  readonly provider = 'mock' as const;
+
+  normalizeOutcome(outcome: TypePaymentOutcome): TypePaymentOutcome {
+    return outcome;
+  }
+}

package/vona/src/suite/a-commerce/modules/commerce-payment/src/service/paymentAttempt.ts

@@ -4,7 +4,7 @@ import { BeanBase } from 'vona';
 import { Service } from 'vona-module-a-bean';
 import { Core } from 'vona-module-a-core';
 
-import type { EntityPaymentAttempt } from '../entity/paymentAttempt.tsx';
+import type { EntityPaymentAttempt, TypePaymentAttemptState } from '../entity/paymentAttempt.tsx';
 
 export interface IPaymentAttemptCreateCommand {
   orderId: TableIdentity;
@@ -14,6 +14,11 @@ export interface IPaymentAttemptCreateCommand {
   correlationId: string;
 }
 
+export type TypePaymentAttemptFinalState = Extract<
+  TypePaymentAttemptState,
+  'succeeded' | 'failed' | 'cancelled'
+>;
+
 @Service()
 export class ServicePaymentAttempt extends BeanBase {
   async create(command: IPaymentAttemptCreateCommand): Promise<EntityPaymentAttempt> {
@@ -27,15 +32,25 @@ export class ServicePaymentAttempt extends BeanBase {
     });
   }
 
-  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
-  async cancel(orderId: TableIdentity): Promise<EntityPaymentAttempt | undefined> {
+  async finalize(
+    orderId: TableIdentity,
+    state: TypePaymentAttemptFinalState,
+  ): Promise<EntityPaymentAttempt | undefined> {
     const attempt = await this.scope.model.paymentAttempt.getForUpdate({ orderId });
-    if (!attempt || attempt.state === 'cancelled') return attempt;
-    const cancelledAt = new Date();
+    if (!attempt || attempt.state === state) return attempt;
+    if (attempt.state !== 'created') this.app.throw(409, 'payment attempt is already finalized');
+    const finalizedAt = new Date();
+    const cancelledAt = state === 'cancelled' ? finalizedAt : undefined;
     await this.scope.model.paymentAttempt.updateById(attempt.id, {
-      state: 'cancelled',
+      state,
+      finalizedAt,
       cancelledAt,
     });
-    return { ...attempt, state: 'cancelled', cancelledAt };
+    return { ...attempt, state, finalizedAt, cancelledAt };
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async cancel(orderId: TableIdentity): Promise<EntityPaymentAttempt | undefined> {
+    return await this.finalize(orderId, 'cancelled');
   }
 }

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/dto/couponIssue.tsx

@@ -14,7 +14,7 @@ export class DtoCouponIssue {
   @Api.field(v.required(), v.tableIdentity())
   userId: TableIdentity;
 
-  @Api.field(v.required(), v.min(1), v.max(100))
+  @Api.field(v.required(), v.min(1), v.max(80))
   correlationId: string;
 
   @Api.field(v.required(), v.min(1), v.max(255))

package/vona/src/suite/a-commerce/modules/commerce-promotion/src/service/coupon.ts

@@ -42,7 +42,7 @@ const serializationRetryOptions = {
   minTimeout: 0,
   maxTimeout: 0,
   randomize: false,
-  errorCodes: ['40001'],
+  errorCodes: ['40001', 'ER_LOCK_DEADLOCK', 'ER_LOCK_WAIT_TIMEOUT'],
   ownerOnly: true,
 };
 
@@ -52,9 +52,14 @@ export class ServiceCoupon extends BeanBase {
   @Core.retryable(serializationRetryOptions)
   async issue(command: ICouponIssueCommand): Promise<EntityCouponGrant> {
     this._assertCommand(command);
+    if (command.correlationId.length > 80) {
+      this.app.throw(400, 'coupon issuance correlationId is too long');
+    }
     const template = await this.scope.model.couponTemplate.getByIdForUpdate(command.templateId);
     if (!template) this.app.throw(404, 'coupon template not found');
     this._assertTemplateIssuable(template);
+    const user = await this.bean.user.findOneById(command.userId);
+    if (!user) this.app.throw(404, 'coupon recipient not found');
     const existing = await this.scope.model.couponGrant.get({
       couponCode: command.correlationId,
     });