@greatapps/common 1.1.790 → 1.1.792

package/src/modules/affiliates/services/affiliates.service.ts

@@ -0,0 +1,240 @@
+import 'server-only';
+
+import { api } from '../../../infra/api/client';
+import {
+  ApiError,
+  type ApiPaginatedActionResult,
+  type PaginatedSuccessResult,
+  type SuccessResult,
+} from '../../../infra/api/types';
+import { buildQueryParams } from '../../../infra/utils/params';
+import { assertManagementSubscription } from '../../auth/utils/assert-management-subscription';
+import { getUserContext } from '../../auth/utils/get-user-context';
+import {
+  AffiliateCouponSchema,
+  AffiliateLeadSchema,
+  AffiliateSchema,
+  AffiliateTransactionSchema,
+  EMPTY_REPORT_ANALYTICS_DATA,
+  ReportAnalyticsDataSchema,
+  WithdrawalLimitsSchema,
+  type Affiliate,
+  type AffiliateCoupon,
+  type AffiliateLead,
+  type AffiliateTransaction,
+  type EnsureAffiliateData,
+  type EnsureAffiliateRequest,
+  type ListAffiliateLeadsParams,
+  type ListAffiliateTransactionsParams,
+  type ReportAnalyticsData,
+  type ReportAnalyticsParams,
+  type RequestDepositRequest,
+  type UpdateAffiliateRequest,
+  type WithdrawalLimits,
+} from '../types/affiliate.type';
+
+interface ApiDataResponse<T> {
+  status: 0 | 1;
+  message?: string;
+  data?: T[];
+  total?: number;
+}
+
+/**
+ * Leituras do programa de afiliados sempre a partir da conta da sessão: o afiliado nunca vem do
+ * client, então uma conta não lê relatório, transações ou cupons do afiliado de outra.
+ */
+class AffiliatesService {
+  async findCurrent(): Promise<SuccessResult<Affiliate | null>> {
+    const { id_account } = await getUserContext();
+    const response = await api.apps.get<ApiPaginatedActionResult<Affiliate>>(
+      `/affiliates?${buildQueryParams({ id_account, limit: 1, page: 1 })}`
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao buscar afiliado',
+        'FIND_CURRENT_AFFILIATE_FAILED',
+        400
+      );
+    }
+
+    const affiliate = response.data?.[0];
+    return { success: true, data: affiliate ? AffiliateSchema.parse(affiliate) : null };
+  }
+
+  async reportAnalytics(params: ReportAnalyticsParams): Promise<SuccessResult<ReportAnalyticsData>> {
+    const affiliateId = await this.requireCurrentAffiliateId();
+    const response = await api.apps.get<ApiDataResponse<ReportAnalyticsData>>(
+      `/affiliates/${affiliateId}/action/reportAnalytics?${buildQueryParams({ ...params })}`
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao buscar relatório de afiliado',
+        'REPORT_ANALYTICS_FAILED',
+        400
+      );
+    }
+
+    const raw = response.data?.[0];
+    return { success: true, data: raw ? ReportAnalyticsDataSchema.parse(raw) : EMPTY_REPORT_ANALYTICS_DATA };
+  }
+
+  async listTransactions(
+    params: ListAffiliateTransactionsParams
+  ): Promise<PaginatedSuccessResult<AffiliateTransaction>> {
+    const affiliateId = await this.requireCurrentAffiliateId();
+    const response = await api.apps.get<ApiDataResponse<AffiliateTransaction>>(
+      `/affiliates/${affiliateId}/action/listTransactions?${buildQueryParams({ ...params })}`
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao listar transações de afiliado',
+        'LIST_TRANSACTIONS_FAILED',
+        400
+      );
+    }
+
+    return {
+      success: true,
+      data: (response.data ?? []).map((item) => AffiliateTransactionSchema.parse(item)),
+      total: response.total ?? 0,
+    };
+  }
+
+  async listCoupons(): Promise<PaginatedSuccessResult<AffiliateCoupon>> {
+    const affiliateId = await this.requireCurrentAffiliateId();
+    const response = await api.apps.get<ApiDataResponse<AffiliateCoupon>>(
+      `/coupons?${buildQueryParams({ id_affiliate: affiliateId })}`
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(response.message || 'Erro ao listar cupons', 'LIST_COUPONS_FAILED', 400);
+    }
+
+    return {
+      success: true,
+      data: (response.data ?? []).map((item) => AffiliateCouponSchema.parse(item)),
+      total: response.total ?? 0,
+    };
+  }
+
+  /** Leads indicados pelo afiliado da conta (a listagem de contas filtrada por `id_affiliate`). */
+  async listLeads(params: ListAffiliateLeadsParams): Promise<PaginatedSuccessResult<AffiliateLead>> {
+    const affiliateId = await this.requireCurrentAffiliateId();
+    const response = await api.apps.get<ApiDataResponse<AffiliateLead>>(
+      `/accounts?${buildQueryParams({ ...params, id_affiliate: affiliateId })}`
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao listar leads do afiliado',
+        'LIST_AFFILIATE_LEADS_FAILED',
+        400
+      );
+    }
+
+    return {
+      success: true,
+      data: (response.data ?? []).map((item) => AffiliateLeadSchema.parse(item)),
+      total: response.total ?? 0,
+    };
+  }
+
+  async getWithdrawalLimits(): Promise<SuccessResult<WithdrawalLimits>> {
+    const affiliateId = await this.requireCurrentAffiliateId();
+    const response = await api.apps.get<ApiDataResponse<WithdrawalLimits>>(
+      `/affiliates/${affiliateId}/action/withdrawalLimits`
+    );
+
+    if (response.status === 0 || !response.data?.[0]) {
+      throw new ApiError(
+        response.message || 'Erro ao buscar limites de saque',
+        'GET_WITHDRAWAL_LIMITS_FAILED',
+        400
+      );
+    }
+
+    return { success: true, data: WithdrawalLimitsSchema.parse(response.data[0]) };
+  }
+
+  /** Entrada no programa: cria o afiliado da conta com os cupons padrão, ou devolve o que já existe. */
+  async ensureAffiliate(body: EnsureAffiliateRequest): Promise<SuccessResult<EnsureAffiliateData>> {
+    await assertManagementSubscription();
+    const { id_account } = await getUserContext();
+
+    const response = await api.apps.post<ApiDataResponse<EnsureAffiliateData>>(
+      '/affiliates/action/ensure',
+      { id_account, ...body }
+    );
+
+    if (response.status === 0 || !response.data?.length) {
+      throw new ApiError(
+        response.message || 'Erro ao entrar no programa de afiliados',
+        'ENSURE_AFFILIATE_FAILED',
+        400
+      );
+    }
+
+    const raw = response.data[0];
+
+    return {
+      success: true,
+      data: {
+        affiliate: AffiliateSchema.parse(raw.affiliate),
+        coupons: raw.coupons ?? [],
+        created: raw.created ?? [],
+        failed: raw.failed ?? [],
+      },
+    };
+  }
+
+  async requestDeposit(body: RequestDepositRequest): Promise<{ success: true; message: string }> {
+    const affiliateId = await this.requireCurrentAffiliateId();
+    const response = await api.apps.post<{ status: 0 | 1; message?: string }>(
+      `/affiliates/${affiliateId}/action/requestDeposit`,
+      body
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao solicitar saque',
+        'REQUEST_DEPOSIT_FAILED',
+        400
+      );
+    }
+
+    return { success: true, message: response.message || 'Solicitação enviada com sucesso.' };
+  }
+
+  /** Conta de recebimento (PIX e titular) do afiliado da conta. */
+  async updateAffiliate(body: UpdateAffiliateRequest): Promise<SuccessResult<Affiliate>> {
+    const affiliateId = await this.requireCurrentAffiliateId();
+    const response = await api.apps.put<ApiDataResponse<Affiliate>>(
+      `/affiliates/${affiliateId}`,
+      body
+    );
+
+    if (response.status === 0 || !response.data?.[0]) {
+      throw new ApiError(
+        response.message || 'Erro ao atualizar conta de recebimento',
+        'UPDATE_AFFILIATE_FAILED',
+        400
+      );
+    }
+
+    return { success: true, data: AffiliateSchema.parse(response.data[0]) };
+  }
+
+  private async requireCurrentAffiliateId(): Promise<number> {
+    const { data: affiliate } = await this.findCurrent();
+    if (!affiliate) {
+      throw new ApiError('Afiliado não encontrado', 'AFFILIATE_NOT_FOUND', 404);
+    }
+    return affiliate.id;
+  }
+}
+
+export const affiliatesService = new AffiliatesService();

