feat(database): mysql 数据库包，商品以及 sku 表

.gitignore

+.idea
+tunnel.toml
+vendor
\ No newline at end of file

go.mod

+module git.chillcy.com/golang/colorway
+
+go 1.24.3
+
+require (
+	git.chillcy.com/golang/chillcy/pkg v0.0.0-20250627035541-7956996f27ce
+	github.com/iancoleman/strcase v0.3.0
+	github.com/zeromicro/go-zero v1.8.4
+	google.golang.org/grpc v1.73.0
+	google.golang.org/protobuf v1.36.6
+	gorm.io/driver/mysql v1.6.0
+	gorm.io/gorm v1.30.0
+)
+
+require (
+	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/coreos/go-semver v0.3.1 // indirect
+	github.com/coreos/go-systemd/v22 v22.5.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	github.com/emicklei/go-restful/v3 v3.11.0 // indirect
+	github.com/fatih/color v1.18.0 // indirect
+	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-openapi/jsonpointer v0.19.6 // indirect
+	github.com/go-openapi/jsonreference v0.20.2 // indirect
+	github.com/go-openapi/swag v0.22.4 // indirect
+	github.com/go-sql-driver/mysql v1.9.0 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang/mock v1.6.0 // indirect
+	github.com/golang/protobuf v1.5.4 // indirect
+	github.com/google/gnostic-models v0.6.8 // indirect
+	github.com/google/go-cmp v0.7.0 // indirect
+	github.com/google/gofuzz v1.2.0 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/grafana/pyroscope-go v1.2.2 // indirect
+	github.com/grafana/pyroscope-go/godeltaprof v0.1.8 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/josharian/intern v1.0.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/compress v1.17.11 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/openzipkin/zipkin-go v0.4.3 // indirect
+	github.com/patrickmn/go-cache v2.1.0+incompatible // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/prometheus/client_golang v1.21.1 // indirect
+	github.com/prometheus/client_model v0.6.1 // indirect
+	github.com/prometheus/common v0.62.0 // indirect
+	github.com/prometheus/procfs v0.15.1 // indirect
+	github.com/redis/go-redis/v9 v9.10.0 // indirect
+	github.com/spaolacci/murmur3 v1.1.0 // indirect
+	go.etcd.io/etcd/api/v3 v3.5.15 // indirect
+	go.etcd.io/etcd/client/pkg/v3 v3.5.15 // indirect
+	go.etcd.io/etcd/client/v3 v3.5.15 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/otel v1.35.0 // indirect
+	go.opentelemetry.io/otel/exporters/jaeger v1.17.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.24.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.24.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.24.0 // indirect
+	go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.24.0 // indirect
+	go.opentelemetry.io/otel/exporters/zipkin v1.24.0 // indirect
+	go.opentelemetry.io/otel/metric v1.35.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.35.0 // indirect
+	go.opentelemetry.io/otel/trace v1.35.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.3.1 // indirect
+	go.uber.org/atomic v1.10.0 // indirect
+	go.uber.org/automaxprocs v1.6.0 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
+	go.uber.org/zap v1.24.0 // indirect
+	golang.org/x/crypto v0.36.0 // indirect
+	golang.org/x/net v0.38.0 // indirect
+	golang.org/x/oauth2 v0.28.0 // indirect
+	golang.org/x/sys v0.31.0 // indirect
+	golang.org/x/term v0.30.0 // indirect
+	golang.org/x/text v0.23.0 // indirect
+	golang.org/x/time v0.10.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20250324211829-b45e905df463 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250324211829-b45e905df463 // indirect
+	gopkg.in/inf.v0 v0.9.1 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+	k8s.io/api v0.30.2 // indirect
+	k8s.io/apimachinery v0.30.2 // indirect
+	k8s.io/client-go v0.30.2 // indirect
+	k8s.io/klog/v2 v2.120.1 // indirect
+	k8s.io/kube-openapi v0.0.0-20240228011516-70dd3763d340 // indirect
+	k8s.io/utils v0.0.0-20240711033017-18e509b52bc8 // indirect
+	sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect
+	sigs.k8s.io/structured-merge-diff/v4 v4.4.1 // indirect
+	sigs.k8s.io/yaml v1.3.0 // indirect
+)

