repository·main·Indexed 41 days ago
https://github.com/jzero-io/jzeroA framework built on top of go-zero that automates the generation of API, gateway, and RPC projects. It uses a template-driven approach to generate server and client code from API, proto, or SQL definitions, reducing boilerplate while maintaining full compatibility with the go-zero ecosystem.
jzero-admin is a backend management system designed as a best-practice template for jzero. It provides a pre-built foundation for common administrative tasks and supports extensibility through plugins.
Key Features:
mysql, postgres, and sqlite.i18n support.jzero is a framework built on top of go-zero and go-zero/goctl. It automates the initialization of API, gateway, and RPC projects by generating both server and client code from descriptive files (api, proto, or sql).
go-zero ecosystem without modifying its core components.jzero is a framework built on top of go-zero and go-zero/goctl. It provides a one-click initialization for api, gateway, and rpc projects.
Key capabilities:
api, proto, or sql).jzero-skills.The jzero-intellij plugin provides several productivity features for working with jzero projects in GoLand:
api/proto and sql files.api/proto files directly to their corresponding logic files.api/proto definitions.api/proto or sql files to trigger code generation..jzero.yaml file to trigger code generation.jzero uses templates to provide predefined code structures and engineering standards. There are four main types of templates:
frame): Provides core framework capabilities and supports optional features like model, cache, or redis.home): A template specified by a path, typically used for project-specific needs within a directory.local): A global template stored in your local machine at ~/.jzero/templates/local.remote+branch): Used for enterprise-specific templates hosted in remote repositories.The jzero new command renders both the content of .tpl files and the file/directory names themselves using Go text/template syntax.
.tpl files are processed. If a file ends in .tpl.tpl, only one .tpl suffix is removed and the content is not re-rendered (useful for preserving template source text).{{ .APP }} or {{ .Module }} can be used in directory and file names to create dynamic structures.Example path rendering:
internal/{{ .APP | lower }}/{{ FormatStyle .Style "service_context.go.tpl" }}
Skills are modular knowledge packages designed to empower AI Agents (like Claude) with domain-specific expertise. They bridge the knowledge gap by teaching AI Agents about specific frameworks, libraries, and architectural patterns.
In the context of jzero, the jzero-skills package provides the AI Agent with comprehensive knowledge of the jzero framework, including REST API patterns, RPC services, and database operations. This allows AI Agents to act as effective collaborators that understand your specific technology stack without requiring repetitive explanations.
For better project structure, it is recommended to place generated zrpcclient code under a third_party directory. To avoid configuration conflicts between the server and the client, use a separate .jzero.yaml file within the client directory.
Example structure for third_party/matchingclient/:
third_party/matchingclient/.jzero.yaml with:gen:
zrpcclient:
output: .jzero gen zrpcclient while inside the third_party/matchingclient directory.This results in a clean separation of the client's proto definitions, models, and typed code from your main service logic.
# third_party/matchingclient/.jzero.yaml
gen:
zrpcclient:
output: .To avoid a massive types.go file and to prevent naming conflicts between different API modules, use the go_package option within the info block. This groups the generated message structs into the specified Go package folder.
info (
go_package: "version"
)You can configure middleware for entire services or individual methods using specific proto options. Multiple middleware names should be separated by commas.
(jzero.api.http_group) to add HTTP middleware to all methods in a service, or (jzero.api.zrpc_group) for zRPC middleware.(jzero.api.http) or (jzero.api.zrpc) to apply middleware to a specific RPC method.After running jzero gen, the middleware wiring is generated in files such as internal/middleware/middleware_gen.go.
import "jzero/api/http.proto";
import "jzero/api/zrpc.proto";
service User {
// Adds HTTP middleware to all methods in this service
option (jzero.api.http_group) = {
middleware: "auth",
};
rpc CreateUser(CreateUserRequest) returns(CreateUserResponse) {
option (google.api.http) = {
post: "/api/v1/user/create",
body: "*"
};
// Adds zRPC middleware to this specific method
option (jzero.api.zrpc) = {
middleware: "withValue1",
};
};
rpc ListUser(ListUserRequest) returns(ListUserResponse) {
option (google.api.http) = {
get: "/api/v1/user/{username}/list",
};
};
}When running jzero gen on .api and .sql files, the following directory structure is automatically populated to maintain project standards:
internal/model/model.go: Contains all model registrations.internal/model/{name}/*.go: The Model layer containing CRUD methods and field constants.internal/handler/{name}/{name}_compact.go: The HTTP/RPC handler implementation.internal/handler/routes.go: Centralized route registration.internal/logic/{name}/{method}.go: The business logic implementation files (initially containing empty implementations).internal/types/{name}/types.go: Type struct definitions.The jzero CLI template uses a three-layer command structure based on the Cobra framework to organize functionality:
mycli). It defines global configuration, global flags (like --debug or --config), and registers top-level commands.mycli config, mycli plugin, mycli server). These can have their own independent flags and arguments.mycli config init, mycli plugin install). This allows for modular, multi-level nesting.Flag Types:
# Example hierarchy
mycli config init # Subcommand of 'config'
mycli plugin install # Subcommand of 'plugin'
mycli server start # Subcommand of 'server'