Skip to content
BranchesTags

Repository files navigation

🍽️ Delicia — Distributed Full‑Stack Food Ordering & Real-Time Logistics Platform

Delicia CI Pipeline License: MIT Node.js React Vite Docker Kafka Redis

Delicia is a production-grade, event-driven full-stack food delivery and logistics platform built on the MERN stack and enhanced with Apache Kafka, Redis Geospatial Indexing, Server-Sent Events (SSE), Docker, and OpenAI GPT.

It features an end-to-end customer ordering web application, an interactive driver tracking system, a secured administrative analytics dashboard, and automated event streaming for order allocation and real-time delivery tracking.

📑 Table of Contents

⚡ Key Architecture & Highlights

  • Event-Driven Micro-Messaging (Apache Kafka): Decoupled event streaming pipeline utilizing kafkajs for handling order-allocated and driver-location-updates topics asynchronously.
  • Geospatial Nearest-Driver Matching (Redis): Uses Redis GEOSEARCH (FROMLONLAT radius querying) to compute proximity and automatically assign orders to the nearest available delivery partner.
  • Real-Time GPS Streaming (Server-Sent Events): Low-latency, unidirectional SSE channel (/api/order/track/:orderId) streaming live telemetry updates to the frontend map UI without client-side polling overhead.
  • Dual Payment Processing: Integrated with Stripe Checkout for online payments alongside Cash on Delivery (COD) checkout workflows and instant verification callbacks.
  • Containerized Infrastructure (Docker Compose): Single-command orchestration for Zookeeper, Apache Kafka, and Redis services.
  • Multi-Job Automated CI/CD Pipeline (GitHub Actions): Automated pipeline with live MongoDB container execution, Jest backend API test verification, and ESLint + Vite build validation for both frontend applications.
  • Analytics Engine (Recharts): Visual sales, revenue curves, order volumes, and categorical distributions in the Admin control panel.

🏛 System Architecture Flow

flowchart TD
    subgraph Client Applications
        A[Customer Frontend - Vite/React]
        B[Admin Dashboard - Vite/React]
        S[Driver Telemetry Simulator]
    end

    subgraph Backend API Gateway
        API[Express.js REST API :4000]
        SSE[SSE Stream Engine]
    end

    subgraph Distributed Services
        K[Apache Kafka Broker :9092]
        R[(Redis 7.2 Cache & GeoIndex :6379)]
        M[(MongoDB Atlas Database)]
        OAI[OpenAI GPT API]
        ST[Stripe Payment Gateway]
    end

    A -->|Browse, Cart, Order, Auth| API
    A -->|Subscribe to Live Location| SSE
    B -->|Menu & Order CRUD, Analytics| API
    S -->|Push Live GPS Coordinates| API

    API -->|Persist Users, Orders, Menu| M
    API -->|Geospatial Radius Query & Caching| R
    API -->|Publish Location & Order Events| K
    API -->|Process Payments| ST
    API -->|Delicia AI Assistant Chat| OAI

    K -->|Consume Location Updates| SSE
    SSE -->|Stream Lat/Lon Coordinates| A
Loading

🖼️ Application Screenshots

Customer Home & Food Discovery

Home Page

Category Filtering, Search & Menu Catalog

Menu Page

Cart, Pricing & Localized Checkout (₹ INR)

Cart Page

Secured Admin Analytics & Operations Dashboard

Admin Dashboard

📌 High-resolution images are located in the screenshots/ directory.

✨ Feature Breakdown

1. Customer Web Application

  • Interactive Menu & Category Filtering: Filter by Salad, Rolls, Deserts, Sandwich, Cake, Pure Veg, Pasta, Noodles, and more.
  • Dynamic Search & Filtering: Multi-condition search across dish names, descriptions, price boundaries, and bestseller chips.
  • Cart State Management: Persistent cart context with quantity controls, delivery charge computation, and instant total calculations.
  • Currency Localization: Complete support for Indian Rupees (₹ INR) using Intl.NumberFormat("en-IN").
  • User Profile & Order Center: Dedicated user dashboard managing personal details, avatar uploads (multer), multi-address book, password updates, and historical orders.
  • Dual Payment Workflow: Seamless integration with Stripe Checkout and direct Cash on Delivery (COD) verification.

2. Real-Time Driver Tracking & Logistics

  • Proximity Allocation: Redis Geospatial GEOSEARCH automatically locates available drivers within a 10km radius upon payment confirmation.
  • Real-Time Map & Telemetry: Live order tracking interface (/tracking/:orderId) with Server-Sent Events (SSE) streaming live vehicle coordinates directly from Kafka events.
  • Driver Simulator: Built-in simulator script (simulate-driver.js) generating realistic GPS telemetry trajectories.