internal/pkg/database/manager.go

+package database
+
+import (
+	"fmt"
+	"git.chillcy.com/golang/colorway/internal/pkg/database/repository"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"reflect"
+)
+
+type Manager struct {
+	CompleteSpuRepository repository.CompleteSpuInterface
+	ColorSpuRepository    repository.ColorSpuInterface
+	SkuRepository         repository.SkuInterface
+}
+
+func (receiver *Manager) init() error {
+	return receiver.methodCall([]string{"AutoMigrate"})
+}
+
+func (receiver *Manager) methodCall(methodNames []string) error {
+	v := reflect.ValueOf(receiver).Elem() // 获取指针指向的值
+	t := reflect.TypeOf(receiver).Elem()  // 获取指针指向的类型
+	for _, methodName := range methodNames {
+		for i := 0; i < v.NumField(); i++ {
+			field := v.Field(i)
+			fieldType := t.Field(i)
+
+			// 检查字段是否为 nil
+			if field.IsNil() {
+				return fmt.Errorf("字段 %s 为 nil，跳过\n", fieldType.Name)
+			}
+
+			// 检查是否有 methodName 方法
+			method := field.MethodByName(methodName)
+			if !method.IsValid() {
+				return fmt.Errorf("字段 %s 没有 %s 方法\n", fieldType.Name, methodName)
+			}
+
+			// 调用 methodName 方法
+			fmt.Printf("调用 %s.%s()\n", fieldType.Name, methodName)
+			method.Call(nil)
+		}
+	}
+
+	return nil
+
+}
+
+func NewManager(dsn string) (*Manager, error) {
+	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
+		DisableForeignKeyConstraintWhenMigrating: false, // 启用外键约束创建
+	})
+	if err != nil {
+		return nil, err
+	}
+	manager := &Manager{
+		CompleteSpuRepository: repository.NewCompleteSpu(db),
+		ColorSpuRepository:    repository.NewColorSpu(db),
+		SkuRepository:         repository.NewSku(db),
+	}
+	err = manager.init()
+	return manager, err
+}

internal/pkg/database/model/colorspu.go

+package model
+
+import "gorm.io/gorm"
+
+type ColorSpu struct {
+	gorm.Model
+	StyleNumber string `gorm:"uniqueIndex:style; size:50; not null"`
+	ColorCode   string `gorm:"uniqueIndex:style; size:50; not null"`
+	// 外键
+	Skus Skus `gorm:"foreignKey:StyleNumber,ColorCode; references:StyleNumber,ColorCode; constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"`
+}
+
+type ColorSpus []ColorSpu

internal/pkg/database/model/completespu.go

+package model
+
+import "gorm.io/gorm"
+
+type CompleteSpu struct {
+	gorm.Model
+	StyleNumber string `gorm:"uniqueIndex; size:50; not null"`
+	Title       string `gorm:"size:100"`
+	Description string `gorm:"type:text"`
+	Gender      string `gorm:"size:20; not null"`
+	Season      string `gorm:"size:20"`
+	// 外键
+	ColorSpus ColorSpus `gorm:"foreignKey:StyleNumber; references:StyleNumber; constraint:OnUpdate:CASCADE,OnDelete:CASCADE;"`
+}

internal/pkg/database/model/sku.go

+package model
+
+import "gorm.io/gorm"
+
+type Sku struct {
+	gorm.Model
+	Pc3SkuId    string  `gorm:"uniqueIndex; not null; size:24"`
+	StyleNumber string  `gorm:"size:50; not null"`
+	ColorCode   string  `gorm:"size:50; not null"`
+	Source      string  `gorm:"size:50; not null"`
+	Site        string  `gorm:"size:50; not null"`
+	Size        string  `gorm:"size:50; not null"`
+	Stock       int     `gorm:"not null"`
+	Price       float64 `gorm:"type:decimal(10,2); not null"`
+	Currency    string  `gorm:"size:50; not null"`
+}
+
+type Skus []Sku

