From b42cc1549a0c51078ebb04c7641b78dafb97d9d3 Mon Sep 17 00:00:00 2001 From: Lakhan Samani Date: Mon, 24 Jan 2022 10:22:55 +0530 Subject: [PATCH] fix: env to return custom access token script --- server/graph/generated/generated.go | 181 ++++++++++++++++++++++++++++ server/graph/model/models_gen.go | 5 + server/graph/schema.graphqls | 5 + server/resolvers/env.go | 8 ++ 4 files changed, 199 insertions(+) diff --git a/server/graph/generated/generated.go b/server/graph/generated/generated.go index 6953b26..a6f7dad 100644 --- a/server/graph/generated/generated.go +++ b/server/graph/generated/generated.go @@ -56,6 +56,10 @@ type ComplexityRoot struct { AppURL func(childComplexity int) int AuthorizerURL func(childComplexity int) int CookieName func(childComplexity int) int + CustomAccessTokenScript func(childComplexity int) int + DatabaseName func(childComplexity int) int + DatabaseType func(childComplexity int) int + DatabaseURL func(childComplexity int) int DefaultRoles func(childComplexity int) int DisableBasicAuthentication func(childComplexity int) int DisableEmailVerification func(childComplexity int) int @@ -273,6 +277,34 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Env.CookieName(childComplexity), true + case "Env.CUSTOM_ACCESS_TOKEN_SCRIPT": + if e.complexity.Env.CustomAccessTokenScript == nil { + break + } + + return e.complexity.Env.CustomAccessTokenScript(childComplexity), true + + case "Env.DATABASE_NAME": + if e.complexity.Env.DatabaseName == nil { + break + } + + return e.complexity.Env.DatabaseName(childComplexity), true + + case "Env.DATABASE_TYPE": + if e.complexity.Env.DatabaseType == nil { + break + } + + return e.complexity.Env.DatabaseType(childComplexity), true + + case "Env.DATABASE_URL": + if e.complexity.Env.DatabaseURL == nil { + break + } + + return e.complexity.Env.DatabaseURL(childComplexity), true + case "Env.DEFAULT_ROLES": if e.complexity.Env.DefaultRoles == nil { break @@ -1071,6 +1103,10 @@ type ValidJWTResponse { type Env { ADMIN_SECRET: String + DATABASE_NAME: String + DATABASE_URL: String + DATABASE_TYPE: String + CUSTOM_ACCESS_TOKEN_SCRIPT: String SMTP_HOST: String SMTP_PORT: String SMTP_USERNAME: String @@ -1104,6 +1140,7 @@ type Env { input UpdateEnvInput { ADMIN_SECRET: String + CUSTOM_ACCESS_TOKEN_SCRIPT: String OLD_ADMIN_SECRET: String SMTP_HOST: String SMTP_PORT: String @@ -1710,6 +1747,134 @@ func (ec *executionContext) _Env_ADMIN_SECRET(ctx context.Context, field graphql return ec.marshalOString2ᚖstring(ctx, field.Selections, res) } +func (ec *executionContext) _Env_DATABASE_NAME(ctx context.Context, field graphql.CollectedField, obj *model.Env) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "Env", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.DatabaseName, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*string) + fc.Result = res + return ec.marshalOString2ᚖstring(ctx, field.Selections, res) +} + +func (ec *executionContext) _Env_DATABASE_URL(ctx context.Context, field graphql.CollectedField, obj *model.Env) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "Env", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.DatabaseURL, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*string) + fc.Result = res + return ec.marshalOString2ᚖstring(ctx, field.Selections, res) +} + +func (ec *executionContext) _Env_DATABASE_TYPE(ctx context.Context, field graphql.CollectedField, obj *model.Env) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "Env", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.DatabaseType, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*string) + fc.Result = res + return ec.marshalOString2ᚖstring(ctx, field.Selections, res) +} + +func (ec *executionContext) _Env_CUSTOM_ACCESS_TOKEN_SCRIPT(ctx context.Context, field graphql.CollectedField, obj *model.Env) (ret graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + fc := &graphql.FieldContext{ + Object: "Env", + Field: field, + Args: nil, + IsMethod: false, + IsResolver: false, + } + + ctx = graphql.WithFieldContext(ctx, fc) + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.CustomAccessTokenScript, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*string) + fc.Result = res + return ec.marshalOString2ᚖstring(ctx, field.Selections, res) +} + func (ec *executionContext) _Env_SMTP_HOST(ctx context.Context, field graphql.CollectedField, obj *model.Env) (ret graphql.Marshaler) { defer func() { if r := recover(); r != nil { @@ -6361,6 +6526,14 @@ func (ec *executionContext) unmarshalInputUpdateEnvInput(ctx context.Context, ob if err != nil { return it, err } + case "CUSTOM_ACCESS_TOKEN_SCRIPT": + var err error + + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("CUSTOM_ACCESS_TOKEN_SCRIPT")) + it.CustomAccessTokenScript, err = ec.unmarshalOString2ᚖstring(ctx, v) + if err != nil { + return it, err + } case "OLD_ADMIN_SECRET": var err error @@ -6898,6 +7071,14 @@ func (ec *executionContext) _Env(ctx context.Context, sel ast.SelectionSet, obj out.Values[i] = graphql.MarshalString("Env") case "ADMIN_SECRET": out.Values[i] = ec._Env_ADMIN_SECRET(ctx, field, obj) + case "DATABASE_NAME": + out.Values[i] = ec._Env_DATABASE_NAME(ctx, field, obj) + case "DATABASE_URL": + out.Values[i] = ec._Env_DATABASE_URL(ctx, field, obj) + case "DATABASE_TYPE": + out.Values[i] = ec._Env_DATABASE_TYPE(ctx, field, obj) + case "CUSTOM_ACCESS_TOKEN_SCRIPT": + out.Values[i] = ec._Env_CUSTOM_ACCESS_TOKEN_SCRIPT(ctx, field, obj) case "SMTP_HOST": out.Values[i] = ec._Env_SMTP_HOST(ctx, field, obj) case "SMTP_PORT": diff --git a/server/graph/model/models_gen.go b/server/graph/model/models_gen.go index 53d3d3b..0f98755 100644 --- a/server/graph/model/models_gen.go +++ b/server/graph/model/models_gen.go @@ -23,6 +23,10 @@ type DeleteUserInput struct { type Env struct { AdminSecret *string `json:"ADMIN_SECRET"` + DatabaseName *string `json:"DATABASE_NAME"` + DatabaseURL *string `json:"DATABASE_URL"` + DatabaseType *string `json:"DATABASE_TYPE"` + CustomAccessTokenScript *string `json:"CUSTOM_ACCESS_TOKEN_SCRIPT"` SMTPHost *string `json:"SMTP_HOST"` SMTPPort *string `json:"SMTP_PORT"` SMTPUsername *string `json:"SMTP_USERNAME"` @@ -125,6 +129,7 @@ type SignUpInput struct { type UpdateEnvInput struct { AdminSecret *string `json:"ADMIN_SECRET"` + CustomAccessTokenScript *string `json:"CUSTOM_ACCESS_TOKEN_SCRIPT"` OldAdminSecret *string `json:"OLD_ADMIN_SECRET"` SMTPHost *string `json:"SMTP_HOST"` SMTPPort *string `json:"SMTP_PORT"` diff --git a/server/graph/schema.graphqls b/server/graph/schema.graphqls index 2ff8f59..0eaa5bf 100644 --- a/server/graph/schema.graphqls +++ b/server/graph/schema.graphqls @@ -69,6 +69,10 @@ type ValidJWTResponse { type Env { ADMIN_SECRET: String + DATABASE_NAME: String + DATABASE_URL: String + DATABASE_TYPE: String + CUSTOM_ACCESS_TOKEN_SCRIPT: String SMTP_HOST: String SMTP_PORT: String SMTP_USERNAME: String @@ -102,6 +106,7 @@ type Env { input UpdateEnvInput { ADMIN_SECRET: String + CUSTOM_ACCESS_TOKEN_SCRIPT: String OLD_ADMIN_SECRET: String SMTP_HOST: String SMTP_PORT: String diff --git a/server/resolvers/env.go b/server/resolvers/env.go index 02b772c..de7d0d5 100644 --- a/server/resolvers/env.go +++ b/server/resolvers/env.go @@ -28,6 +28,10 @@ func EnvResolver(ctx context.Context) (*model.Env, error) { // get clone of store store := envstore.EnvInMemoryStoreObj.GetEnvStoreClone() adminSecret := store.StringEnv[constants.EnvKeyAdminSecret] + databaseURL := store.StringEnv[constants.EnvKeyDatabaseURL] + databaseName := store.StringEnv[constants.EnvKeyDatabaseName] + databaseType := store.StringEnv[constants.EnvKeyDatabaseType] + customAccessTokenScript := store.StringEnv[constants.EnvKeyCustomAccessTokenScript] smtpHost := store.StringEnv[constants.EnvKeySmtpHost] smtpPort := store.StringEnv[constants.EnvKeySmtpPort] smtpUsername := store.StringEnv[constants.EnvKeySmtpUsername] @@ -60,6 +64,10 @@ func EnvResolver(ctx context.Context) (*model.Env, error) { res = &model.Env{ AdminSecret: &adminSecret, + DatabaseName: &databaseName, + DatabaseURL: &databaseURL, + DatabaseType: &databaseType, + CustomAccessTokenScript: &customAccessTokenScript, SMTPHost: &smtpHost, SMTPPort: &smtpPort, SMTPPassword: &smtpPassword,