// Spring Boot — paginated CRUD
@GetMapping
public Page<UserDto> getUsers(
    @RequestParam(defaultValue="0") int page,
    @RequestParam(defaultValue="20") int size,
    @RequestParam(defaultValue="name") String sort,
    @RequestParam(required=false) String search) {
  var pageable = PageRequest.of(page, size, Sort.by(sort));
  return search == null
    ? userRepo.findAll(pageable).map(mapper::toDto)
    : userRepo.searchByName(search, pageable).map(mapper::toDto);
}

@PostMapping
@ResponseStatus(HttpStatus.CREATED)
public UserDto createUser(@Valid @RequestBody CreateUserRequest req) {
  if (userRepo.existsByEmail(req.email()))
    throw new ConflictException("Email already exists");
  return mapper.toDto(userRepo.save(mapper.toEntity(req)));
}

@PutMapping("/{id}")
public UserDto updateUser(@PathVariable Long id,
    @Valid @RequestBody UpdateUserRequest req) {
  var user = userRepo.findById(id)
    .orElseThrow(() -> new ResourceNotFoundException(id));
  mapper.updateEntity(user, req);
  return mapper.toDto(userRepo.save(user));
}

// Express — paginated CRUD
router.get('/', authenticate, async (req, res, next) => {
  try {
    const { page = 1, limit = 20, search, sort = 'name' } = req.query;
    const skip = (page - 1) * limit;
    const filter = search
      ? { name: { $regex: search, $options: 'i' } } : {};
    const [users, total] = await Promise.all([
      User.find(filter).sort(sort).skip(skip).limit(+limit).lean(),
      User.countDocuments(filter),
    ]);
    res.json({
      data: users, page: +page, limit: +limit,
      total, pages: Math.ceil(total / limit)
    });
  } catch (err) { next(err); }
});

router.post('/', authenticate, validate(createSchema), async (req, res, next) => {
  try {
    const exists = await User.findOne({ email: req.body.email });
    if (exists) return res.status(409).json({ error: 'Email exists' });
    const user = await User.create(req.body);
    res.status(201).json(user);
  } catch (err) { next(err); }
});

from fastapi import APIRouter, Depends, Query
from sqlalchemy import select, func

router = APIRouter(prefix="/api/v1/users", tags=["users"])

@router.get("/", response_model=PaginatedResponse[UserResponse])
async def list_users(
    page: int = Query(1, ge=1),
    size: int = Query(20, ge=1, le=100),
    search: str | None = None,
    sort: str = "name",
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    q = select(User)
    if search:
        q = q.where(User.name.ilike(f"%{search}%"))
    total = await db.scalar(select(func.count()).select_from(q.subquery()))
    q = q.order_by(getattr(User, sort)).offset((page-1)*size).limit(size)
    users = (await db.execute(q)).scalars().all()
    return {"data": users, "page": page, "size": size, "total": total}

@router.post("/", response_model=UserResponse, status_code=201)
async def create_user(body: UserCreate, db: AsyncSession = Depends(get_db)):
    if await db.scalar(select(User).where(User.email == body.email)):
        raise HTTPException(409, "Email already exists")
    user = User(**body.model_dump())
    db.add(user)
    await db.commit()
    await db.refresh(user)
    return user

// Spring WebSocket Config
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
  @Override
  public void configureMessageBroker(MessageBrokerRegistry reg) {
    reg.enableSimpleBroker("/topic", "/queue");
    reg.setApplicationDestinationPrefixes("/app");
  }

  @Override
  public void registerStompEndpoints(StompEndpointRegistry reg) {
    reg.addEndpoint("/ws").withSockJS();
  }
}

// Message Controller
@Controller
public class ChatController {
  @MessageMapping("/chat/{roomId}/send")
  @SendTo("/topic/chat/{roomId}")
  public ChatMessage send(@DestinationVariable String roomId,
                          @Payload ChatMessage msg,
                          Principal principal) {
    msg.setSender(principal.getName());
    msg.setTimestamp(Instant.now());
    chatService.persist(msg);
    return msg;
  }
}

