database

Documentation

Index

• Variables
• func RegisterDriver(name string, dr DriverRegister)
• func WithDefaults()
• type Builder
  • func NewBuilder[T interface{}](tx *gorm.DB, paginator Paginator[T]) *Builder[T]
  • func (b *Builder[T]) First(conds ...interface{}) (result T, err error)
  • func (b *Builder[T]) Get() (result []T, err error)
  • func (b *Builder[T]) Paginate(opts ...PaginateOptions) (*PageResult[T], error)
  • func (b *Builder[T]) Query(fn func(*gorm.DB) *gorm.DB) *Builder[T]
• type Config
• type ConnectionConfig
• type DriverRegister
  • func GetDriverRegister(name string) (DriverRegister, bool)
• type Injector
  • func (ij Injector) Injection(abs interface{}, last reflect.Value) (reflect.Value, error)
  • func (ij Injector) When(abs interface{}) bool
• type Logger
  • func NewLogger(logger *zap.Logger, level logger.LogLevel) *Logger
  • func (l *Logger) Error(_ context.Context, msg string, data ...interface{})
  • func (l *Logger) Info(_ context.Context, msg string, data ...interface{})
  • func (l *Logger) LogMode(level logger.LogLevel) logger.Interface
  • func (l *Logger) Trace(ctx context.Context, begin time.Time, ...)
  • func (l *Logger) Warn(_ context.Context, msg string, data ...interface{})
• type Model
  • func (m Model) Paginate() (map[string]interface{}, error)
• type PageMeta
• type PageParams
• type PageResult
  • func (pr *PageResult[T]) With(key string, data interface{}) *PageResult[T]
  • func (pr *PageResult[T]) WithOut(key string) *PageResult[T]
• type PaginateOptions
• type Paginator
  • func NewPaginator[T interface{}](params PageParams) Paginator[T]
  • func (p Paginator[T]) Paginate(tx *gorm.DB, opts ...PaginateOptions) (*PageResult[T], error)
• type RequestPageParams
  • func (r RequestPageParams) Page() int
  • func (r RequestPageParams) PerPage() int
• type Service
  • func NewService() *Service
  • func (s *Service) Lifetime(ioc container.Interface, request contracts.RequestContract)
  • func (s *Service) Register(app *framework.App) error

Variables

var (
	MaxIdelConns = 10
	MaxOpenConns = 100
	MaxLifeTime  = time.Hour
	MaxIdleTime  = time.Hour
)

var (
	DefaultPageSize = 15
	PageKey         = "page"
	PageSizeKey     = "per_page"
	PageParamsType  = reflection.InterfaceType[PageParams]()
)

var DestSliceType = reflect.TypeOf([]interface{}{})

var Migrator func(tx *gorm.DB)

var ModelType = reflect.TypeOf(Model{})

Functions

func RegisterDriver

func RegisterDriver(name string, dr DriverRegister)

RegisterDriver register db driver

func WithDefaults

func WithDefaults()

Types

type Builder

type Builder[T interface{}] struct {
	*gorm.DB
	Paginator Paginator[T]
}

func NewBuilder

func NewBuilder[T interface{}](tx *gorm.DB, paginator Paginator[T]) *Builder[T]

func (*Builder[T]) First

func (b *Builder[T]) First(conds ...interface{}) (result T, err error)

func (*Builder[T]) Get

func (b *Builder[T]) Get() (result []T, err error)

func (*Builder[T]) Paginate

func (b *Builder[T]) Paginate(opts ...PaginateOptions) (*PageResult[T], error)

func (*Builder[T]) Query

func (b *Builder[T]) Query(fn func(*gorm.DB) *gorm.DB) *Builder[T]

type Config

type Config struct {
	Default     string                       `yaml:"default" env:"DB_CONNECTION"`
	Connections map[string]*ConnectionConfig `yaml:"connections"`
	//ImplicitInjection: whether injection model to request handler implicit
	//  usage:
	//      w.Get("/users/:user", func(user models.User) models.User {
	//			return user
	//      })
	//
	ImplicitInjection bool   `yaml:"implicit_injection"`
	AuthMigrate       bool   `yaml:"migrate"`
	LogChannel        string `yaml:"log_channel"`
	WithForeignKey    bool   `yaml:"with_foreign_key" default:"false"`
	WithMigrationLog  bool   `yaml:"with_migration_log" default:"false"`
}

