// src/domain/order.js — everything marked is COPIED, not referenced
const createOrderLine = ({ variant, product, quantity }) => ({
  variantId: variant.id, sku: variant.sku, quantity,
  productName: product.name,                        // frozen
  size: variant.size, color: variant.color,         // frozen
  unitPriceCents: variant.priceCents,               // frozen: the essential one
  amountCents: variant.priceCents * quantity,
});
module.exports = { createOrderLine };

// src/services/carts.js
async function mergeCarts({ cartRepository, guestToken, userId }) {
  const guestCart = await cartRepository.findByToken(guestToken);
  if (!guestCart) return cartRepository.getOrCreateForUser(userId);
  const userCart = await cartRepository.getOrCreateForUser(userId);
  for (const line of guestCart.lines) {
    const existing = userCart.lines.find((l) => l.variantId === line.variantId);
    // Business rule: add quantities up, never replace silently.
    // Replacing makes the user "lose" what they had just added.
    if (existing) existing.quantity = Math.min(existing.quantity + line.quantity, LINE_LIMIT);
    else userCart.lines.push(line);
  }
  await cartRepository.save(userCart);
  await cartRepository.remove(guestCart.id);
  return userCart;
}
module.exports = { mergeCarts };

// src/services/amount-calculation.js
const VAT_RATE_PER_MILLE = 210;   // 21% expressed per mille, so no decimals
const FREE_SHIPPING_THRESHOLD = 5000;
const STANDARD_SHIPPING = 495;
function calculateAmount({ lines, shippingCents }) {
  const subtotalCents = lines.reduce(
    (sum, l) => sum + l.unitPriceCents * l.quantity, 0);
  // Round to the cent once, and over the complete subtotal.
  // Rounding line by line accumulates drift of up to N/2 cents.
  const taxCents = Math.round((subtotalCents * VAT_RATE_PER_MILLE) / 1000);
  return { subtotalCents, taxCents, shippingCents,
           totalCents: subtotalCents + taxCents + shippingCents };
}
// Pure function of the subtotal: testable with no database.
const calculateShipping = (subtotal) => subtotal === 0 ? 0
  : (subtotal >= FREE_SHIPPING_THRESHOLD ? 0 : STANDARD_SHIPPING);
module.exports = { calculateAmount, calculateShipping, VAT_RATE_PER_MILLE };

// src/repositories/inventory-sql.js
async function reserveStock({ sequelize, lines, orderId, minutes = 20 }) {
  return sequelize.transaction(async (t) => {
    for (const line of lines) {
      // SELECT ... FOR UPDATE serializes the buyers of the same variant.
      const [variant] = await sequelize.query(
        'SELECT stock, reserved_stock FROM variants WHERE id = :id FOR UPDATE',
        { replacements: { id: line.variantId }, type: SELECT, transaction: t });
      const available = variant.stock - variant.reserved_stock;
      // M6 domain error: the central handler translates it into a 409.
      if (available < line.quantity) throw new StateConflict('INSUFFICIENT_STOCK',
        { sku: line.sku, requested: line.quantity, available });
      await sequelize.query(
        'UPDATE variants SET reserved_stock = reserved_stock + :n WHERE id = :id',
        { replacements: { n: line.quantity, id: line.variantId }, transaction: t });
    }
    await inventoryRepository.createReservation({ orderId, minutes }, t);
  });
}

// src/services/payments.js
async function createPaymentIntent({ order, user }) {
  const intent = await stripe.paymentIntents.create({
    amount: order.totalCents,       // the server sets the amount (section 5)
    currency: order.currency,       // 'eur'
    // The metadata is the bridge between Stripe's world and ours.
    metadata: { orderId: order.id, userId: user.id },
    receipt_email: user.email,      // [email protected]
    automatic_payment_methods: { enabled: true },
  // Outbound idempotency: on a retry, Stripe does not create two intents.
  }, { idempotencyKey: `intent-${order.id}` });
  return { externalReference: intent.id, clientSecret: intent.client_secret };
}
module.exports = { createPaymentIntent, stripe };

