A centralized service for managing and orchestrating microfrontends across multiple environments. 🚀 This project provides a JSON-based configuration system that describes microfrontends, including their versions, and enables independent deployment and management without requiring a complete frontend rebuild.

The service supports multiple environments (DEV, UAT, PROD, etc.) and maintains separate configurations for each environment, allowing for different versions of microfrontends to be deployed in different stages of development. 📦

This project uses a monorepo architecture with the following structure:

• 📦 Monorepo: Managed with pnpm workspaces for centralized dependency management
• ⚡ Turbo: Build system for optimized task orchestration and caching
• 🎨 Biome: Unified linting and formatting across all packages
• 🪝 Lefthook: Git hooks for automated code quality checks
• 📋 Commitlint: Enforced conventional commit messages

• Layered Architecture: Models → Services → Controllers → Plugins
• Auto-loading: Controllers and plugins auto-loaded from their directories
• Authorization: Project-scoped access control via BaseAuthorizedService
• Multi-auth: Supports local JWT, Auth0, Google OAuth, Azure EntraID
• Database: MongoDB with Mongoose, Redis for caching

• UI: shadcn/ui components with Tailwind CSS
• State: React Query for server state, Zustand for client state
• Routing: React Router with lazy-loaded pages
• Forms: react-hook-form with TypeScript validation
• i18n: Complete internationalization with react-i18next

• Microfrontend Orchestrator Hub 🏗️
  • 🏗️ Architecture
    • Backend (Fastify + TypeScript)
    • Frontend (React + TypeScript)
  • Table of Contents 📑
  • Features 🎯
  • Documentation 📚
  • Run with Docker
  • Run with Terraform (OpenTofu)
  • Environment variables 🔧
  • Local Installation for development 🛠️
    • Prerequisites
    • Quick Start
    • Available Commands
    • Development URLs
  • Contributing 🤝
    • Development Workflow
    • Code Quality
    • Development Guidelines
  • License
  • Planned Integrations 🔍

• 📝 JSON-based configuration of microfrontends with version management
• 🌐 Multi-environment support (DEV, UAT, PROD, etc.)
• 🚀 Independent deployment of microfrontends
• 📋 Environment-specific configurations
• 🔌 Integration with various microfrontend technologies (coming soon)

• Cursor Rules - Development guidelines and coding standards
• Commit Conventions - Conventional Commits specification
• Changelog - Project version history
• Security - Security policy and procedures

Simply run the docker-compose.yaml

docker compose up -d

You have a terraform template in the terraform folder. You can run it with:

cd terraform
terraform init
terraform apply

• Node.js 18+ and pnpm installed
• Docker and Docker Compose

1. Clone the repository 📝

git clone <repository-url>
cd mfe-orchestrator

2. Install dependencies (monorepo setup) 📦

pnpm install

3. Start Docker services �

cd docker-local
docker compose -f docker-compose-development.yaml up -d

4. Create environment file 🔧 Create .env file in ./backend directory:

NOSQL_DATABASE_URL=mongodb://root:example@localhost:27018/admin
NOSQL_DATABASE_USERNAME=root
NOSQL_DATABASE_PASSWORD=example
REDIS_URL=redis://localhost:6379

REGISTRATION_ALLOWED=true
ALLOW_EMBEDDED_LOGIN=true
NODE_ENV=development
MICROFRONTEND_HOST_FOLDER=/path/to/your/microfrontends

# Optional: GitHub OAuth for code repository integration
CODE_REPOSITORY_GITHUB_CLIENT_ID=your_github_client_id
CODE_REPOSITORY_GITHUB_CLIENT_SECRET=your_github_client_secret

5. Start development servers 🚀

# Start both backend and frontend in development mode
pnpm dev

# Or start them individually:
# Backend only: pnpm dev:backend
# Frontend only: pnpm dev:frontend

The monorepo provides these workspace-level commands:

# Development
pnpm dev              # Start both backend and frontend
pnpm dev:backend      # Start backend only
pnpm dev:frontend     # Start frontend only

# Building
pnpm build            # Build all packages
pnpm build:backend    # Build backend only
pnpm build:frontend   # Build frontend only

# Code Quality
pnpm lint             # Lint all packages with Biome
pnpm format           # Format all packages with Biome
pnpm typecheck        # TypeScript check for all packages

# Testing
pnpm test             # Run tests in all packages

• Backend: http://localhost:8080
• Frontend: http://localhost:3000
• API Documentation: http://localhost:8080/api-docs

1. Fork the repository 🍴
2. Create your feature branch 🌱

git checkout -b feature/AmazingFeature

3. Follow development guidelines 📋

   • Use conventional commit messages (enforced by commitlint)
   • Code is automatically linted and formatted with Biome
   • Git hooks ensure code quality before commits

4. Commit your changes ✍️

git commit -m 'feat: add some amazing feature'

5. Push to the branch ⬆️

git push origin feature/AmazingFeature

6. Open a Pull Request 🔗

This project uses automated tools to maintain code quality:

• 🎨 Biome: Unified linting and formatting
• 🪝 Lefthook: Git hooks for pre-commit checks
• 📋 Commitlint: Conventional commit validation
• ⚡ Turbo: Optimized build pipeline

• Use conventional commits (feat, fix, chore, docs, etc.)
• Write tests for new features
• Ensure TypeScript strict mode compliance
• Update documentation for user-facing changes

ISC

• Module Federation
• micro-lc