generator

type APIGroup struct {
	Option
}

type Access struct {
	Preset AccessPreset
}

type AccessPreset string

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

type ApiOption struct {
	GeneratorOption
	Matcher TemplateMatcher
	Prefix  string
	Order   int
}

type ApiVerOption struct {
	GeneratorOption
}

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

type Authentication struct {
	Method AuthenticationMethod
}

type AuthenticationMethod string

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

type CleanupOption struct {
	GeneratorOption
	Order int
}

type Components struct {
	Contract Contract
	Security Security
}

type Contract struct {
	Path   string
	Naming ContractNaming
}

type ContractNaming struct {
	RegExps map[string]string
}

type DirOption struct {
	GeneratorOption
	Matcher        TemplateMatcher
	OutputResolver TemplateOutputResolver
}

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

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

type FileOption struct {
	GeneratorOption
	Matcher        TemplateMatcher
	OutputResolver TemplateOutputResolver
	Prefix         string
	Order          int
}

type FileType string

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

type GenerationData map[string]interface{}

type Generator interface {
	// Generate files based on given template.
	// Provided template could be
	// 	- Path to a loaded template file
	// 	- Directory path in the template FS
	//
	// Generator's implementation decide what to with the given template, including:
	// 	- Creating directories
	//  - Generating single file
	//  - Generating multiple files
	Generate(ctx context.Context, tmplDesc TemplateDescriptor) error
}

type GeneratorOption struct {
	Option
	Template *template.Template
	Data     GenerationData
}

type GeneratorOptions func(opt *GeneratorOption)

type Generators struct {
	Option
	// contains filtered or unexported fields
}

type GoSourceFormatter struct{}

type Group interface {
	order.Ordered

	// Name unique identifier of the group
	Name() string

	// CustomizeTemplate is used to customize *template.Template for group specific need
	CustomizeTemplate() (TemplateOptions, error)

	// CustomizeData customize data and load group specific data. All data is shared with other groups.
	// This function of all groups are called in order before any invocation of their Generators().
	// The results are propagate to other groups and served to Generators() for constructing generators.
	// Important: For each top-level component in Data should be owned by the group that generating it.
	// 			  Other groups can read it but should not change or replace it.
	//			  The exception is "ProjectMetadata" object, which all groups can add to it
	CustomizeData(data GenerationData) error

	// Generators prepare generators with proper generator list based on options. Group can decide the group is not
	// applicable, in such case, Group can return empty list without error
	// The returned generators should be sorted.
	Generators(opts ...GeneratorOptions) ([]Generator, error)
}

type LanaiModule struct {
	Name        string
	Alias       string
	InitPackage string
}

type LanaiModuleGroup []*LanaiModule

type LanaiModules struct {
	Basic       LanaiModuleGroup
	Web         LanaiModuleGroup
	Data        LanaiModuleGroup
	Integration LanaiModuleGroup
	Security    LanaiModuleGroup
	Others      LanaiModuleGroup
}

type OPAPolicyData struct {
	APIPackage string
}

type OPAPolicyGroup struct {
	Option
}

type Option struct {
	// Project general project information
	Project Project

	// Components defines what to generate and their settings
	Components Components

	// TemplateFS filesystem containing templates. Could be embed.FS or os.DirFS
	TemplateFS fs.FS

	// DefaultRegenMode default output file operation mode during re-generation
	DefaultRegenMode RegenMode

	// RegenRules rules of output file operation mode during re-generation
	RegenRules RegenRules
}

type Options func(opt *Option)

type Project struct {
	Name        string
	Module      string
	Description string
	Port        int
	ContextPath string
}

type ProjectGroup struct {
	Option
}

type ProjectMetadata struct {
	Project
	EnabledModules utils.StringSet
}

type RegenMode string

type RegenRule struct {
	// Pattern wildcard pattern of output file path
	Pattern string
	// Mode regeneration mode on matched output files in case of changes. (ignore, overwrite, reference, etc.)
	Mode RegenMode
}

type RegenRules []RegenRule

type RegoFormatter struct{}

type Security struct {
	Authentication Authentication
	Access         Access
}

type SecurityGroup struct {
	Option
}

type TemplateDescriptor struct {
	Path     string
	FileInfo fs.FileInfo
}

type TemplateFuncProvider func(funcMap template.FuncMap) (template.FuncMap, error)

type TemplateMatcher cmdutils.ChainableMatcher[TemplateDescriptor]

type TemplateOption struct {
	Pattern       string
	FuncProviders []TemplateFuncProvider
	PreloadHooks  []TemplatePreHook
	PostHooks     []TemplatePostHook
}

type TemplateOptions func(opt *TemplateOption)

type TemplateOutputDescriptor struct {
	Path string
}

type TemplateOutputResolver interface {
	Resolve(ctx context.Context, tmplDesc TemplateDescriptor, data GenerationData) (TemplateOutputDescriptor, error)
}

type TemplateOutputResolverFunc func(ctx context.Context, tmplDesc TemplateDescriptor, data GenerationData) (TemplateOutputDescriptor, error)

type TemplatePostHook func(tmpl *template.Template) (*template.Template, error)

type TemplatePreHook func(tmpl *template.Template, tmplPaths []string) (*template.Template, []string, error)

type TextFormatter interface {
	Format(in []byte) ([]byte, error)
}

type YamlFormatter struct{}