// Socket.io server
io.on('connection', (socket) => {
  socket.on('join-room', async (roomId) => {
    socket.join(roomId);
    const history = await Message.find({ roomId })
      .sort({ createdAt: -1 }).limit(50);
    socket.emit('message-history', history.reverse());
    socket.to(roomId).emit('user-joined', {
      userId: socket.user.id, timestamp: new Date()
    });
  });

  socket.on('send-message', async ({ roomId, text }) => {
    const msg = await Message.create({
      roomId, text, sender: socket.user.id
    });
    io.to(roomId).emit('new-message', msg);
  });

  socket.on('typing', ({ roomId }) =>
    socket.to(roomId).emit('user-typing', { userId: socket.user.id })
  );
});

from fastapi import WebSocket, WebSocketDisconnect

class ConnectionManager:
    def __init__(self):
        self.rooms: dict[str, list[WebSocket]] = {}

    async def connect(self, ws: WebSocket, room: str):
        await ws.accept()
        self.rooms.setdefault(room, []).append(ws)

    async def broadcast(self, room: str, msg: dict, exclude=None):
        for ws in self.rooms.get(room, []):
            if ws != exclude:
                await ws.send_json(msg)

manager = ConnectionManager()

@app.websocket("/ws/{room_id}")
async def chat_endpoint(ws: WebSocket, room_id: str, token: str):
    user = verify_token(token)
    await manager.connect(ws, room_id)
    try:
        while True:
            data = await ws.receive_json()
            msg = {"text": data["text"], "userId": user.id}
            await manager.broadcast(room_id, msg, exclude=ws)
    except WebSocketDisconnect:
        manager.rooms[room_id].remove(ws)

// Spring Boot S3 upload
@PostMapping("/upload")
public ResponseEntity<FileResponse> upload(
    @RequestParam MultipartFile file) {
  if (file.getSize() > 50 * 1024 * 1024)
    throw new BadRequestException("File too large");
  String key = "uploads/" + UUID.randomUUID() + "-" + file.getOriginalFilename();
  s3Client.putObject(PutObjectRequest.builder()
    .bucket(bucket).key(key)
    .contentType(file.getContentType()).build(),
    RequestBody.fromInputStream(file.getInputStream(), file.getSize()));
  String url = s3Client.utilities()
    .getUrl(b -> b.bucket(bucket).key(key)).toString();
  return ResponseEntity.ok(new FileResponse(key, url, file.getSize()));
}

// Generate presigned download URL
public String presign(String key) {
  return s3Presigner.presignGetObject(b -> b
    .getObjectRequest(r -> r.bucket(bucket).key(key))
    .signatureDuration(Duration.ofMinutes(15))).url().toString();
}

// Multer + S3 upload
import multer from 'multer';
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
import { getSignedUrl } from '@aws-sdk/s3-request-presigner';

const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: 50_000_000 } });
const s3 = new S3Client({ region: process.env.AWS_REGION });

router.post('/upload', authenticate, upload.single('file'), async (req, res) => {
  const key = `uploads/${crypto.randomUUID()}-${req.file.originalname}`;
  await s3.send(new PutObjectCommand({
    Bucket: process.env.S3_BUCKET,
    Key: key,
    Body: req.file.buffer,
    ContentType: req.file.mimetype,
  }));
  const url = await getSignedUrl(s3,
    new GetObjectCommand({ Bucket: process.env.S3_BUCKET, Key: key }),
    { expiresIn: 900 }
  );
  res.json({ key, url, size: req.file.size });
});

import boto3, uuid
from fastapi import UploadFile, File, Depends

s3 = boto3.client("s3", region_name=settings.aws_region)

@router.post("/upload", response_model=FileResponse)
async def upload_file(
    file: UploadFile = File(...),
    current_user: User = Depends(get_current_user),
):
    if file.size and file.size > 50 * 1024 * 1024:
        raise HTTPException(400, "File too large")
    key = f"uploads/{uuid.uuid4()}-{file.filename}"
    content = await file.read()
    s3.put_object(
        Bucket=settings.s3_bucket,
        Key=key,
        Body=content,
        ContentType=file.content_type,
    )
    url = s3.generate_presigned_url(
        "get_object",
        Params={"Bucket": settings.s3_bucket, "Key": key},
        ExpiresIn=900,
    )
    return {"key": key, "url": url, "size": len(content)}

