generator

package
v0.0.0-...-2c23381 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 3, 2025 License: MIT Imports: 27 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ApplyMainFunctionDirTemplate = "/cmd/apply"
	ApplyMainFunctionTemplate    = `` /* 1776-byte string literal not displayed */

)
View Source 
const (
	ConfigDir      = "configs"
	ConfigFile     = "app"
	ConfigTemplate = `` /* 1280-byte string literal not displayed */

)
View Source 
const (
	ControllerDir      = "internal/controllers"
	ControllerTemplate = `package {{ .Package }}
{{- if gt (len .Imports) 0 }}

import (
{{- range .Imports}}
	{{.}}
{{- end}}
)
{{- end }}

type {{ .Name }}Request struct {
	{{- if not .RequestFields}} // Add your request data {{ else }}
	{{- range .RequestFields}}
	{{ .Field }} {{ .Type }} {{ .Tag }}
	{{- end }}
	{{- end }}
}

type {{ .Name }}Response struct {
	{{- if not .ResponseFields}} // Add your response data {{ else }}
	{{- range .ResponseFields}}
	{{ .Field }} {{ .Type }} {{ .Tag }}
	{{- end}}
	{{- end }}
}

type {{ .Name }}Controller struct {
	raiden.ControllerBase
	Http	string ` + "{{ .HttpTag }}" + `
	Payload	*{{ .Name }}Request
	Result	{{ .Name }}Response
}

func (c *{{ .Name }}Controller) Get(ctx raiden.Context) error {
	{{ .DefaultAction }}
	return ctx.SendJson(c.Result)
}
`
)
View Source 
const (
	ImportMainFunctionDirTemplate = "/cmd/import"
	ImportMainFunctionTemplate    = `` /* 2068-byte string literal not displayed */

)
View Source 
const (
	JobRegisterFilename = "jobs.go"
	JobRegisterDir      = "internal/bootstrap"
	JobDir              = "internal/jobs"
	JobRegisterTemplate = `` /* 274-byte string literal not displayed */

)
View Source 
const (
	LibRegisterFilename = "libs.go"
	LibRegisterDir      = "internal/bootstrap"
	LibDir              = "internal/libs"
	LibRegisterTemplate = `` /* 283-byte string literal not displayed */

)
View Source 
const (
	MainFunctionDirTemplate = "/cmd/%s"
	MainFunctionTemplate    = `` /* 473-byte string literal not displayed */

)
View Source 
const (
	ModelDir      = "internal/models"
	ModelTemplate = `package {{ .Package }}
{{- if gt (len .Imports) 0 }}

import (
{{- range .Imports}}
	"{{.}}"
{{- end}}
)
{{- end }}

type {{ .StructName }} struct {
	db.ModelBase

{{- range .Columns }}
	{{ .Name | ToGoIdentifier }} {{ .Type }} ` + "`{{ .Tag }}`" + `
{{- end }}

	// Table information
	Metadata string ` + "`json:\"-\" schema:\"{{ .Schema}}\" tableName:\"{{ .TableName }}\" rlsEnable:\"{{ .RlsEnable }}\" rlsForced:\"{{ .RlsForced }}\"`" + `

	// Access control
	Acl string ` + "`json:\"-\" {{ .RlsTag }}`" + `

{{- if gt (len .Relations) 0 }}

	// Relations
{{- end }}
{{- range .Relations }}
	{{ .Table | ToGoIdentifier }} {{ .Type }} ` + "`{{ .Tag }}`" + `
{{- end }}
}
`
)
View Source 
const (
	ModelRegisterFilename = "models.go"
	ModelRegisterDir      = "internal/bootstrap"
	ModelRegisterTemplate = `` /* 263-byte string literal not displayed */

)
View Source 
const (
	RestControllerDir      = "internal/controllers/rest/v1"
	RestControllerTemplate = `` /* 242-byte string literal not displayed */

)
View Source 
const (
	RoleDir      = "internal/roles"
	RoleTemplate = `` /* 1603-byte string literal not displayed */

)
View Source 
const (
	RoleRegisterFilename = "roles.go"
	RoleRegisterDir      = "internal/bootstrap"
	RoleRegisterTemplate = `` /* 258-byte string literal not displayed */

)
View Source 
const (
	RouterFilename = "route.go"
	RouterDir      = "internal/bootstrap"
	RouterTemplate = `` /* 700-byte string literal not displayed */

)
View Source 
const (
	RpcDir      = "internal/rpc"
	RpcTemplate = `package {{ .Package }}
{{- if gt (len .Imports) 0 }}

import (
{{- range .Imports}}
	{{.}}
{{- end}}
)
{{- end }}

type {{ .Name }}Params struct {
	{{- range .Params }}
	{{ .Field }} {{ .Type }} ` + "`{{ .Tag }}`" + `
	{{- end }}
}

{{- if gt (len .ReturnColumn) 0 }}
type {{ .Name }}Item struct {
	{{- range .ReturnColumn }}
	{{ .Field }} {{ .Type }} ` + "`{{ .Tag }}`" + `
	{{- end }}
}

type {{ .Name }}Result {{ if .IsReturnArr }}[]{{ end }}{{ .Name }}Item
{{- else }}
type {{ .Name }}Result {{ if .IsReturnArr }}[]{{ end }}{{ .ReturnDecl }}
{{- end }}

type {{ .Name }} struct {
	raiden.RpcBase
	Params   *{{ .Name }}Params ` + "`json:\"-\"`" + `
	Return   {{ .Name }}Result ` + "`json:\"-\"`" + `
}

func (r *{{ .Name }}) GetName() string {
	return "{{ .Name | ToSnakeCase }}"
}

{{- if ne .Schema "public" }}

func (r *{{.Name }}) GetSchema() string {
	return "{{ .Schema }}"
}

{{- end }}
{{- if not .UseParamPrefix }}

func  (r *{{.Name }}) UseParamPrefix() bool {
	return false
}

{{- end }}
{{- if ne .Security "RpcSecurityTypeInvoker" }}

func (r *{{.Name }}) GetSecurity() raiden.RpcSecurityType {
	return raiden.{{ .Security }}
}
{{- end }}
{{- if ne .Behavior "RpcBehaviorVolatile" }}

func (r *{{.Name }}) GetBehavior() raiden.RpcBehaviorType {
	return raiden.{{ .Behavior }}
}
{{- end }}

func (r *{{.Name }}) GetReturnType() raiden.RpcReturnDataType {
	return raiden.{{ .ReturnType }}
}
{{- if ne .Models "" }}

func (r *{{ .Name }}) BindModels() {
	{{ .Models }}
}
{{- end }}

func (r *{{ .Name }}) GetRawDefinition() string {
	return ` + "`{{ .Definition }}`" + `
}`
)
View Source 
const (
	RpcRegisterFilename = "rpc.go"
	RpcRegisterDir      = "internal/bootstrap"
	RpcRegisterTemplate = `` /* 251-byte string literal not displayed */

)
View Source 
const (
	StorageDir      = "internal/storages"
	StorageTemplate = `package {{ .Package }}
{{- if gt (len .Imports) 0 }}

import (
{{- range .Imports}}
	{{.}}
{{- end}}
)
{{- end }}

type {{ .StructName | ToGoIdentifier }} struct {
	raiden.BucketBase

	// Access control
	Acl string ` + "`json:\"-\" {{ .ObjectAcl }}`" + `
}

func (r *{{ .StructName | ToGoIdentifier }}) Name() string {
	return "{{ .Name }}"
}

{{- if .Public }}
func (r *{{ .StructName | ToGoIdentifier }}) Public() bool {
	return {{ .Public }}
}
{{- end }}
{{- if ne .FileSizeLimit 0}}

func (r *{{ .StructName | ToGoIdentifier }}) FileSizeLimit() int {
	return {{ .FileSizeLimit }} // bytes
}
{{- end }}
{{- if ne .AllowedMimeTypes "" }}
func (r *{{ .StructName | ToGoIdentifier }}) AllowedMimeTypes() []string {
	return {{ .AllowedMimeTypes }}
}
{{- end }}
`
)
View Source 
const (
	StorageRegisterFilename = "storages.go"
	StorageRegisterDir      = "internal/bootstrap"
	StorageRegisterTemplate = `` /* 271-byte string literal not displayed */

)
View Source 
const (
	SubscriberRegisterFilename = "subscribers.go"
	SubscriberRegisterDir      = "internal/bootstrap"
	SubscriberDir              = "internal/subscribers"
	SubscriberRegisterTemplate = `` /* 302-byte string literal not displayed */

)
View Source 
const (
	TypeDir      = "internal/types"
	TypeTemplate = `` /* 631-byte string literal not displayed */

)
View Source 
const (
	TypeRegisterFilename = "types.go"
	TypeRegisterDir      = "internal/bootstrap"
	TypeRegisterTemplate = `` /* 259-byte string literal not displayed */

)
View Source 
const (
	JobTemplate = `` /* 948-byte string literal not displayed */

)

