ZenithCart — High-Throughput Headless E-Commerce Engine

A. Low-Latency gRPC Contract Definitions

To speed up communication between the Next.js API router and the Go inventory backend, the contract is compiled using Protocol Buffers.

/** protobuf definition: inventory.proto **/
syntax = "proto3";
package inventory;

service InventoryService {
  rpc ReserveStock (StockRequest) returns (StockResponse);
}

message StockRequest {
  string product_id = 1;
  int32 quantity = 2;
}

message StockResponse {
  bool success = 1;
  int32 remaining_stock = 2;
  string reservation_token = 3;
}

B. Go-Redis Inventory Lock Engine

To support thousands of checkout calls on the same item, we acquire a temporary key lock in Redis with a 5-second TTL. If stock is available, we decrement the value atomically in Redis.

/** Atomic Go-Redis stock reservation logic **/
func (s *server) ReserveStock(ctx context.Context, req *pb.StockRequest) (*pb.StockResponse, error) {
  lockKey := fmt.Sprintf("lock:product:%s", req.ProductId)
  stockKey := fmt.Sprintf("stock:product:%s", req.ProductId)
  
  -- Acquire distributed lock
  ok, err := s.redisClient.SetNX(ctx, lockKey, "locked", 5*time.Second).Result()
  if !ok || err != nil {
    return &pb.StockResponse{Success: false}, fmt.Errorf("concurrency lock timeout")
  }
  defer s.redisClient.Del(ctx, lockKey)
  
  -- Check and decrement atomically
  currentStock, _ := s.redisClient.Get(ctx, stockKey).Int()
  if currentStock < int(req.Quantity) {
    return &pb.StockResponse{Success: false}, nil
  }
  
  s.redisClient.DecrBy(ctx, stockKey, int64(req.Quantity))
  return &pb.StockResponse{Success: true, RemainingStock: int32(currentStock - int(req.Quantity))}, nil
}

C. Batch DB Writes & Transaction Persistence

Rather than blocking the client checkout request, orders are pushed to a RabbitMQ queue. Dedicated worker routines consume the queue in batches and bulk-insert them into PostgreSQL, boosting overall write throughput.