fix: bump ory/x and update config usage

client/sdk_test.go

@@ -77,8 +77,8 @@ func createTestClient(prefix string) *models.OAuth2Client {
 
 func TestClientSDK(t *testing.T) {
 	conf := internal.NewConfigurationWithDefaults()
-	conf.Set(config.KeySubjectTypesSupported, []string{"public"})
-	conf.Set(config.KeyDefaultClientScope, []string{"foo", "bar"})
+	conf.MustSet(config.KeySubjectTypesSupported, []string{"public"})
+	conf.MustSet(config.KeyDefaultClientScope, []string{"foo", "bar"})
 	r := internal.NewRegistryMemory(t, conf)
 
 	router := x.NewRouterAdmin()

client/validator_test.go

@@ -38,8 +38,8 @@ import (
 
 func TestValidate(t *testing.T) {
 	c := internal.NewConfigurationWithDefaults()
-	c.Set(config.KeySubjectTypesSupported, []string{"pairwise", "public"})
-	c.Set(config.KeyDefaultClientScope, []string{"openid"})
+	c.MustSet(config.KeySubjectTypesSupported, []string{"pairwise", "public"})
+	c.MustSet(config.KeyDefaultClientScope, []string{"openid"})
 
 	v := NewValidator(c)
 	for k, tc := range []struct {
@@ -110,7 +110,7 @@ func TestValidate(t *testing.T) {
 		},
 		{
 			v: func(t *testing.T) *Validator {
-				c.Set(config.KeySubjectTypesSupported, []string{"pairwise"})
+				c.MustSet(config.KeySubjectTypesSupported, []string{"pairwise"})
 				return NewValidator(c)
 			},
 			in: &Client{OutfacingID: "foo"},

cmd/cli/handler_migrate.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/ory/x/configx"
+
 	"github.com/ory/x/errorsx"
 
 	"github.com/ory/x/cmdx"
@@ -26,7 +28,11 @@ func (h *MigrateHandler) MigrateSQL(cmd *cobra.Command, args []string) {
 	var d driver.Registry
 
 	if flagx.MustGetBool(cmd, "read-from-env") {
-		d = driver.New(cmd.Flags(), driver.DisableValidation(),
+		d = driver.New(
+			driver.WithOptions(
+				configx.SkipValidation(),
+				configx.WithFlags(cmd.Flags())),
+			driver.DisableValidation(),
 			driver.DisablePreloading())
 		if len(d.Config().DSN()) == 0 {
 			fmt.Println(cmd.UsageString())
@@ -41,7 +47,13 @@ func (h *MigrateHandler) MigrateSQL(cmd *cobra.Command, args []string) {
 			os.Exit(1)
 			return
 		}
-		d = driver.New(cmd.Flags(), driver.ForceConfigValue(config.KeyDSN, args[0]), driver.DisableValidation(),
+		d = driver.New(
+			driver.WithOptions(
+				configx.WithFlags(cmd.Flags()),
+				configx.SkipValidation(),
+				configx.WithValue(config.KeyDSN, args[0]),
+			),
+			driver.DisableValidation(),
 			driver.DisablePreloading())
 	}
 

cmd/server/handler.go

@@ -29,6 +29,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/ory/x/configx"
+
 	analytics "github.com/ory/analytics-go/v4"
 
 	"github.com/ory/x/reqlog"
@@ -86,7 +88,7 @@ func isDSNAllowed(r driver.Registry) {
 }
 
 func RunServeAdmin(cmd *cobra.Command, args []string) {
-	d := driver.New(cmd.Flags())
+	d := driver.New(driver.WithOptions(configx.WithFlags(cmd.Flags())))
 	isDSNAllowed(d)
 
 	admin, _, adminmw, _ := setup(d, cmd)
@@ -104,7 +106,7 @@ func RunServeAdmin(cmd *cobra.Command, args []string) {
 }
 
 func RunServePublic(cmd *cobra.Command, args []string) {
-	d := driver.New(cmd.Flags())
+	d := driver.New(driver.WithOptions(configx.WithFlags(cmd.Flags())))
 	isDSNAllowed(d)
 
 	_, public, _, publicmw := setup(d, cmd)
@@ -122,7 +124,7 @@ func RunServePublic(cmd *cobra.Command, args []string) {
 }
 
 func RunServeAll(cmd *cobra.Command, args []string) {
-	d := driver.New(cmd.Flags())
+	d := driver.New(driver.WithOptions(configx.WithFlags(cmd.Flags())))
 
 	admin, public, adminmw, publicmw := setup(d, cmd)
 	cert := GetOrCreateTLSCertificate(cmd, d) // we do not want to run this concurrently.

consent/sdk_test.go

@@ -42,8 +42,8 @@ import (
 
 func TestSDK(t *testing.T) {
 	conf := internal.NewConfigurationWithDefaults()
-	conf.Set(config.KeyIssuerURL, "https://www.ory.sh")
-	conf.Set(config.KeyAccessTokenLifespan, time.Minute)
+	conf.MustSet(config.KeyIssuerURL, "https://www.ory.sh")
+	conf.MustSet(config.KeyAccessTokenLifespan, time.Minute)
 	reg := internal.NewRegistryMemory(t, conf)
 
 	router := x.NewRouterPublic()

consent/strategy_logout_test.go

@@ -30,8 +30,8 @@ import (
 
 func TestLogoutFlows(t *testing.T) {
 	reg := internal.NewMockedRegistry(t)
-	reg.Config().Set(config.KeyAccessTokenStrategy, "opaque")
-	reg.Config().Set(config.KeyConsentRequestMaxAge, time.Hour)
+	reg.Config().MustSet(config.KeyAccessTokenStrategy, "opaque")
+	reg.Config().MustSet(config.KeyConsentRequestMaxAge, time.Hour)
 
 	defaultRedirectedMessage := "redirected to default server"
 	postLogoutCallback := func(w http.ResponseWriter, r *http.Request) {
@@ -40,7 +40,7 @@ func TestLogoutFlows(t *testing.T) {
 	}
 	defaultLogoutURL := testhelpers.NewCallbackURL(t, "logged-out", postLogoutCallback)
 	customPostLogoutURL := testhelpers.NewCallbackURL(t, "logged-out/custom", postLogoutCallback)
-	reg.Config().Set(config.KeyLogoutRedirectURL, defaultLogoutURL)
+	reg.Config().MustSet(config.KeyLogoutRedirectURL, defaultLogoutURL)
 
 	publicTS, adminTS := testhelpers.NewOAuth2Server(t, reg)
 	adminApi := hydra.NewHTTPClientWithConfig(nil, &hydra.TransportConfig{Schemes: []string{"http"}, Host: urlx.ParseOrPanic(adminTS.URL).Host})
@@ -143,7 +143,7 @@ func TestLogoutFlows(t *testing.T) {
 
 		t.Cleanup(server.Close)
 
-		reg.Config().Set(config.KeyLogoutURL, server.URL)
+		reg.Config().MustSet(config.KeyLogoutURL, server.URL)
 	}
 
 	acceptLoginAsAndWatchSid := func(t *testing.T, subject string, sid chan string) {

consent/strategy_oauth_test.go

@@ -36,12 +36,12 @@ import (
 
 func TestStrategyLoginConsentNext(t *testing.T) {
 	reg := internal.NewMockedRegistry(t)
-	reg.Config().Set(config.KeyAccessTokenStrategy, "opaque")
-	reg.Config().Set(config.KeyConsentRequestMaxAge, time.Hour)
-	reg.Config().Set(config.KeyConsentRequestMaxAge, time.Hour)
-	reg.Config().Set(config.KeyScopeStrategy, "exact")
-	reg.Config().Set(config.KeySubjectTypesSupported, []string{"pairwise", "public"})
-	reg.Config().Set(config.KeySubjectIdentifierAlgorithmSalt, "76d5d2bf-747f-4592-9fbd-d2b895a54b3a")
+	reg.Config().MustSet(config.KeyAccessTokenStrategy, "opaque")
+	reg.Config().MustSet(config.KeyConsentRequestMaxAge, time.Hour)
+	reg.Config().MustSet(config.KeyConsentRequestMaxAge, time.Hour)
+	reg.Config().MustSet(config.KeyScopeStrategy, "exact")
+	reg.Config().MustSet(config.KeySubjectTypesSupported, []string{"pairwise", "public"})
+	reg.Config().MustSet(config.KeySubjectIdentifierAlgorithmSalt, "76d5d2bf-747f-4592-9fbd-d2b895a54b3a")
 
 	publicTS, adminTS := testhelpers.NewOAuth2Server(t, reg)
 	adminClient := hydra.NewHTTPClientWithConfig(nil, &hydra.TransportConfig{Schemes: []string{"http"}, Host: urlx.ParseOrPanic(adminTS.URL).Host})

driver/config/provider.go

@@ -9,8 +9,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/spf13/pflag"
-
 	"github.com/ory/x/dbal"
 
 	"github.com/markbates/pkger"
@@ -91,15 +89,15 @@ type Provider struct {
 	p               *configx.Provider
 }
 
-func MustNew(flags *pflag.FlagSet, l *logrusx.Logger) *Provider {
-	p, err := New(flags, l)
+func MustNew(l *logrusx.Logger, opts ...configx.OptionModifier) *Provider {
+	p, err := New(l, opts...)
 	if err != nil {
 		l.WithError(err).Fatalf("Unable to load config.")
 	}
 	return p
 }
 
-func New(flags *pflag.FlagSet, l *logrusx.Logger) (*Provider, error) {
+func New(l *logrusx.Logger, opts ...configx.OptionModifier) (*Provider, error) {
 	f, err := pkger.Open("/.schema/config.schema.json")
 	if err != nil {
 		return nil, err
@@ -110,23 +108,30 @@ func New(flags *pflag.FlagSet, l *logrusx.Logger) (*Provider, error) {
 		return nil, err
 	}
 
-	p, err := configx.New(
-		schema,
-		flags,
+	opts = append([]configx.OptionModifier{
 		configx.WithStderrValidationReporter(),
-		configx.OmitKeysFromTracing([]string{"dsn", "secrets.system", "secrets.cookie"}),
-		configx.WithImmutables([]string{"log", "serve", "dsn", "profiling"}),
+		configx.OmitKeysFromTracing("dsn", "secrets.system", "secrets.cookie"),
+		configx.WithImmutables("log", "serve", "dsn", "profiling"),
 		configx.WithLogrusWatcher(l),
-	)
+	}, opts...)
+
+	p, err := configx.New(schema, opts...)
 	if err != nil {
 		return nil, err
 	}
 
+	l.UseConfig(p)
 	return &Provider{l: l, p: p}, nil
 }
 
-func (p *Provider) Set(key string, value interface{}) {
-	p.p.Set(key, value)
+func (p *Provider) Set(key string, value interface{}) error {
+	return p.p.Set(key, value)
+}
+
+func (p *Provider) MustSet(key string, value interface{}) {
+	if err := p.Set(key, value); err != nil {
+		p.l.WithError(err).Fatalf("Unable to set \"%s\" to \"%s\".", key, value)
+	}
 }
 
 func (p *Provider) Source() *configx.Provider {

driver/config/provider_test.go

@@ -9,8 +9,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/spf13/pflag"
-
 	"github.com/ory/x/configx"
 	"github.com/ory/x/dbal"
 
@@ -27,7 +25,7 @@ import (
 )
 
 func newProvider() *Provider {
-	return MustNew(pflag.NewFlagSet("config", pflag.ContinueOnError), logrusx.New("", ""))
+	return MustNew(logrusx.New("", ""))
 }
 
 func setupEnv(env map[string]string) func(t *testing.T) (func(), func()) {
@@ -75,7 +73,7 @@ func TestSubjectTypesSupported(t *testing.T) {
 			setup, clean := tc.env(t)
 			setup()
 			p := newProvider()
-			p.Set(KeySubjectIdentifierAlgorithmSalt, "00000000")
+			p.MustSet(KeySubjectIdentifierAlgorithmSalt, "00000000")
 			assert.EqualValues(t, tc.e, p.SubjectTypesSupported())
 			clean()
 		})
@@ -89,7 +87,7 @@ func TestWellKnownKeysUnique(t *testing.T) {
 
 func TestCORSOptions(t *testing.T) {
 	p := newProvider()
-	p.Set("serve.public.cors.enabled", true)
+	p.MustSet("serve.public.cors.enabled", true)
 
 	conf, enabled := p.PublicCORS()
 	assert.True(t, enabled)
@@ -110,12 +108,12 @@ func TestProviderAdminDisableHealthAccessLog(t *testing.T) {
 	l := logrusx.New("", "")
 	l.Logrus().SetOutput(ioutil.Discard)
 
-	p := MustNew(pflag.NewFlagSet("config", pflag.ContinueOnError), l)
+	p := MustNew(l)
 
 	value := p.AdminDisableHealthAccessLog()
 	assert.Equal(t, false, value)
 
-	p.Set(KeyAdminDisableHealthAccessLog, "true")
+	p.MustSet(KeyAdminDisableHealthAccessLog, "true")
 
 	value = p.AdminDisableHealthAccessLog()
 	assert.Equal(t, true, value)
@@ -125,12 +123,12 @@ func TestProviderPublicDisableHealthAccessLog(t *testing.T) {
 	l := logrusx.New("", "")
 	l.Logrus().SetOutput(ioutil.Discard)
 
-	p := MustNew(pflag.NewFlagSet("config", pflag.ContinueOnError), l)
+	p := MustNew(l)
 
 	value := p.PublicDisableHealthAccessLog()
 	assert.Equal(t, false, value)
 
-	p.Set(KeyPublicDisableHealthAccessLog, "true")
+	p.MustSet(KeyPublicDisableHealthAccessLog, "true")
 
 	value = p.PublicDisableHealthAccessLog()
 	assert.Equal(t, true, value)
@@ -139,40 +137,37 @@ func TestProviderPublicDisableHealthAccessLog(t *testing.T) {
 func TestProviderIssuerURL(t *testing.T) {
 	l := logrusx.New("", "")
 	l.Logrus().SetOutput(ioutil.Discard)
-	p := MustNew(pflag.NewFlagSet("config", pflag.ContinueOnError), l)
-	p.Set(KeyIssuerURL, "http://hydra.localhost")
+	p := MustNew(l)
+	p.MustSet(KeyIssuerURL, "http://hydra.localhost")
 	assert.Equal(t, "http://hydra.localhost/", p.IssuerURL().String())
 
-	p2 := MustNew(pflag.NewFlagSet("config", pflag.ContinueOnError), l)
-	p2.Set(KeyIssuerURL, "http://hydra.localhost/")
+	p2 := MustNew(l)
+	p2.MustSet(KeyIssuerURL, "http://hydra.localhost/")
 	assert.Equal(t, "http://hydra.localhost/", p2.IssuerURL().String())
 }
 
 func TestProviderCookieSameSiteMode(t *testing.T) {
 	l := logrusx.New("", "")
 	l.Logrus().SetOutput(ioutil.Discard)
 
-	p := MustNew(pflag.NewFlagSet("config", pflag.ContinueOnError), l)
-	p.Set("dangerous-force-http", false)
-	p.Set(KeyCookieSameSiteMode, "")
+	p := MustNew(l, configx.SkipValidation())
+	p.MustSet("dangerous-force-http", false)
+	p.MustSet(KeyCookieSameSiteMode, "")
 	assert.Equal(t, http.SameSiteDefaultMode, p.CookieSameSiteMode())
 
-	p.Set(KeyCookieSameSiteMode, "none")
+	p.MustSet(KeyCookieSameSiteMode, "none")
 	assert.Equal(t, http.SameSiteNoneMode, p.CookieSameSiteMode())
 
-	p = MustNew(pflag.NewFlagSet("config", pflag.ContinueOnError), l)
-	p.Set("dangerous-force-http", true)
+	p = MustNew(l, configx.SkipValidation())
+	p.MustSet("dangerous-force-http", true)
 	assert.Equal(t, http.SameSiteLaxMode, p.CookieSameSiteMode())
-	p.Set(KeyCookieSameSiteMode, "none")
+	p.MustSet(KeyCookieSameSiteMode, "none")
 	assert.Equal(t, http.SameSiteLaxMode, p.CookieSameSiteMode())
 }
 
 func TestViperProviderValidates(t *testing.T) {
 	l := logrusx.New("", "")
-	flags := pflag.NewFlagSet("config", pflag.ContinueOnError)
-	configx.RegisterFlags(flags)
-	require.NoError(t, flags.Parse([]string{"--config", "../../internal/.hydra.yaml"}))
-	c := MustNew(flags, l)
+	c := MustNew(l, configx.WithConfigFiles("../../internal/.hydra.yaml"))
 
 	// log
 	assert.Equal(t, "debug", c.Source().String(KeyLogLevel))