cabloy 5.1.122 → 5.1.124

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

@@ -0,0 +1,72 @@
+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 { TypePaymentNextAction, TypePaymentSessionState } from '../types/payment.ts';
+
+export interface IEntityOptionsPaymentSession extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsPaymentSession>('payPaymentSession')
+export class EntityPaymentSession extends EntityBase {
+  @Api.field(v.tableIdentity())
+  userId: TableIdentity;
+
+  @Api.field(z.string())
+  payScene: string;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  businessReference: string;
+
+  @Api.field(z.string())
+  providerName: string;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  clientName: string;
+
+  @Api.field(z.enum(['sandbox', 'live']))
+  environment: 'sandbox' | 'live';
+
+  @Api.field(z.number().int().nonnegative())
+  amountMinor: number;
+
+  @Api.field(v.required(), v.min(3), v.max(3))
+  currency: string;
+
+  @Api.field(
+    z.enum([
+      'created',
+      'starting',
+      'requires_action',
+      'processing',
+      'succeeded',
+      'failed',
+      'cancelled',
+      'expired',
+    ]),
+  )
+  state: TypePaymentSessionState;
+
+  @Api.field(v.optional())
+  nextAction?: TypePaymentNextAction;
+
+  @Api.field(v.optional(), v.max(255))
+  providerPaymentId?: string;
+
+  @Api.field(v.optional(), v.max(255))
+  providerOrderId?: string;
+
+  @Api.field(v.optional(), v.max(255))
+  providerCaptureId?: string;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  correlationId: string;
+
+  @Api.field(v.required())
+  expiresAt: Date;
+
+  @Api.field(v.optional())
+  finalizedAt?: Date;
+}

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/entity/providerOperation.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 { TypeProviderOperationKind, TypeProviderOperationState } from '../types/payment.ts';
+
+export interface IEntityOptionsProviderOperation extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsProviderOperation>('payProviderOperation')
+export class EntityProviderOperation extends EntityBase {
+  @Api.field(v.tableIdentity())
+  paymentSessionId: TableIdentity;
+
+  @Api.field(z.enum(['start', 'confirm', 'query', 'refund']))
+  kind: TypeProviderOperationKind;
+
+  @Api.field(
+    z.enum(['created', 'claimed', 'submitted', 'succeeded', 'failed', 'reconciliation_required']),
+  )
+  state: TypeProviderOperationState;
+
+  @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.optional(), v.max(255))
+  providerRequestId?: string;
+
+  @Api.field(v.optional(), v.max(255))
+  providerResourceId?: string;
+
+  @Api.field(z.number().int().nonnegative())
+  attemptCount: number;
+
+  @Api.field(v.optional())
+  claimedAt?: Date;
+
+  @Api.field(v.optional())
+  nextAttemptAt?: Date;
+
+  @Api.field(v.optional(), v.max(100))
+  errorCode?: string;
+
+  @Api.field(v.optional(), v.max(255))
+  errorSummary?: string;
+
+  @Api.field(v.optional())
+  finalizedAt?: Date;
+}

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

@@ -0,0 +1,37 @@
+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 { TypeRefundOperationState } from '../types/payment.ts';
+
+export interface IEntityOptionsRefundOperation extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsRefundOperation>('payRefundOperation')
+export class EntityRefundOperation extends EntityBase {
+  @Api.field(v.tableIdentity())
+  paymentSessionId: TableIdentity;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  businessReference: string;
+
+  @Api.field(z.number().int().positive())
+  amountMinor: number;
+
+  @Api.field(v.required(), v.min(3), v.max(3))
+  currency: string;
+
+  @Api.field(z.enum(['created', 'submitting', 'pending', 'succeeded', 'failed', 'cancelled']))
+  state: TypeRefundOperationState;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  idempotencyKey: string;
+
+  @Api.field(v.optional(), v.max(255))
+  providerRefundId?: string;
+
+  @Api.field(v.optional())
+  finalizedAt?: Date;
+}

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

@@ -0,0 +1,59 @@
+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 interface IEntityOptionsWebhookInbox extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsWebhookInbox>('payWebhookInbox')
+export class EntityWebhookInbox extends EntityBase {
+  @Api.field(v.required(), v.min(1), v.max(100))
+  providerName: string;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  clientName: string;
+
+  @Api.field(z.enum(['sandbox', 'live']))
+  environment: 'sandbox' | 'live';
+
+  @Api.field(v.required(), v.min(1), v.max(255))
+  providerEventId: string;
+
+  @Api.field(v.required(), v.min(1), v.max(100))
+  eventType: string;
+
+  @Api.field(v.optional(), v.tableIdentity())
+  paymentSessionId?: TableIdentity;
+
+  @Api.field(v.optional(), v.tableIdentity())
+  refundOperationId?: TableIdentity;
+
+  @Api.field(v.optional(), z.enum(['succeeded', 'failed', 'cancelled']))
+  paymentState?: 'succeeded' | 'failed' | 'cancelled';
+
+  @Api.field(v.optional(), z.number().int().nonnegative())
+  amountMinor?: number;
+
+  @Api.field(v.optional(), v.min(3), v.max(3))
+  currency?: string;
+
+  @Api.field(v.optional(), v.max(255))
+  providerCaptureId?: string;
+
+  @Api.field(v.required(), v.min(64), v.max(64))
+  payloadHash: string;
+
+  @Api.field(z.enum(['received', 'processed', 'failed']))
+  state: 'received' | 'processed' | 'failed';
+
+  @Api.field(z.number().int().nonnegative())
+  retryCount: number;
+
+  @Api.field(v.optional())
+  processedAt?: Date;
+
+  @Api.field(v.optional(), v.max(255))
+  errorSummary?: string;
+}

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

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

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

@@ -0,0 +1,2 @@
+export * from './payProvider.ts';
+export * from './payScene.ts';

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

@@ -0,0 +1,7 @@
+import { createBeanDecorator } from 'vona';
+
+import type { IDecoratorPayProviderOptions } from '../types/payProvider.ts';
+
+export function PayProvider<T extends IDecoratorPayProviderOptions>(options?: T): ClassDecorator {
+  return createBeanDecorator('payProvider', options);
+}

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

@@ -0,0 +1,7 @@
+import { createBeanDecorator } from 'vona';
+
+import type { IDecoratorPaySceneOptions } from '../types/payScene.ts';
+
+export function PayScene(options?: IDecoratorPaySceneOptions): ClassDecorator {
+  return createBeanDecorator('payScene', options);
+}

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/model/outboxEvent.ts

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

package/vona/src/suite-vendor/a-pay/modules/a-pay/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-vendor/a-pay/modules/a-pay/src/model/paymentSession.ts

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

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/model/providerOperation.ts

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

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/model/refundOperation.ts

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

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/model/webhookInbox.ts

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

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/service/outbox.ts