type ConnectionConfig

type ConnectionConfig struct {
	Driver     string `yaml:"driver" default:"mysql"`
	DSN        string `yaml:"dsn"`
	LogChannel string `yaml:"log_channel"`
	LogLevel   string `yaml:"log_level" default:"info"`
}

type DriverRegister

type DriverRegister func(dsn string) gorm.Dialector

func GetDriverRegister

func GetDriverRegister(name string) (DriverRegister, bool)

GetDriverRegister: get registerd driver

type Injector

type Injector struct {
	// contains filtered or unexported fields
}

func (Injector) Injection

func (ij Injector) Injection(abs interface{}, last reflect.Value) (reflect.Value, error)

func (Injector) When

func (ij Injector) When(abs interface{}) bool

type Logger

type Logger struct {
	SlowThreshold time.Duration
	// contains filtered or unexported fields
}

func NewLogger

func NewLogger(logger *zap.Logger, level logger.LogLevel) *Logger

func (*Logger) Error

func (l *Logger) Error(_ context.Context, msg string, data ...interface{})

func (*Logger) Info

func (l *Logger) Info(_ context.Context, msg string, data ...interface{})

func (*Logger) LogMode

func (l *Logger) LogMode(level logger.LogLevel) logger.Interface

func (*Logger) Trace

func (l *Logger) Trace(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error)

func (*Logger) Warn

func (l *Logger) Warn(_ context.Context, msg string, data ...interface{})

type Model

type Model struct {
	*gorm.DB  `gorm:"-" json:"-" msgpack:"-"`
	Paginator *gormdb.Paginator `gorm:"-" json:"-"  msgpack:"-"`
	Dest      interface{}       `gorm:"-" json:"-"  msgpack:"-"`
	DestSlice interface{}       `gorm:"-" json:"-"  msgpack:"-"`
}

func (Model) Paginate

func (m Model) Paginate() (map[string]interface{}, error)

type PageMeta

type PageMeta struct {
	Total    int64 `json:"total"`
	PerPage  int   `json:"per_page"`
	Page     int   `json:"page"`
	LastPage int   `json:"last_page"`
	From     int   `json:"from"`
	To       int   `json:"to"`
}

type PageParams

type PageParams interface {
	Page() int
	PerPage() int
}

type PageResult

type PageResult[T interface{}] struct {
	Meta  PageMeta               `json:"meta"`
	Data  []T                    `json:"data"`
	Extra map[string]interface{} `json:"extra,omitempty"`
}

func (*PageResult[T]) With

func (pr *PageResult[T]) With(key string, data interface{}) *PageResult[T]

func (*PageResult[T]) WithOut

func (pr *PageResult[T]) WithOut(key string) *PageResult[T]

type PaginateOptions

type PaginateOptions struct {
	AggTableScope func(tx *gorm.DB) *gorm.DB
}

type Paginator

type Paginator[T interface{}] struct {
	Params PageParams
}

func NewPaginator

func NewPaginator[T interface{}](params PageParams) Paginator[T]

func (Paginator[T]) Paginate

func (p Paginator[T]) Paginate(tx *gorm.DB, opts ...PaginateOptions) (*PageResult[T], error)

type RequestPageParams

type RequestPageParams struct {
	// contains filtered or unexported fields
}

func (RequestPageParams) Page

func (r RequestPageParams) Page() int

func (RequestPageParams) PerPage

func (r RequestPageParams) PerPage() int

type Service

type Service struct {
	// contains filtered or unexported fields
}

Service of database

func NewService

func NewService() *Service

func (*Service) Lifetime

func (s *Service) Lifetime(ioc container.Interface, request contracts.RequestContract)

Lifetime container callback usually register request lifetime instance to IoC-Container (per-request unique) this function will run before every request

func (*Service) Register

func (s *Service) Register(app *framework.App) error

Register service when app starting, before http server start you can configure service, initialize global vars etc. running at main goroutine