internal/pkg/database/option/query.go

+package option
+
+import "gorm.io/gorm"
+
+// Query 查询选项
+type Query func(*gorm.DB) *gorm.DB
+
+// Where 条件查询
+func Where(condition interface{}, args ...interface{}) Query {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Where(condition, args...)
+	}
+}
+
+// Order 排序
+func Order(value interface{}) Query {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Order(value)
+	}
+}
+
+// Limit 限制数量
+func Limit(limit int) Query {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Limit(limit)
+	}
+}
+
+// Offset 偏移量
+func Offset(offset int) Query {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Offset(offset)
+	}
+}
+
+// Preload 预加载
+func Preload(query string, args ...interface{}) Query {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Preload(query, args...)
+	}
+}
+
+// Joins 关联查询
+func Joins(query string, args ...interface{}) Query {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Joins(query, args...)
+	}
+}
+
+// Select 选择字段
+func Select(query interface{}, args ...interface{}) Query {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Select(query, args...)
+	}
+}
+
+// Group 分组
+func Group(name string) Query {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Group(name)
+	}
+}
+
+// Having Having条件
+func Having(query interface{}, args ...interface{}) Query {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Having(query, args...)
+	}
+}

internal/pkg/database/repository/base.go

+package repository
+
+import (
+	"context"
+	"git.chillcy.com/golang/colorway/internal/pkg/database/option"
+	"gorm.io/gorm"
+)
+
+type BaseInterface interface {
+	AutoMigrate() error
+}
+
+// Base 基础仓储
+type Base[T any] struct {
+	db *gorm.DB
+}
+
+// NewBase 创建基础仓储
+func NewBase[T any](db *gorm.DB) *Base[T] {
+	return &Base[T]{db: db}
+}
+
+// Create 创建记录
+func (receiver *Base[T]) Create(ctx context.Context, entity *T) error {
+	return receiver.db.WithContext(ctx).Create(entity).Error
+}
+
+// GetByID 根据ID获取记录
+func (receiver *Base[T]) GetByID(ctx context.Context, id interface{}) (*T, error) {
+	var entity T
+	err := receiver.db.WithContext(ctx).First(&entity, id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &entity, nil
+}
+
+// Update 更新记录
+func (receiver *Base[T]) Update(ctx context.Context, entity *T) error {
+	return receiver.db.WithContext(ctx).Save(entity).Error
+}
+
+// Delete 删除记录
+func (receiver *Base[T]) Delete(ctx context.Context, id interface{}) error {
+	var entity T
+	return receiver.db.WithContext(ctx).Delete(&entity, id).Error
+}
+
+// List 查询列表
+func (receiver *Base[T]) List(ctx context.Context, opts ...option.Query) ([]*T, error) {
+	var entities []*T
+	query := receiver.db.WithContext(ctx)
+
+	for _, opt := range opts {
+		query = opt(query)
+	}
+
+	err := query.Find(&entities).Error
+	return entities, err
+}
+
+// Count 统计数量
+func (receiver *Base[T]) Count(ctx context.Context, opts ...option.Query) (int64, error) {
+	var count int64
+	query := receiver.db.WithContext(ctx).Model(new(T))
+
+	for _, opt := range opts {
+		query = opt(query)
+	}
+
+	err := query.Count(&count).Error
+	return count, err
+}
+
+// Paginate 分页查询
+func (receiver *Base[T]) Paginate(ctx context.Context, page, pageSize int, opts ...option.Query) (*PaginateResult[T], error) {
+	var entities []*T
+	var total int64
+
+	query := receiver.db.WithContext(ctx).Model(new(T))
+
+	// 应用查询条件
+	for _, opt := range opts {
+		query = opt(query)
+	}
+
+	// 获取总数
+	if err := query.Count(&total).Error; err != nil {
+		return nil, err
+	}
+
+	// 分页查询
+	offset := (page - 1) * pageSize
+	if err := query.Offset(offset).Limit(pageSize).Find(&entities).Error; err != nil {
+		return nil, err
+	}
+
+	return &PaginateResult[T]{
+		Data:     entities,
+		Total:    total,
+		Page:     page,
+		PageSize: pageSize,
+		Pages:    int((total + int64(pageSize) - 1) / int64(pageSize)),
+	}, nil
+}
+
+type PaginateResult[T any] struct {
+	Data     []*T
+	Total    int64
+	Page     int
+	PageSize int
+	Pages    int
+}
+
+func (receiver *Base[T]) AutoMigrate() error {
+	var t T
+	return receiver.db.AutoMigrate(&t)
+}
+
+func (receiver *Base[T]) getTableName(table any) (string, error) {
+	tableStmt := &gorm.Statement{DB: receiver.db}
+	err := tableStmt.Parse(table)
+	if err != nil {
+		return "", err
+	}
+	return tableStmt.Schema.Table, nil
+}

internal/pkg/database/repository/colorspu.go

+package repository
+
+import (
+	"git.chillcy.com/golang/colorway/internal/pkg/database/model"
+	"gorm.io/gorm"
+)
+
+type ColorSpuInterface interface {
+	BaseInterface
+}
+
+type ColorSpu struct {
+	*Base[model.ColorSpu]
+}
+
+func NewColorSpu(db *gorm.DB) *ColorSpu {
+	return &ColorSpu{
+		Base: NewBase[model.ColorSpu](db),
+	}
+}

internal/pkg/database/repository/completespu.go

+package repository
+
+import (
+	"git.chillcy.com/golang/colorway/internal/pkg/database/model"
+	"gorm.io/gorm"
+)
+
+type CompleteSpuInterface interface {
+	BaseInterface
+}
+
+type CompleteSpu struct {
+	*Base[model.CompleteSpu]
+}
+
+func NewCompleteSpu(db *gorm.DB) *CompleteSpu {
+	return &CompleteSpu{
+		Base: NewBase[model.CompleteSpu](db),
+	}
+}

internal/pkg/database/repository/sku.go

+package repository
+
+import (
+	"git.chillcy.com/golang/colorway/internal/pkg/database/model"
+	"gorm.io/gorm"
+)
+
+type SkuInterface interface {
+	BaseInterface
+}
+
+type Sku struct {
+	*Base[model.Sku]
+}
+
+func NewSku(db *gorm.DB) *Sku {
+	return &Sku{
+		Base: NewBase[model.Sku](db),
+	}
+}

internal/pkg/database/transaction/transaction.go

+package transaction
+
+import (
+	"context"
+	"gorm.io/gorm"
+)
+
+// Manager 事务管理器
+type Manager struct {
+	db *gorm.DB
+}
+
+// NewManager 创建事务管理器
+func NewManager(db *gorm.DB) *Manager {
+	return &Manager{db: db}
+}
+
+// WithTransaction 在事务中执行操作
+func (tm *Manager) WithTransaction(ctx context.Context, fn func(tx *gorm.DB) error) error {
+	return tm.db.WithContext(ctx).Transaction(fn)
+}
+
+// WithTransactionResult 在事务中执行操作并返回结果
+//func (tm *Manager) WithTransactionResult[T any](ctx context.Context, fn func(tx *gorm.DB) (T, error)) (T, error) {
+//	var result T
+//	err := tm.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+//		var err error
+//		result, err = fn(tx)
+//		return err
+//	})
+//	return result, err
+//}
+
+// UnitOfWork 工作单元
+type UnitOfWork struct {
+	tx *gorm.DB
+}
+
+// NewUnitOfWork 创建工作单元
+func (tm *Manager) NewUnitOfWork(ctx context.Context) *UnitOfWork {
+	return &UnitOfWork{
+		tx: tm.db.WithContext(ctx).Begin(),
+	}
+}
+
+// GetDB 获取事务数据库连接
+func (uow *UnitOfWork) GetDB() *gorm.DB {
+	return uow.tx
+}
+
+// Commit 提交事务
+func (uow *UnitOfWork) Commit() error {
+	return uow.tx.Commit().Error
+}
+
+// Rollback 回滚事务
+func (uow *UnitOfWork) Rollback() error {
+	return uow.tx.Rollback().Error
+}

internal/rpc/client/colorway/colorway.go

+// Code generated by goctl. DO NOT EDIT.
+// Source: colorway.proto
+
+package colorway
+
+import (
+	"context"
+
+	"git.chillcy.com/golang/colorway/internal/rpc/pb/colorway"
+
+	"github.com/zeromicro/go-zero/zrpc"
+	"google.golang.org/grpc"
+)
+
+type (
+	Request  = colorway.Request
+	Response = colorway.Response
+
+	Colorway interface {
+		Ping(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
+	}
+
+	defaultColorway struct {
+		cli zrpc.Client
+	}
+)
+
+func NewColorway(cli zrpc.Client) Colorway {
+	return &defaultColorway{
+		cli: cli,
+	}
+}
+
+func (m *defaultColorway) Ping(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	client := colorway.NewColorwayClient(m.cli.Conn())
+	return client.Ping(ctx, in, opts...)
+}

internal/rpc/colorway.go

+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"git.chillcy.com/golang/colorway/internal/rpc/internal/config"
+	colorwayServer "git.chillcy.com/golang/colorway/internal/rpc/internal/server/colorway"
+	"git.chillcy.com/golang/colorway/internal/rpc/internal/svc"
+	"git.chillcy.com/golang/colorway/internal/rpc/pb/colorway"
+
+	"github.com/zeromicro/go-zero/core/conf"
+	"github.com/zeromicro/go-zero/core/service"
+	"github.com/zeromicro/go-zero/zrpc"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/reflection"
+)
+
+var configFile = flag.String("f", "internal/rpc/etc/dev.yaml", "the config file")
+
+func main() {
+	flag.Parse()
+
+	var c config.Config
+	conf.MustLoad(*configFile, &c)
+	ctx := svc.NewServiceContext(c)
+
+	s := zrpc.MustNewServer(c.RpcServerConf, func(grpcServer *grpc.Server) {
+		colorway.RegisterColorwayServer(grpcServer, colorwayServer.NewColorwayServer(ctx))
+
+		if c.Mode == service.DevMode || c.Mode == service.TestMode {
+			reflection.Register(grpcServer)
+		}
+	})
+	defer s.Stop()
+
+	fmt.Printf("Starting rpc server at %s...\n", c.ListenOn)
+	s.Start()
+}

internal/rpc/colorway.proto

+syntax = "proto3";
+
+package colorway;
+option go_package="./colorway";
+
+message Request {
+  string ping = 1;
+}
+
+message Response {
+  string pong = 1;
+}
+
+service Colorway {
+  rpc Ping(Request) returns(Response);
+}

internal/rpc/etc/colorway.yaml

+Name: colorway.rpc
+ListenOn: 0.0.0.0:8080
+Etcd:
+  Hosts:
+  - 127.0.0.1:2379
+  Key: colorway.rpc

internal/rpc/etc/dev.yaml

+Name: colorway.rpc
+ListenOn: 0.0.0.0:5200
+Mode: dev

internal/rpc/generate.go

+package main
+
+//go:generate goctl rpc protoc colorway.proto --go_out=./pb --go-grpc_out=./pb --zrpc_out=. --client=true -m

internal/rpc/internal/config/config.go

+package config
+
+import "github.com/zeromicro/go-zero/zrpc"
+
+type Config struct {
+	zrpc.RpcServerConf
+}

internal/rpc/internal/logic/colorway/pinglogic.go

+package colorwaylogic
+
+import (
+	"context"
+
+	"git.chillcy.com/golang/colorway/internal/rpc/internal/svc"
+	"git.chillcy.com/golang/colorway/internal/rpc/pb/colorway"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type PingLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewPingLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PingLogic {
+	return &PingLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *PingLogic) Ping(in *colorway.Request) (*colorway.Response, error) {
+	// todo: add your logic here and delete this line
+
+	return &colorway.Response{}, nil
+}

internal/rpc/internal/server/colorway/colorwayserver.go

+// Code generated by goctl. DO NOT EDIT.
+// Source: colorway.proto
+
+package server
+
+import (
+	"context"
+
+	"git.chillcy.com/golang/colorway/internal/rpc/internal/logic/colorway"
+	"git.chillcy.com/golang/colorway/internal/rpc/internal/svc"
+	"git.chillcy.com/golang/colorway/internal/rpc/pb/colorway"
+)
+
+type ColorwayServer struct {
+	svcCtx *svc.ServiceContext
+	colorway.UnimplementedColorwayServer
+}
+
+func NewColorwayServer(svcCtx *svc.ServiceContext) *ColorwayServer {
+	return &ColorwayServer{
+		svcCtx: svcCtx,
+	}
+}
+
+func (s *ColorwayServer) Ping(ctx context.Context, in *colorway.Request) (*colorway.Response, error) {
+	l := colorwaylogic.NewPingLogic(ctx, s.svcCtx)
+	return l.Ping(in)
+}

internal/rpc/internal/svc/servicecontext.go

+package svc
+
+import (
+	"git.chillcy.com/golang/chillcy/pkg/etcd"
+	"git.chillcy.com/golang/colorway/internal/pkg/database"
+	"git.chillcy.com/golang/colorway/internal/rpc/internal/config"
+)
+
+type ServiceContext struct {
+	Config          config.Config
+	DatabaseManager *database.Manager
+}
+
+func NewServiceContext(c config.Config) *ServiceContext {
+	etcd.Init(etcd.Env(c.Mode))
+	// todo dsn etcd
+	dsn := "root:root@tcp(127.0.0.1:3306)/colorway?charset=utf8mb4&collation=utf8mb4_unicode_ci&parseTime=true&loc=Local"
+	manager, err := database.NewManager(dsn)
+	if err != nil {
+		panic(err)
+	}
+	return &ServiceContext{
+		Config:          c,
+		DatabaseManager: manager,
+	}
+}

internal/rpc/pb/colorway/colorway.pb.go

+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.32.0
+// 	protoc        v3.19.4
+// source: colorway.proto
+
+package colorway
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type Request struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Ping string `protobuf:"bytes,1,opt,name=ping,proto3" json:"ping,omitempty"`
+}
+
+func (x *Request) Reset() {
+	*x = Request{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_colorway_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Request) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Request) ProtoMessage() {}
+
+func (x *Request) ProtoReflect() protoreflect.Message {
+	mi := &file_colorway_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Request.ProtoReflect.Descriptor instead.
+func (*Request) Descriptor() ([]byte, []int) {
+	return file_colorway_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *Request) GetPing() string {
+	if x != nil {
+		return x.Ping
+	}
+	return ""
+}
+
+type Response struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Pong string `protobuf:"bytes,1,opt,name=pong,proto3" json:"pong,omitempty"`
+}
+
+func (x *Response) Reset() {
+	*x = Response{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_colorway_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *Response) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Response) ProtoMessage() {}
+
+func (x *Response) ProtoReflect() protoreflect.Message {
+	mi := &file_colorway_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Response.ProtoReflect.Descriptor instead.
+func (*Response) Descriptor() ([]byte, []int) {
+	return file_colorway_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *Response) GetPong() string {
+	if x != nil {
+		return x.Pong
+	}
+	return ""
+}
+
+var File_colorway_proto protoreflect.FileDescriptor
+
+var file_colorway_proto_rawDesc = []byte{
+	0x0a, 0x0e, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x77, 0x61, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x12, 0x08, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x77, 0x61, 0x79, 0x22, 0x1d, 0x0a, 0x07, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x69, 0x6e, 0x67, 0x22, 0x1e, 0x0a, 0x08, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x6e, 0x67, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x6f, 0x6e, 0x67, 0x32, 0x39, 0x0a, 0x08, 0x43, 0x6f, 0x6c,
+	0x6f, 0x72, 0x77, 0x61, 0x79, 0x12, 0x2d, 0x0a, 0x04, 0x50, 0x69, 0x6e, 0x67, 0x12, 0x11, 0x2e,
+	0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x77, 0x61, 0x79, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x12, 0x2e, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x77, 0x61, 0x79, 0x2e, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x42, 0x0c, 0x5a, 0x0a, 0x2e, 0x2f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x77,
+	0x61, 0x79, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_colorway_proto_rawDescOnce sync.Once
+	file_colorway_proto_rawDescData = file_colorway_proto_rawDesc
+)
+
+func file_colorway_proto_rawDescGZIP() []byte {
+	file_colorway_proto_rawDescOnce.Do(func() {
+		file_colorway_proto_rawDescData = protoimpl.X.CompressGZIP(file_colorway_proto_rawDescData)
+	})
+	return file_colorway_proto_rawDescData
+}
+
+var file_colorway_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_colorway_proto_goTypes = []interface{}{
+	(*Request)(nil),  // 0: colorway.Request
+	(*Response)(nil), // 1: colorway.Response
+}
+var file_colorway_proto_depIdxs = []int32{
+	0, // 0: colorway.Colorway.Ping:input_type -> colorway.Request
+	1, // 1: colorway.Colorway.Ping:output_type -> colorway.Response
+	1, // [1:2] is the sub-list for method output_type
+	0, // [0:1] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_colorway_proto_init() }
+func file_colorway_proto_init() {
+	if File_colorway_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_colorway_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Request); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_colorway_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*Response); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_colorway_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_colorway_proto_goTypes,
+		DependencyIndexes: file_colorway_proto_depIdxs,
+		MessageInfos:      file_colorway_proto_msgTypes,
+	}.Build()
+	File_colorway_proto = out.File
+	file_colorway_proto_rawDesc = nil
+	file_colorway_proto_goTypes = nil
+	file_colorway_proto_depIdxs = nil
+}