Variables

View Source 
var ApplyLogger hclog.Logger = logger.HcLog().Named("generator.apply")
View Source 
var ConfigLogger hclog.Logger = logger.HcLog().Named("generator.config")
View Source 
var ControllerLogger hclog.Logger = logger.HcLog().Named("generator.controller")
View Source 
var GeneratorLogger hclog.Logger = logger.HcLog().Named("generator")
View Source 
var ImportLogger hclog.Logger = logger.HcLog().Named("generator.import")
View Source 
var JobLogger hclog.Logger = logger.HcLog().Named("generator.Job")
View Source 
var JobRegisterLogger hclog.Logger = logger.HcLog().Named("generator.job_register")
View Source 
var LibRegisterLogger hclog.Logger = logger.HcLog().Named("generator.lib_register")
View Source 
var MainLogger hclog.Logger = logger.HcLog().Named("generator.main")
View Source 
var ModelLogger hclog.Logger = logger.HcLog().Named("generator.model")
View Source 
var ModelRegisterLogger hclog.Logger = logger.HcLog().Named("generator.model_register")
View Source 
var RestControllerLogger hclog.Logger = logger.HcLog().Named("generator.rest_controller")
View Source 
var RoleLogger hclog.Logger = logger.HcLog().Named("generator.role")
View Source 
var RoleRegisterLogger hclog.Logger = logger.HcLog().Named("generator.role_register")
View Source 
var RouterLogger hclog.Logger = logger.HcLog().Named("generator.router")
View Source 
var RpcLogger hclog.Logger = logger.HcLog().Named("generator.rpc")
View Source 
var RpcRegisterLogger hclog.Logger = logger.HcLog().Named("generator.rpc_register")
View Source 
var StorageLogger hclog.Logger = logger.HcLog().Named("generator.storage")
View Source 
var StorageRegisterLogger hclog.Logger = logger.HcLog().Named("generator.storage_register")
View Source 
var SubscriberRegisterLogger hclog.Logger = logger.HcLog().Named("generator.subscriber_register")
View Source 
var TypeLogger hclog.Logger = logger.HcLog().Named("generator.type")
View Source 
var TypeRegisterLogger hclog.Logger = logger.HcLog().Named("generator.type_register")

