A powerful desktop application for creating and managing mock HTTP servers

MockWails is a comprehensive desktop application designed for developers, testers, and API designers who need to create and manage mock HTTP servers efficiently. Built with modern technologies including Wails v2, Go, and React, it provides a seamless experience for API mocking and testing.

• 🚀 Fast & Lightweight: Native desktop pericnoformance with minimal resource usage
• 🎯 Developer-Friendly: Intuitive interface designed by developers, for developers
• ⚡ Instant Setup: Create and deploy mock servers in seconds
• 🔧 Highly Configurable: Fine-tune every aspect of your mock responses
• 💾 Persistent Storage: All configurations saved locally with SQLite
• 🔄 Auto-Recovery: Servers automatically restart when the application launches
• 🌐 Multi-Platform: Available for Windows, macOS, and Linux

The application allows you to define sophisticated mock servers with specific endpoints, HTTP methods, response statuses, custom headers, and response bodies. All configurations are persisted in a local SQLite database, ensuring your mock setups are preserved across application restarts. Active servers are automatically restarted when the application launches, making it perfect for development workflows.

• 🏗️ Create and Manage Mock Servers: Intuitive interface for creating, editing, and deleting mock servers with comprehensive configuration options
• 🎨 Customizable Responses: Full control over HTTP responses including:
  • Custom endpoints and HTTP methods (GET, POST, PUT, DELETE, PATCH)
  • Configurable status codes (200, 404, 500, etc.)
  • Custom headers and response bodies (JSON, XML, HTML, plain text)
  • Request validation with expected headers and body matching
  • Simulated response latency for realistic testing
• 💾 Persistent Storage: All mock server configurations are automatically saved to a local SQLite database
• 🔄 Automatic Restart: Active servers intelligently restart when the application launches, maintaining your development workflow
• 🎯 Easy to Use UI: Clean, modern, and intuitive user interface with dark/light theme support

• 📊 Real-time Status Monitoring: Live status indicators showing which servers are running
• 🔍 Request Inspection: Monitor incoming requests to your mock servers
• ⚡ Quick Actions: Start, stop, edit, and delete servers with single-click actions
• 🔄 Bulk Operations: Manage multiple servers simultaneously
• 📱 Responsive Design: Optimized interface that works perfectly on any screen size
• 🎨 Modern UI Components: Built with Shadcn UI for consistency and accessibility

• 🚀 Hot Reload: Instant updates during development
• 📝 TypeScript Support: Full type safety across the entire application
• 🧪 Testing Ready: Perfect for API testing, frontend development, and CI/CD pipelines
• 🔧 Extensible: Clean architecture for easy customization and extension

• Go 1.21+: Download and install Go
• Node.js 18+: Download and install Node.js
• Wails CLI: Install with go install github.com/wailsapp/wails/v2/cmd/wails@latest

1. Clone the repository:

   git clone https://github.com/tacheraSasi/mockwails.git
   cd mockwails

2. Install dependencies:

   make deps

3. Run in development mode:

   make dev

4. Build for production:

   # For your current platform
   wails build
   
   # Or use make commands for specific platforms
   make build-mac      # macOS universal binary
   make build-windows  # Windows 64-bit
   make build-linux    # Linux 64-bit

1. Launch MockWails and click "Create Mock Endpoint"
2. Configure your endpoint:
   • Name: "User API"
   • Endpoint: "/api/users"
   • Method: "GET"
   • Response: {"users": [{"id": 1, "name": "John Doe"}]}
   • Status Code: 200
3. Click "Create" - your mock server starts automatically
4. Test it: Visit http://localhost:8080/api/users in your browser

{
  "endpoint": "/api/users",
  "method": "POST",
  "expectedHeaders": {
    "Content-Type": "application/json",
    "Authorization": "Bearer token"
  },
  "expectedBody": {
    "name": "string",
    "email": "string"
  },
  "response": {
    "status": 201,
    "headers": {
      "Content-Type": "application/json"
    },
    "body": {
      "id": 123,
      "message": "User created successfully"
    }
  },
  "latency": 500
}

• Go: High-performance backend with excellent concurrency
• Wails v2: Modern desktop app framework bridging Go and web technologies
• SQLite: Embedded database for configuration persistence
• GORM: Elegant ORM for database operations

• React 18: Modern UI library with hooks and concurrent features
• TypeScript: Type safety and enhanced developer experience
• Shadcn UI: Beautiful, accessible, and customizable components
• Tailwind CSS: Utility-first CSS framework for rapid styling
• Vite: Lightning-fast build tool and development server

