Backend Code Generation

The GoWind Toolkit backend code generator turns a database schema into a complete set of Go-Kratos microservice code in one click — Protobuf definitions, ORM models, the data access layer, the business logic layer, Wire dependency injection, and the full layered stack.

Overall Workflow

Backend code generation takes just 4 steps, and works the same for monoliths and microservice projects:

1. Initialize the project: generate an enterprise-grade standard microservice architecture in one click
2. Bind a database: connect directly or import SQL to quickly load your table structures
3. Configure the tables: choose a packaging mode as needed and filter out unused tables
4. Generate in one click: produce the full set of layered backend business code automatically

Step 1: Create a Backend Project

Entry Point

Open the GoWind Toolkit desktop client and click [Create Backend Project] in the top-right corner of the home page to open the creation dialog.

Configuration Options

Creation Steps

1. Pick an empty folder with a pure-English path
2. Fill in the project name and the Go module name
3. Keep the template repository and branch at their defaults
4. Click confirm, and the tool automatically initializes the complete project architecture

Generated Project Directory

go-wind-demo/
├── api/          # Proto definitions, gRPC interfaces, request/response structs
├── cmd/          # Entry points for all services
├── internal/     # Core private business code
│   ├── data/     # Database data access layer
│   ├── server/   # Routing, middleware, service registration
│   └── service/  # Interface implementation layer
├── go.mod        # Dependency management file
└── go.sum        # Dependency checksum file

gow new myproject
cd myproject && go mod tidy

Step 2: Connect to a Database & Import Table Structures

Import Modes

The tool supports three import methods:

Database Connection

Switch to the [Database Import] tab and enter your database connection info:

user:password@tcp(127.0.0.1:3306)/db_name?charset=utf8mb4&parseTime=True&loc=Local

Supported databases:

• MySQL (recommended)
• PostgreSQL
• SQLite
• Oracle

Import Steps

1. After entering the connection info, click [Test Connection] to confirm the database is reachable
2. Once connected, click [Import Table Structures]
3. The tool automatically loads every table in the database and displays them visually

# Interactive
gow generate

# Full command line
gow generate --dsn "mysql://user:pass@tcp(localhost:3306)/dbname" --service user

Step 3: Table Packaging Configuration

Three Packaging Modes

Fine-Grained Configuration

1. Assign each data table to the corresponding business service
2. Untick log tables, junction tables, and temporary tables to avoid generating redundant code
3. Individually edit table model names, package names, and comments

Step 4: Generate Code in One Click

Generation Parameters

What Gets Generated

Click [Generate Code] and the tool automatically produces the full set of code in one go:

• Proto definitions: gRPC request/response structs
• ORM models: Ent entity models and database mapping structures
• Data layer: DAO database access code
• Biz layer: complete CRUD business code
• Service layer: interface implementations, routing, and service registration code
• Wire: dependency injection code

Project Verification

After generation completes, run this in the project root:

go mod tidy

If it runs without errors, the project is ready to use.

# Generate for a specific ORM and set of tables
gow generate --dsn "mysql://..." \
  --service user --orm ent --servers grpc --tables users,roles

# Generate proto files only
gow generate --dsn "postgres://..." --service admin --proto-only

# Generate a REST service (proxied from a gRPC service)
gow generate --dsn "mysql://..." --service user-admin \
  --servers rest --source-module user --skip-orm

CLI Command Cheat Sheet

Microservice Evolution (Module Extraction)

As your business grows, use gow extract to pull modules out of one service into a new one:

# Extract the role module from the admin service into the user service
gow extract admin user -o role

# Extract multiple entities
gow extract admin user -o role,permission

# Specify the ORM type manually
gow extract admin user -o role --orm gorm

# Keep the source files (deleted by default)
gow extract admin user -o role --keep-source

The target service is created automatically if it doesn't exist, and the ORM type is auto-detected.

Troubleshooting

Related documents:

• Introduction to GoWind Toolkit
• Frontend Code Generation