Functions

func BuildRelationFields 

func BuildRelationFields(table objects.Table, relations []state.Relation) (mappedRelations []state.Relation)

func BuildRelationTag 

func BuildRelationTag(r *state.Relation) string

func BuildRlsTag 

func BuildRlsTag(rlsList objects.Policies, name string, rlsType supabase.RlsType) string

func CreateInternalFolder 

func CreateInternalFolder(basePath string) (err error)

func DefaultWriter 

func DefaultWriter(filePath string) (*os.File, error)

----- Generate functionality -----

func ExtractRpcParam 

func ExtractRpcParam(fn *objects.Function) (params []raiden.RpcParam, usePrefix bool, err error)

func ExtractRpcTable 

func ExtractRpcTable(def string) (string, map[string]*RpcScannedTable, error)

code for detect table in query and return array of object contain table name, table aliases and relation

func Generate 

func Generate(input GenerateInput, writer io.Writer) error

func GenerateApplyMainFunction 

func GenerateApplyMainFunction(basePath string, config *raiden.Config, generateFn GenerateFn) error

func GenerateArrayDeclaration 

func GenerateArrayDeclaration(value reflect.Value, withoutQuote bool) string

func GenerateConfig 

func GenerateConfig(basePath string, config *raiden.Config, generateFn GenerateFn) error

func GenerateController 

func GenerateController(file string, data GenerateControllerData, generateFn GenerateFn) error

----- Generate controller -----

func GenerateHelloWorldController 