internal/rpc/pb/colorway/colorway_grpc.pb.go

+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.3.0
+// - protoc             v3.19.4
+// source: colorway.proto
+
+package colorway
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
+const _ = grpc.SupportPackageIsVersion7
+
+const (
+	Colorway_Ping_FullMethodName = "/colorway.Colorway/Ping"
+)
+
+// ColorwayClient is the client API for Colorway service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type ColorwayClient interface {
+	Ping(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
+}
+
+type colorwayClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewColorwayClient(cc grpc.ClientConnInterface) ColorwayClient {
+	return &colorwayClient{cc}
+}
+
+func (c *colorwayClient) Ping(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	out := new(Response)
+	err := c.cc.Invoke(ctx, Colorway_Ping_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// ColorwayServer is the server API for Colorway service.
+// All implementations must embed UnimplementedColorwayServer
+// for forward compatibility
+type ColorwayServer interface {
+	Ping(context.Context, *Request) (*Response, error)
+	mustEmbedUnimplementedColorwayServer()
+}
+
+// UnimplementedColorwayServer must be embedded to have forward compatible implementations.
+type UnimplementedColorwayServer struct {
+}
+
+func (UnimplementedColorwayServer) Ping(context.Context, *Request) (*Response, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
+}
+func (UnimplementedColorwayServer) mustEmbedUnimplementedColorwayServer() {}
+
+// UnsafeColorwayServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to ColorwayServer will
+// result in compilation errors.
+type UnsafeColorwayServer interface {
+	mustEmbedUnimplementedColorwayServer()
+}
+
+func RegisterColorwayServer(s grpc.ServiceRegistrar, srv ColorwayServer) {
+	s.RegisterService(&Colorway_ServiceDesc, srv)
+}
+
+func _Colorway_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(Request)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ColorwayServer).Ping(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Colorway_Ping_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ColorwayServer).Ping(ctx, req.(*Request))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// Colorway_ServiceDesc is the grpc.ServiceDesc for Colorway service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Colorway_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "colorway.Colorway",
+	HandlerType: (*ColorwayServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Ping",
+			Handler:    _Colorway_Ping_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "colorway.proto",
+}

pkg/model/generate.go

+package model
+
+//go:generate goctl model mysql