MoaazMuhmmad/My-Redis_API

Redis API Django Project

This is a Django REST framework project integrated with Redis and Celery, deployed on Hugging Face Spaces using Docker.

🛒 Session-Based Cart API

A high-performance shopping cart REST API built with Django REST Framework and Redis as a fast in-memory session store. The project demonstrates real-world use of Redis as a caching/storage layer instead of a traditional database — achieving near-instant cart operations.

🏗️ Architecture Overview

Client (Postman / Browser)
        │
        ▼
┌──────────────────┐
│   Django DRF     │  ← REST API + Session Middleware
│   (Port 8000)    │
└────────┬─────────┘
         │
    ┌────┴─────┐         ┌──────────────────┐
    │  Redis   │         │   PostgreSQL      │
    │ (Cart    │         │  (Products &      │
    │  Data)   │         │   Categories)     │
    └──────────┘         └──────────────────┘
         │
    ┌────┴──────────┐
    │  RedisInsight  │  ← Visual Redis UI (Port 5540)
    └───────────────┘

Key Design Decision: Cart data lives in Redis (not PostgreSQL) using session-keyed hashes — this gives O(1) read/write speed and automatic expiry when the session ends.

✨ Features

• —Session-based cart — no authentication required, cart is tied to the browser session
• —Redis HSET storage — each cart stored as cart:{session_id} hash in Redis
• —Full product & category inventory API backed by PostgreSQL
• —Swagger UI auto-generated via drf-spectacular
• —Dockerized — one command to run everything (Django + Redis + PostgreSQL + RedisInsight)
• —Admin panel auto-seeded with superuser on first run

🧱 Tech Stack

📁 Project Structure

Session_Based_Cart/
├── app/
│   ├── cart/                   # Cart app (Redis-powered)
│   │   ├── redis_cart.py       # Redis operations (add, get)
│   │   ├── serializers.py      # Request/Response validation
│   │   ├── views.py            # API endpoints
│   │   └── urls.py
│   ├── inventory/              # Products & Categories app
│   │   ├── models.py           # Category (tree) + Product models
│   │   ├── serializers.py
│   │   ├── views.py
│   │   └── urls.py
│   ├── core/
│   │   ├── settings.py         # Redis + DB config
│   │   └── urls.py             # Main URL routing + Swagger
│   └── manage.py
├── docker-compose.yml
├── Dockerfile
├── requirements.txt
└── init.sql                    # DB seed data

🚀 Quick Start (Live Demo)

Prerequisites

• —Docker Desktop installed and running

1. Clone the repository

git clone https://github.com/iiMoaaz/Session_Based_Cart.git
cd Session_Based_Cart

2. Start all services

docker compose up --build

This single command will:

• —Build the Django image
• —Start PostgreSQL and run migrations automatically
• —Start Redis
• —Create an admin superuser automatically
• —Start RedisInsight (Redis visual UI)

Wait for the log line:

django_app | Starting development server at http://0.0.0.0:8000/

3. Access the services

Admin credentials: admin / admin

📖 API Endpoints

Inventory

GET /api/products/

Returns all products from PostgreSQL.

Response:

[
  {
    "id": 1,
    "category": 2,
    "name": "Wireless Headphones",
    "description": "Noise-cancelling over-ear headphones",
    "price": "149.99"
  }
]

GET /api/categories/

Returns all product categories.

Response:

[
  {
    "id": 1,
    "name": "Electronics",
    "slug": "electronics",
    "is_active": true
  }
]

Cart (Redis-powered)

POST /api/cart/add/

Adds a product to the session cart. Creates a new session automatically if one doesn't exist.

Request Body:

{
  "product_id": 1,
  "name": "Wireless Headphones",
  "price": 149.99,
  "quantity": 2
}

Response:

{
  "message": "Added to cart."
}

What happens in Redis:

HSET cart:{session_key} 1 '{"product_id": 1, "name": "Wireless Headphones", "price": 149.99, "quantity": 2}'

GET /api/cart/get/

Returns all items in the current session's cart.

Response:

[
  {
    "product_id": 1,
    "name": "Wireless Headphones",
    "price": 149.99,
    "quantity": 2
  }
]

🔍 How Redis Storage Works

Cart data is stored in Redis as a Hash data structure:

Key:   cart:{django_session_key}
Field: {product_id}
Value: JSON string of product data

Example in Redis CLI:

HGETALL cart:abc123xyz

# Output:
# 1) "1"
# 2) "{\"product_id\": 1, \"name\": \"Headphones\", \"price\": 149.99, \"quantity\": 2}"

Why Redis instead of the database?

• —Cart reads/writes are extremely frequent — Redis handles millions of ops/sec
• —Cart data is temporary by nature — it doesn't need to persist long-term
• —Session expiry naturally cleans up abandoned carts

🛠️ Local Development (Without Docker)

Requirements

• —Python 3.11+
• —Redis running locally on port 6379
• —PostgreSQL running locally

# Create virtual environment
python -m venv venv
venv\Scripts\activate        # Windows
source venv/bin/activate     # macOS/Linux

# Install dependencies
pip install -r requirements.txt

# Update settings.py — change Redis/DB hosts from 'redis'/'postgres' to 'localhost'

cd app
python manage.py migrate
python manage.py createsuperuser
python manage.py runserver

🧪 Testing the API Manually

Using Swagger UI (Recommended)

1. 1.Open http://localhost:8000/docs/
2. 2.Try POST /api/cart/add/ with a product payload
3. 3.Try GET /api/cart/get/ to see the cart

Using curl

# Add item to cart
curl -X POST http://localhost:8000/api/cart/add/ \
  -H "Content-Type: application/json" \
  -c cookies.txt -b cookies.txt \
  -d '{"product_id": 1, "name": "Headphones", "price": 149.99, "quantity": 1}'

# Get cart
curl http://localhost:8000/api/cart/get/ \
  -c cookies.txt -b cookies.txt

Note: The -c cookies.txt -b cookies.txt flags persist the session cookie across requests.

Viewing Cart Data in RedisInsight

1. 1.Open http://localhost:5540
2. 2.Add connection: host redis, port 6379
3. 3.Browse keys — look for cart:* keys

📦 Dependencies

Django==5.2
djangorestframework==3.16.0
drf-spectacular==0.28.0        # Swagger/OpenAPI auto-generation
redis==5.2.1                   # Redis Python client
psycopg[binary]==3.2.7         # PostgreSQL adapter

🔒 Security Notes (Production Checklist)

This project is configured for development only. Before deploying to production:

• —[ ] Replace SECRET_KEY with a secure random value (use environment variables)
• —[ ] Set DEBUG = False
• —[ ] Configure ALLOWED_HOSTS with your domain
• —[ ] Change admin credentials from admin/admin
• —[ ] Add Redis password authentication
• —[ ] Use environment variables for all secrets (.env file + python-decouple)
• —[ ] Switch runserver to gunicorn or uvicorn

👨‍💻 Author

Moaz — @iiMoaaz

📄 License

MIT License