certs

type CertificateFiles struct {
	RootCAPaths          []string
	CertificatePath      string
	PrivateKeyPath       string
	PrivateKeyPassphrase string
}

type DefaultManager struct {
	sync.Mutex
	Properties       Properties
	ConfigLoaderFunc func(target interface{}, configPath string) error
	// contains filtered or unexported fields
}

type Manager interface {
	Source(ctx context.Context, opts ...Options) (Source, error)
}

type Option struct {
	// Preset name of the preset config. Set this field to reuse configuration from properties (tls.presets.<name>).
	// This field is exclusive with ConfigPath, Type and RawConfig
	Preset string

	// ConfigPath is similar to Preset, but should be the full property path. e.g.  "redis.tls.config".
	// This field is exclusive with Preset, Type and RawConfig
	ConfigPath string

	// RawConfig raw configuration of the certificate source, required when Type is set.
	// This field is exclusive with Preset and ConfigPath
	// Supported types: json.RawMessage, []byte (JSON), string (JSON), or any struct compatible with corresponding SourceType
	RawConfig interface{}

	// Type type of the certificate source. Set this field for manual configuration
	// This field is ignored if any of Preset or ConfigPath is set.
	// If RawConfig includes "type" field, Type is optional. In such case, if Type is set, it overrides the value from RawConfig
	Type SourceType
}

type Options func(opt *Option)

type Properties struct {
	Sources map[SourceType]json.RawMessage `json:"sources"`
	Presets map[string]json.RawMessage     `json:"presets"`
}

type Registrar interface {
	Register(items ...interface{}) error
	MustRegister(items ...interface{})
}

type Source interface {
	// TLSConfig get certificates as tls.Config. For native drivers that support standard tls.Config
	TLSConfig(ctx context.Context, opts ...TLSOptions) (*tls.Config, error)
	// Files get certificates as local files. For drivers that support filesystem based certificates config e.g. postgres DSN
	Files(ctx context.Context) (*CertificateFiles, error)
}

type SourceConfig struct {
	RawConfig json.RawMessage
}

type SourceFactory interface {
	Type() SourceType
	LoadAndInit(ctx context.Context, opts ...SourceOptions) (Source, error)
}

type SourceOptions func(srcCfg *SourceConfig)

type SourceProperties struct {
	// Preset is optional. When set, it should match a key in Properties.Presets
	Preset string `json:"preset"`
	// Type is required when Preset is not set, optional and ignored when Preset is set.
	Type SourceType `json:"type"`
	// Raw stores configuration as JSON.
	// When Preset is set, Raw might be empty. Otherwise, Raw should at least have "type"
	Raw json.RawMessage `json:"-"`
}

type SourceType string

type TLSOption struct {
}

type TLSOptions func(opt *TLSOption)