cloudz

type API interface {
	Plugin
	GetConfig() *APIConfig
	GetLocalMetadata() *APILocalMetadata
	GetCloudMetadata(require bool) *APICloudMetadata
}

type APICloudMetadata struct {
	Exports CloudExports
	URL     *url.URL
}

type APIConfig struct {
	Stage     Stage    `validate:"required"`
	Name      string   `validate:"required,resource-name"`
	RouteKeys []string `validate:"required"`
	Local     *APIConfigLocal
	Cloud     *APIConfigCloud
	EventHook APIEventHookFunc
}

type APIConfigCloud struct {
	DomainName string `validate:"required,fqdn"`
	CORSDomain string `validate:"required,fqdn"`
}

type APIConfigFunc func(Stage, *APIDependencies) *APIConfig

type APIConfigLocal struct {
	ExternalPort uint16 `validate:"required"`
}

type APIDependencies struct {
	Certificate       Certificate `validate:"required"`
	Function          Function    `validate:"required"`
	OtherDependencies OtherDependencies
}

type APIEventHookFunc func(API, Event, string)

type APILocalMetadata struct {
	ExternalURL *url.URL
	InternalURL *url.URL
}

type App interface {
	GetConfig() *AppConfig
	GetOperations() opz.Operations
	GetSortedPlugins() [][]Plugin
}

type AppConfig struct {
	DisplayName   string      `validate:"required"`
	Name          string      `validate:"required,resource-name"`
	ConfigDirPath string      `validate:"required,dir"`
	BuildDirPath  string      `validate:"required,parent-dir"`
	AWSConfig     *aws.Config `validate:"required"`
	Plugins       []Plugin    `validate:"required"`
}

type Bucket interface {
	Plugin
	GetConfig() *BucketConfig
	GetLocalMetadata() *BucketLocalMetadata
	GetCloudMetadata(require bool) *BucketCloudMetadata
}

type BucketCloudMetadata struct {
	Exports    CloudExports
	BucketName string
	BucketURL  *url.URL
}

type BucketConfig struct {
	Stage                 Stage  `validate:"required"`
	Name                  string `validate:"required,resource-name"`
	IsPublicAccessEnabled bool
	Local                 *BucketConfigLocal
	Cloud                 *BucketConfigCloud
	EventHook             BucketEventHookFunc
}

type BucketConfigCloud struct {
	IsVersioningEnabled                   bool
	DeleteObjectsAfterDays                *uint16
	DeletePreviousObjectVersionsAfterDays *uint16
}

type BucketConfigFunc func(Stage, *BucketDependencies) *BucketConfig

type BucketConfigLocal struct {
	ExternalPort        uint16 `validate:"required"`
	ConsoleExternalPort uint16 `validate:"required"`
}

type BucketDependencies struct {
	OtherDependencies OtherDependencies
}

type BucketEventHookFunc func(Bucket, Event, string)

type BucketLocalMetadata struct {
	ContainerName      string
	AccessKey          string
	SecretKey          string
	BucketName         string
	ExternalURL        *url.URL
	InternalURL        *url.URL
	ConsoleExternalURL *url.URL
}

type Certificate interface {
	Plugin
	GetConfig() *CertificateConfig
	GetCloudMetadata(require bool) *CertificateCloudMetadata
}

type CertificateCloudMetadata struct {
	Exports CloudExports
	ARN     string
}

type CertificateConfig struct {
	Stage     Stage  `validate:"required"`
	Name      string `validate:"required,resource-name"`
	Cloud     *CertificateConfigCloud
	EventHook CertificateEventHookFunc
}

type CertificateConfigCloud struct {
	DomainName   string `validate:"required"`
	HostedZoneID string `validate:"required"`
}

type CertificateConfigFunc func(Stage, *CertificateDependencies) *CertificateConfig

type CertificateDependencies struct {
	OtherDependencies OtherDependencies
}

type CertificateEventHookFunc func(Certificate, Event, string)

type CloudAtt string

