generator

package
v1.0.0-beta.2 Latest Latest
Warning

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

 Go to latest Published: May 31, 2024 License: MIT Imports: 23 Imported by: 0

Documentation

Index

Constants

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

)
View Source 
const (
	ConfigDir      = "configs"
	ConfigFile     = "app"
	ConfigTemplate = `` /* 670-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    = `` /* 2003-byte string literal not displayed */

)
View Source 
const (
	MainFunctionDirTemplate = "/cmd/%s"
	MainFunctionTemplate    = `` /* 399-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 {
	raiden.ModelBase
{{- range .Columns }}
	{{ .Name | ToGoIdentifier }} {{ .Type }} ` + "`{{ .Tag }}`" + `
{{- end }}

	// Table information
	Metadata string ` + "`json:\"-\" schema:\"{{ .Schema}}\" 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 (
	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 = `` /* 592-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 */

)

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 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 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")

Functions

func BuildJoinTag 

func BuildJoinTag(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 GenerateHelloWordController 

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

----- Generate hello word -----

func GenerateImportMainFunction 

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

func GenerateMainFunction 

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

func GenerateModel 

func GenerateModel(folderPath string, input *GenerateModelInput, generateFn GenerateFn) error

func GenerateModelRegister 

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

func GenerateModels 

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

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, generateFn GenerateFn) error

Generate route configuration file

func GenerateRpc 

func GenerateRpc(basePath string, projectName string, functions []objects.Function, 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 RpcNormalizeTableAliases 

func RpcNormalizeTableAliases(mapTables map[string]*RpcScannedTable) 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)

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) (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 FoundRoute 

type FoundRoute struct {
	Package string
	Name    string
	Tag     string
	Methods []string
	Model   string
	Storage string
}

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

type GenerateApplyMainFunctionData 

type GenerateApplyMainFunctionData struct {
	Package string
	Imports []string
}

----- 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
}

----- 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 -----

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(table objects.Table) (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
}

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

type GenerateModelInput 

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

----- 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 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 {
	Type       string
	Path       string
	Methods    string
	Controller string
	Model      string
	Storage    string
}

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

func WalkScanControllers 

func WalkScanControllers(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 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.