func GenerateHelloWorldController(basePath string, generateFn GenerateFn) (err error)

----- Generate hello world -----

func GenerateHelloWorldJob 

func GenerateHelloWorldJob(basePath string, generateFn GenerateFn) (err error)

----- Generate hello world -----

func GenerateImportMainFunction 

func GenerateImportMainFunction(basePath string, config *raiden.Config, generateFn GenerateFn) error

func GenerateJob 

func GenerateJob(file string, data GenerateJobData, generateFn GenerateFn) error

----- Generate Job -----

func GenerateJobRegister 

func GenerateJobRegister(basePath string, projectName string, generateFn GenerateFn) error

func GenerateLibRegister 

func GenerateLibRegister(basePath string, projectName string, generateFn GenerateFn) error

func GenerateMainFunction 

func GenerateMainFunction(basePath string, config *raiden.Config, generateFn GenerateFn) error

func GenerateModel 

func GenerateModel(folderPath string, projectName string, input *GenerateModelInput, mapDataType map[string]objects.Type, generateFn GenerateFn) error

func GenerateModelRegister 

func GenerateModelRegister(basePath string, projectName string, generateFn GenerateFn) error

func GenerateModels 

func GenerateModels(basePath string, projectName string, tables []*GenerateModelInput, mapDataType map[string]objects.Type, generateFn GenerateFn) (err error)

func GenerateRestController 

func GenerateRestController(controllerPath string, projectName string, table *objects.Table, generateFn GenerateFn) error

func GenerateRestControllers 

func GenerateRestControllers(basePath string, projectName string, tables []*GenerateModelInput, generateFn GenerateFn) (err error)

----- Generate rest controller -----

func GenerateRole 

func GenerateRole(folderPath string, role objects.Role, generateFn GenerateFn) error

func GenerateRoleRegister 

func GenerateRoleRegister(basePath string, projectName string, generateFn GenerateFn) error

func GenerateRoles 

func GenerateRoles(basePath string, roles []objects.Role, generateFn GenerateFn) (err error)

func GenerateRoute 

func GenerateRoute(basePath string, projectName string, mode raiden.Mode, generateFn GenerateFn) error

Generate route configuration file

func GenerateRpc 

func GenerateRpc(basePath string, projectName string, functions []objects.Function, tables []objects.Table, generateFn GenerateFn) (err error)

func GenerateRpcRegister 

func GenerateRpcRegister(basePath string, projectName string, generateFn GenerateFn) error

func GenerateStorage 

func GenerateStorage(folderPath string, storage *GenerateStorageInput, generateFn GenerateFn) error

func GenerateStorages 

func GenerateStorages(basePath string, storages []*GenerateStorageInput, generateFn GenerateFn) (err error)

func GenerateStoragesRegister 

func GenerateStoragesRegister(basePath string, projectName string, generateFn GenerateFn) error

func GenerateSubscriberRegister 

func GenerateSubscriberRegister(basePath string, projectName string, generateFn GenerateFn) error

func GenerateType 

func GenerateType(folderPath string, t objects.Type, generateFn GenerateFn) error

func GenerateTypeRegister 

func GenerateTypeRegister(basePath string, projectName string, generateFn GenerateFn) error

func GenerateTypes 

func GenerateTypes(basePath string, types []objects.Type, generateFn GenerateFn) (err error)

func RpcNormalizeTableAliases 

func RpcNormalizeTableAliases(mapTables map[string]*RpcScannedTable) error

func WalkScanJob 

func WalkScanJob(jobDir string) ([]string, error)

func WalkScanModel 

func WalkScanModel(modelDir string) ([]string, error)

func WalkScanRole 

func WalkScanRole(roleDir string) ([]string, error)

func WalkScanRpc 

func WalkScanRpc(rpcDir string) ([]string, error)

func WalkScanStorage 

func WalkScanStorage(storageDir string) ([]string, error)

func WalkScanSubscriber 

func WalkScanSubscriber(subscriberDir string) ([]string, error)

func WalkScanType 

func WalkScanType(typeDir string) ([]string, error)

Types

type ControllerFieldAttribute 

type ControllerFieldAttribute struct {
	Field string
	Type  string
	Tag   string
}

----- Define type, variable and constant -----

type ExtractRpcDataResult 