package/src/modules/affiliates/types/affiliate.type.ts

@@ -0,0 +1,180 @@
+import z from 'zod';
+
+export const AffiliateSchema = z.object({
+  id: z.number(),
+  deleted: z
+    .number()
+    .transform((val) => val === 1)
+    .optional()
+    .default(false),
+  datetime_alt: z.union([z.date(), z.coerce.date()]).nullable().optional(),
+  datetime_del: z.union([z.date(), z.coerce.date()]).nullable().optional(),
+  datetime_add: z.union([z.date(), z.coerce.date()]).nullable().optional(),
+  id_wl: z.number(),
+  id_account: z.number(),
+  active: z.boolean(),
+  balance: z.union([z.number(), z.string()]).nullable().optional(),
+  pix: z.string().nullable().optional(),
+  bank: z.string().nullable().optional(),
+  agency: z.string().nullable().optional(),
+  account: z.string().nullable().optional(),
+  holder_document: z.string().nullable().optional(),
+  holder_name: z.string().nullable().optional(),
+});
+
+export type Affiliate = z.infer<typeof AffiliateSchema>;
+
+export const ReportAnalyticsPeriodSchema = z.object({
+  period: z.coerce.number(),
+  total: z.coerce.number(),
+});
+
+export const ReportAnalyticsGraphicDataItemSchema = z.object({
+  date: z.string(),
+  views: z.coerce.number(),
+  leads: z.coerce.number(),
+  customers: z.coerce.number().optional(),
+});
+
+export const ReportAnalyticsDataSchema = z.object({
+  leads: ReportAnalyticsPeriodSchema,
+  views: ReportAnalyticsPeriodSchema,
+  customers: ReportAnalyticsPeriodSchema,
+  income: z.coerce.number(),
+  graphicData: z.array(ReportAnalyticsGraphicDataItemSchema),
+});
+
+export type ReportAnalyticsData = z.infer<typeof ReportAnalyticsDataSchema>;
+
+export interface ReportAnalyticsParams {
+  date_start: string;
+  date_end: string;
+}
+
+export const EMPTY_REPORT_ANALYTICS_DATA: ReportAnalyticsData = {
+  leads: { period: 0, total: 0 },
+  views: { period: 0, total: 0 },
+  customers: { period: 0, total: 0 },
+  income: 0,
+  graphicData: [],
+};
+
+export const AffiliateTransactionSchema = z.object({
+  id: z.number(),
+  datetime_add: z.string(),
+  value: z.coerce.number(),
+  status: z
+    .string()
+    .transform((s) => s.toLowerCase())
+    .pipe(z.enum(['pending', 'consolidated', 'canceled', 'refused'])),
+  type: z.number(),
+  email: z.string().optional(),
+  comission: z.coerce.number().optional(),
+  attachment: z.string().nullable().optional(),
+  refused_reason: z.string().nullable().optional(),
+});
+
+export type AffiliateTransaction = z.infer<typeof AffiliateTransactionSchema>;
+
+export interface ListAffiliateTransactionsParams {
+  page?: number;
+  limit?: number;
+  sort?: string;
+  date_start?: string;
+  date_end?: string;
+}
+
+/** Cupom de afiliado: só o que a aba de afiliados usa do cupom. */
+export const AffiliateCouponSchema = z.object({
+  id: z.number(),
+  id_affiliate: z.number().nullable().optional(),
+  title: z.string(),
+  code: z.string(),
+  discount: z.number(),
+  discount_type: z.number().nullable(),
+  active: z.boolean(),
+});
+
+export type AffiliateCoupon = z.infer<typeof AffiliateCouponSchema>;
+
+// ============================================================================
+// Programa de afiliados: entrada, saque e conta de recebimento
+// ============================================================================
+
+/** Descontos dos cupons criados junto com o afiliado. */
+export const DEFAULT_AFFILIATE_DISCOUNTS = [0, 5, 10];
+
+export interface EnsureAffiliateRequest {
+  gestor_name: string;
+  discounts?: number[];
+}
+
+export interface EnsureAffiliateCoupon {
+  id: number;
+  code: string;
+  discount: number;
+  discount_type: number | null;
+  active: boolean;
+  id_affiliate: number;
+  id_wl: number;
+  title?: string;
+}
+
+export interface EnsureAffiliateData {
+  affiliate: Affiliate;
+  coupons: EnsureAffiliateCoupon[];
+  created: EnsureAffiliateCoupon[];
+  failed: { discount: number; error: string }[];
+}
+
+export interface RequestDepositRequest {
+  value: number;
+  attachment?: string;
+}
+
+export interface UpdateAffiliateRequest {
+  bank?: string;
+  pix?: string;
+  agency?: string;
+  account?: string;
+  holder_name?: string;
+  holder_document?: string;
+}
+
+export const AffiliateLeadSchema = z.object({
+  id: z.number(),
+  name: z.string().nullable().optional(),
+  datetime_add: z.string().nullable().optional(),
+});
+
+export type AffiliateLead = z.infer<typeof AffiliateLeadSchema>;
+
+export interface ListAffiliateLeadsParams {
+  page?: number;
+  limit?: number;
+  sort?: string;
+  search?: string;
+}
+
+export const DEFAULT_LIST_AFFILIATE_LEADS_PARAMS: ListAffiliateLeadsParams = {
+  page: 1,
+  limit: 50,
+  sort: 'id:DESC',
+};
+
+/** Regras de saque do backend: mínimo, teto mensal de CPF, nota fiscal de CNPJ e bloqueios. */
+export const WithdrawalLimitsSchema = z.object({
+  personType: z.enum(['cpf', 'cnpj']),
+  financialDocumentType: z.number(),
+  requiresInvoice: z.boolean(),
+  minValue: z.number(),
+  maxValuePerMonth: z.number().nullable(),
+  monthlyUsed: z.number().nullable(),
+  monthlyRemaining: z.number().nullable(),
+  balance: z.number(),
+  availableToWithdraw: z.number(),
+  canWithdraw: z.boolean(),
+  blockReason: z.enum(['PIX_DOCUMENT_MISMATCH']).nullable(),
+});
+
+export type WithdrawalLimits = z.infer<typeof WithdrawalLimitsSchema>;