• Biome: Fast formatter and linter for JavaScript/TypeScript
• React Hook Form: Performant forms with easy validation
• Sonner: Beautiful toast notifications

For the best development experience with hot reload:

# Install dependencies (only needed once)
make deps

# Start development server with hot reload
make dev

This starts the app with hot reload for both frontend and backend. For frontend-only development in a browser (with access to Go methods), open http://localhost:34115 in your browser.

1. Backend Changes: Modify Go files - Wails automatically rebuilds and restarts
2. Frontend Changes: Edit React/TypeScript files - Vite provides instant hot reload
3. Database Changes: Update models in db/ - restart required for schema changes
4. UI Components: Modify components in frontend/src/components/ - see changes instantly

mockwails/
├── app.go              # Main application logic and Wails bindings
├── main.go             # Application entry point
├── wails.json          # Wails configuration
├── config/             # Application configuration
│   └── config.go
├── db/                 # Database models and operations
│   ├── db.go           # Database initialization
│   ├── server.go       # Server model definitions
│   ├── server_ops.go   # Server CRUD operations
│   └── migrate.go      # Database migrations
├── mockserver/         # HTTP server implementation
│   ├── server.go       # Mock server logic
│   └── templates.go    # HTML templates for 404 pages
├── utils/              # Utility functions
│   └── utils.go
├── frontend/           # React frontend
│   ├── src/
│   │   ├── components/ # Reusable UI components
│   │   ├── pages/      # Application pages
│   │   ├── contexts/   # React contexts
│   │   └── lib/        # Utility functions
│   └── wailsjs/        # Generated Wails bindings
└── build/              # Build outputs and assets

To build a redistributable, production-ready package:

# Build for your current platform
wails build

# Or use platform-specific make commands
make build-windows    # Windows 64-bit (.exe)
make build-linux      # Linux 64-bit (AppImage)
make build-mac        # macOS universal binary (.app)

• Windows: build/bin/MockWails.exe
• macOS: build/bin/MockWails.app
• Linux: build/bin/MockWails (executable)

The built applications are self-contained and don't require any additional dependencies. They can be distributed directly to end users.

The project includes a comprehensive Makefile to simplify common development tasks. Run make help to see all available commands:

• make dev - Run the application in development mode with hot reloading
• make deps - Install frontend dependencies from package.json
• make clean - Clean build artifacts and temporary files

• make build-windows - Build the application for Windows (64-bit)
• make build-linux - Build the application for Linux (64-bit)
• make build-mac - Build the application for macOS (universal binary)

• make lint - Lint the frontend code using Biome
• make format - Format the frontend code using Biome
• make check - Check and apply automatic fixes to the frontend code using Biome

• make db-reset - Reset the database (removes all data)
• make db-migrate - Run database migrations

# Setup project
make deps

# Start development
make dev

# Before committing
make check
make lint

# Build for production
make build-mac

• Frontend Development: Mock backend APIs before they're implemented
• API Design: Prototype and test API responses during design phase
• Integration Testing: Create predictable endpoints for automated testing
• Third-party API Simulation: Mock external services for development

• Build Pipelines: Provide consistent mock services for automated tests
• Environment Testing: Simulate different API responses and error conditions
• Load Testing: Create lightweight mock endpoints for performance testing
• Staging Environments: Replace expensive external dependencies

• API Learning: Understand HTTP protocols and REST principles
• Workshop Demos: Quick setup for coding workshops and tutorials
• Student Projects: Provide APIs for learning frontend development
• Interview Preparation: Practice API integration skills

We welcome contributions! Here's how you can help:

1. Fork the repository on GitHub
2. Clone your fork: git clone https://github.com/yourusername/mockwails.git
3. Create a branch: git checkout -b feature/amazing-feature
4. Make your changes and test thoroughly
5. Commit your changes: git commit -m 'Add amazing feature'
6. Push to the branch: git push origin feature/amazing-feature
7. Open a Pull Request

• Follow existing code style and patterns
• Write clear commit messages
• Add tests for new features
• Update documentation as needed
• Run make check before submitting

• 🐛 Bug Reports: Found a bug? Open an issue with details
• 💡 Feature Requests: Have an idea? We'd love to hear it
• 📖 Documentation: Help improve our docs
• 🧪 Testing: Add test cases and improve coverage
• 🎨 UI/UX: Enhance the user interface and experience

This project is licensed under the MIT License - see the LICENSE file for details.

• Wails Team - For the amazing desktop app framework
• Shadcn - For the beautiful UI component library
• Go Community - For the robust backend language
• React Team - For the powerful frontend framework

• GitHub Issues: Report bugs or request features
• Discussions: Join community discussions