// Spring Data JPA — revenue aggregation
@Query(value = """
  SELECT category,
    SUM(amount) AS revenue,
    COUNT(*) AS order_count,
    AVG(amount) AS avg_order
  FROM orders
  WHERE status = 'COMPLETED'
    AND created_at >= :start
  GROUP BY category
  ORDER BY revenue DESC
  """, nativeQuery = true)
List<RevenueByCategory> revenueByCategory(
    @Param("start") LocalDateTime start);

// Dashboard DTO projection
public interface RevenueByCategory {
  String getCategory();
  BigDecimal getRevenue();
  Long getOrderCount();
  BigDecimal getAvgOrder();
}

// Controller
@GetMapping("/metrics/revenue")
@PreAuthorize("hasRole('ADMIN')")
public List<RevenueByCategory> revenue(
    @RequestParam @DateTimeFormat(iso = DATE_TIME) LocalDateTime from) {
  return orderRepo.revenueByCategory(from);
}

// MongoDB aggregation
const revenue = await Order.aggregate([
  { $match: { status: 'completed',
    createdAt: { $gte: new Date(Date.now() - 30*864e5) } } },
  { $group: {
    _id: '$category',
    revenue: { $sum: '$amount' },
    count: { $sum: 1 },
    avg: { $avg: '$amount' }
  }},
  { $sort: { revenue: -1 } },
  { $project: {
    category: '$_id',
    revenue: { $round: ['$revenue', 2] },
    count: 1, avg: { $round: ['$avg', 2] }, _id: 0
  }}
]);

// Cache for 5 minutes
const cached = await redis.get('metrics:revenue');
if (cached) return JSON.parse(cached);
await redis.setex('metrics:revenue', 300, JSON.stringify(revenue));

from sqlalchemy import select, func, case
from datetime import datetime, timedelta

@router.get("/metrics/revenue")
async def revenue_by_category(
    days: int = Query(30, ge=1, le=365),
    db: AsyncSession = Depends(get_db),
    _: User = Depends(require_role("admin")),
):
    since = datetime.utcnow() - timedelta(days=days)
    result = await db.execute(
        select(
            Order.category,
            func.sum(Order.amount).label("revenue"),
            func.count().label("count"),
            func.avg(Order.amount).label("avg_order"),
        )
        .where(Order.status == "completed", Order.created_at >= since)
        .group_by(Order.category)
        .order_by(func.sum(Order.amount).desc())
    )
    return [
        {"category": r.category, "revenue": float(r.revenue),
         "count": r.count, "avg": float(r.avg_order)}
        for r in result
    ]

// Stripe checkout session (Java)
@PostMapping("/checkout")
public ResponseEntity<CheckoutResponse> createCheckout(
    @RequestBody CheckoutRequest req,
    Principal principal) {
  var user = userService.findByEmail(principal.getName());
  var items = req.items().stream().map(item ->
    SessionCreateParams.LineItem.builder()
      .setQuantity(item.quantity())
      .setPriceData(SessionCreateParams.LineItem.PriceData.builder()
        .setCurrency("usd")
        .setUnitAmount(item.price() * 100)
        .setProductData(SessionCreateParams.LineItem.PriceData
          .ProductData.builder().setName(item.name()).build())
        .build())
      .build()
  ).toList();
  var session = Session.create(SessionCreateParams.builder()
    .setMode(SessionCreateParams.Mode.PAYMENT)
    .setSuccessUrl(frontendUrl + "/success?session_id={CHECKOUT_SESSION_ID}")
    .setCancelUrl(frontendUrl + "/cart")
    .addAllLineItem(items)
    .putMetadata("userId", user.getId().toString())
    .build());
  return ResponseEntity.ok(new CheckoutResponse(session.getUrl()));
}

// Stripe checkout session (Node.js)
import Stripe from 'stripe';
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);

router.post('/checkout', authenticate, async (req, res) => {
  const { items } = req.body;
  const lineItems = items.map(item => ({
    price_data: {
      currency: 'usd',
      unit_amount: Math.round(item.price * 100),
      product_data: { name: item.name, images: [item.imageUrl] },
    },
    quantity: item.quantity,
  }));
  const session = await stripe.checkout.sessions.create({
    mode: 'payment',
    line_items: lineItems,
    success_url: `${process.env.FRONTEND_URL}/success?sid={CHECKOUT_SESSION_ID}`,
    cancel_url: `${process.env.FRONTEND_URL}/cart`,
    metadata: { userId: req.user.id },
  });
  res.json({ url: session.url });
});