package/src/modules/affiliates/utils/get-affiliate-share-link.ts

@@ -0,0 +1,8 @@
+import type { AffiliateCoupon } from '../types/affiliate.type';
+
+/** Cupom sem desconto compartilha o link de afiliado; com desconto, o link do cupom. */
+export function getAffiliateShareLink(baseUrl: string, coupon: Pick<AffiliateCoupon, 'id' | 'code' | 'discount'>): string {
+  const base = baseUrl.replace(/\/$/, '');
+  if (coupon.discount === 0) return `${base}/a/${coupon.code}`;
+  return `${base}/cupom/${coupon.id}`;
+}

package/src/modules/charges/actions/get-nota-fiscal.action.ts

@@ -0,0 +1,8 @@
+'use server';
+
+import { safeMutationAction } from '../../../utils/safeMutationAction';
+import { chargesService } from '../services/charges.service';
+
+export async function getNotaFiscalAction(chargeId: number | string) {
+  return safeMutationAction(() => chargesService.getNotaFiscal(chargeId));
+}

package/src/modules/charges/actions/refresh-pix.action.ts

@@ -0,0 +1,8 @@
+'use server';
+
+import { safeMutationAction } from '../../../utils/safeMutationAction';
+import { chargesService } from '../services/charges.service';
+
+export async function refreshChargePixAction(chargeId: string) {
+  return safeMutationAction(() => chargesService.refreshPix(chargeId));
+}