type ExtractRpcDataResult struct {
	Rpc                raiden.RpcBase
	MapScannedTable    map[string]*RpcScannedTable
	OriginalReturnType string
	UseParamPrefix     bool
}

----- Define type, variable and constant -----

func ExtractRpcFunction 

func ExtractRpcFunction(fn *objects.Function, tables []objects.Table) (result ExtractRpcDataResult, err error)

func (*ExtractRpcDataResult) GetBehavior 

func (r *ExtractRpcDataResult) GetBehavior() (behavior string)

func (*ExtractRpcDataResult) GetModelDecl 

func (r *ExtractRpcDataResult) GetModelDecl() (modelDecl string)

func (*ExtractRpcDataResult) GetParams 

func (r *ExtractRpcDataResult) GetParams(mapImports map[string]bool) (columns []RpcColumn, err error)

func (*ExtractRpcDataResult) GetReturn 

func (r *ExtractRpcDataResult) GetReturn(mapImports map[string]bool) (returnDecl string, returnColumns []RpcColumn, isReturnArr bool, err error)

func (*ExtractRpcDataResult) GetSecurity 

func (r *ExtractRpcDataResult) GetSecurity() (security string)

type FileWriter 

type FileWriter struct {
	FilePath string
	// contains filtered or unexported fields
}

func (*FileWriter) Close 

func (fw *FileWriter) Close() error

Close closes the underlying file

func (*FileWriter) Write 

func (fw *FileWriter) Write(p []byte) (int, error)

type FoundRoute 

type FoundRoute struct {
	Import struct {
		Alias string
		Path  string
	}
	Package string
	Name    string
	Type    string
	Path    string
	Methods []string
	Model   string
	Storage string
}

----- Define type, variable and constant -----

type GenerateApplyMainFunctionData 

type GenerateApplyMainFunctionData struct {
	Package string
	Imports []string
	Mode    raiden.Mode
}

----- Define type, variable and constant -----

type GenerateControllerData 

type GenerateControllerData struct {
	DefaultAction  string
	HttpTag        string
	Imports        []string
	Name           string
	Package        string
	RequestFields  []ControllerFieldAttribute
	ResponseFields []ControllerFieldAttribute
}

type GenerateFn 

type GenerateFn func(input GenerateInput, writer io.Writer) error

type GenerateImportMainFunctionData 

type GenerateImportMainFunctionData struct {
	Package string
	Imports []string
	Mode    raiden.Mode
}

----- Define type, variable and constant -----

type GenerateInput 

type GenerateInput struct {
	BindData     any
	Template     string
	TemplateName string
	OutputPath   string
	FuncMap      []template.FuncMap
}

----- Define type, variable and constant -----

func CreateRouteInput 

func CreateRouteInput(projectName string, routePath string, routes []GenerateRouteItem) (input GenerateInput, err error)

type GenerateJobData 

type GenerateJobData struct {
	Imports           []string
	JobName           string
	SnakeCasedJobName string
	Package           string
}

type GenerateLibItem 

type GenerateLibItem struct {
	Type  string
	Alias string
}

----- Define type, variable and constant -----

func WalkScanLib 

func WalkScanLib(libDir string) ([]GenerateLibItem, error)

type GenerateLibItemData 

type GenerateLibItemData struct {
	Imports []string
	Package string
	Libs    []GenerateLibItem
}

----- Define type, variable and constant -----

type GenerateMainFunctionData 

type GenerateMainFunctionData struct {
	Package string
	Imports []string
}

----- Define type, variable and constant -----

type GenerateModelColumn 

type GenerateModelColumn struct {
	Name string
	Type string
	Tag  string
}

----- Define type, variable and constant -----

func MapTableAttributes 

func MapTableAttributes(projectName string, table objects.Table, mapDataType map[string]objects.Type, validationTags state.ModelValidationTag) (columns []GenerateModelColumn, importsPath []string)

map table to column, map pg type to go type and get dependency import path

type GenerateModelData 

type GenerateModelData struct {
	Columns    []GenerateModelColumn
	Imports    []string
	Package    string
	Relations  []state.Relation
	RlsTag     string
	RlsEnable  bool
	RlsForced  bool
	StructName string
	Schema     string
	TableName  string
}

----- Define type, variable and constant -----

type GenerateModelInput 