// src/app.js — excerpt of the middleware order
function createApplication(dependencies = {}) {
  const app = express();
  app.use(helmet());
  app.use(requestId);
  // CRITICAL ORDER: the webhook needs a Buffer, not an object.
  app.use('/api/v1/webhooks/payments',
    express.raw({ type: 'application/json', limit: '1mb' }),
    createPaymentsWebhookRoutes(dependencies));
  app.use(express.json({ limit: '100kb' }));  // everything else does use JSON
  // ... normal routers and the central error handler (M6) ...
  return app;
}

// src/routes/payments-webhook.js
routes.post('/', async (req, res) => {
  let event;
  try {
    // req.body is a Buffer thanks to express.raw.
    event = stripe.webhooks.constructEvent(req.body,
      req.get('stripe-signature'), configuration.stripe.webhookSecret);
  } catch (error) {
    return res.status(400).json({ error: { code: 'INVALID_SIGNATURE',
      message: 'Signature could not be verified', status: 400, details: null } });
  }
  // Idempotency: Stripe retries for days if you do not answer 2xx.
  // event.id acts as the Idempotency-Key (M10), persisted in the database.
  const isNew = await paymentEventRepository.recordIfNew(event.id, event.type);
  if (!isNew) return res.status(200).json({ received: true, duplicate: true });
  try {
    const object = event.data.object;
    if (event.type === 'payment_intent.succeeded') {
      await orderService.confirmPayment({ orderId: object.metadata.orderId,
        externalReference: object.id, amountCents: object.amount_received });
    } else if (event.type === 'payment_intent.payment_failed') {
      await orderService.markPaymentFailed({ orderId: object.metadata.orderId });
    }
    return res.status(200).json({ received: true });  // fast 200, queue separately
  } catch (error) {
    // A 500 makes Stripe retry: correct for a transient failure.
    await paymentEventRepository.markFailed(event.id, error.message);
    return res.status(500).json({ error: { code: 'INTERNAL_ERROR',
      message: 'Retry', status: 500, details: null } });
  }
});

// src/domain/order-statuses.js
const TRANSITIONS = {
  cart: ['pending_payment'],
  pending_payment: ['paid', 'cancelled'],
  paid: ['preparing', 'refunded', 'cancelled'],
  preparing: ['shipped', 'refunded'],
  shipped: ['delivered', 'refunded'],
  delivered: ['refunded'],
  cancelled: [], refunded: [],   // terminal statuses: no way out
};

function transition(order, newStatus) {
  const allowed = TRANSITIONS[order.status] ?? [];
  if (!allowed.includes(newStatus)) throw new StateConflict('INVALID_TRANSITION',
    { currentStatus: order.status, requestedStatus: newStatus, allowed });
  return { ...order, status: newStatus, updatedAt: new Date().toISOString() };
}
module.exports = { transition, TRANSITIONS };

// src/services/orders.js — excerpt
async function confirmPayment({ orderId, externalReference, amountCents }) {
  const order = await orderRepository.get(orderId);
  if (!order) throw new ResourceNotFound('ORDER_NOT_FOUND', { orderId });
  // Defense: the amount charged must match the amount computed.
  if (amountCents !== order.totalCents) throw new StateConflict(
    'AMOUNT_MISMATCH', { orderId, amountCents });
  const confirmed = transition(order, 'paid');
  // Consumes the reservation in a transaction: stock -= n, reservedStock -= n.
  await orderRepository.confirmInTransaction({ order: confirmed, externalReference });
  // A fixed jobId = idempotency for free: BullMQ rejects an existing id,
  // so even if the webhook were processed twice the email goes out once.
  await emailQueue.add('order-confirmation', { orderId }, { attempts: 5,
    backoff: { type: 'exponential', delay: 2000 }, jobId: `confirmation-${orderId}` });
  await invoiceQueue.add('generate-invoice', { orderId }, { jobId: `invoice-${orderId}` });
  return confirmed;
}

