create-omnidev-turbo

Scaffold a production-ready Turborepo monorepo in seconds

A powerful CLI tool to bootstrap modern TypeScript monorepos with best practices baked in.

Features

✨ Production-Ready Setup - Everything you need to start building immediately

🚀 Modern Stack

• Turborepo for blazing-fast builds
• Bun as runtime and package manager
• TypeScript with strict mode enabled
• Vitest for lightning-fast testing
• ESLint with strict TypeScript rules
• Prettier for consistent formatting

🛠️ Pre-configured

• Shared ESLint and TypeScript configs
• GitHub Actions CI/CD workflows
• Docker and Docker Compose support
• VSCode settings and extensions
• Git ignore patterns
• Dependabot configuration

📦 Monorepo Structure

• Backend app with hot reload
• Shared utility packages
• Workspace-based dependencies
• Path aliases configured

Quick Start

Using Bun (Recommended)

bun create omnidev-turbo my-app
cd my-app
bun install
bun run dev

Using npm

npm create omnidev-turbo@latest my-app
cd my-app
npm install
npm run dev

Using npx

npx create-omnidev-turbo my-app
cd my-app
npm install
npm run dev

What's Included

Project Structure

my-app/
├── apps/
│   └── backend/              # Backend application
│       ├── src/
│       │   ├── config/       # Configuration files
│       │   ├── routes/       # API routes
│       │   ├── middleware/   # Express middleware
│       │   ├── utils/        # App-specific utilities
│       │   └── tests/        # Test files
│       ├── Dockerfile        # Docker configuration
│       └── package.json
├── packages/
│   ├── eslint-config/        # Shared ESLint config
│   ├── tsconfig/             # Shared TypeScript config
│   └── utils/                # Shared utilities
├── .github/
│   └── workflows/
│       ├── ci.yml            # CI pipeline
│       └── release.yml       # Release workflow
├── docker-compose.yml        # Multi-container setup
├── turbo.json                # Turborepo configuration
└── package.json              # Root package.json

Available Scripts

# Development
bun run dev          # Start all apps in dev mode
bun run build        # Build all apps and packages
bun run test         # Run all tests
bun run test:watch   # Run tests in watch mode

# Code Quality
bun run lint         # Lint all packages
bun run format       # Format all files
bun run typecheck    # Type-check all packages

# Maintenance
bun run clean        # Clean build artifacts

Configuration Files

• TypeScript: Strict mode enabled with comprehensive type checking
• ESLint: Strict rules with unused imports removal and consistent code style
• Prettier: Opinionated formatting for consistent code
• Turbo: Optimized caching and task orchestration
• Docker: Multi-stage builds for production deployments
• GitHub Actions: Automated CI/CD with linting, testing, and building

ESLint Rules

The included ESLint configuration enforces:

• No explicit any types
• Consistent type imports
• Automatic unused imports removal
• Strict TypeScript rules
• No console.log (warnings with exceptions)
• Consistent code style (quotes, semicolons, etc.)

TypeScript Configuration

All projects use strict TypeScript with:

• strict: true
• noImplicitAny: true
• noUnusedLocals: true
• noUnusedParameters: true
• noImplicitReturns: true
• Path aliases configured
• Source maps enabled

Docker Support

Each app includes a production-ready Dockerfile with multi-stage builds:

# Build and run a specific app
docker build -f apps/backend/Dockerfile -t my-app-backend .
docker run -p 3000:3000 my-app-backend

# Or use docker-compose for all services
docker-compose up

CI/CD

GitHub Actions workflows are included for:

1. CI Pipeline (.github/workflows/ci.yml)

   • Runs on push and pull requests
   • Linting and type checking
   • Running tests
   • Building all packages

2. Release Pipeline (.github/workflows/release.yml)

   • Triggered on version tags
   • Creates GitHub releases
   • Automated release notes

Adding New Apps

# Create new app directory
mkdir -p apps/my-new-app/src

# Add package.json
cat > apps/my-new-app/package.json << EOF
{
  "name": "@repo/my-new-app",
  "version": "0.0.1",
  "private": true,
  "scripts": {
    "dev": "bun run src/index.ts",
    "build": "tsc",
    "test": "vitest run"
  },
  "dependencies": {
    "@repo/utils": "workspace:*"
  },
  "devDependencies": {
    "@repo/eslint-config": "workspace:*",
    "@repo/tsconfig": "workspace:*",
    "typescript": "^5.6.3"
  }
}
EOF

# Add tsconfig.json
cat > apps/my-new-app/tsconfig.json << EOF
{
  "extends": "@repo/tsconfig/base.json",
  "compilerOptions": {
    "outDir": "dist",
    "rootDir": "src"
  },
  "include": ["src"]
}
EOF

Publishing to NPM

1. Update package.json with your information:

   • Change author
   • Update repository URL
   • Update bugs and homepage URLs

2. Login to npm:

   npm login

3. Publish:

   npm publish

Requirements

• Bun v1.0.0 or higher (recommended)
• Node.js v18.0.0 or higher (alternative)

License

MIT

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Support

If you encounter any issues, please file an issue on the GitHub repository.