3. Admin Analytics & Operations Portal

  • Secured Authentication: JWT-protected admin portal with restricted role access.
  • Interactive Analytics (Recharts): Visual graphs displaying total revenue, active orders, user counts, item distribution, and daily performance metrics.
  • Menu Management (CRUD): Add dishes with custom image uploads via Multer, update menu pricing, and manage category listings.
  • Order Lifecycle Workflow: Real-time status management (Food Processing ➔ Out for Delivery ➔ Delivered).

4. AI Assistant & Support System

  • Delicia AI Chatbot: Built-in floating assistant powered by OpenAI GPT (/api/chat) offering personalized dish recommendations, order assistance, and FAQ resolution.
  • Partner & Franchise Portal: Application submission workflow (/partner) with document/resume attachment uploads and automated email notifications.
  • Contact & Inquiries: Customer support contact forms routed via Nodemailer.

🧰 Tech Stack & Tooling

Layer Technologies
Frontend (User & Admin) React 18, Vite, Tailwind CSS v4, Framer Motion, GSAP, Lucide Icons, Recharts, React Router v6, Axios, React Toastify
Backend API Node.js, Express.js (ES Modules), Mongoose, Multer, JWT, Bcrypt, CORS, Dotenv
Distributed Messaging & Cache Apache Kafka (kafkajs), Confluent Zookeeper, Redis 7.2 (ioredis Geospatial)
Real-Time Communication Server-Sent Events (SSE)
Database & Cloud MongoDB / MongoDB Atlas
Integrations & AI Stripe API, OpenAI GPT API, Nodemailer (SMTP)
DevOps & Infrastructure Docker, Docker Compose, GitHub Actions CI/CD
Testing & Quality Jest, Supertest, ESLint

🔌 API Reference

🔐 Authentication & Profile (/api/user)

  • POST /api/user/register — Register new customer account
  • POST /api/user/login — Authenticate and return JWT token
  • GET /api/user/profile — Fetch current user profile (Authenticated)
  • PUT /api/user/updateprofile — Update name, phone, and profile details
  • PUT /api/user/changepassword — Update account security password
  • POST /api/user/upload-avatar — Upload profile avatar image (multipart/form-data)
  • GET /api/user/useraddresses — Retrieve saved delivery addresses
  • PUT /api/user/update-address — Add or modify saved delivery address

🍲 Food & Menu (/api/food)

  • GET /api/food/list — Retrieve menu items (supports search, category filter, sorting, pagination)
  • POST /api/food/add — Add new food dish with image file (multipart/form-data)
  • POST /api/food/remove — Delete food dish by ID

🛒 Cart Operations (/api/cart)

  • POST /api/cart/get — Fetch user's cart contents
  • POST /api/cart/add — Add item / increment quantity in cart
  • POST /api/cart/remove — Decrement / remove item from cart

📦 Orders & Tracking (/api/order)

  • POST /api/order/place — Place an order (generates Stripe checkout session or COD order)
  • POST /api/order/verify — Verify Stripe transaction, trigger Redis driver match & Kafka allocation
  • POST /api/order/userorders — Retrieve orders for authenticated user
  • GET /api/order/list — List all customer orders (Admin)
  • POST /api/order/status — Update order progress state (Admin)
  • GET /api/order/track/:orderId — SSE stream broadcasting live driver telemetry

🛵 Driver & Telemetry (/api/driver)

  • POST /api/driver/register — Register a delivery driver
  • POST /api/driver/location — Push GPS latitude/longitude (updates Redis Geo & Kafka stream)

📊 Admin, AI & Inquiries

  • POST /api/admin/login — Admin portal authentication
  • GET /api/dashboard/stats — High-level analytics metrics (Revenue, Orders, Category splits)
  • POST /api/chat — Query Delicia AI assistant (OpenAI GPT)
  • POST /api/contact — Submit customer support message (Nodemailer)
  • POST /api/partner — Submit partner/franchise application with documents

📁 Repository Structure

