Bloggo: Blog CMS

A modern, feature-rich blog management system built with Go. Bloggo provides a complete content management solution with post versioning, role-based permissions, statistics tracking, and comprehensive analytics.

• Post Creation & Editing - Rich content management with cover images and metadata
• Version Control - Track and manage multiple versions of posts with approval workflow
• Draft System - Save drafts and publish when ready
• Categories & Tags - Organize content with flexible categorization
• Cover Images - Upload and serve automatically optimized cover images (resized and saved in WebP format)

• Role-Based Access Control - Admin, Editor, and Author roles with granular permissions
• User Authentication - JWT-based secure authentication
• Profile Management - User profiles with avatar support
• Permission System - Fine-grained permission control for different actions

• View Tracking - Track timestamp based post views with user agent analysis
• Device Analytics - Desktop vs mobile traffic analysis
• Operating System Detection - Detailed OS statistics
• Browser Analytics - Browser usage statistics
• Read Time Calculation - Automatic reading time estimation
• Performance Optimized - Denormalized read counts for fast retrieval

• Modular Architecture - Clean, maintainable codebase with module-based design
• SQLite Database - Lightweight, embedded database with full SQL support
• File Storage - Organized file storage system for uploads
• Rate Limiting - Built-in rate limiting for API protection
• Caching Headers - Optimized caching for static assets

Nothing! Bloggo is pre-compiled via github workflows and does not requires any additional software. Just download and run the exacurable from Releases Page

bloggo/
├── cli/                    # Application entry point
├── internal/
│   ├── app/               # Application core
│   ├── config/            # Configuration management
│   ├── db/                # Database initialization and queries
│   ├── infrastructure/    # Infrastructure components
│   │   ├── bucket/        # File storage abstraction
│   │   ├── permissions/   # Permission system
│   │   └── tokens/        # Token management
│   ├── middleware/        # HTTP middlewares
│   ├── module/            # Feature modules
│   │   ├── category/      # Category management
│   │   ├── post/          # Post management
│   │   ├── session/       # Authentication
│   │   ├── statistics/    # Analytics
│   │   ├── storage/       # File serving
│   │   ├── tag/           # Tag management
│   │   └── user/          # User management
│   └── utils/             # Utility packages
├── uploads/               # File storage directory
├── .env                  # Environment variables (create from .env.example)
├── bloggo.sqlite         # SQLite database
├── go.mod                # Go module definition
└── LICENSE               # GPLv3 License

Configuration is managed through environment variables. Create a .env file from .env.example:

cp .env.example .env

Key environment variables include:

• PORT - Server port (default: 8723)
• JWT_SECRET - JWT signing secret (required, min 32 characters)
• ACCESS_TOKEN_DURATION - Access token lifetime in seconds (default: 900)
• REFRESH_TOKEN_DURATION - Refresh token lifetime in seconds (default: 604800)
• GEMINI_API_KEY - Google Gemini API key (optional, for AI features)
• TRUSTED_FRONTEND_KEY - Key for trusted frontend requests (required, min 32 characters)

The application uses SQLite with the following main entities:

• Users - User accounts and profiles
• Roles & Permissions - Role-based access control
• Posts & Post Versions - Content with version control
• Categories & Tags - Content organization
• Post Views - Analytics and tracking
• Sessions - Authentication management

• JWT Authentication - Secure token-based authentication
• Password Hashing - bcrypt password hashing
• Rate Limiting - Protection against abuse
• Input Validation - Comprehensive input validation
• SQL Injection Protection - Parameterized queries

• Optimized Queries - Efficient database queries with proper indexing
• Denormalized Counters - Fast read counts without expensive aggregations
• Caching Headers - Proper HTTP caching for static assets
• Connection Pooling - Efficient database connection management
• Modular Loading - Lazy loading of modules and dependencies

• Modular Design - Each feature is a self-contained module
• Repository Pattern - Clean separation of data access
• Service Layer - Business logic abstraction
• Handler Layer - HTTP request handling

• Chi Router - Fast HTTP router
• SQLite3 - Embedded database
• JWT - JSON Web Tokens for authentication
• Validator - Request validation
• WebP - Image processing and optimization

This project is licensed under the GNU General Public License v3.0 - see the LICENSE file for details.

Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

If you encounter any issues or have questions, please open an issue in the repository.

Bloggo - A modern blog management system built with ❤️ and Go