GearUp

Originally this project was made by 3 members at my Uni and we already submitted it as a final term project. Then I've forked it and been developing it to continue my learning journey about microservices and internal communications.

🏗️ Project Architecture

The system follows a microservices architecture where each service has a dedicated responsibility and communicates with others via HTTP (internal) or RabbitMQ (asynchronous events/RPC).

flowchart LR
    subgraph Clients
        client["Storefront Client"]
        admin["Admin Dashboard"]
    end

    gateway["Nginx API Gateway (:5000)"]

    auth["auth-service"]
    user["user-service"]
    cart["cart-service"]
    order["order-service"]
    payment["payment-service"]
    notify["notify-service"]
    product["product-service"]
    media["media-service"]
    moderation["moderation-service"]

    pg[("PostgreSQL")]
    redis[("Redis")]
    rabbit{{"RabbitMQ"}}
    stripe["Stripe API"]

    client & admin --> gateway
    gateway --> auth & user & cart & order & payment & notify & product

    auth --> user & redis & rabbit
    user & cart & order & product --> pg & rabbit
    payment --> stripe & rabbit
    notify & media & moderation --- rabbit

Loading

🛰️ Microservices Grid

Service	Port	Description
Gateway	5000	Nginx-based entry point for all client requests.
Auth	Internal	Identity provider, JWT management, and session handling.
User	Internal	User profile management and account settings.
Product	Internal	Catalog management, inventory, and search.
Cart	Internal	Persistent shopping cart management.
Order	Internal	Order lifecycle management and tracking.
Payment	Internal	Integration with Stripe for secure transactions.
Notify	Internal	Real-time notifications and email dispatch.
Media	Worker	Background image processing and storage integration.
Moderation	Worker	AI-powered content moderation for reviews/media.

🛠️ Tech Stack

• Frontend: React, TypeScript, Tailwind CSS, Vite (Dashboard).
• Backend: Node.js, TypeScript, Express, Prisma (ORM).
• Database: PostgreSQL (Primary), Redis (Caching/Sessions).
• Messaging: RabbitMQ (Event-driven & RPC).
• Infrastructure: Nginx, Docker/Podman, Stripe.

🚀 Getting Started

Prerequisites

• Podman (recommended) or Docker
• Podman Compose or Docker Compose
• Node.js 18+ (for local development outside containers)

🏃 How to Run Locally

You can spin up the entire stack using the provided helper scripts:

1. Development Mode (Hot-Reload)

Starts all services with local code mounting. Changes in your src folders will automatically trigger a restart of the corresponding service.

./dev.sh

2. Standard Production-like Build

Builds images from scratch and runs the stack in the background.

podman-compose up -d --build

3. Full Reset

Stops all containers, prunes unused volumes/images, and performs a clean rebuild.

./restart.sh

🌉 Accessing the Platform

• Storefront: http://localhost:3000 (Local Dev)
• Admin Dashboard: http://localhost:5173 (Local Dev)
• API Gateway: http://localhost:5000
• RabbitMQ Management: http://localhost:15672 (User/Pass: admin/admin)
• Redis Insight: http://localhost:5540

---

📜 Development Commands

• Watch Logs:

  podman logs -f gearup-product   # Watch product service
  podman logs -f gearup-auth      # Watch auth service

• Inspect Database:

  ./inspect_postgresql.sh