package/src/modules/charges/hooks/nota-fiscal.hook.ts

@@ -0,0 +1,13 @@
+'use client';
+
+import { useMutation } from '@tanstack/react-query';
+import { withAction } from '../../../utils/withAction';
+import { getNotaFiscalAction } from '../actions/get-nota-fiscal.action';
+import type { NotaFiscalResult } from '../types/nota-fiscal.type';
+
+/** Busca sob demanda a nota fiscal de uma cobrança: `{ emitida, notas[] }` com os links. */
+export function useNotaFiscal() {
+  return useMutation<NotaFiscalResult, Error, number | string>({
+    mutationFn: (chargeId) => withAction(getNotaFiscalAction)(chargeId),
+  });
+}

package/src/modules/charges/hooks/refresh-pix.hook.ts

@@ -0,0 +1,13 @@
+'use client';
+
+import { useMutation } from '@tanstack/react-query';
+import { withAction } from '../../../utils/withAction';
+import { refreshChargePixAction } from '../actions/refresh-pix.action';
+import type { PixRefreshResult } from '../types/refresh-pix.type';
+
+/** Regenera o PIX de uma fatura aberta ("Ver código PIX"). */
+export function useRefreshChargePix() {
+  return useMutation<PixRefreshResult, Error, string>({
+    mutationFn: (chargeId) => withAction(refreshChargePixAction)(chargeId),
+  });
+}

