Merge branch 'master' into version

pkg/api/resolver_mutation_configure.go

@@ -3,10 +3,11 @@ package api
 import (
 	"context"
 	"fmt"
+	"path/filepath"
+
 	"github.com/stashapp/stash/pkg/manager/config"
 	"github.com/stashapp/stash/pkg/models"
 	"github.com/stashapp/stash/pkg/utils"
-	"path/filepath"
 )
 
 func (r *mutationResolver) ConfigureGeneral(ctx context.Context, input models.ConfigGeneralInput) (*models.ConfigGeneralResult, error) {
@@ -41,3 +42,23 @@ func (r *mutationResolver) ConfigureGeneral(ctx context.Context, input models.Co
 
 	return makeConfigGeneralResult(), nil
 }
+
+func (r *mutationResolver) ConfigureInterface(ctx context.Context, input models.ConfigInterfaceInput) (*models.ConfigInterfaceResult, error) {
+	css := ""
+
+	if input.CSS != nil {
+		css = *input.CSS
+	}
+
+	config.SetCSS(css)
+
+	if input.CSSEnabled != nil {
+		config.Set(config.CSSEnabled, *input.CSSEnabled)
+	}
+
+	if err := config.Write(); err != nil {
+		return makeConfigInterfaceResult(), err
+	}
+
+	return makeConfigInterfaceResult(), nil
+}

pkg/api/resolver_query_configuration.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"context"
+
 	"github.com/stashapp/stash/pkg/manager/config"
 	"github.com/stashapp/stash/pkg/models"
 	"github.com/stashapp/stash/pkg/utils"
@@ -21,7 +22,8 @@ func (r *queryResolver) Directories(ctx context.Context, path *string) ([]string
 
 func makeConfigResult() *models.ConfigResult {
 	return &models.ConfigResult{
-		General: makeConfigGeneralResult(),
+		General:   makeConfigGeneralResult(),
+		Interface: makeConfigInterfaceResult(),
 	}
 }
 
@@ -32,3 +34,12 @@ func makeConfigGeneralResult() *models.ConfigGeneralResult {
 		GeneratedPath: config.GetGeneratedPath(),
 	}
 }
+
+func makeConfigInterfaceResult() *models.ConfigInterfaceResult {
+	css := config.GetCSS()
+	cssEnabled := config.GetCSSEnabled()
+	return &models.ConfigInterfaceResult{
+		CSS:        &css,
+		CSSEnabled: &cssEnabled,
+	}
+}

pkg/api/server.go

@@ -76,6 +76,21 @@ func Start() {
 	r.Mount("/scene", sceneRoutes{}.Routes())
 	r.Mount("/studio", studioRoutes{}.Routes())
 
+	r.HandleFunc("/css", func(w http.ResponseWriter, r *http.Request) {
+		if !config.GetCSSEnabled() {
+			return
+		}
+		
+		// search for custom.css in current directory, then $HOME/.stash
+		fn := config.GetCSSPath()
+		exists, _ := utils.FileExists(fn)
+		if !exists {
+			return
+		}
+
+		http.ServeFile(w, r, fn)
+	})
+
 	// Serve the setup UI
 	r.HandleFunc("/setup*", func(w http.ResponseWriter, r *http.Request) {
 		ext := path.Ext(r.URL.Path)

pkg/manager/config/config.go

@@ -1,7 +1,10 @@
 package config
 
 import (
+	"io/ioutil"
 	"github.com/spf13/viper"
+
+	"github.com/stashapp/stash/pkg/utils"
 )
 
 const Stash = "stash"
@@ -15,6 +18,8 @@ const Database = "database"
 const Host = "host"
 const Port = "port"
 
+const CSSEnabled = "cssEnabled"
+
 func Set(key string, value interface{}) {
 	viper.Set(key, value)
 }
@@ -51,6 +56,46 @@ func GetPort() int {
 	return viper.GetInt(Port)
 }
 
+func GetCSSPath() string {
+	// search for custom.css in current directory, then $HOME/.stash
+	fn := "custom.css"
+	exists, _ := utils.FileExists(fn)
+	if !exists {
+		fn = "$HOME/.stash/" + fn
+	}
+
+	return fn
+}
+
+func GetCSS() string {
+	fn := GetCSSPath()
+
+	exists, _ := utils.FileExists(fn)
+	if !exists {
+		return ""
+	}
+
+	buf, err := ioutil.ReadFile(fn)
+
+	if err != nil {
+		return ""
+	}
+
+	return string(buf)
+}
+
+func SetCSS(css string) {
+	fn := GetCSSPath()
+
+	buf := []byte(css)
+
+	ioutil.WriteFile(fn, buf, 0777)
+}
+
+func GetCSSEnabled() bool {
+	return viper.GetBool(CSSEnabled)
+}
+
 func IsValid() bool {
 	setPaths := viper.IsSet(Stash) && viper.IsSet(Cache) && viper.IsSet(Generated) && viper.IsSet(Metadata)
 	// TODO: check valid paths

pkg/manager/manager.go

@@ -1,8 +1,9 @@
 package manager
 
 import (
-	"fmt"
-	"github.com/fsnotify/fsnotify"
+	"net"
+	"sync"
+
 	"github.com/spf13/pflag"
 	"github.com/spf13/viper"
 	"github.com/stashapp/stash/pkg/ffmpeg"
@@ -10,8 +11,6 @@ import (
 	"github.com/stashapp/stash/pkg/manager/config"
 	"github.com/stashapp/stash/pkg/manager/paths"
 	"github.com/stashapp/stash/pkg/utils"
-	"net"
-	"sync"
 )
 
 type singleton struct {
@@ -71,12 +70,15 @@ func initConfig() {
 	// Set generated to the metadata path for backwards compat
 	viper.SetDefault(config.Generated, viper.GetString(config.Metadata))
 
+	// Disabling config watching due to race condition issue
+	// See: https://github.com/spf13/viper/issues/174
+	// Changes to the config outside the system will require a restart
 	// Watch for changes
-	viper.WatchConfig()
-	viper.OnConfigChange(func(e fsnotify.Event) {
-		fmt.Println("Config file changed:", e.Name)
-		instance.refreshConfig()
-	})
+	// viper.WatchConfig()
+	// viper.OnConfigChange(func(e fsnotify.Event) {
+	// 	fmt.Println("Config file changed:", e.Name)
+	// 	instance.refreshConfig()
+	// })
 
 	//viper.Set("stash", []string{"/", "/stuff"})
 	//viper.WriteConfig()
@@ -92,15 +94,15 @@ func initFlags() {
 	}
 }
 
-func initEnvs()	{
+func initEnvs() {
 	viper.SetEnvPrefix("stash") // will be uppercased automatically
-	viper.BindEnv("host") // STASH_HOST
-	viper.BindEnv("port") // STASH_PORT
-	viper.BindEnv("stash") // STASH_STASH
-	viper.BindEnv("generated") // STASH_GENERATED
-	viper.BindEnv("metadata") // STASH_METADATA
-	viper.BindEnv("cache") // STASH_CACHE
-}	
+	viper.BindEnv("host")       // STASH_HOST
+	viper.BindEnv("port")       // STASH_PORT
+	viper.BindEnv("stash")      // STASH_STASH
+	viper.BindEnv("generated")  // STASH_GENERATED
+	viper.BindEnv("metadata")   // STASH_METADATA
+	viper.BindEnv("cache")      // STASH_CACHE
+}
 
 func initFFMPEG() {
 	configDirectory := paths.GetConfigDirectory()

pkg/models/generated_exec.go

@@ -56,8 +56,14 @@ type ComplexityRoot struct {
 		Stashes       func(childComplexity int) int
 	}
 
+	ConfigInterfaceResult struct {
+		CSS        func(childComplexity int) int
+		CSSEnabled func(childComplexity int) int
+	}
+
 	ConfigResult struct {
-		General func(childComplexity int) int
+		General   func(childComplexity int) int
+		Interface func(childComplexity int) int
 	}
 
 	FindGalleriesResultType struct {
@@ -107,6 +113,7 @@ type ComplexityRoot struct {
 
 	Mutation struct {
 		ConfigureGeneral   func(childComplexity int, input ConfigGeneralInput) int
+		ConfigureInterface func(childComplexity int, input ConfigInterfaceInput) int
 		PerformerCreate    func(childComplexity int, input PerformerCreateInput) int
 		PerformerDestroy   func(childComplexity int, input PerformerDestroyInput) int
 		PerformerUpdate    func(childComplexity int, input PerformerUpdateInput) int
@@ -304,6 +311,7 @@ type MutationResolver interface {
 	TagUpdate(ctx context.Context, input TagUpdateInput) (*Tag, error)
 	TagDestroy(ctx context.Context, input TagDestroyInput) (bool, error)
 	ConfigureGeneral(ctx context.Context, input ConfigGeneralInput) (*ConfigGeneralResult, error)
+	ConfigureInterface(ctx context.Context, input ConfigInterfaceInput) (*ConfigInterfaceResult, error)
 }
 type PerformerResolver interface {
 	Name(ctx context.Context, obj *Performer) (*string, error)
@@ -431,6 +439,20 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 
 		return e.complexity.ConfigGeneralResult.Stashes(childComplexity), true
 
+	case "ConfigInterfaceResult.css":
+		if e.complexity.ConfigInterfaceResult.CSS == nil {
+			break
+		}
+
+		return e.complexity.ConfigInterfaceResult.CSS(childComplexity), true
+
+	case "ConfigInterfaceResult.cssEnabled":
+		if e.complexity.ConfigInterfaceResult.CSSEnabled == nil {
+			break
+		}
+
+		return e.complexity.ConfigInterfaceResult.CSSEnabled(childComplexity), true
+
 	case "ConfigResult.general":
 		if e.complexity.ConfigResult.General == nil {
 			break
@@ -438,6 +460,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 
 		return e.complexity.ConfigResult.General(childComplexity), true
 
+	case "ConfigResult.interface":
+		if e.complexity.ConfigResult.Interface == nil {
+			break
+		}
+
+		return e.complexity.ConfigResult.Interface(childComplexity), true
+
 	case "FindGalleriesResultType.count":
 		if e.complexity.FindGalleriesResultType.Count == nil {
 			break
@@ -597,6 +626,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in
 
 		return e.complexity.Mutation.ConfigureGeneral(childComplexity, args["input"].(ConfigGeneralInput)), true
 
+	case "Mutation.configureInterface":
+		if e.complexity.Mutation.ConfigureInterface == nil {
+			break
+		}
+
+		args, err := ec.field_Mutation_configureInterface_args(context.TODO(), rawArgs)
+		if err != nil {
+			return 0, false
+		}
+
+		return e.complexity.Mutation.ConfigureInterface(childComplexity, args["input"].(ConfigInterfaceInput)), true
+
 	case "Mutation.performerCreate":
 		if e.complexity.Mutation.PerformerCreate == nil {
 			break
@@ -1911,6 +1952,7 @@ type Mutation {
 
   """Change general configuration options"""
   configureGeneral(input: ConfigGeneralInput!): ConfigGeneralResult!
+  configureInterface(input: ConfigInterfaceInput!): ConfigInterfaceResult!
 }
 
 type Subscription {
@@ -1941,9 +1983,22 @@ type ConfigGeneralResult {
   generatedPath: String!
 }
 
+input ConfigInterfaceInput {
+  """Custom CSS"""
+  css: String
+  cssEnabled: Boolean
+}
+
+type ConfigInterfaceResult {
+  """Custom CSS"""
+  css: String
+  cssEnabled: Boolean
+}
+
 """All configuration settings"""
 type ConfigResult {
   general: ConfigGeneralResult!
+  interface: ConfigInterfaceResult!
 }`},
 	&ast.Source{Name: "graphql/schema/types/filters.graphql", Input: `enum SortDirectionEnum {
   ASC
@@ -2329,6 +2384,20 @@ func (ec *executionContext) field_Mutation_configureGeneral_args(ctx context.Con
 	return args, nil
 }
 
+func (ec *executionContext) field_Mutation_configureInterface_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
+	var err error
+	args := map[string]interface{}{}
+	var arg0 ConfigInterfaceInput
+	if tmp, ok := rawArgs["input"]; ok {
+		arg0, err = ec.unmarshalNConfigInterfaceInput2githubᚗcomᚋstashappᚋstashᚋpkgᚋmodelsᚐConfigInterfaceInput(ctx, tmp)
+		if err != nil {
+			return nil, err
+		}
+	}
+	args["input"] = arg0
+	return args, nil
+}
+
 func (ec *executionContext) field_Mutation_performerCreate_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 	var err error
 	args := map[string]interface{}{}
@@ -2952,6 +3021,54 @@ func (ec *executionContext) _ConfigGeneralResult_generatedPath(ctx context.Conte
 	return ec.marshalNString2string(ctx, field.Selections, res)
 }
 
+func (ec *executionContext) _ConfigInterfaceResult_css(ctx context.Context, field graphql.CollectedField, obj *ConfigInterfaceResult) graphql.Marshaler {
+	ctx = ec.Tracer.StartFieldExecution(ctx, field)
+	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+	rctx := &graphql.ResolverContext{
+		Object:   "ConfigInterfaceResult",
+		Field:    field,
+		Args:     nil,
+		IsMethod: false,
+	}
+	ctx = graphql.WithResolverContext(ctx, rctx)
+	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.CSS, nil
+	})
+	if resTmp == nil {
+		return graphql.Null
+	}
+	res := resTmp.(*string)
+	rctx.Result = res
+	ctx = ec.Tracer.StartFieldChildExecution(ctx)
+	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
+}
+
+func (ec *executionContext) _ConfigInterfaceResult_cssEnabled(ctx context.Context, field graphql.CollectedField, obj *ConfigInterfaceResult) graphql.Marshaler {
+	ctx = ec.Tracer.StartFieldExecution(ctx, field)
+	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+	rctx := &graphql.ResolverContext{
+		Object:   "ConfigInterfaceResult",
+		Field:    field,
+		Args:     nil,
+		IsMethod: false,
+	}
+	ctx = graphql.WithResolverContext(ctx, rctx)
+	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.CSSEnabled, nil
+	})
+	if resTmp == nil {
+		return graphql.Null
+	}
+	res := resTmp.(*bool)
+	rctx.Result = res
+	ctx = ec.Tracer.StartFieldChildExecution(ctx)
+	return ec.marshalOBoolean2ᚖbool(ctx, field.Selections, res)
+}
+
 func (ec *executionContext) _ConfigResult_general(ctx context.Context, field graphql.CollectedField, obj *ConfigResult) graphql.Marshaler {
 	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
@@ -2979,6 +3096,33 @@ func (ec *executionContext) _ConfigResult_general(ctx context.Context, field gra
 	return ec.marshalNConfigGeneralResult2ᚖgithubᚗcomᚋstashappᚋstashᚋpkgᚋmodelsᚐConfigGeneralResult(ctx, field.Selections, res)
 }
 
+func (ec *executionContext) _ConfigResult_interface(ctx context.Context, field graphql.CollectedField, obj *ConfigResult) graphql.Marshaler {
+	ctx = ec.Tracer.StartFieldExecution(ctx, field)
+	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+	rctx := &graphql.ResolverContext{
+		Object:   "ConfigResult",
+		Field:    field,
+		Args:     nil,
+		IsMethod: false,
+	}
+	ctx = graphql.WithResolverContext(ctx, rctx)
+	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return obj.Interface, nil
+	})
+	if resTmp == nil {
+		if !ec.HasError(rctx) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(*ConfigInterfaceResult)
+	rctx.Result = res
+	ctx = ec.Tracer.StartFieldChildExecution(ctx)
+	return ec.marshalNConfigInterfaceResult2ᚖgithubᚗcomᚋstashappᚋstashᚋpkgᚋmodelsᚐConfigInterfaceResult(ctx, field.Selections, res)
+}
+
 func (ec *executionContext) _FindGalleriesResultType_count(ctx context.Context, field graphql.CollectedField, obj *FindGalleriesResultType) graphql.Marshaler {
 	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
@@ -3986,6 +4130,40 @@ func (ec *executionContext) _Mutation_configureGeneral(ctx context.Context, fiel
 	return ec.marshalNConfigGeneralResult2ᚖgithubᚗcomᚋstashappᚋstashᚋpkgᚋmodelsᚐConfigGeneralResult(ctx, field.Selections, res)
 }
 
+func (ec *executionContext) _Mutation_configureInterface(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
+	ctx = ec.Tracer.StartFieldExecution(ctx, field)
+	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
+	rctx := &graphql.ResolverContext{
+		Object:   "Mutation",
+		Field:    field,
+		Args:     nil,
+		IsMethod: true,
+	}
+	ctx = graphql.WithResolverContext(ctx, rctx)
+	rawArgs := field.ArgumentMap(ec.Variables)
+	args, err := ec.field_Mutation_configureInterface_args(ctx, rawArgs)
+	if err != nil {
+		ec.Error(ctx, err)
+		return graphql.Null
+	}
+	rctx.Args = args
+	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
+	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
+		ctx = rctx // use context from middleware stack in children
+		return ec.resolvers.Mutation().ConfigureInterface(rctx, args["input"].(ConfigInterfaceInput))
+	})
+	if resTmp == nil {
+		if !ec.HasError(rctx) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	res := resTmp.(*ConfigInterfaceResult)
+	rctx.Result = res
+	ctx = ec.Tracer.StartFieldChildExecution(ctx)
+	return ec.marshalNConfigInterfaceResult2ᚖgithubᚗcomᚋstashappᚋstashᚋpkgᚋmodelsᚐConfigInterfaceResult(ctx, field.Selections, res)
+}
+
 func (ec *executionContext) _Performer_id(ctx context.Context, field graphql.CollectedField, obj *Performer) graphql.Marshaler {
 	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
@@ -8165,6 +8343,30 @@ func (ec *executionContext) unmarshalInputConfigGeneralInput(ctx context.Context
 	return it, nil
 }
 
+func (ec *executionContext) unmarshalInputConfigInterfaceInput(ctx context.Context, v interface{}) (ConfigInterfaceInput, error) {
+	var it ConfigInterfaceInput
+	var asMap = v.(map[string]interface{})
+
+	for k, v := range asMap {
+		switch k {
+		case "css":
+			var err error
+			it.CSS, err = ec.unmarshalOString2ᚖstring(ctx, v)
+			if err != nil {
+				return it, err
+			}
+		case "cssEnabled":
+			var err error
+			it.CSSEnabled, err = ec.unmarshalOBoolean2ᚖbool(ctx, v)
+			if err != nil {
+				return it, err
+			}
+		}
+	}
+
+	return it, nil
+}
+
 func (ec *executionContext) unmarshalInputFindFilterType(ctx context.Context, v interface{}) (FindFilterType, error) {
 	var it FindFilterType
 	var asMap = v.(map[string]interface{})
@@ -8984,6 +9186,32 @@ func (ec *executionContext) _ConfigGeneralResult(ctx context.Context, sel ast.Se
 	return out
 }
 
+var configInterfaceResultImplementors = []string{"ConfigInterfaceResult"}
+
+func (ec *executionContext) _ConfigInterfaceResult(ctx context.Context, sel ast.SelectionSet, obj *ConfigInterfaceResult) graphql.Marshaler {
+	fields := graphql.CollectFields(ec.RequestContext, sel, configInterfaceResultImplementors)
+
+	out := graphql.NewFieldSet(fields)
+	var invalids uint32
+	for i, field := range fields {
+		switch field.Name {
+		case "__typename":
+			out.Values[i] = graphql.MarshalString("ConfigInterfaceResult")
+		case "css":
+			out.Values[i] = ec._ConfigInterfaceResult_css(ctx, field, obj)
+		case "cssEnabled":
+			out.Values[i] = ec._ConfigInterfaceResult_cssEnabled(ctx, field, obj)
+		default:
+			panic("unknown field " + strconv.Quote(field.Name))
+		}
+	}
+	out.Dispatch()
+	if invalids > 0 {
+		return graphql.Null
+	}
+	return out
+}
+
 var configResultImplementors = []string{"ConfigResult"}
 
 func (ec *executionContext) _ConfigResult(ctx context.Context, sel ast.SelectionSet, obj *ConfigResult) graphql.Marshaler {
@@ -9000,6 +9228,11 @@ func (ec *executionContext) _ConfigResult(ctx context.Context, sel ast.Selection
 			if out.Values[i] == graphql.Null {
 				invalids++
 			}
+		case "interface":
+			out.Values[i] = ec._ConfigResult_interface(ctx, field, obj)
+			if out.Values[i] == graphql.Null {
+				invalids++
+			}
 		default:
 			panic("unknown field " + strconv.Quote(field.Name))
 		}
@@ -9359,6 +9592,11 @@ func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet)
 			if out.Values[i] == graphql.Null {
 				invalids++
 			}
+		case "configureInterface":
+			out.Values[i] = ec._Mutation_configureInterface(ctx, field)
+			if out.Values[i] == graphql.Null {
+				invalids++
+			}
 		default:
 			panic("unknown field " + strconv.Quote(field.Name))
 		}
@@ -11005,6 +11243,24 @@ func (ec *executionContext) marshalNConfigGeneralResult2ᚖgithubᚗcomᚋstasha
 	return ec._ConfigGeneralResult(ctx, sel, v)
 }
 
+func (ec *executionContext) unmarshalNConfigInterfaceInput2githubᚗcomᚋstashappᚋstashᚋpkgᚋmodelsᚐConfigInterfaceInput(ctx context.Context, v interface{}) (ConfigInterfaceInput, error) {
+	return ec.unmarshalInputConfigInterfaceInput(ctx, v)
+}
+
+func (ec *executionContext) marshalNConfigInterfaceResult2githubᚗcomᚋstashappᚋstashᚋpkgᚋmodelsᚐConfigInterfaceResult(ctx context.Context, sel ast.SelectionSet, v ConfigInterfaceResult) graphql.Marshaler {
+	return ec._ConfigInterfaceResult(ctx, sel, &v)
+}
+
+func (ec *executionContext) marshalNConfigInterfaceResult2ᚖgithubᚗcomᚋstashappᚋstashᚋpkgᚋmodelsᚐConfigInterfaceResult(ctx context.Context, sel ast.SelectionSet, v *ConfigInterfaceResult) graphql.Marshaler {
+	if v == nil {
+		if !ec.HasError(graphql.GetResolverContext(ctx)) {
+			ec.Errorf(ctx, "must not be null")
+		}
+		return graphql.Null
+	}
+	return ec._ConfigInterfaceResult(ctx, sel, v)
+}
+
 func (ec *executionContext) marshalNConfigResult2githubᚗcomᚋstashappᚋstashᚋpkgᚋmodelsᚐConfigResult(ctx context.Context, sel ast.SelectionSet, v ConfigResult) graphql.Marshaler {
 	return ec._ConfigResult(ctx, sel, &v)
 }

pkg/models/generated_models.go

@@ -26,9 +26,22 @@ type ConfigGeneralResult struct {
 	GeneratedPath string `json:"generatedPath"`
 }
 
+type ConfigInterfaceInput struct {
+	// Custom CSS
+	CSS        *string `json:"css"`
+	CSSEnabled *bool   `json:"cssEnabled"`
+}
+
+type ConfigInterfaceResult struct {
+	// Custom CSS
+	CSS        *string `json:"css"`
+	CSSEnabled *bool   `json:"cssEnabled"`
+}
+
 // All configuration settings
 type ConfigResult struct {
-	General *ConfigGeneralResult `json:"general"`
+	General   *ConfigGeneralResult   `json:"general"`
+	Interface *ConfigInterfaceResult `json:"interface"`
 }
 
 type FindFilterType struct {