Next.js Edge Rendering + Node.js Event-Driven Architecture: The Ultimate Stack for Modern E-commerce

• Real-Time Inventory with Server-Sent Events (SSE):
  
  Node.js with express-sse makes implementing SSE for real-time inventory updates straightforward:
  
  javascript filename: server.js
  const express = require(‘express’);
  const SSE = require(‘express-sse’);
  const app = express();
  const sse = new SSE();
  
  app.get(‘/events’, sse.init); // SSE endpoint
  
  // Simulate inventory updates (replace with actual database updates)
  setInterval(() => {
  const productStock = {
  ‘product123’: Math.floor(Math.random() * 5) // Example: Random stock level
  };
  sse.send(productStock, ‘inventory-update’); // Send SSE event
  }, 3000); // Send update every 3 seconds
  
  app.listen(3000, () => console.log(‘SSE server listening on port 3000’));
  

javascript  filename: `app/components/StockDisplay.js` (Frontend React Component)

import { useEffect, useState } from ‘react’;

export default function StockDisplay({ productId }) {

  const [stockLevel, setStockLevel] = useState(null);

  useEffect(() => {

    const eventSource = new EventSource(‘/events’); // Connect to SSE endpoint

    eventSource.addEventListener(‘inventory-update’, (event) => {

      const data = JSON.parse(event.data);

      if (data[productId]) {

        setStockLevel(data[productId]);

      }

    });

    eventSource.onerror = (error) => {

      console.error(“SSE error”, error);

      eventSource.close();

    };

    return () => eventSource.close(); // Cleanup on unmount

  }, [productId]);

  if (stockLevel === null) return <p>Loading stock…</p>;

  return <p>Stock Level: {stockLevel} {stockLevel <= 2 ? ‘(Only a few left!)’ : ”}</p>;

}

• Code Explanation: The Node.js server sets up an SSE endpoint (/events). It simulates inventory updates and periodically sends SSE events named inventory-update with product stock data. The StockDisplay React component on the frontend connects to this SSE endpoint using EventSource. It listens for inventory-update events and updates the displayed stock level dynamically as events are received, providing a real-time stock indicator.
  
  
• Event-Driven Order Processing with RabbitMQ:
  
  Here’s a simplified example of publishing an order event to RabbitMQ when an order is placed:
  
  javascript filename: order-service.js (Node.js Backend – Order Service)
  const amqp = require(‘amqplib’);
  
  async function placeOrder(orderData) {
  const connection = await amqp.connect(‘amqp://localhost’); // RabbitMQ connection
  const channel = await connection.createChannel();
  const exchangeName = ‘order_events’;
  
  await channel.assertExchange(exchangeName, ‘fanout’, { durable: false }); // Fanout exchange
  
  const eventPayload = JSON.stringify({
  eventType: ‘order_placed’,
  order: orderData,
  timestamp: Date.now()
  });
  
  channel.publish(exchangeName, ”, Buffer.from(eventPayload)); // Publish event
  
  console.log(” [x] Order event published to RabbitMQ”);
  
  setTimeout(() => { // Close connection after publishing (for example)
  connection.close();
  process.exit(0);
  }, 500);
  }
  
  placeOrder({ /* … order details … */ }); // Example order placement

Worker Service for Fraud Detection (Code Snippet)

javascript  filename: `fraud-worker.js` (Node.js Backend – Fraud Worker)

const amqp = require(‘amqplib’);

async function consumeOrderEvents() {

  const connection = await amqp.connect(‘amqp://localhost’);

  const channel = await connection.createChannel();

  const exchangeName = ‘order_events’;

  await channel.assertExchange(exchangeName, ‘fanout’, { durable: false });

  const q = await channel.assertQueue(”, { exclusive: true }); // Exclusive queue

  channel.bindQueue(q.queue, exchangeName, ”); // Bind queue to exchange

  console.log(” [*] Waiting for order events…”);

  channel.consume(q.queue, (msg) => {

    if (msg.content) {

      const event = JSON.parse(msg.content.toString());

      if (event.eventType === ‘order_placed’) {

        const order = event.order;

        console.log(” [x] Received order event:”, order);

        // — Fraud Detection Logic — (Replace with actual logic)

        const isFraudulent = Math.random() < 0.2; // Simulate fraud check

        if (isFraudulent) {

          console.log(” [!] Potential Fraudulent Order Detected:”, order.orderId);

          //  …  Handle fraudulent order (e.g., flag order, send alert) …

        } else {

          console.log(” [v] Order passed fraud check:”, order.orderId);

          // … Proceed with order processing …

        }

      }

    }

  }, { noAck: true }); // Auto-acknowledge messages

}

consumeOrderEvents();

• Code Explanation: order-service.js demonstrates publishing an order_placed event to a RabbitMQ fanout exchange named order_events. fraud-worker.js is a separate Node.js service that subscribes to the same order_events exchange via an exclusive queue. When an order event is published, RabbitMQ delivers it to the fraud worker. The worker then performs fraud detection logic (simulated in the example) and takes appropriate actions. Other worker services (payment, shipping) would similarly subscribe to order_events or other relevant exchanges to process their respective parts of the order pipeline.
  
  
• Personalized1 Pricing with Redis and Worker Threads (Conceptual):
  
  For personalized pricing, you can use Redis as a fast in-memory data store to track user behavior (e.g., products viewed, items added to cart, Browse history). When a user views a product, your backend can:
  
  
  1. Fetch User Data from Redis: Retrieve the user’s behavioral data from Redis based on their session ID or user ID.
  2. Offload Discount Calculation to Worker Threads: Send the user data and product details to a worker thread. Worker threads can execute computationally intensive discount algorithms (e.g., collaborative filtering, machine learning models) without blocking the main Node.js event loop.
  3. Return Personalized Price: The worker thread calculates the personalized discount (if any) and returns the adjusted price to the main thread.
  4. Serve Personalized Price to Frontend: The backend then sends the personalized price to the Next.js frontend to display to the user.

This approach ensures that personalized pricing logic doesn’t degrade backend performance, maintaining responsiveness even with complex personalization rules. Libraries like ioredis for Redis interaction and Node.js’s built-in worker_threads module would be used for implementation.

This step-by-step guide provides a foundational understanding and practical code examples to start building your real-time e-commerce platform. Remember that these are simplified examples, and a production-ready system would require more robust error handling, security considerations, and comprehensive testing.