Configuration

package mysvc

import (
    "encore.dev/config"
)

type SomeConfigType struct {
    ReadOnly config.Bool    // Put the system into read-only mode
    Example  config.String
}

var cfg *SomeConfigType = config.Load[*SomeConfigType]()

-- mysvc/encore.gen.cue --
// Code generated by encore. DO NOT EDIT.
package mysvc

#Meta: {
	APIBaseURL: string
	Environment: {
		Name:  string
		Type:  "production" | "development" | "ephemeral" | "test"
		Cloud: "aws" | "gcp" | "encore" | "local"
	}
}

#Config: {
	ReadOnly: bool   // Put the system into read-only mode
    Example:  string
}
#Config
-- mysvc/myconfig.cue --
// Set example to "hello world"
Example: "hello world"

// By default we're not in read only mode
ReadOnly: bool | *false

// But on the old production environment, we're in read only mode
if #Meta.Environment.Name == "old-prod" {
    ReadOnly: true
}

type FooBar {
    A int `cue:">100"`
    B int `cue:"A-50"` // If A is set, B can be inferred by CUE
    C int `cue:"A+B"`  // Which then allows CUE to infer this too
}

var _ = config.Load[*FooBar]()

#Config: {
    A: int & >100
    B: int & A-50 // If A is set, B can be inferred by CUE
    C: int & A+B  // Which then allows CUE to infer this too
}

-- svc/svc.go --
type mysvc

import (
    "encore.dev/config"
)

type Server struct {
    // The config wrappers do not have to be in the top level struct
    Enabled config.Bool
    Port    config.Int
}

type SvcConfig struct {
    GameServerPorts config.Values[Server]
}

var cfg = config.Load[*SvcConfig]()

func startServers() {
    for _, server := range cfg.GameServerPorts() {
        if server.Enabled() {
            go startServer(server.Port())
        }
    }
}

func startServer(port int) {
  // ...
}
-- svc/servers.cue --
GameServerPorts: [
    {
        Enabled: false
        Port:    12345
    },
    {
        Enabled: true
        Port:    1337
    },
]

// An application running due to `encore run`
if #Meta.Environment.Type == "development" && #Meta.Environment.Cloud == "local" {}

// An application running in a development environment in the Cloud
if #Meta.Environment.Type == "development" && #Meta.Environment.Cloud != "local" {}

// An application running in a production environment
if #Meta.Environment.Type == "production" {}

// An application running in an environment that Encore has created
// for an open Pull Request on Github
if #Meta.Environment.Type == "ephemeral" {}

-- config.cue --
// By default we want to send emails
SendEmails: bool | *true

// But in all tests we want to disable emails
if #Meta.Environment.Type == "test" {
    SendEmails: false
}
-- signup.go --
import (
    "context"

    "encore.dev/config"
)

type Config struct {
    SendEmails config.Bool
}

var cfg = config.Load[Config]()

//encore:api public
func Signup(ctx context.Context, p *SignupParams) error {
    user := createUser(p)

    if cfg.SendEmails() {
        SendWelcomeEmail(user)
    }

    return nil
}
-- signup_test.go --
import (
    "errors"
    "testing"

    "encore.dev/et"
)

func TestSignup(t *testing.T) {
    err := Signup(context.Background(), &SignupParams { ... })
    if err != nil {
        // We don't expect an error here
        t.Fatal(err)
    }

    if emailWasSent() {
        // We don't expect an email to be sent
        // as it's disabled for all tests
        t.Fatal("email was sent")
    }
}

func TestSignup_TestEmails(t *testing.T) {
    // For this test, we want to enable the welcome
    // emails so we can test that they are sent
    et.SetCfg(cfg.SendEmails, true)

    err := Signup(context.Background(), &SignupParams { ... })
    if err != nil {
        // We don't expect an error here
        t.Fatal(err)
    }

    // Check the email was sent
    if !emailWasSent() {
        t.Fatal("email was not sent")
    }
}

// ReadOnlyMode is a boolean and if we don't provide a value, it
// will default to false.
ReadOnlyMode: bool | *false

if #Meta.Environment.Name == "old-prod" {
    // On this environment, we want to set ReadOnlyMode to true
    ReadOnlyMode: true
}

import (
    "list" // import CUE's list package
)

// Set some port numbers defaulting just to 8080
// but in development including 8443
portNumbers: [...int] | *[8080]
if #Meta.Environment.Type == "development" {
    portNumbers: [8080, 8443]
}

// Port numbers must be an array and all values
// are integers 1024 or above.
portNumbers: [...int & >= 1024]

// The ports are considered valid if they contain the port number 8080.
_portsAreValid: list.Contains(portNumbers, 8080)

// Ensure that the ports are valid by constraining the value to be true.
// CUE will report an error if the value is false (that is if the portNumbers list
// does not contain the value 8080).
_portsAreValid: true

SendEmailsFrom: [
	// These act as individual case statements
    if #Meta.Environment.Type == "production" { "[email protected]" },
    if #Meta.Environment.Name == "staging"    { "[email protected]" },

    // This last value without a condition acts as the default case
    "[email protected]",
][0] // Return the first value which matches the condition

// Define the type we want to use
#Server: {
	server: string
	port: int & > 1024
	enabled: bool | *true
}

// Specify that servers is a map of strings to #Server
// where they key we assign the variable Name
servers: [Name=string]: #Server & {
	// Then we union the key with the value of server
	server: Name
}

servers: {
	"Foo": {
        port: 8080
    },
    "Bar": {
        port:    8081
        enabled: false
    },
}

{
    "servers": {
        "Foo": {
            "server":  "Foo",
            "port":    8080,
            "enabled": true
        },
        "Bar": {
            "server":  "Bar",
            "port":    8081,
            "enabled": false
        }
    }
}