flutter
Flutter makes it easy and fast to build beautiful apps for mobile and beyond
- 181k
- Dart
- BSD-3-Clause
- 24 min ago
Go-API is a simple, powerful, and high-performance Go framework for building web APIs.
Repo seakee/go-api, read from GitHub 10 h ago. seakee has not joined Take My Repo.
seakee/go-api is a public repo on GitHub by seakee. Go-API is a simple, powerful, and high-performance Go framework for building web APIs. It declares the MIT license on GitHub. It is written mainly in Go, has 6 stars and last changed on 2026-03-25. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
go-api is a powerful, high-performance Go framework designed for building enterprise-grade web APIs. It provides a complete solution with layered architecture, dependency injection, comprehensive middleware support, and automatic code generation capabilities.
# Download the project generator
curl -O https://raw.githubusercontent.com/seakee/go-api/main/scripts/generate.sh
chmod +x generate.sh
# Generate a new project
./generate.sh my-api-project v1.0.0
cd my-api-project
# Install dependencies and run
go mod tidy
make run
# Clone the repository
git clone https://github.com/seakee/go-api.git
cd go-api
# Install dependencies
go mod download
# Copy and configure local settings
cp bin/configs/local.json.default bin/configs/local.json
# Edit bin/configs/local.json with your database settings
# Run the application
make run
go-api/
โโโ app/ # Application layer
โ โโโ config/ # Configuration management
โ โ โโโ config.go # Config loader and structures
โ โโโ http/ # HTTP layer
โ โ โโโ controller/ # HTTP controllers
โ โ โ โโโ auth/ # Authentication controllers
โ โ โ โ โโโ app.go # App CRUD operations
โ โ โ โ โโโ handler.go # Auth handler interface
โ โ โ โ โโโ jwt.go # JWT token operations
โ โ โ โโโ base.go # Base controller
โ โ โโโ middleware/ # HTTP middleware
โ โ โ โโโ check_app_auth.go # JWT authentication
โ โ โ โโโ cors.go # CORS handling
โ โ โ โโโ handler.go # Middleware interface
โ โ โ โโโ request_logger.go # Request logging
โ โ โ โโโ set_trace_id.go # Trace ID injection
โ โ โโโ router/ # Route definitions
โ โ โ โโโ external/ # External API routes
โ โ โ โ โโโ service/ # External service routes
โ โ โ โ โโโ auth/ # Auth endpoints
โ โ โ โโโ internal/ # Internal API routes
โ โ โ โ โโโ service/ # Internal service routes
โ โ โ โ โโโ auth/ # Auth endpoints
โ โ โ โโโ handler.go # Main router
โ โ โโโ context.go # HTTP context wrapper
โ โโโ model/ # Data models
โ โ โโโ auth/ # Authentication models
โ โ โโโ app.go # App model (MySQL)
โ โ โโโ app_mgo.go # App model (MongoDB)
โ โโโ pkg/ # Utility packages
โ โ โโโ e/ # Error codes
โ โ โ โโโ code.go # Error code definitions
โ โ โโโ jwt/ # JWT utilities
โ โ โ โโโ jwt.go # JWT generation/parsing
โ โ โโโ schedule/ # Task scheduling
โ โ โ โโโ schedule.go # Job scheduler
โ โ โโโ trace/ # Distributed tracing
โ โ โโโ trace.go # Trace ID generation
โ โโโ repository/ # Data access layer
โ โ โโโ auth/ # Auth repository
โ โ โโโ app.go # App repository
โ โโโ service/ # Business logic layer
โ โ โโโ auth/ # Auth services
โ โ โโโ app.go # App service
โ โโโ worker/ # Background workers
โ โโโ handler.go # Worker handler
โโโ bin/ # Runtime resources
โ โโโ configs/ # Configuration files
โ โ โโโ dev.json # Development config
โ โ โโโ local.json # Local config
โ โ โโโ prod.json # Production config
โ โโโ data/ # Data files
โ โ โโโ sql/ # SQL scripts
โ โ โโโ auth_app.sql # App table schema
โ โโโ lang/ # Language files
โ โโโ en-US.json # English messages
โ โโโ zh-CN.json # Chinese messages
โโโ bootstrap/ # Application bootstrap
โ โโโ app.go # Main app initialization
โ โโโ database.go # Database setup
โ โโโ http.go # HTTP server setup
โ โโโ kafka.go # Kafka setup
โ โโโ schedule.go # Scheduler setup
โโโ command/ # CLI commands
โ โโโ codegen/ # Code generator
โ โโโ codegen/ # Generator logic
โ โโโ handler.go # CLI handler
โ โโโ README.md # Generator docs
โโโ scripts/ # Utility scripts
โ โโโ generate.sh # Project generator
โโโ docs/ # Project documentation
โ โโโ Home.md # Wiki homepage (English)
โ โโโ Home-zh.md # Wiki homepage (Chinese)
โ โโโ Architecture-Design.md # Architecture documentation
โ โโโ Development-Guide.md # Development workflow guide
โ โโโ API-Documentation.md # Complete API reference
โ โโโ Code-Generator-Guide.md # Code generation tool guide
โ โโโ Deployment-Guide.md # Production deployment guide
โโโ Dockerfile # Docker configuration
โโโ Makefile # Build automation
โโโ docker-compose.yml # Docker Compose
โโโ go.mod # Go module
โโโ go.sum # Dependencies
โโโ main.go # Application entry point
The framework follows a strict 4-layer architecture:
Supports multiple environments with JSON-based configuration:
{
"system": {
"name": "go-api",
"run_mode": "debug",
"http_port": ":8080",
"jwt_secret": "your-secret-key"
},
"databases": [
{
"enable": true,
"db_type": "mysql",
"db_name": "go-api",
"db_host": "localhost",
"db_port": 3306,
"charset": "utf8mb4",
"conn_max_lifetime": 3
}
]
}
Built-in middleware for common functionality:
Complete JWT-based authentication:
# Get JWT token
curl -X POST http://localhost:8080/go-api/external/service/auth/token \
-d "app_id=your_app_id&app_secret=your_app_secret"
# Use token in requests
curl -H "Authorization: your_jwt_token" \
http://localhost:8080/go-api/external/service/auth/app
// app/http/controller/user/handler.go
package user
import (
"github.com/gin-gonic/gin"
"github.com/seakee/go-api/app/http"
)
type Handler interface {
Create() gin.HandlerFunc
GetByID() gin.HandlerFunc
}
type handler struct {
controller.BaseController
service userService.UserService
}
func NewHandler(appCtx *http.Context) Handler {
return &handler{
BaseController: controller.BaseController{
AppCtx: appCtx,
Logger: appCtx.Logger,
Redis: appCtx.Redis["go-api"],
I18n: appCtx.I18n,
},
service: userService.NewUserService(appCtx.SqlDB["go-api"], appCtx.Redis["go-api"]),
}
}
// app/http/router/external/service/user/user.go
func RegisterRoutes(api *gin.RouterGroup, ctx *http.Context) {
userHandler := user.NewHandler(ctx)
{
api.POST("user", ctx.Middleware.CheckAppAuth(), userHandler.Create())
api.GET("user/:id", userHandler.GetByID())
}
}
// app/http/middleware/handler.go
type Middleware interface {
CheckAppAuth() gin.HandlerFunc
YourNewMiddleware() gin.HandlerFunc // Add this
}
// app/http/middleware/your_middleware.go
func (m middleware) YourNewMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
// Your middleware logic
c.Next()
}
}
Generate models and repositories from SQL files:
# Generate from SQL file
go run ./command/codegen/handler.go -name user_table
# Generate all SQL files
go run ./command/codegen/handler.go
# Custom paths
go run ./command/codegen/handler.go -sql custom/sql -model custom/model
SQL file format:
CREATE TABLE `users` (
`id` int NOT NULL AUTO_INCREMENT COMMENT 'Primary Key',
`username` varchar(50) NOT NULL COMMENT 'Username',
`email` varchar(100) NOT NULL COMMENT 'Email Address',
`status` tinyint(1) NOT NULL DEFAULT '1' COMMENT 'Status',
`created_at` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
`updated_at` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='User Information';
| Method | Endpoint | Description | Auth Required |
|---|---|---|---|
| POST | /go-api/external/service/auth/token |
Get JWT token | No |
| POST | /go-api/external/service/auth/app |
Create app | Yes |
| GET | /go-api/external/service/ping |
Health check | No |
| Method | Endpoint | Description | Auth Required |
|---|---|---|---|
| POST | /go-api/internal/service/auth/token |
Get JWT token | No |
| POST | /go-api/internal/service/auth/app |
Create app | Yes |
| GET | /go-api/internal/service/ping |
Health check | No |
# docker-compose.yml
version: '3.8'
services:
go-api:
build: .
ports:
- "8080:8080"
volumes:
- ./bin/configs:/bin/configs
- ./bin/logs:/bin/logs
environment:
- RUN_ENV=prod
- APP_NAME=go-api
depends_on:
- mysql
- redis
mysql:
image: mysql:8.0
environment:
MYSQL_ROOT_PASSWORD: password
MYSQL_DATABASE: go-api
ports:
- "3306:3306"
redis:
image: redis:7-alpine
ports:
- "6379:6379"
# Build Docker image
make docker-build
# Run with Docker Compose
docker-compose up -d
# Run single container
make docker-run
# Development
make run # Run application
make test # Run tests
make fmt # Format code
make all # fmt + test + build
# Production
make build # Build binary
make docker-build # Build Docker image
make docker-run # Run Docker container
| Variable | Description | Default |
|---|---|---|
RUN_ENV |
Runtime environment | local |
APP_NAME |
Application name | go-api |
CONFIG_DIR |
Configuration directory | ./bin/configs |
Complete project documentation is available in the docs/ directory:
git checkout -b feature/new-featuregit commit -am 'Add new feature'git push origin feature/new-featureSee Contributing Guide for more details.
This project is licensed under the MIT License - see the LICENSE file for details.
seakee/go-api is a public repo on GitHub by seakee. Go-API is a simple, powerful, and high-performance Go framework for building web APIs.
It declares the MIT license on GitHub.
Its maker tagged it for macOS, Windows and Linux, or as Docker or cross-platform. That is declared by the maker; Take My Repo has not tested it.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-03-25. GitHub counts 0 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Flutter makes it easy and fast to build beautiful apps for mobile and beyond
f.k.a. Awesome ChatGPT Prompts. Share, discover, and collect prompts from the community. Free and open source โ self-host for your organization with complete privacy.
Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
The Python micro framework for building web applications.

A self-hosted CPA / CLIProxyAPI management panel and AI gateway observability dashboard for requests, usage, cost, quota, failures, and account health.
Vue 3 admin frontend for dudu-admin-api with authentication, RBAC, and dynamic routing.

ๅบไบLaravel6.0ใVue2.6ใElement-ui2.10ๅผๅ็ๅๅๅ็ฆป็ๅๅฐ็ฎก็่ๆๆถ
Dockmon is a Go service that collects Docker container logs and stores them in MySQL.
Go admin backend API for Dudu with auth, RBAC, menus, and audit logs.
DuDu Proxy is a high-performance proxy server supporting both HTTP and SOCKS5 protocols, featuring authentication, IP banning, rate limiting, and circuit breaker capabilities.
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/seakee/go-apiTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.