1// BAD: couplage fort, le use case depend directement de Prisma et Stripe
2
3import { prisma } from '@/lib/prisma';
4import Stripe from 'stripe';
5
6const stripe = new Stripe(process.env.STRIPE_SECRET!);
7
8export async function createOrder(amountCents: number, customerId: string) {
9  if (amountCents < 100) throw new Error('Montant minimum: 1 EUR');
10
11  const payment = await stripe.paymentIntents.create({
12    amount: amountCents,
13    currency: 'eur',
14  });
15
16  return prisma.order.create({
17    data: {
18      customerId,
19      amountCents,
20      status: payment.status === 'succeeded' ? 'PAID' : 'PENDING',
21      paymentId: payment.id,
22    },
23  });
24}
25
26// Si Stripe ou Prisma changent, la logique metier doit etre reecrite.

1// OK Le domaine definit les ports (interfaces)
2
3export interface PaymentPort {
4  charge(input: {
5    amountCents: number;
6    currency: string;
7    reference: string;
8  }): Promise<{
9    provider: string;
10    transactionId: string;
11    authorized: true;
12  }>;
13}
14
15export interface OrderRepositoryPort {
16  save(order: OrderEntity): Promise<PersistedOrder>;
17}
18
19// Use case: depend uniquement des interfaces
20export async function createOrderUseCase(
21  command: CreateOrderCommand,
22  deps: {
23    paymentPort: PaymentPort;
24    orderRepository: OrderRepositoryPort;
25  }
26) {
27  // logique metier pure
28}
29
30// Les adapters (Stripe, Postgres, Mock...) se branchent via deps.

1// Controller (adapter entrant)
2export async function createOrderAction(formData: FormData) {
3  const amountCents = Number(formData.get('amountCents'));
4
5  const result = await createOrderUseCase(
6    {
7      customerId: 'customer_42',
8      amountCents,
9      currency: 'EUR',
10    },
11    {
12      paymentPort: new StripePaymentAdapter(stripeClient),
13      orderRepository: new PostgresOrderRepository(prisma),
14    }
15  );
16
17  return result;
18}
19
20// Le use case ne depend pas de Next.js, Prisma ou Stripe.

1src/
2  domain/
3    orders/
4      entities/order.ts
5      ports/payment-port.ts
6      ports/order-repository-port.ts
7      use-cases/create-order.ts
8
9  infrastructure/
10    orders/
11      adapters/inbound/create-order-action.ts
12      adapters/outbound/stripe-payment-adapter.ts
13      adapters/outbound/postgres-order-repository.ts
14
15  app/
16    (dashboard)/orders/page.tsx
17
18// Regle de lecture:
19// - domain/ ne depend de rien d externe
20// - infrastructure/ depend du domain
21// - app/ assemble les dependencies

1// Plan de migration en 4 etapes
2
3// 1) Choisir un use case critique
4//    Exemple: create-order
5
6// 2) Extraire les ports sortants dans le domaine
7//    PaymentPort, OrderRepositoryPort
8
9// 3) Creer des adapters techniques
10//    StripePaymentAdapter, PostgresOrderRepository
11
12// 4) Assembler dans un controller/server action
13//    createOrderUseCase(command, { paymentPort, orderRepository })
14
15// Ensuite repeter use case par use case.
16// La migration devient incrementale plutot que big bang.

1import { describe, expect, it } from 'vitest';
2import { createOrderUseCase } from './create-order';
3
4describe('createOrderUseCase', () => {
5  it('cree une commande payee', async () => {
6    const fakePaymentPort = {
7      charge: async () => ({
8        provider: 'FakePay',
9        transactionId: 'tx_test',
10        authorized: true as const,
11      }),
12    };
13
14    const fakeRepository = {
15      save: async (order: any) => ({
16        ...order,
17        storage: 'InMemory',
18        persistedAt: new Date().toISOString(),
19      }),
20    };
21
22    const result = await createOrderUseCase(
23      {
24        customerId: 'c_1',
25        amountCents: 2400,
26        currency: 'EUR',
27      },
28      {
29        paymentPort: fakePaymentPort,
30        orderRepository: fakeRepository,
31      }
32    );
33
34    expect(result.order.status).toBe('PAID');
35    expect(result.payment.provider).toBe('FakePay');
36  });
37});