type GenerateModelInput struct {
	Table          objects.Table
	Relations      []state.Relation
	Policies       objects.Policies
	ValidationTags state.ModelValidationTag
}

----- Define type, variable and constant -----

type GenerateRegisterJobData 

type GenerateRegisterJobData struct {
	Imports []string
	Package string
	Jobs    []string
}

----- Define type, variable and constant -----

type GenerateRegisterModelData 

type GenerateRegisterModelData struct {
	Imports []string
	Package string
	Models  []string
}

----- Define type, variable and constant -----

type GenerateRegisterRoleData 

type GenerateRegisterRoleData struct {
	Imports []string
	Package string
	Roles   []string
}

----- Define type, variable and constant -----

type GenerateRegisterRpcData 

type GenerateRegisterRpcData struct {
	Imports []string
	Package string
	Rpc     []string
}

----- Define type, variable and constant -----

type GenerateRegisterStorageData 

type GenerateRegisterStorageData struct {
	Imports  []string
	Package  string
	Storages []string
}

----- Define type, variable and constant -----

type GenerateRegisterSubscriberData 

type GenerateRegisterSubscriberData struct {
	Imports     []string
	Package     string
	Subscribers []string
}

----- Define type, variable and constant -----

type GenerateRegisterTypeData 

type GenerateRegisterTypeData struct {
	Imports []string
	Package string
	Types   []string
}

----- Define type, variable and constant -----

type GenerateRestControllerData 

type GenerateRestControllerData struct {
	Imports []string
	Model   string
	Package string
}

----- Define type, variable and constant -----

type GenerateRoleData 

type GenerateRoleData struct {
	Imports                []string
	Package                string
	Name                   string
	DefaultLimitConnection int
	ConnectionLimit        int
	InheritRole            bool
	IsReplicationRole      bool
	IsSuperuser            bool
	CanBypassRls           bool
	CanCreateDB            bool
	CanCreateRole          bool
	CanLogin               bool
	ValidUntil             string
}

----- Define type, variable and constant -----

type GenerateRouteItem 

type GenerateRouteItem struct {
	Import struct {
		Alias string
		Path  string
	}
	Type       string
	Path       string
	Methods    string
	Controller string
	Model      string
	Storage    string
}

----- Define type, variable and constant -----

func BuildRouteItem 

func BuildRouteItem(mode raiden.Mode, foundRoute *FoundRoute) (GenerateRouteItem, error)

func WalkScanControllers 

func WalkScanControllers(mode raiden.Mode, controllerPath string) ([]GenerateRouteItem, error)

type GenerateRouterData 

type GenerateRouterData struct {
	Imports []string
	Package string
	Routes  []GenerateRouteItem
}

----- Define type, variable and constant -----

type GenerateRpcData 

type GenerateRpcData struct {
	Package string
	Imports []string

	UseParamPrefix bool
	Params         []RpcColumn

	ReturnType   string
	ReturnColumn []RpcColumn
	ReturnDecl   string
	IsReturnArr  bool

	Name     string
	Schema   string
	Security string
	Behavior string

	Models     string
	Definition string
}

----- Define type, variable and constant -----

type GenerateStorageInput 

type GenerateStorageInput struct {
	Bucket   objects.Bucket
	Policies objects.Policies
}

type GenerateStoragesData 

type GenerateStoragesData struct {
	Imports           []string
	Package           string
	Name              string
	StructName        string
	Public            bool
	FileSizeLimit     int
	AvifAutoDetection bool
	AllowedMimeTypes  string
	ObjectAcl         string
}

type GenerateTypeData 

type GenerateTypeData struct {
	Imports    []string
	Package    string
	Name       string
	Schema     string
	Format     string
	Enums      string
	Attributes string
	Comment    string
}

----- Define type, variable and constant -----

type JobFieldAttribute 

type JobFieldAttribute struct {
	Field string
	Type  string
	Tag   string
}

----- Define type, variable and constant -----

type Rls 

type Rls struct {
	CanWrite []string
	CanRead  []string
}

type RpcColumn 

type RpcColumn struct {
	Field string
	Type  string
	Tag   string
}

----- Define type, variable and constant -----

type RpcScannedTable 

type RpcScannedTable struct {
	Name     string
	Alias    string
	Relation []string
}

----- Define type, variable and constant -----

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.