cabloy 5.1.113 → 5.1.115

package/vona/src/suite/a-commerce/modules/commerce-payment/src/bean/meta.index.ts

@@ -0,0 +1,15 @@
+import type { IMetaOptionsIndex } from 'vona-module-a-index';
+
+import { BeanBase } from 'vona';
+import { Meta } from 'vona-module-a-meta';
+import { $tableColumns } from 'vona-module-a-ormutils';
+
+@Meta<IMetaOptionsIndex>({
+  indexes: {
+    ...$tableColumns('commercePaymentAttempt', 'orderId'),
+    ...$tableColumns('commercePaymentAttempt', 'userId'),
+    ...$tableColumns('commercePaymentAttempt', 'state'),
+    ...$tableColumns('commercePaymentAttempt', 'correlationId'),
+  },
+})
+export class MetaIndex extends BeanBase {}

package/vona/src/suite/a-commerce/modules/commerce-payment/src/bean/meta.version.ts

@@ -0,0 +1,35 @@
+import type { IMetaVersionUpdate, IMetaVersionUpdateOptions } from 'vona-module-a-version';
+
+import { BeanBase } from 'vona';
+import { Meta } from 'vona-module-a-meta';
+
+@Meta()
+export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
+  async update(options: IMetaVersionUpdateOptions) {
+    if (options.version !== 1) return;
+
+    const entityPaymentAttempt = this.scope.entity.paymentAttempt;
+    await this.bean.model.createTable(entityPaymentAttempt.$table, table => {
+      table.comment(entityPaymentAttempt.$comment.$table);
+      table.basicFields();
+      table
+        .tableIdentity(entityPaymentAttempt.orderId)
+        .comment(entityPaymentAttempt.$comment.orderId);
+      table.userId(entityPaymentAttempt.userId).comment(entityPaymentAttempt.$comment.userId);
+      table.string(entityPaymentAttempt.state, 20).comment(entityPaymentAttempt.$comment.state);
+      table
+        .string(entityPaymentAttempt.currency, 3)
+        .comment(entityPaymentAttempt.$comment.currency);
+      table
+        .integer(entityPaymentAttempt.amountCents)
+        .comment(entityPaymentAttempt.$comment.amountCents);
+      table
+        .string(entityPaymentAttempt.correlationId, 100)
+        .comment(entityPaymentAttempt.$comment.correlationId);
+      table
+        .dateTime(entityPaymentAttempt.cancelledAt)
+        .nullable()
+        .comment(entityPaymentAttempt.$comment.cancelledAt);
+    });
+  }
+}

package/vona/src/suite/a-commerce/modules/commerce-payment/src/dto/paymentAttemptView.tsx

@@ -0,0 +1,26 @@
+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-web';
+import { z } from 'zod';
+
+export interface IDtoOptionsPaymentAttemptView extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsPaymentAttemptView>()
+export class DtoPaymentAttemptView {
+  @Api.field(v.tableIdentity())
+  id: TableIdentity;
+
+  @Api.field(v.tableIdentity())
+  orderId: TableIdentity;
+
+  @Api.field(z.enum(['created', 'cancelled']))
+  state: 'created' | 'cancelled';
+
+  @Api.field(z.literal('USD'))
+  currency: 'USD';
+
+  @Api.field(z.number().int().nonnegative())
+  amountCents: number;
+}

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

@@ -0,0 +1,34 @@
+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';
+
+export type TypePaymentAttemptState = 'created' | 'cancelled';
+
+export interface IEntityOptionsPaymentAttempt extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsPaymentAttempt>('commercePaymentAttempt')
+export class EntityPaymentAttempt extends EntityBase {
+  @Api.field(v.tableIdentity())
+  orderId: TableIdentity;
+
+  @Api.field(v.tableIdentity())
+  userId: TableIdentity;
+
+  @Api.field(z.enum(['created', 'cancelled']))
+  state: TypePaymentAttemptState;
+
+  @Api.field(z.literal('USD'))
+  currency: 'USD';
+
+  @Api.field(z.number().int().nonnegative())
+  amountCents: number;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  correlationId: string;
+
+  @Api.field(v.optional())
+  cancelledAt?: Date;
+}

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

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

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

@@ -0,0 +1,41 @@
+import type { TableIdentity } from 'table-identity';
+
+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';
+
+export interface IPaymentAttemptCreateCommand {
+  orderId: TableIdentity;
+  userId: TableIdentity;
+  currency: 'USD';
+  amountCents: number;
+  correlationId: string;
+}
+
+@Service()
+export class ServicePaymentAttempt extends BeanBase {
+  async create(command: IPaymentAttemptCreateCommand): Promise<EntityPaymentAttempt> {
+    return await this.scope.model.paymentAttempt.insert({
+      orderId: command.orderId,
+      userId: command.userId,
+      state: 'created',
+      currency: command.currency,
+      amountCents: command.amountCents,
+      correlationId: command.correlationId,
+    });
+  }
+
+  @Core.transaction({ isolationLevel: 'SERIALIZABLE' })
+  async cancel(orderId: TableIdentity): Promise<EntityPaymentAttempt | undefined> {
+    const attempt = await this.scope.model.paymentAttempt.getForUpdate({ orderId });
+    if (!attempt || attempt.state === 'cancelled') return attempt;
+    const cancelledAt = new Date();
+    await this.scope.model.paymentAttempt.updateById(attempt.id, {
+      state: 'cancelled',
+      cancelledAt,
+    });
+    return { ...attempt, state: 'cancelled', cancelledAt };
+  }
+}

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

@@ -0,0 +1,33 @@
+import assert from 'node:assert';
+import { randomUUID } from 'node:crypto';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('paymentAttempt.test.ts', { concurrency: false }, () => {
+  it('creates and internally cancels an attempt exactly once', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      const scope = app.scope('commerce-payment');
+      const suffix = randomUUID().slice(0, 12);
+      let attemptId: number | undefined;
+      try {
+        const user = await app.bean.user.register({ name: `payment-${suffix}` }, true);
+        const created = await scope.service.paymentAttempt.create({
+          orderId: 900_001,
+          userId: user.id,
+          currency: 'USD',
+          amountCents: 1299,
+          correlationId: `payment-${suffix}`,
+        });
+        attemptId = created.id as number;
+        assert.equal(created.state, 'created');
+        const cancelled = await scope.service.paymentAttempt.cancel(created.orderId);
+        assert.equal(cancelled?.state, 'cancelled');
+        const replay = await scope.service.paymentAttempt.cancel(created.orderId);
+        assert.equal(replay?.id, created.id);
+        assert.equal(replay?.state, 'cancelled');
+      } finally {
+        if (attemptId !== undefined) await scope.model.paymentAttempt.delete({ id: attemptId });
+      }
+    });
+  });
+});

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

@@ -46,7 +46,9 @@
   "title": "commerce-promotion",
   "vonaModule": {
     "dependencies": {
-      "a-vona": "5.0.0"
-    }
+      "a-vona": "5.0.0",
+      "commerce-siteadmin": "5.0.0"
+    },
+    "fileVersion": 1
   }
 }