type CloudExports interface {
	GetRef(ref CloudRef) string
	GetAtt(ref CloudRef, att CloudAtt) string
}

type CloudRef string

type CloudStage interface {
	Stage
	GetCloudConfig() *CloudStageConfig
	GetArtifactsKeyPrefix(p Plugin, additionalParts ...string) string
	IsDeployed() bool
	Deploy()
}

type CloudStageConfig struct {
	*StageConfig `validate:"required"`
	Name         string    `validate:"required,resource-name"`
	Version      string    `validate:"required"`
	Mode         StageMode `validate:"required,oneof=prod staging"`
}

type Event string

type Function interface {
	Plugin
	GetConfig() *FunctionConfig
	GetDependencies() *FunctionDependencies
	GetLocalMetadata() *FunctionLocalMetadata
	GetCloudMetadata(require bool) *FunctionCloudMetadata
}

type FunctionBuilder interface {
	GetLocalServiceConfigVolumes(p Function, buildDirPath string) []dctypes.ServiceVolumeConfig
	LocalBeforeCreateEventHook(p Function, buildDirPath string)
	GetCloudRuntime(p Function) string
	BuildCloudPackage(p Function, buildDirPath string)
}

type FunctionCloudMetadata struct {
	Exports      CloudExports
	FunctionName string
}

type FunctionConfig struct {
	Stage          Stage           `validate:"required"`
	Name           string          `validate:"required"`
	Builder        FunctionBuilder `validate:"required"`
	TimeoutSeconds uint16          `validate:"required"`
	Environment    map[string]string
	Local          *FunctionConfigLocal
	Cloud          *FunctionConfigCloud
	EventHook      FunctionEventHookFunc
}

type FunctionConfigCloud struct {
	Memory       int `validate:"required"`
	RolePolicies []goiam.Role_Policy
}

type FunctionConfigFunc func(Stage, *FunctionDependencies) *FunctionConfig

type FunctionConfigLocal struct {
	ExternalPort     uint16
	WatchExcludeDirs []string
}

type FunctionDependencies struct {
	ArtifactsBucket   Bucket `validate:"required"`
	Network           Network
	OtherDependencies OtherDependencies
}

type FunctionEventHookFunc func(Function, Event, string)

type FunctionLocalMetadata struct {
	ExternalURL *url.URL
	InternalURL *url.URL
}

type Hasura interface {
	Plugin
	GetConfig() *HasuraConfig
	GetDependencies() *HasuraDependencies
	GetLocalMetadata() *HasuraLocalMetadata
	GetCloudMetadata(require bool) *HasuraCloudMetadata
	ApplyLocalMetadata()
}

type HasuraCloudMetadata struct {
	Exports CloudExports
	URL     *url.URL
}

type HasuraConfig struct {
	Stage            Stage `validate:"required"`
	EnableAllowList  bool
	UnauthorizedRole *string
	JWT              *HasuraConfigJWT `validate:"required"`
	Environment      map[string]string
	Local            *HasuraConfigLocal
	Cloud            *HasuraConfigCloud
	EventHook        HasuraEventHookFunc
}

type HasuraConfigCloud struct {
	DomainName  string `validate:"required"`
	Replicas    int    `validate:"required"`
	CPU         int    `validate:"required"`
	Memory      int    `validate:"required"`
	AdminSecret string `validate:"required,min=16"`
	CORSDomain  *string
}

type HasuraConfigFunc func(Stage, *HasuraDependencies) *HasuraConfig

type HasuraConfigJWT struct {
	PublicKey *rsa.PublicKey `validate:"required"`
	Issuer    string         `validate:"required"`
	Audience  string         `validate:"required"`
}

type HasuraConfigLocal struct {
	ExternalPort           uint16 `validate:"required"`
	ConsoleExternalPort    uint16 `validate:"required"`
	ConsoleAPIExternalPort uint16 `validate:"required"`
}