Delicia/
├── .github/
│   └── workflows/
│       └── ci.yml               # GitHub Actions CI Pipeline (Mongo, Jest, Lint, Build)
├── admin/                       # Admin Analytics & Management Dashboard (Vite + React)
│   ├── src/
│   │   ├── components/          # Navbar, Sidebar, UI components
│   │   └── pages/               # Dashboard (Charts), Add, List, Orders, Login
│   ├── package.json
│   └── vite.config.js
├── backend/                     # Node.js Express REST API & Streaming Engine
│   ├── config/                  # MongoDB, Kafka, and Redis client configurations
│   ├── controllers/             # Business logic (User, Order, Food, Driver, Dashboard, etc.)
│   ├── middleware/              # Auth verification & Multer file upload handlers
│   ├── models/                  # Mongoose Schemas (User, Food, Order, Driver, Admin)
│   ├── routes/                  # Express route declarations
│   ├── tests/                   # Jest & Supertest automated API tests
│   ├── uploads/                 # Static media storage for dishes & avatars
│   ├── server.js                # Server entry point, SSE stream & OpenAI endpoint
│   └── package.json
├── frontend/                    # Customer-Facing Web Application (Vite + React)
│   ├── src/
│   │   ├── components/          # Navbar, Footer, FoodDisplay, Chatbot, LoginPopup, etc.
│   │   ├── Context/             # React Context Store for Cart & Global State
│   │   ├── pages/               # Home, Cart, PlaceOrder, MyOrders, Dashboard, Tracking
│   │   └── assets/              # Icons, banners, and graphical assets
│   ├── package.json
│   └── vite.config.js
├── screenshots/                 # Application preview screenshots
├── docker-compose.yml           # Multi-container orchestration (Kafka, Zookeeper, Redis)
├── simulate-driver.js           # Live driver GPS telemetry simulation script
└── README.md

⚙️ Getting Started & Local Setup

Prerequisites

  • Node.js: v18.x or higher
  • npm: v9.x or higher
  • Docker & Docker Compose: Installed and running (Docker Desktop)
  • MongoDB: Local instance or free MongoDB Atlas cluster

1. Clone Repository

git clone https://github.com/Vikaumar/Delicia.git
cd Delicia

2. Start Infrastructure (Docker Compose)

Launch Apache Kafka, Zookeeper, and Redis containers:

docker-compose up -d

Verify services are healthy:

  • Redis: localhost:6379
  • Kafka: localhost:9092
  • Zookeeper: localhost:2181

3. Backend Setup

cd backend
npm install

Create a .env file inside backend/ (refer to Environment Configuration):

# Start backend in development mode (with nodemon)
npm run dev

Backend runs on: http://localhost:4000

4. Frontend Setup

Open a new terminal:

cd frontend
npm install
npm run dev

Customer web application runs on: http://localhost:5173

5. Admin Dashboard Setup

Open a new terminal:

cd admin
npm install
npm run dev

Admin management dashboard runs on: http://localhost:5174

6. Simulate Driver Live Telemetry

To test real-time geospatial driver allocation and live map SSE streaming:

# In the root directory:
npm install axios
node simulate-driver.js

This registers a simulated delivery driver and pushes GPS coordinates to the backend every 2 seconds.

🔐 Environment Configuration

Create a .env file in the backend/ directory:

# ─── Server & Ports ───
PORT=4000
NODE_ENV=development

# ─── Database ───
MONGO_URI=mongodb+srv://<username>:<password>@cluster.mongodb.net/Delicia?retryWrites=true&w=majority

# ─── Authentication ───
JWT_SECRET=your_jwt_secret_key_here

# ─── Stripe Payment Gateway ───
STRIPE_SECRET_KEY=sk_test_your_stripe_secret_key

# ─── OpenAI Chatbot Assistant ───
OPENAI_API_KEY=sk-proj-your_openai_api_key

# ─── Application URLs (CORS & Callbacks) ───
FRONTEND_URL=http://localhost:5173
ADMIN_URL=http://localhost:5174

# ─── Email & Notifications (Nodemailer SMTP) ───
SUPPORT_EMAIL=support@delicia.com
PARTNERS_EMAIL=partners@delicia.com
EMAIL_HOST=smtp.example.com
EMAIL_PORT=587
EMAIL_USER=your_email@example.com
EMAIL_PASS=your_email_password
EMAIL_FROM="Delicia Support <support@delicia.com>"

🧪 Automated Testing & CI/CD

Running Backend Tests Locally

The project includes automated integration tests using Jest and Supertest:

cd backend
npm test

Continuous Integration (GitHub Actions)

The repository contains a robust CI workflow (.github/workflows/ci.yml) that automatically triggers on every push and pull request to main:

  1. Backend Integration Pipeline: Spins up a native mongo:latest service container and executes the Jest test suite.
  2. Frontend Quality Check: Executes ESLint analysis and verifies Vite production build bundle creation.
  3. Admin Portal Check: Executes ESLint validation and verifies Vite production build.

📜 License

This project is open source and available under the MIT License.

👨‍💻 Author

Vikas Kumar

  • 🎓 B.Tech CSE, IIIT Kota (3rd Year)
  • 💼 Aspiring Full‑Stack / Software Development Engineer
  • 🔗 GitHub: @Vikaumar

⭐ If you find this project helpful, consider starring the repository!

About

delicia-frontend.vercel.app

Resources

Readme
MIT license
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages