tychat-contracts 1.0.85 → 1.0.87

package/src/cashback/index.ts

@@ -0,0 +1,7 @@
+export * from './cashback-enums';
+export * from './cashback-kafka-topics';
+export * from './cashback-kafka-payloads';
+export * from './cashback-config-response.dto';
+export * from './referral-code-response.dto';
+export * from './use-referral-code-response.dto';
+export * from './cashback-balance-response.dto';

package/src/cashback/referral-code-response.dto.ts

@@ -0,0 +1,49 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { CashbackDiscountTypeDto, CashbackExpirationTypeDto } from './cashback-enums';
+
+/**
+ * Response DTO for a referral code
+ */
+export class ReferralCodeResponseDto {
+  @ApiProperty({ description: 'Referral code ID (UUID)' })
+  id: string;
+
+  @ApiProperty({ description: 'Patient ID who owns this code' })
+  patientId: string;
+
+  @ApiProperty({ description: 'The 8-character referral code', example: 'ABCD1234' })
+  code: string;
+
+  @ApiProperty({ description: 'Cashback percentage snapshot' })
+  cashbackPercentage: number;
+
+  @ApiProperty({ description: 'Discount type snapshot', enum: CashbackDiscountTypeDto })
+  discountType: CashbackDiscountTypeDto;
+
+  @ApiProperty({ description: 'Discount value snapshot' })
+  discountValue: number;
+
+  @ApiProperty({ description: 'Expiration type snapshot', enum: CashbackExpirationTypeDto })
+  expirationType: CashbackExpirationTypeDto;
+
+  @ApiPropertyOptional({ description: 'Expiration days snapshot' })
+  expirationDays?: number | null;
+
+  @ApiPropertyOptional({ description: 'Max total uses snapshot' })
+  maxTotalUses?: number | null;
+
+  @ApiPropertyOptional({ description: 'Max uses per patient snapshot' })
+  maxUsesPerPatient?: number | null;
+
+  @ApiPropertyOptional({ description: 'Code expiration date' })
+  codeExpiresAt?: string | null;
+
+  @ApiProperty({ description: 'Total number of times used' })
+  totalUsesCount: number;
+
+  @ApiProperty({ description: 'Whether code is active' })
+  isActive: boolean;
+
+  @ApiProperty({ description: 'Creation timestamp' })
+  createdAt: string;
+}

package/src/cashback/use-referral-code-response.dto.ts

@@ -0,0 +1,15 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+/**
+ * Response DTO for using a referral code
+ */
+export class UseReferralCodeResponseDto {
+  @ApiProperty({ description: 'Cashback amount awarded to the referrer' })
+  cashbackAmount: number;
+
+  @ApiProperty({ description: 'Discount amount applied to the referred patient' })
+  discountAmount: number;
+
+  @ApiProperty({ description: 'Patient ID of the referrer (code owner)' })
+  referrerPatientId: string;
+}

package/src/index.ts

@@ -16,3 +16,4 @@ export * from './tenants';
 export * from './conversations';
 export * from './connections';
 export * from './analytics';
+export * from './cashback';

package/src/payment-gateway/create-gateway-payment.dto.ts

@@ -72,14 +72,15 @@ export class CreateGatewayPaymentDto {
   @Min(0.01)
   amount: number;
 
-  @ApiProperty({
-    description: 'Payment gateway to use',
+  @ApiPropertyOptional({
+    description:
+      'Gateway explícito. Se omitido, o payment-gateway-service resolve pela rota global (prioridade + métodos).',
     enum: PAYMENT_GATEWAYS,
     example: 'ASAAS',
   })
+  @IsOptional()
   @IsEnum(PAYMENT_GATEWAYS)
-  @IsNotEmpty()
-  gateway: PaymentGatewayDto;
+  gateway?: PaymentGatewayDto;
 
   @ApiProperty({
     description: 'Payment method',

package/src/payment-gateway/index.ts

@@ -1,4 +1,9 @@
 export * from './payment-gateway.enums';
+export * from './payment-gateway-routing-matrix';
+export * from './payment-gateway-routing.dto';
+export * from './initiate-billing-payment-response.dto';
+export * from './initiate-billing-payment.mapper';
+export * from './platform-configuration.topics';
 export * from './create-gateway-payment.dto';
 export * from './update-gateway-payment.dto';
 export * from './gateway-payment-response.dto';

package/src/payment-gateway/initiate-billing-payment-response.dto.ts

@@ -0,0 +1,25 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { GatewayPaymentResponseDto } from './gateway-payment-response.dto';
+
+/**
+ * Resposta de iniciar pagamento de cobrança: inclui o registro do pagamento e
+ * campos explícitos copiados de metadata quando presentes (PIX, checkout, boleto).
+ */
+export class InitiateBillingPaymentResponseDto extends GatewayPaymentResponseDto {
+  @ApiPropertyOptional({
+    description: 'URL para fluxo de pagamento (cartão, checkout hospedado, etc.)',
+  })
+  checkoutUrl?: string | null;
+
+  @ApiPropertyOptional({ description: 'QR Code PIX em base64 quando aplicável' })
+  pixQrCode?: string | null;
+
+  @ApiPropertyOptional({ description: 'PIX copia e cola quando aplicável' })
+  pixCopyPaste?: string | null;
+
+  @ApiPropertyOptional({ description: 'URL do boleto quando aplicável' })
+  boletoUrl?: string | null;
+
+  @ApiPropertyOptional({ description: 'Código de barras do boleto quando aplicável' })
+  boletoBarcode?: string | null;
+}

package/src/payment-gateway/initiate-billing-payment.mapper.ts

@@ -0,0 +1,19 @@
+import type { GatewayPaymentResponseDto } from './gateway-payment-response.dto';
+import { InitiateBillingPaymentResponseDto } from './initiate-billing-payment-response.dto';
+
+/**
+ * Copia campos conhecidos de `metadata` para a resposta explícita de checkout/PIX/boleto.
+ */
+export function toInitiateBillingPaymentResponseDto(
+  payment: GatewayPaymentResponseDto,
+): InitiateBillingPaymentResponseDto {
+  const meta = (payment.metadata ?? {}) as Record<string, unknown>;
+  return {
+    ...payment,
+    checkoutUrl: (meta.paymentUrl as string | undefined) ?? undefined,
+    pixQrCode: (meta.pixQrCode as string | undefined) ?? undefined,
+    pixCopyPaste: (meta.pixCopyPaste as string | undefined) ?? undefined,
+    boletoUrl: (meta.boletoUrl as string | undefined) ?? undefined,
+    boletoBarcode: (meta.boletoBarcode as string | undefined) ?? undefined,
+  };
+}

package/src/payment-gateway/payment-gateway-routing-matrix.ts

@@ -0,0 +1,18 @@
+import type { GatewayPaymentMethodDto, PaymentGatewayDto } from './payment-gateway.enums';
+
+/**
+ * Matriz fixa gateway × meio (alinhada ao README do payment-gateway-service).
+ * Usada para validar configuração persistida e para checagens determinísticas.
+ */
+const SUPPORTED: Record<PaymentGatewayDto, ReadonlySet<GatewayPaymentMethodDto>> = {
+  ASAAS: new Set(['PIX', 'CREDIT_CARD', 'DEBIT_CARD', 'BOLETO']),
+  MERCADO_PAGO: new Set(['PIX', 'CREDIT_CARD', 'DEBIT_CARD']),
+  STRIPE: new Set(['CREDIT_CARD', 'DEBIT_CARD']),
+};
+
+export function isMethodSupportedByGateway(
+  gateway: PaymentGatewayDto,
+  method: GatewayPaymentMethodDto,
+): boolean {
+  return SUPPORTED[gateway]?.has(method) ?? false;
+}

package/src/payment-gateway/payment-gateway-routing.dto.ts

@@ -0,0 +1,84 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import {
+  ArrayMinSize,
+  IsArray,
+  IsEnum,
+  Validate,
+  ValidateNested,
+  ValidationArguments,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from 'class-validator';
+import {
+  GATEWAY_PAYMENT_METHODS,
+  type GatewayPaymentMethodDto,
+  PAYMENT_GATEWAYS,
+  type PaymentGatewayDto,
+} from './payment-gateway.enums';
+import { isMethodSupportedByGateway } from './payment-gateway-routing-matrix';
+
+@ValidatorConstraint({ name: 'paymentGatewayRoutingEntriesValid', async: false })
+export class PaymentGatewayRoutingEntriesConstraint implements ValidatorConstraintInterface {
+  validate(entries: unknown, _args: ValidationArguments): boolean {
+    if (!Array.isArray(entries) || entries.length < 1) {
+      return false;
+    }
+    const seenGateways = new Set<string>();
+    for (const raw of entries) {
+      if (!raw || typeof raw !== 'object') {
+        return false;
+      }
+      const e = raw as { gateway?: unknown; methods?: unknown };
+      if (typeof e.gateway !== 'string' || !PAYMENT_GATEWAYS.includes(e.gateway as PaymentGatewayDto)) {
+        return false;
+      }
+      const gateway = e.gateway as PaymentGatewayDto;
+      if (seenGateways.has(gateway)) {
+        return false;
+      }
+      seenGateways.add(gateway);
+      if (!Array.isArray(e.methods) || e.methods.length < 1) {
+        return false;
+      }
+      for (const m of e.methods) {
+        if (typeof m !== 'string' || !GATEWAY_PAYMENT_METHODS.includes(m as GatewayPaymentMethodDto)) {
+          return false;
+        }
+        if (!isMethodSupportedByGateway(gateway, m as GatewayPaymentMethodDto)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  defaultMessage(): string {
+    return (
+      'paymentGatewayRouting.entries inválido: ordem vazia, gateway duplicado, methods vazio ' +
+      'ou combinação gateway/método não suportada pela plataforma'
+    );
+  }
+}
+
+export class PaymentGatewayRoutingEntryDto {
+  @ApiProperty({ enum: PAYMENT_GATEWAYS })
+  @IsEnum(PAYMENT_GATEWAYS as unknown as object)
+  gateway: PaymentGatewayDto;
+
+  @ApiProperty({ enum: GATEWAY_PAYMENT_METHODS, isArray: true })
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsEnum(GATEWAY_PAYMENT_METHODS as unknown as object, { each: true })
+  methods: GatewayPaymentMethodDto[];
+}
+
+export class PaymentGatewayRoutingDto {
+  @ApiProperty({ type: [PaymentGatewayRoutingEntryDto] })
+  @IsArray()
+  @ArrayMinSize(1)
+  @ValidateNested({ each: true })
+  @Type(() => PaymentGatewayRoutingEntryDto)
+  @Validate(PaymentGatewayRoutingEntriesConstraint)
+  entries: PaymentGatewayRoutingEntryDto[];
+}

package/src/payment-gateway/platform-configuration.topics.ts

@@ -0,0 +1,2 @@
+/** RPC: retorno da configuração global da plataforma (tenant-service → consumidores). */
+export const TOPIC_PLATFORM_CONFIGURATION_GET = 'platform.configuration.get';