type HasuraDependencies struct {
	Certificate       Certificate     `validate:"required"`
	ImageRepository   ImageRepository `validate:"required"`
	LoadBalancer      LoadBalancer    `validate:"required"`
	Network           Network         `validate:"required"`
	Postgres          Postgres        `validate:"required"`
	OtherDependencies OtherDependencies
}

type HasuraEventHookFunc func(Hasura, Event, string)

type HasuraLocalMetadata struct {
	ContainerName        string
	ConsoleContainerName string
	AdminSecret          string
	ExternalURL          *url.URL
	InternalURL          *url.URL
	ConsoleExternalURL   *url.URL
}

type ImageRepository interface {
	Plugin
	GetConfig() *ImageRepositoryConfig
	GetLocalMetadata() *ImageRepositoryLocalMetadata
	GetCloudMetadata(require bool) *ImageRepositoryCloudMetadata
}

type ImageRepositoryCloudMetadata struct {
	Exports   CloudExports
	ImageName string
}

type ImageRepositoryConfig struct {
	Stage     Stage  `validate:"required"`
	Name      string `validate:"required,resource-name"`
	Cloud     *ImageRepositoryConfigCloud
	EventHook ImageRepositoryEventHookFunc
}

type ImageRepositoryConfigCloud struct {
	IsScanOnPushEnabled  bool
	AreTagsMutable       bool
	TaggedImagesPolicy   *ImageRepositoryConfigTaggedImagesPolicy
	UntaggedImagesPolicy *ImageRepositoryConfigUntaggedImagesPolicy
}

type ImageRepositoryConfigFunc func(Stage, *ImageRepositoryDependencies) *ImageRepositoryConfig

type ImageRepositoryConfigTaggedImagesPolicy struct {
	TagPrefixes  []string `validate:"required"`
	MaximumCount int      `validate:"required"`
}

type ImageRepositoryConfigUntaggedImagesPolicy struct {
	DeleteAfterDays int `validate:"required"`
}

type ImageRepositoryDependencies struct {
	OtherDependencies OtherDependencies
}

type ImageRepositoryEventHookFunc func(ImageRepository, Event, string)

type ImageRepositoryLocalMetadata struct {
	ImageName string
}

type LoadBalancer interface {
	Plugin
	GetConfig() *LoadBalancerConfig
	GetDependencies() *LoadBalancerDependencies
	GetCloudMetadata(require bool) *LoadBalancerCloudMetadata
}

type LoadBalancerCloudMetadata struct {
	Exports CloudExports
}

type LoadBalancerConfig struct {
	Stage     Stage `validate:"required"`
	EventHook LoadBalancerEventHookFunc
}

type LoadBalancerConfigFunc func(Stage, *LoadBalancerDependencies) *LoadBalancerConfig

type LoadBalancerDependencies struct {
	Certificate       Certificate `validate:"required"`
	Network           Network     `validate:"required"`
	OtherDependencies OtherDependencies
}

type LoadBalancerEventHookFunc func(LoadBalancer, Event, string)

type LocalStage interface {
	Stage
	GetLocalConfig() *LocalStageConfig
	GetServiceNetworkConfig() map[string]*dctypes.ServiceNetworkConfig
	Create()
	Destroy()
}

type LocalStageConfig struct {
	*StageConfig `validate:"required"`
}

type Mail interface {
	Plugin
	GetConfig() *MailConfig
	GetDependencies() *MailDependencies
	GetLocalMetadata() *MailLocalMetadata
}

type MailConfig struct {
	Stage     Stage `validate:"required"`
	Local     *MailConfigLocal
	EventHook MailEventHookFunc
}

type MailConfigFunc func(Stage, *MailDependencies) *MailConfig

type MailConfigLocal struct {
	ExternalPort     uint16 `validate:"required"`
	SMTPExternalPort uint16 `validate:"required"`
}

type MailDependencies struct {
	OtherDependencies OtherDependencies
}

type MailEventHookFunc func(Mail, Event, string)

type MailLocalMetadata struct {
	ContainerName      string
	ExternalURL        *url.URL
	InternalURL        *url.URL
	ConsoleExternalURL *url.URL
}