// test/store/checkout.test.js
describe('store checkout', () => {
  it('rejects a webhook with an invalid signature', async () => {
    await request(createApplication()).post('/api/v1/webhooks/payments')
      .set('stripe-signature', 't=1,v1=fake').set('Content-Type', 'application/json')
      .send(Buffer.from(JSON.stringify({ type: 'payment_intent.succeeded' })))
      .expect(400)
      .expect((r) => expect(r.body.error.code).to.equal('INVALID_SIGNATURE'));
  });
  it('prevents overselling when two purchases race for the last unit', async () => {
    await seedVariant({ sku: 'EV-VIN-003-UNI', stock: 1 });
    const results = await Promise.allSettled([
      startPayment({ sku: 'EV-VIN-003-UNI', quantity: 1, user: 'usr-lucia' }),
      startPayment({ sku: 'EV-VIN-003-UNI', quantity: 1, user: 'usr-marc' }),
    ]);
    expect(results.filter((r) => r.status === 'fulfilled')).to.have.lengthOf(1);
    expect(results.find((r) => r.status === 'rejected').reason.appCode)
      .to.equal('INSUFFICIENT_STOCK');
  });
  it('ignores a payment_failed that arrives after confirmation', async () => {
    await sendSignedWebhook(successEvent);
    await sendSignedWebhook(lateFailureEvent);
    expect((await orderRepository.get('ord-8812')).status).to.equal('paid');
  });
});

// src/queues/maintenance.js
await maintenanceQueue.add('release-reservations', {},
  { repeat: { every: 60_000 }, jobId: 'release-reservations-repeatable' });
new Worker('maintenance', async () => {
  for (const reservation of await inventoryRepository.expiredReservations()) {
    await sequelize.transaction(async (t) => {
      for (const line of reservation.lines) {
        await sequelize.query(
          'UPDATE variants SET reserved_stock = reserved_stock - :n WHERE id = :id',
          { replacements: { n: line.quantity, id: line.variantId }, transaction: t });
      }
      // The status condition is essential: without it, a race with the
      // webhook would cancel an order that has already been charged.
      await sequelize.query(
        `UPDATE orders SET status = 'cancelled' WHERE id = :id AND status = 'pending_payment'`,
        { replacements: { id: reservation.orderId }, transaction: t });
      await inventoryRepository.removeReservation(reservation.id, t);
    });
  }
}, { connection });

it('charges shipping at 4999 and not at 5000', () => {
  expect(calculateShipping(4999)).to.equal(495);
  expect(calculateShipping(5000)).to.equal(0);
});
it('computes VAT over the complete subtotal', () => {
  const lines = [{ unitPriceCents: 1999, quantity: 3 }];
  const r = calculateAmount({ lines, shippingCents: calculateShipping(5997) });
  expect(r.subtotalCents).to.equal(5997);
  expect(r.taxCents).to.equal(1259);  // round(5997 * 210 / 1000)
  expect(r.totalCents).to.equal(7256);
});
it('returns everything at zero for an empty cart', () => {
  expect(calculateAmount({ lines: [], shippingCents: 0 }).totalCents).to.equal(0);
});

async function recordIfNew(eventId, type) {
  // ON CONFLICT DO NOTHING RETURNING performs the check and the insert in a
  // single atomic statement: there is no race window between two processes.
  const [rows] = await sequelize.query(
    `INSERT INTO payment_events (event_id, type) VALUES (:eventId, :type)
     ON CONFLICT (event_id) DO NOTHING RETURNING event_id`,
    { replacements: { eventId, type } });
  return rows.length > 0;   // false if it already existed: this is a redelivery
}

it('processes only once with simultaneous deliveries', async () => {
  const spy = sinon.spy(orderService, 'confirmPayment');
  await Promise.all([sendSignedWebhook(successEvent), sendSignedWebhook(successEvent)]);
  expect(spy.callCount).to.equal(1);
});