import stripe
stripe.api_key = settings.stripe_secret_key

@router.post("/checkout")
async def create_checkout(
    body: CheckoutRequest,
    current_user: User = Depends(get_current_user),
):
    line_items = [
        {
            "price_data": {
                "currency": "usd",
                "unit_amount": int(item.price * 100),
                "product_data": {"name": item.name},
            },
            "quantity": item.quantity,
        }
        for item in body.items
    ]
    session = stripe.checkout.Session.create(
        mode="payment",
        line_items=line_items,
        success_url=f"{settings.frontend_url}/success?sid={{CHECKOUT_SESSION_ID}}",
        cancel_url=f"{settings.frontend_url}/cart",
        metadata={"user_id": str(current_user.id)},
    )
    return {"url": session.url}

// Spring — resilient HTTP client with Resilience4j
@Service
public class WeatherService {
  private final WebClient client;

  @CircuitBreaker(name = "weather", fallbackMethod = "fallback")
  @Retry(name = "weather")
  @TimeLimiter(name = "weather")
  public CompletableFuture<WeatherDto> getCurrent(String city) {
    return client.get()
      .uri("/current?city={city}&appid={key}", city, apiKey)
      .retrieve()
      .onStatus(HttpStatus::is4xxClientError,
        r -> Mono.error(new WeatherClientException(city)))
      .bodyToMono(WeatherDto.class)
      .toFuture();
  }

  private CompletableFuture<WeatherDto> fallback(String city, Exception e) {
    log.warn("Weather circuit open for {}", city);
    return CompletableFuture.completedFuture(WeatherDto.unknown());
  }
}

// Webhook handler with signature verification
@PostMapping("/webhooks/stripe")
public ResponseEntity<Void> stripeWebhook(
    @RequestBody String payload,
    @RequestHeader("Stripe-Signature") String sig) {
  Event event = Webhook.constructEvent(payload, sig, webhookSecret);
  switch (event.getType()) {
    case "payment_intent.succeeded" -> handlePayment(event);
    case "customer.subscription.deleted" -> cancelSubscription(event);
  }
  return ResponseEntity.ok().build();
}

// Node.js — retry with exponential backoff
async function fetchWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const resp = await fetch(url, options);
      if (resp.status === 429) {
        const retryAfter = +resp.headers.get('Retry-After') || 60;
        await sleep(retryAfter * 1000);
        continue;
      }
      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
      return await resp.json();
    } catch (err) {
      if (attempt === maxRetries) throw err;
      await sleep(Math.pow(2, attempt) * 1000 + Math.random() * 500);
    }
  }
}

// Stripe webhook verification
router.post('/webhooks/stripe',
  express.raw({ type: 'application/json' }),
  (req, res) => {
    const event = stripe.webhooks.constructEvent(
      req.body, req.headers['stripe-signature'], process.env.STRIPE_WEBHOOK_SECRET
    );
    if (event.type === 'payment_intent.succeeded') handlePayment(event.data.object);
    res.json({ received: true });
  }
);

import httpx, asyncio
from tenacity import retry, stop_after_attempt, wait_exponential

# Retry with exponential backoff
@retry(stop=stop_after_attempt(3),
       wait=wait_exponential(multiplier=1, min=1, max=60))
async def call_external_api(url: str, params: dict) -> dict:
    async with httpx.AsyncClient(timeout=10.0) as client:
        resp = await client.get(url, params=params,
                                headers={"Authorization": f"Bearer {settings.api_key}"})
        resp.raise_for_status()
        return resp.json()

# Stripe webhook
@router.post("/webhooks/stripe")
async def stripe_webhook(
    request: Request,
    stripe_signature: str = Header(None),
):
    payload = await request.body()
    try:
        event = stripe.Webhook.construct_event(
            payload, stripe_signature, settings.stripe_webhook_secret)
    except stripe.error.SignatureVerificationError:
        raise HTTPException(400, "Invalid signature")
    if event["type"] == "payment_intent.succeeded":
        await handle_payment(event["data"]["object"])
    return {"received": True}