type Network interface {
	Plugin
	GetConfig() *NetworkConfig
	GetCloudMetadata(require bool) *NetworkCloudMetadata
}

type NetworkCloudMetadata struct {
	Exports CloudExports
}

type NetworkConfig struct {
	Stage     Stage `validate:"required"`
	EventHook NetworkEventHookFunc
}

type NetworkConfigFunc func(Stage, *NetworkDependencies) *NetworkConfig

type NetworkDependencies struct {
	OtherDependencies OtherDependencies
}

type NetworkEventHookFunc func(Network, Event, string)

type OtherDependencies []Plugin

type Plugin interface {
	GetDisplayName() string
	GetName() string
	GetInstanceName() *string // nil for singleton Plugins
	GetDependenciesMap() map[Plugin]struct{}
	Configure(stage Stage)
	GetStage() Stage
	IsDeployed() bool
	UpdateLocalTemplate(tpl *dctypes.Config, buildDirPath string)
	GetCloudTemplate(buildDirPath string) *gocf.Template
	UpdateCloudMetadata(stack *awscft.Stack)
	EventHook(event Event, buildDirPath string)
}

type PolicyStatement struct {
	Actions   []string
	Resources []string
	Principal interface{}
}

type Postgres interface {
	Plugin
	GetConfig() *PostgresConfig
	GetDependencies() *PostgresDependencies
	GetLocalMetadata() *PostgresLocalMetadata
	GetCloudMetadata(require bool) *PostgresCloudMetadata
}

type PostgresCloudMetadata struct {
	Exports CloudExports
	URL     *url.URL
}

type PostgresConfig struct {
	Stage     Stage `validate:"required"`
	Local     *PostgresConfigLocal
	Cloud     *PostgresConfigCloud
	EventHook PostgresEventHookFunc
}

type PostgresConfigCloud struct {
	Password            string `validate:"required,min=16"`
	AllocatedStorageGBs int    `validate:"required,min=5"`
	InstanceClass       string `validate:"required"`
}

type PostgresConfigFunc func(Stage, *PostgresDependencies) *PostgresConfig

type PostgresConfigLocal struct {
	ExternalPort      uint16 `validate:"required"`
	AdminExternalPort uint16 `validate:"required"`
}

type PostgresDependencies struct {
	Network           Network `validate:"required"`
	OtherDependencies OtherDependencies
}

type PostgresEventHookFunc func(Postgres, Event, string)

type PostgresLocalMetadata struct {
	ContainerName           string
	ExternalURL             *url.URL
	InternalURL             *url.URL
	AdminConsoleExternalURL *url.URL
}

type PostgresProxy interface {
	Plugin
	GetConfig() *PostgresProxyConfig
	GetLocalMetadata() *PostgresProxyLocalMetadata
	GetCloudMetadata(require bool) *PostgresProxyCloudMetadata
}

type PostgresProxyCloudMetadata struct {
	Exports CloudExports
	URL     *url.URL
}

type PostgresProxyConfig struct {
	Stage     Stage `validate:"required"`
	EventHook PostgresProxyEventHookFunc
}

type PostgresProxyConfigFunc func(Stage, *PostgresProxyDependencies) *PostgresProxyConfig

type PostgresProxyDependencies struct {
	Network           Network  `validate:"required"`
	Postgres          Postgres `validate:"required"`
	OtherDependencies []Plugin
}

type PostgresProxyEventHookFunc func(PostgresProxy, Event, string)

type PostgresProxyLocalMetadata struct {
	ExternalURL *url.URL
	InternalURL *url.URL
}

type Stage interface {
	GetName() string
	GetTarget() StageTarget
	GetMode() StageMode
	GetConfig() *StageConfig
	AsCloudStage() CloudStage
	AsLocalStage() LocalStage
}

type StageConfig struct {
	App          App `validate:"required"`
	CustomConfig interface{}
}

type StageMode string

type StageTarget string