@@ -0,0 +1,156 @@
+import type { TableIdentity } from 'table-identity';
+
+import { randomUUID } from 'node:crypto';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { Core } from 'vona-module-a-core';
+
+import type { IPaymentOutcomeEvent } from '../types/payment.ts';
+
+const ClaimLeaseMilliseconds = 60_000;
+const MaxAttempts = 10;
+
+@Service()
+export class ServiceOutbox extends BeanBase {
+  async enqueue(
+    paymentSessionId: TableIdentity,
+    eventType: 'payment.outcome.v1',
+    payload: IPaymentOutcomeEvent,
+  ) {
+    const event = await this.scope.model.outboxEvent.insert({
+      eventType,
+      paymentSessionId,
+      payload,
+      state: 'pending',
+      attemptCount: 0,
+      nextAttemptAt: new Date(),
+    });
+    if (!this.app.meta.isTest) {
+      this.ctx.db.commit(() => {
+        this.scope.queue.outboxDispatch.push({ outboxEventId: event.id });
+      });
+    }
+    return event;
+  }
+
+  @Core.transaction()
+  async claim(id: TableIdentity) {
+    const event = await this.scope.model.outboxEvent.getByIdForUpdate(id);
+    if (!event || event.state === 'dispatched' || event.state === 'failed') return undefined;
+    const now = new Date();
+    const eligible =
+      (event.state === 'pending' && (!event.nextAttemptAt || event.nextAttemptAt <= now)) ||
+      (event.state === 'claimed' && !!event.claimExpiresAt && event.claimExpiresAt <= now);
+    if (!eligible) return undefined;
+    if (event.attemptCount >= MaxAttempts) {
+      await this.scope.model.outboxEvent.updateById(event.id, {
+        state: 'failed',
+        errorSummary: 'outbox delivery attempts exhausted',
+      });
+      return undefined;
+    }
+    const claimToken = randomUUID();
+    const claimedAt = now;
+    const claimExpiresAt = new Date(now.getTime() + ClaimLeaseMilliseconds);
+    await this.scope.model.outboxEvent.updateById(event.id, {
+      state: 'claimed',
+      claimedAt,
+      claimToken,
+      claimExpiresAt,
+      attemptCount: event.attemptCount + 1,
+      errorSummary: undefined,
+    });
+    return {
+      ...event,
+      state: 'claimed' as const,
+      claimedAt,
+      claimToken,
+      claimExpiresAt,
+      attemptCount: event.attemptCount + 1,
+      errorSummary: undefined,
+    };
+  }
+
+  @Core.transaction()
+  async markDispatched(id: TableIdentity, claimToken: string) {
+    const event = await this.scope.model.outboxEvent.getByIdForUpdate(id);
+    if (!event || event.state !== 'claimed' || event.claimToken !== claimToken) return undefined;
+    const dispatchedAt = new Date();
+    await this.scope.model.outboxEvent.updateById(event.id, {
+      state: 'dispatched',
+      dispatchedAt,
+      claimedAt: undefined,
+      claimToken: undefined,
+      claimExpiresAt: undefined,
+      errorSummary: undefined,
+    });
+    return { ...event, state: 'dispatched' as const, dispatchedAt };
+  }
+
+  @Core.transaction()
+  async release(id: TableIdentity, claimToken: string, error: unknown) {
+    const event = await this.scope.model.outboxEvent.getByIdForUpdate(id);
+    if (!event || event.state !== 'claimed' || event.claimToken !== claimToken) return undefined;
+    const errorSummary = summarizeError(error);
+    if (event.attemptCount >= MaxAttempts) {
+      await this.scope.model.outboxEvent.updateById(event.id, {
+        state: 'failed',
+        claimedAt: undefined,
+        claimToken: undefined,
+        claimExpiresAt: undefined,
+        errorSummary,
+      });
+      return { ...event, state: 'failed' as const, errorSummary };
+    }
+    const nextAttemptAt = new Date(Date.now() + retryDelayMilliseconds(event.attemptCount));
+    await this.scope.model.outboxEvent.updateById(event.id, {
+      state: 'pending',
+      claimedAt: undefined,
+      claimToken: undefined,
+      claimExpiresAt: undefined,
+      nextAttemptAt,
+      errorSummary,
+    });
+    return { ...event, state: 'pending' as const, nextAttemptAt, errorSummary };
+  }
+
+  async queueDue(limit = 100) {
+    const now = new Date();
+    const pending = await this.scope.model.outboxEvent.select({
+      where: {
+        state: 'pending',
+        nextAttemptAt: { _lte_: now },
+      },
+      orders: [
+        ['nextAttemptAt', 'asc'],
+        ['id', 'asc'],
+      ],
+      limit,
+    });
+    const claimed = await this.scope.model.outboxEvent.select({
+      where: {
+        state: 'claimed',
+        claimExpiresAt: { _lte_: now },
+      },
+      orders: [
+        ['claimExpiresAt', 'asc'],
+        ['id', 'asc'],
+      ],
+      limit: Math.max(0, limit - pending.length),
+    });
+    const events = [...pending, ...claimed];
+    for (const event of events) {
+      await this.scope.queue.outboxDispatch.pushAsync({ outboxEventId: event.id });
+    }
+    return events.length;
+  }
+}
+
+function retryDelayMilliseconds(attemptCount: number) {
+  return Math.min(60_000, 1_000 * 2 ** Math.max(0, attemptCount - 1));
+}
+
+function summarizeError(error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.slice(0, 255);
+}