package/src/modules/charges/services/charges.service.ts

@@ -5,6 +5,72 @@ import { ApiError, ApiActionResult, ApiPaginatedActionResult, PaginatedSuccessRe
 import { buildQueryParams } from '../../../infra/utils/params';
 import { getUserContext } from '../../auth/utils/get-user-context';
 import { Charge, FindChargesParams, PayChargeInput } from '../types/charge.type';
+import type { NotaFiscalLink, NotaFiscalResult } from '../types/nota-fiscal.type';
+import type { PixRefreshResult } from '../types/refresh-pix.type';
+
+type NotaFiscalApiResponse = {
+  status: number;
+  message?: string;
+  data?: Array<{ invoice?: Record<string, unknown> | null }>;
+};
+
+type PixRefreshApiResponse = {
+  status: number;
+  message?: string;
+  data?: Array<{
+    recurring?: boolean;
+    pix?: {
+      qr_code?: string | null;
+      qr_code_image?: string | null;
+      payment_link?: string | null;
+      expires_at?: string | null;
+      correlation_id?: string | null;
+    } | null;
+  }>;
+};
+
+const asString = (value: unknown): string | null =>
+  typeof value === 'string' && value.length > 0 ? value : null;
+
+/**
+ * Normaliza a venda do eNotas (shape variável) numa lista de links: a venda pode trazer
+ * `ListaNFes` (array), `nfe` (objeto) ou os campos no topo. Os links só vêm preenchidos depois
+ * que a nota é autorizada — ficam nulos enquanto a emissão está na fila.
+ */
+function extractNotaLinks(invoice: Record<string, unknown> | null | undefined): NotaFiscalLink[] {
+  if (!invoice) return [];
+
+  const candidates: Record<string, unknown>[] = [];
+  if (Array.isArray(invoice.ListaNFes)) {
+    candidates.push(...(invoice.ListaNFes as Record<string, unknown>[]));
+  }
+  if (invoice.nfe && typeof invoice.nfe === 'object') {
+    candidates.push(invoice.nfe as Record<string, unknown>);
+  }
+  if (candidates.length === 0) {
+    candidates.push(invoice);
+  }
+
+  return candidates
+    .map((item) => {
+      const prefeitura =
+        item.prefeitura && typeof item.prefeitura === 'object'
+          ? (item.prefeitura as Record<string, unknown>)
+          : {};
+
+      return {
+        situacao: asString(item.situacao),
+        linkPdf:
+          asString(item.linkDownloadPDF) ??
+          asString(item.linkDownload) ??
+          asString(item.linkVisualizacao) ??
+          asString(prefeitura.linkImpressao),
+        linkXml:
+          asString(item.linkDownloadXML) ?? asString(item.linkXml) ?? asString(prefeitura.linkXml),
+      };
+    })
+    .filter((nota) => nota.linkPdf || nota.linkXml);
+}
 
 class ChargesService {
   async listCharges(params?: Partial<FindChargesParams>): Promise<PaginatedSuccessResult<Charge>> {
@@ -58,6 +124,61 @@ class ChargesService {
 
     return { data: response.data[0], success: true };
   }
+
+  /**
+   * Nota fiscal (eNotas) emitida para a cobrança. Vale para Stripe (id `in_xxx`) e Vindi (id
+   * numérico) — o backend resolve a venda pelo metadata da invoice ou pela coluna da charge.
+   */
+  async getNotaFiscal(chargeId: number | string): Promise<NotaFiscalResult> {
+    const { id_account } = await getUserContext();
+    const response = await api.apps.get<NotaFiscalApiResponse>(
+      `/charges/${chargeId}/action/nota-fiscal?${buildQueryParams({ id_account })}`
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Não foi possível consultar a nota fiscal',
+        'GET_NOTA_FISCAL_FAILED',
+        400
+      );
+    }
+
+    const notas = extractNotaLinks(response.data?.[0]?.invoice ?? null);
+
+    return { emitida: notas.length > 0, notas };
+  }
+
+  /**
+   * Recarrega o PIX de uma fatura aberta ("Ver código PIX"). Devolve o mesmo QR se ainda válido,
+   * ou gera outro se expirou. Cobrança automática (mandato) volta `recurring: true`, sem QR manual.
+   */
+  async refreshPix(chargeId: string): Promise<PixRefreshResult> {
+    const response = await api.apps.post<PixRefreshApiResponse>(
+      `/charges/${chargeId}/action/pix-refresh`,
+      {}
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(response.message || 'Não foi possível gerar o PIX', 'REFRESH_PIX_FAILED', 400);
+    }
+
+    const row = response.data?.[0] ?? null;
+    const pix = row?.pix ?? null;
+
+    return {
+      recurring: Boolean(row?.recurring),
+      pix: pix
+        ? {
+            qr_code: pix.qr_code ?? null,
+            qr_code_image: pix.qr_code_image ?? null,
+            payment_link: pix.payment_link ?? null,
+            expires_at: pix.expires_at ?? null,
+            correlation_id: pix.correlation_id ?? null,
+          }
+        : null,
+      message: response.message ?? null,
+    };
+  }
 }
 
 export const chargesService = new ChargesService();

package/src/modules/charges/types/nota-fiscal.type.ts

@@ -0,0 +1,20 @@
+/**
+ * Nota fiscal (eNotas) de uma cobrança.
+ *
+ * O backend delega ao worker de invoices, que consulta a venda no eNotas e devolve o objeto bruto
+ * em `data[0].invoice`. A nota com valor fiscal é a do eNotas — a invoice/recibo do gateway não tem.
+ */
+export interface NotaFiscalLink {
+  /** Situação já traduzida pelo worker (Aguardando/Recebido/Autorizado/Rejeitado/Cancelado). */
+  situacao: string | null;
+  /** Link de download do PDF (DANFE). */
+  linkPdf: string | null;
+  /** Link de download do XML. */
+  linkXml: string | null;
+}
+
+export interface NotaFiscalResult {
+  /** `true` quando há ao menos uma NFe com link disponível. */
+  emitida: boolean;
+  notas: NotaFiscalLink[];
+}

package/src/modules/charges/types/refresh-pix.type.ts

@@ -0,0 +1,14 @@
+export interface PixRefreshData {
+  qr_code: string | null;
+  qr_code_image: string | null;
+  payment_link: string | null;
+  expires_at: string | null;
+  correlation_id: string | null;
+}
+
+export interface PixRefreshResult {
+  /** Cobrança automática (mandato): o backend não devolve QR manual. */
+  recurring: boolean;
+  pix: PixRefreshData | null;
+  message: string | null;
+}

package/src/modules/charges/utils/get-charge-download-url.ts

@@ -0,0 +1,10 @@
+import type { Charge } from '../types/charge.type';
+
+/**
+ * URL pra baixar o recibo/boleto de uma charge, ou null quando nenhuma URL está disponível
+ * (caso comum em charges antigas Vindi/enotas que não expõem invoice_url/invoice_pdf/gateway_billet).
+ */
+export function getChargeDownloadUrl(charge: Charge | null | undefined): string | null {
+  if (!charge) return null;
+  return charge.invoice_pdf || charge.invoice_url || charge.gateway_billet || null;
+}

package/src/modules/coupons/constants/query-keys.constants.ts

@@ -0,0 +1 @@
+export const COUPON_QUERY_KEY = ['coupon'] as const;

package/src/modules/coupons/handlers/find-coupon-by-code.handler.ts

@@ -0,0 +1,16 @@
+import 'server-only';
+
+import type { NextRequest } from 'next/server';
+import { ApiError } from '../../../infra/api/types';
+import { safeRouteHandler } from '../../../infra/route/safe-route-handler';
+import { couponsService } from '../services/coupons.service';
+
+export function createFindCouponByCodeHandler() {
+  return async function GET(req: NextRequest) {
+    return safeRouteHandler(() => {
+      const code = req.nextUrl.searchParams.get('code');
+      if (!code) throw new ApiError('Informe o código do cupom', 'COUPON_CODE_REQUIRED', 400);
+      return couponsService.getCouponByCode(code);
+    });
+  };
+}