diff --git a/cmd/config/example.go b/cmd/config/example.go index e3c1c72c7..ac9836c69 100644 --- a/cmd/config/example.go +++ b/cmd/config/example.go @@ -106,6 +106,10 @@ func commandExample(cCtx *cli.Context) error { //nolint:funlen,maintidx }, Autoscaler: nil, }, + RateLimit: &model.ConfigRateLimit{ + Limit: 100, + Interval: "15m", + }, }, Functions: &model.ConfigFunctions{ Node: &model.ConfigFunctionsNode{ @@ -120,6 +124,10 @@ func commandExample(cCtx *cli.Context) error { //nolint:funlen,maintidx }, }, }, + RateLimit: &model.ConfigRateLimit{ + Limit: 100, + Interval: "15m", + }, }, Auth: &model.ConfigAuth{ Version: ptr("0.25.0"), @@ -314,6 +322,28 @@ func commandExample(cCtx *cli.Context) error { //nolint:funlen,maintidx Enabled: ptr(true), Issuer: ptr("issuer"), }, + RateLimit: &model.ConfigAuthRateLimit{ + Emails: &model.ConfigRateLimit{ + Limit: 10, + Interval: "5m", + }, + Sms: &model.ConfigRateLimit{ + Limit: 10, + Interval: "5m", + }, + BruteForce: &model.ConfigRateLimit{ + Limit: 10, + Interval: "5m", + }, + Signups: &model.ConfigRateLimit{ + Limit: 10, + Interval: "5m", + }, + Global: &model.ConfigRateLimit{ + Limit: 100, + Interval: "15m", + }, + }, }, Postgres: &model.ConfigPostgres{ Version: ptr("14-20230312-1"), @@ -385,6 +415,10 @@ func commandExample(cCtx *cli.Context) error { //nolint:funlen,maintidx Replicas: ptr(uint8(1)), Autoscaler: nil, }, + RateLimit: &model.ConfigRateLimit{ + Limit: 100, + Interval: "15m", + }, }, Observability: &model.ConfigObservability{ Grafana: &model.ConfigGrafana{ diff --git a/cmd/config/validate_test.go b/cmd/config/validate_test.go index 605edc131..a9d0aa6b8 100644 --- a/cmd/config/validate_test.go +++ b/cmd/config/validate_test.go @@ -171,6 +171,28 @@ func expectedConfig() *model.ConfigConfig { }, }, Totp: &model.ConfigAuthTotp{Enabled: ptr(false)}, + RateLimit: &model.ConfigAuthRateLimit{ + Emails: &model.ConfigRateLimit{ + Limit: 10, + Interval: "1h", + }, + Sms: &model.ConfigRateLimit{ + Limit: 10, + Interval: "1h", + }, + BruteForce: &model.ConfigRateLimit{ + Limit: 10, + Interval: "5m", + }, + Signups: &model.ConfigRateLimit{ + Limit: 10, + Interval: "5m", + }, + Global: &model.ConfigRateLimit{ + Limit: 100, + Interval: "1m", + }, + }, }, Postgres: &model.ConfigPostgres{Version: ptr("14.6-20230406-2")}, Provider: &model.ConfigProvider{}, diff --git a/dockercompose/auth.go b/dockercompose/auth.go index c81e6c662..4c9c42b14 100644 --- a/dockercompose/auth.go +++ b/dockercompose/auth.go @@ -49,6 +49,9 @@ func auth( //nolint:funlen Secure: false, Method: "LOGIN", }, + false, + false, + "00000000-0000-0000-0000-000000000000", ) if err != nil { return nil, fmt.Errorf("failed to get hasura env vars: %w", err) diff --git a/dockercompose/auth_test.go b/dockercompose/auth_test.go index cd9b7188b..295585c57 100644 --- a/dockercompose/auth_test.go +++ b/dockercompose/auth_test.go @@ -102,6 +102,18 @@ func expectedAuth() *Service { "AUTH_PROVIDER_WORKOS_DEFAULT_CONNECTION": "workosConnection", "AUTH_PROVIDER_WORKOS_DEFAULT_ORGANIZATION": "workosOrganization", "AUTH_PROVIDER_WORKOS_ENABLED": "true", + "AUTH_RATE_LIMIT_BRUTE_FORCE_BURST": "3", + "AUTH_RATE_LIMIT_BRUTE_FORCE_INTERVAL": "5m", + "AUTH_RATE_LIMIT_EMAIL_BURST": "3", + "AUTH_RATE_LIMIT_EMAIL_INTERVAL": "5m", + "AUTH_RATE_LIMIT_EMAIL_IS_GLOBAL": "true", + "AUTH_RATE_LIMIT_ENABLE": "true", + "AUTH_RATE_LIMIT_GLOBAL_BURST": "33", + "AUTH_RATE_LIMIT_GLOBAL_INTERVAL": "15m", + "AUTH_RATE_LIMIT_SIGNUPS_BURST": "3", + "AUTH_RATE_LIMIT_SIGNUPS_INTERVAL": "5m", + "AUTH_RATE_LIMIT_SMS_BURST": "3", + "AUTH_RATE_LIMIT_SMS_INTERVAL": "5m", "AUTH_REFRESH_TOKEN_EXPIRES_IN": "99", "AUTH_REQUIRE_ELEVATED_CLAIM": "required", "AUTH_SERVER_URL": "http://dev.auth.local.nhost.run:1336/v1", diff --git a/dockercompose/main_test.go b/dockercompose/main_test.go index 3a1e99af5..c8743c518 100644 --- a/dockercompose/main_test.go +++ b/dockercompose/main_test.go @@ -37,6 +37,28 @@ func getConfig() *model.ConfigConfig { //nolint:maintidx Networking: nil, Autoscaler: nil, }, + RateLimit: &model.ConfigAuthRateLimit{ + Emails: &model.ConfigRateLimit{ + Limit: 10, + Interval: "5m", + }, + Sms: &model.ConfigRateLimit{ + Limit: 10, + Interval: "5m", + }, + BruteForce: &model.ConfigRateLimit{ + Limit: 10, + Interval: "5m", + }, + Signups: &model.ConfigRateLimit{ + Limit: 10, + Interval: "5m", + }, + Global: &model.ConfigRateLimit{ + Limit: 100, + Interval: "15m", + }, + }, Method: &model.ConfigAuthMethod{ Anonymous: &model.ConfigAuthMethodAnonymous{ Enabled: ptr(true), @@ -224,6 +246,7 @@ func getConfig() *model.ConfigConfig { //nolint:maintidx Node: &model.ConfigFunctionsNode{ Version: ptr(18), }, + RateLimit: nil, Resources: &model.ConfigFunctionsResources{ Networking: &model.ConfigNetworking{ Ingresses: []*model.ConfigIngress{ @@ -235,6 +258,7 @@ func getConfig() *model.ConfigConfig { //nolint:maintidx }, }, Hasura: &model.ConfigHasura{ + RateLimit: nil, Resources: &model.ConfigResources{ Compute: &model.ConfigResourcesCompute{ Cpu: 1000, @@ -315,6 +339,7 @@ func getConfig() *model.ConfigConfig { //nolint:maintidx }, }, Storage: &model.ConfigStorage{ + RateLimit: nil, Resources: &model.ConfigResources{ Compute: &model.ConfigResourcesCompute{ Cpu: 500, diff --git a/go.mod b/go.mod index 9895c59b1..b6283f438 100644 --- a/go.mod +++ b/go.mod @@ -14,7 +14,7 @@ require ( github.com/google/go-cmp v0.6.0 github.com/google/uuid v1.6.0 github.com/hashicorp/go-getter v1.7.5 - github.com/nhost/be v0.0.0-20240806070711-58ddcca3b692 + github.com/nhost/be v0.0.0-20240820101832-63c0798e013b github.com/pelletier/go-toml/v2 v2.2.2 github.com/rs/cors/wrapper/gin v0.0.0-20240515105523-1562b1715b35 github.com/sirupsen/logrus v1.9.3 diff --git a/go.sum b/go.sum index 2e86d7745..5479e1416 100644 --- a/go.sum +++ b/go.sum @@ -513,6 +513,8 @@ github.com/nhost/be v0.0.0-20240803071828-881aaa1f7511 h1:Qtm86sqEG50dZzz+7wtpCl github.com/nhost/be v0.0.0-20240803071828-881aaa1f7511/go.mod h1:iNulO8zDQ+jslaNRAm5NKY0W7sJeQ4INvQdS0AEN06w= github.com/nhost/be v0.0.0-20240806070711-58ddcca3b692 h1:KtBE/qk42z4WUIpYb0jMKZz1mQrcxdenHrpL2Gg89FI= github.com/nhost/be v0.0.0-20240806070711-58ddcca3b692/go.mod h1:iNulO8zDQ+jslaNRAm5NKY0W7sJeQ4INvQdS0AEN06w= +github.com/nhost/be v0.0.0-20240820101832-63c0798e013b h1:ZCrX/vGfhnhx5HvjUJUbmKG+6+1yj0FLLbJ+5N1/FYo= +github.com/nhost/be v0.0.0-20240820101832-63c0798e013b/go.mod h1:iNulO8zDQ+jslaNRAm5NKY0W7sJeQ4INvQdS0AEN06w= github.com/onsi/gomega v1.27.10 h1:naR28SdDFlqrG6kScpT8VWpu1xWY5nJRCF3XaYyBjhI= github.com/onsi/gomega v1.27.10/go.mod h1:RsS8tutOdbdgzbPtzzATp12yT7kM5I5aElG3evPbQ0M= github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM= diff --git a/vendor/github.com/nhost/be/services/mimir/graph/generated/generated.go b/vendor/github.com/nhost/be/services/mimir/graph/generated/generated.go index 6ac992b8c..eb50952de 100644 --- a/vendor/github.com/nhost/be/services/mimir/graph/generated/generated.go +++ b/vendor/github.com/nhost/be/services/mimir/graph/generated/generated.go @@ -88,6 +88,7 @@ type ComplexityRoot struct { ConfigAuth struct { ElevatedPrivileges func(childComplexity int) int Method func(childComplexity int) int + RateLimit func(childComplexity int) int Redirections func(childComplexity int) int Resources func(childComplexity int) int Session func(childComplexity int) int @@ -192,6 +193,14 @@ type ComplexityRoot struct { Origins func(childComplexity int) int } + ConfigAuthRateLimit struct { + BruteForce func(childComplexity int) int + Emails func(childComplexity int) int + Global func(childComplexity int) int + Signups func(childComplexity int) int + Sms func(childComplexity int) int + } + ConfigAuthRedirections struct { AllowedUrls func(childComplexity int) int ClientUrl func(childComplexity int) int @@ -296,6 +305,7 @@ type ComplexityRoot struct { ConfigFunctions struct { Node func(childComplexity int) int + RateLimit func(childComplexity int) int Resources func(childComplexity int) int } @@ -335,6 +345,7 @@ type ComplexityRoot struct { Events func(childComplexity int) int JwtSecrets func(childComplexity int) int Logs func(childComplexity int) int + RateLimit func(childComplexity int) int Resources func(childComplexity int) int Settings func(childComplexity int) int Version func(childComplexity int) int @@ -452,6 +463,11 @@ type ComplexityRoot struct { Smtp func(childComplexity int) int } + ConfigRateLimit struct { + Interval func(childComplexity int) int + Limit func(childComplexity int) int + } + ConfigResources struct { Autoscaler func(childComplexity int) int Compute func(childComplexity int) int @@ -487,6 +503,7 @@ type ComplexityRoot struct { Ingresses func(childComplexity int) int Port func(childComplexity int) int Publish func(childComplexity int) int + RateLimit func(childComplexity int) int Type func(childComplexity int) int } @@ -535,6 +552,7 @@ type ComplexityRoot struct { ConfigStorage struct { Antivirus func(childComplexity int) int + RateLimit func(childComplexity int) int Resources func(childComplexity int) int Version func(childComplexity int) int } @@ -785,6 +803,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.ConfigAuth.Method(childComplexity), true + case "ConfigAuth.rateLimit": + if e.complexity.ConfigAuth.RateLimit == nil { + break + } + + return e.complexity.ConfigAuth.RateLimit(childComplexity), true + case "ConfigAuth.redirections": if e.complexity.ConfigAuth.Redirections == nil { break @@ -1205,6 +1230,41 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.ConfigAuthMethodWebauthnRelyingParty.Origins(childComplexity), true + case "ConfigAuthRateLimit.bruteForce": + if e.complexity.ConfigAuthRateLimit.BruteForce == nil { + break + } + + return e.complexity.ConfigAuthRateLimit.BruteForce(childComplexity), true + + case "ConfigAuthRateLimit.emails": + if e.complexity.ConfigAuthRateLimit.Emails == nil { + break + } + + return e.complexity.ConfigAuthRateLimit.Emails(childComplexity), true + + case "ConfigAuthRateLimit.global": + if e.complexity.ConfigAuthRateLimit.Global == nil { + break + } + + return e.complexity.ConfigAuthRateLimit.Global(childComplexity), true + + case "ConfigAuthRateLimit.signups": + if e.complexity.ConfigAuthRateLimit.Signups == nil { + break + } + + return e.complexity.ConfigAuthRateLimit.Signups(childComplexity), true + + case "ConfigAuthRateLimit.sms": + if e.complexity.ConfigAuthRateLimit.Sms == nil { + break + } + + return e.complexity.ConfigAuthRateLimit.Sms(childComplexity), true + case "ConfigAuthRedirections.allowedUrls": if e.complexity.ConfigAuthRedirections.AllowedUrls == nil { break @@ -1548,6 +1608,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.ConfigFunctions.Node(childComplexity), true + case "ConfigFunctions.rateLimit": + if e.complexity.ConfigFunctions.RateLimit == nil { + break + } + + return e.complexity.ConfigFunctions.RateLimit(childComplexity), true + case "ConfigFunctions.resources": if e.complexity.ConfigFunctions.Resources == nil { break @@ -1653,6 +1720,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.ConfigHasura.Logs(childComplexity), true + case "ConfigHasura.rateLimit": + if e.complexity.ConfigHasura.RateLimit == nil { + break + } + + return e.complexity.ConfigHasura.RateLimit(childComplexity), true + case "ConfigHasura.resources": if e.complexity.ConfigHasura.Resources == nil { break @@ -2143,6 +2217,20 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.ConfigProvider.Smtp(childComplexity), true + case "ConfigRateLimit.interval": + if e.complexity.ConfigRateLimit.Interval == nil { + break + } + + return e.complexity.ConfigRateLimit.Interval(childComplexity), true + + case "ConfigRateLimit.limit": + if e.complexity.ConfigRateLimit.Limit == nil { + break + } + + return e.complexity.ConfigRateLimit.Limit(childComplexity), true + case "ConfigResources.autoscaler": if e.complexity.ConfigResources.Autoscaler == nil { break @@ -2276,6 +2364,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.ConfigRunServicePort.Publish(childComplexity), true + case "ConfigRunServicePort.rateLimit": + if e.complexity.ConfigRunServicePort.RateLimit == nil { + break + } + + return e.complexity.ConfigRunServicePort.RateLimit(childComplexity), true + case "ConfigRunServicePort.type": if e.complexity.ConfigRunServicePort.Type == nil { break @@ -2465,6 +2560,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.ConfigStorage.Antivirus(childComplexity), true + case "ConfigStorage.rateLimit": + if e.complexity.ConfigStorage.RateLimit == nil { + break + } + + return e.complexity.ConfigStorage.RateLimit(childComplexity), true + case "ConfigStorage.resources": if e.complexity.ConfigStorage.Resources == nil { break @@ -2953,6 +3055,8 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { ec.unmarshalInputConfigAuthMethodWebauthnInsertInput, ec.unmarshalInputConfigAuthMethodWebauthnRelyingPartyComparisonExp, ec.unmarshalInputConfigAuthMethodWebauthnRelyingPartyInsertInput, + ec.unmarshalInputConfigAuthRateLimitComparisonExp, + ec.unmarshalInputConfigAuthRateLimitInsertInput, ec.unmarshalInputConfigAuthRedirectionsComparisonExp, ec.unmarshalInputConfigAuthRedirectionsInsertInput, ec.unmarshalInputConfigAuthSessionAccessTokenComparisonExp, @@ -3046,6 +3150,8 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { ec.unmarshalInputConfigPostgresStorageInsertInput, ec.unmarshalInputConfigProviderComparisonExp, ec.unmarshalInputConfigProviderInsertInput, + ec.unmarshalInputConfigRateLimitComparisonExp, + ec.unmarshalInputConfigRateLimitInsertInput, ec.unmarshalInputConfigResourcesComparisonExp, ec.unmarshalInputConfigResourcesComputeComparisonExp, ec.unmarshalInputConfigResourcesComputeInsertInput, @@ -3635,6 +3741,10 @@ type ConfigAuth { """ totp: ConfigAuthTotp + """ + + """ + rateLimit: ConfigAuthRateLimit } input ConfigAuthUpdateInput { @@ -3647,6 +3757,7 @@ input ConfigAuthUpdateInput { session: ConfigAuthSessionUpdateInput method: ConfigAuthMethodUpdateInput totp: ConfigAuthTotpUpdateInput + rateLimit: ConfigAuthRateLimitUpdateInput } input ConfigAuthInsertInput { @@ -3659,6 +3770,7 @@ input ConfigAuthInsertInput { session: ConfigAuthSessionInsertInput method: ConfigAuthMethodInsertInput totp: ConfigAuthTotpInsertInput + rateLimit: ConfigAuthRateLimitInsertInput } input ConfigAuthComparisonExp { @@ -3674,6 +3786,7 @@ input ConfigAuthComparisonExp { session: ConfigAuthSessionComparisonExp method: ConfigAuthMethodComparisonExp totp: ConfigAuthTotpComparisonExp + rateLimit: ConfigAuthRateLimitComparisonExp } """ @@ -4302,6 +4415,59 @@ input ConfigAuthMethodWebauthnRelyingPartyComparisonExp { """ +""" +type ConfigAuthRateLimit { + """ + + """ + emails: ConfigRateLimit + """ + + """ + sms: ConfigRateLimit + """ + + """ + bruteForce: ConfigRateLimit + """ + + """ + signups: ConfigRateLimit + """ + + """ + global: ConfigRateLimit +} + +input ConfigAuthRateLimitUpdateInput { + emails: ConfigRateLimitUpdateInput + sms: ConfigRateLimitUpdateInput + bruteForce: ConfigRateLimitUpdateInput + signups: ConfigRateLimitUpdateInput + global: ConfigRateLimitUpdateInput +} + +input ConfigAuthRateLimitInsertInput { + emails: ConfigRateLimitInsertInput + sms: ConfigRateLimitInsertInput + bruteForce: ConfigRateLimitInsertInput + signups: ConfigRateLimitInsertInput + global: ConfigRateLimitInsertInput +} + +input ConfigAuthRateLimitComparisonExp { + _and: [ConfigAuthRateLimitComparisonExp!] + _not: ConfigAuthRateLimitComparisonExp + _or: [ConfigAuthRateLimitComparisonExp!] + emails: ConfigRateLimitComparisonExp + sms: ConfigRateLimitComparisonExp + bruteForce: ConfigRateLimitComparisonExp + signups: ConfigRateLimitComparisonExp + global: ConfigRateLimitComparisonExp +} + +""" + """ type ConfigAuthRedirections { """ @@ -4981,16 +5147,22 @@ type ConfigFunctions { """ resources: ConfigFunctionsResources + """ + + """ + rateLimit: ConfigRateLimit } input ConfigFunctionsUpdateInput { node: ConfigFunctionsNodeUpdateInput resources: ConfigFunctionsResourcesUpdateInput + rateLimit: ConfigRateLimitUpdateInput } input ConfigFunctionsInsertInput { node: ConfigFunctionsNodeInsertInput resources: ConfigFunctionsResourcesInsertInput + rateLimit: ConfigRateLimitInsertInput } input ConfigFunctionsComparisonExp { @@ -4999,6 +5171,7 @@ input ConfigFunctionsComparisonExp { _or: [ConfigFunctionsComparisonExp!] node: ConfigFunctionsNodeComparisonExp resources: ConfigFunctionsResourcesComparisonExp + rateLimit: ConfigRateLimitComparisonExp } """ @@ -5232,6 +5405,10 @@ type ConfigHasura { Resources for the service """ resources: ConfigResources + """ + + """ + rateLimit: ConfigRateLimit } input ConfigHasuraUpdateInput { @@ -5244,6 +5421,7 @@ input ConfigHasuraUpdateInput { logs: ConfigHasuraLogsUpdateInput events: ConfigHasuraEventsUpdateInput resources: ConfigResourcesUpdateInput + rateLimit: ConfigRateLimitUpdateInput } input ConfigHasuraInsertInput { @@ -5256,6 +5434,7 @@ input ConfigHasuraInsertInput { logs: ConfigHasuraLogsInsertInput events: ConfigHasuraEventsInsertInput resources: ConfigResourcesInsertInput + rateLimit: ConfigRateLimitInsertInput } input ConfigHasuraComparisonExp { @@ -5271,6 +5450,7 @@ input ConfigHasuraComparisonExp { logs: ConfigHasuraLogsComparisonExp events: ConfigHasuraEventsComparisonExp resources: ConfigResourcesComparisonExp + rateLimit: ConfigRateLimitComparisonExp } scalar ConfigHasuraAPIs @@ -5995,6 +6175,38 @@ input ConfigProviderComparisonExp { sms: ConfigSmsComparisonExp } +""" + +""" +type ConfigRateLimit { + """ + + """ + limit: ConfigUint32! + """ + + """ + interval: String! +} + +input ConfigRateLimitUpdateInput { + limit: ConfigUint32 + interval: String +} + +input ConfigRateLimitInsertInput { + limit: ConfigUint32! + interval: String! +} + +input ConfigRateLimitComparisonExp { + _and: [ConfigRateLimitComparisonExp!] + _not: ConfigRateLimitComparisonExp + _or: [ConfigRateLimitComparisonExp!] + limit: ConfigUint32ComparisonExp + interval: ConfigStringComparisonExp +} + """ Resource configuration for a service """ @@ -6194,6 +6406,10 @@ type ConfigRunServicePort { """ ingresses: [ConfigIngress!] + """ + + """ + rateLimit: ConfigRateLimit } input ConfigRunServicePortUpdateInput { @@ -6201,6 +6417,7 @@ input ConfigRunServicePortUpdateInput { type: String publish: Boolean ingresses: [ConfigIngressUpdateInput!] + rateLimit: ConfigRateLimitUpdateInput } input ConfigRunServicePortInsertInput { @@ -6208,6 +6425,7 @@ input ConfigRunServicePortInsertInput { type: String! publish: Boolean ingresses: [ConfigIngressInsertInput!] + rateLimit: ConfigRateLimitInsertInput } input ConfigRunServicePortComparisonExp { @@ -6218,6 +6436,7 @@ input ConfigRunServicePortComparisonExp { type: ConfigStringComparisonExp publish: ConfigBooleanComparisonExp ingresses: ConfigIngressComparisonExp + rateLimit: ConfigRateLimitComparisonExp } """ @@ -6525,18 +6744,24 @@ type ConfigStorage { """ antivirus: ConfigStorageAntivirus + """ + + """ + rateLimit: ConfigRateLimit } input ConfigStorageUpdateInput { version: String resources: ConfigResourcesUpdateInput antivirus: ConfigStorageAntivirusUpdateInput + rateLimit: ConfigRateLimitUpdateInput } input ConfigStorageInsertInput { version: String resources: ConfigResourcesInsertInput antivirus: ConfigStorageAntivirusInsertInput + rateLimit: ConfigRateLimitInsertInput } input ConfigStorageComparisonExp { @@ -6546,6 +6771,7 @@ input ConfigStorageComparisonExp { version: ConfigStringComparisonExp resources: ConfigResourcesComparisonExp antivirus: ConfigStorageAntivirusComparisonExp + rateLimit: ConfigRateLimitComparisonExp } """ @@ -9000,6 +9226,59 @@ func (ec *executionContext) fieldContext_ConfigAuth_totp(_ context.Context, fiel return fc, nil } +func (ec *executionContext) _ConfigAuth_rateLimit(ctx context.Context, field graphql.CollectedField, obj *model.ConfigAuth) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ConfigAuth_rateLimit(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.RateLimit, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*model.ConfigAuthRateLimit) + fc.Result = res + return ec.marshalOConfigAuthRateLimit2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimit(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ConfigAuth_rateLimit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigAuth", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "emails": + return ec.fieldContext_ConfigAuthRateLimit_emails(ctx, field) + case "sms": + return ec.fieldContext_ConfigAuthRateLimit_sms(ctx, field) + case "bruteForce": + return ec.fieldContext_ConfigAuthRateLimit_bruteForce(ctx, field) + case "signups": + return ec.fieldContext_ConfigAuthRateLimit_signups(ctx, field) + case "global": + return ec.fieldContext_ConfigAuthRateLimit_global(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigAuthRateLimit", field.Name) + }, + } + return fc, nil +} + func (ec *executionContext) _ConfigAuthElevatedPrivileges_mode(ctx context.Context, field graphql.CollectedField, obj *model.ConfigAuthElevatedPrivileges) (ret graphql.Marshaler) { fc, err := ec.fieldContext_ConfigAuthElevatedPrivileges_mode(ctx, field) if err != nil { @@ -11397,6 +11676,241 @@ func (ec *executionContext) fieldContext_ConfigAuthMethodWebauthnRelyingParty_or return fc, nil } +func (ec *executionContext) _ConfigAuthRateLimit_emails(ctx context.Context, field graphql.CollectedField, obj *model.ConfigAuthRateLimit) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ConfigAuthRateLimit_emails(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Emails, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*model.ConfigRateLimit) + fc.Result = res + return ec.marshalOConfigRateLimit2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimit(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ConfigAuthRateLimit_emails(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigAuthRateLimit", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "limit": + return ec.fieldContext_ConfigRateLimit_limit(ctx, field) + case "interval": + return ec.fieldContext_ConfigRateLimit_interval(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigRateLimit", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigAuthRateLimit_sms(ctx context.Context, field graphql.CollectedField, obj *model.ConfigAuthRateLimit) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ConfigAuthRateLimit_sms(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Sms, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*model.ConfigRateLimit) + fc.Result = res + return ec.marshalOConfigRateLimit2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimit(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ConfigAuthRateLimit_sms(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigAuthRateLimit", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "limit": + return ec.fieldContext_ConfigRateLimit_limit(ctx, field) + case "interval": + return ec.fieldContext_ConfigRateLimit_interval(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigRateLimit", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigAuthRateLimit_bruteForce(ctx context.Context, field graphql.CollectedField, obj *model.ConfigAuthRateLimit) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ConfigAuthRateLimit_bruteForce(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.BruteForce, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*model.ConfigRateLimit) + fc.Result = res + return ec.marshalOConfigRateLimit2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimit(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ConfigAuthRateLimit_bruteForce(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigAuthRateLimit", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "limit": + return ec.fieldContext_ConfigRateLimit_limit(ctx, field) + case "interval": + return ec.fieldContext_ConfigRateLimit_interval(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigRateLimit", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigAuthRateLimit_signups(ctx context.Context, field graphql.CollectedField, obj *model.ConfigAuthRateLimit) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ConfigAuthRateLimit_signups(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Signups, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*model.ConfigRateLimit) + fc.Result = res + return ec.marshalOConfigRateLimit2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimit(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ConfigAuthRateLimit_signups(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigAuthRateLimit", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "limit": + return ec.fieldContext_ConfigRateLimit_limit(ctx, field) + case "interval": + return ec.fieldContext_ConfigRateLimit_interval(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigRateLimit", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigAuthRateLimit_global(ctx context.Context, field graphql.CollectedField, obj *model.ConfigAuthRateLimit) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ConfigAuthRateLimit_global(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Global, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*model.ConfigRateLimit) + fc.Result = res + return ec.marshalOConfigRateLimit2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimit(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ConfigAuthRateLimit_global(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigAuthRateLimit", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "limit": + return ec.fieldContext_ConfigRateLimit_limit(ctx, field) + case "interval": + return ec.fieldContext_ConfigRateLimit_interval(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigRateLimit", field.Name) + }, + } + return fc, nil +} + func (ec *executionContext) _ConfigAuthRedirections_clientUrl(ctx context.Context, field graphql.CollectedField, obj *model.ConfigAuthRedirections) (ret graphql.Marshaler) { fc, err := ec.fieldContext_ConfigAuthRedirections_clientUrl(ctx, field) if err != nil { @@ -13041,6 +13555,8 @@ func (ec *executionContext) fieldContext_ConfigConfig_hasura(_ context.Context, return ec.fieldContext_ConfigHasura_events(ctx, field) case "resources": return ec.fieldContext_ConfigHasura_resources(ctx, field) + case "rateLimit": + return ec.fieldContext_ConfigHasura_rateLimit(ctx, field) } return nil, fmt.Errorf("no field named %q was found under type ConfigHasura", field.Name) }, @@ -13133,6 +13649,8 @@ func (ec *executionContext) fieldContext_ConfigConfig_functions(_ context.Contex return ec.fieldContext_ConfigFunctions_node(ctx, field) case "resources": return ec.fieldContext_ConfigFunctions_resources(ctx, field) + case "rateLimit": + return ec.fieldContext_ConfigFunctions_rateLimit(ctx, field) } return nil, fmt.Errorf("no field named %q was found under type ConfigFunctions", field.Name) }, @@ -13194,6 +13712,8 @@ func (ec *executionContext) fieldContext_ConfigConfig_auth(_ context.Context, fi return ec.fieldContext_ConfigAuth_method(ctx, field) case "totp": return ec.fieldContext_ConfigAuth_totp(ctx, field) + case "rateLimit": + return ec.fieldContext_ConfigAuth_rateLimit(ctx, field) } return nil, fmt.Errorf("no field named %q was found under type ConfigAuth", field.Name) }, @@ -13339,6 +13859,8 @@ func (ec *executionContext) fieldContext_ConfigConfig_storage(_ context.Context, return ec.fieldContext_ConfigStorage_resources(ctx, field) case "antivirus": return ec.fieldContext_ConfigStorage_antivirus(ctx, field) + case "rateLimit": + return ec.fieldContext_ConfigStorage_rateLimit(ctx, field) } return nil, fmt.Errorf("no field named %q was found under type ConfigStorage", field.Name) }, @@ -13625,6 +14147,53 @@ func (ec *executionContext) fieldContext_ConfigFunctions_resources(_ context.Con return fc, nil } +func (ec *executionContext) _ConfigFunctions_rateLimit(ctx context.Context, field graphql.CollectedField, obj *model.ConfigFunctions) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ConfigFunctions_rateLimit(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.RateLimit, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*model.ConfigRateLimit) + fc.Result = res + return ec.marshalOConfigRateLimit2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimit(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ConfigFunctions_rateLimit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigFunctions", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "limit": + return ec.fieldContext_ConfigRateLimit_limit(ctx, field) + case "interval": + return ec.fieldContext_ConfigRateLimit_interval(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigRateLimit", field.Name) + }, + } + return fc, nil +} + func (ec *executionContext) _ConfigFunctionsNode_version(ctx context.Context, field graphql.CollectedField, obj *model.ConfigFunctionsNode) (ret graphql.Marshaler) { fc, err := ec.fieldContext_ConfigFunctionsNode_version(ctx, field) if err != nil { @@ -14462,6 +15031,53 @@ func (ec *executionContext) fieldContext_ConfigHasura_resources(_ context.Contex return fc, nil } +func (ec *executionContext) _ConfigHasura_rateLimit(ctx context.Context, field graphql.CollectedField, obj *model.ConfigHasura) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ConfigHasura_rateLimit(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.RateLimit, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*model.ConfigRateLimit) + fc.Result = res + return ec.marshalOConfigRateLimit2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimit(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ConfigHasura_rateLimit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigHasura", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "limit": + return ec.fieldContext_ConfigRateLimit_limit(ctx, field) + case "interval": + return ec.fieldContext_ConfigRateLimit_interval(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigRateLimit", field.Name) + }, + } + return fc, nil +} + func (ec *executionContext) _ConfigHasuraAuthHook_url(ctx context.Context, field graphql.CollectedField, obj *model.ConfigHasuraAuthHook) (ret graphql.Marshaler) { fc, err := ec.fieldContext_ConfigHasuraAuthHook_url(ctx, field) if err != nil { @@ -17345,6 +17961,94 @@ func (ec *executionContext) fieldContext_ConfigProvider_sms(_ context.Context, f return fc, nil } +func (ec *executionContext) _ConfigRateLimit_limit(ctx context.Context, field graphql.CollectedField, obj *model.ConfigRateLimit) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ConfigRateLimit_limit(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Limit, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(uint32) + fc.Result = res + return ec.marshalNConfigUint322uint32(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ConfigRateLimit_limit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigRateLimit", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ConfigUint32 does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ConfigRateLimit_interval(ctx context.Context, field graphql.CollectedField, obj *model.ConfigRateLimit) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ConfigRateLimit_interval(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Interval, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalNString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ConfigRateLimit_interval(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigRateLimit", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + func (ec *executionContext) _ConfigResources_compute(ctx context.Context, field graphql.CollectedField, obj *model.ConfigResources) (ret graphql.Marshaler) { fc, err := ec.fieldContext_ConfigResources_compute(ctx, field) if err != nil { @@ -17835,6 +18539,8 @@ func (ec *executionContext) fieldContext_ConfigRunServiceConfig_ports(_ context. return ec.fieldContext_ConfigRunServicePort_publish(ctx, field) case "ingresses": return ec.fieldContext_ConfigRunServicePort_ingresses(ctx, field) + case "rateLimit": + return ec.fieldContext_ConfigRunServicePort_rateLimit(ctx, field) } return nil, fmt.Errorf("no field named %q was found under type ConfigRunServicePort", field.Name) }, @@ -18267,6 +18973,53 @@ func (ec *executionContext) fieldContext_ConfigRunServicePort_ingresses(_ contex return fc, nil } +func (ec *executionContext) _ConfigRunServicePort_rateLimit(ctx context.Context, field graphql.CollectedField, obj *model.ConfigRunServicePort) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ConfigRunServicePort_rateLimit(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.RateLimit, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*model.ConfigRateLimit) + fc.Result = res + return ec.marshalOConfigRateLimit2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimit(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ConfigRunServicePort_rateLimit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigRunServicePort", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "limit": + return ec.fieldContext_ConfigRateLimit_limit(ctx, field) + case "interval": + return ec.fieldContext_ConfigRateLimit_interval(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigRateLimit", field.Name) + }, + } + return fc, nil +} + func (ec *executionContext) _ConfigRunServiceResources_compute(ctx context.Context, field graphql.CollectedField, obj *model.ConfigRunServiceResources) (ret graphql.Marshaler) { fc, err := ec.fieldContext_ConfigRunServiceResources_compute(ctx, field) if err != nil { @@ -19492,6 +20245,53 @@ func (ec *executionContext) fieldContext_ConfigStorage_antivirus(_ context.Conte return fc, nil } +func (ec *executionContext) _ConfigStorage_rateLimit(ctx context.Context, field graphql.CollectedField, obj *model.ConfigStorage) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_ConfigStorage_rateLimit(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.RateLimit, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.(*model.ConfigRateLimit) + fc.Result = res + return ec.marshalOConfigRateLimit2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimit(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_ConfigStorage_rateLimit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ConfigStorage", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "limit": + return ec.fieldContext_ConfigRateLimit_limit(ctx, field) + case "interval": + return ec.fieldContext_ConfigRateLimit_interval(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ConfigRateLimit", field.Name) + }, + } + return fc, nil +} + func (ec *executionContext) _ConfigStorageAntivirus_server(ctx context.Context, field graphql.CollectedField, obj *model.ConfigStorageAntivirus) (ret graphql.Marshaler) { fc, err := ec.fieldContext_ConfigStorageAntivirus_server(ctx, field) if err != nil { @@ -24204,7 +25004,7 @@ func (ec *executionContext) unmarshalInputConfigAuthComparisonExp(ctx context.Co asMap[k] = v } - fieldsInOrder := [...]string{"_and", "_not", "_or", "version", "resources", "elevatedPrivileges", "redirections", "signUp", "user", "session", "method", "totp"} + fieldsInOrder := [...]string{"_and", "_not", "_or", "version", "resources", "elevatedPrivileges", "redirections", "signUp", "user", "session", "method", "totp", "rateLimit"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -24295,6 +25095,13 @@ func (ec *executionContext) unmarshalInputConfigAuthComparisonExp(ctx context.Co return it, err } it.Totp = data + case "rateLimit": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rateLimit")) + data, err := ec.unmarshalOConfigAuthRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimitComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.RateLimit = data } } @@ -24383,7 +25190,7 @@ func (ec *executionContext) unmarshalInputConfigAuthInsertInput(ctx context.Cont asMap[k] = v } - fieldsInOrder := [...]string{"version", "resources", "elevatedPrivileges", "redirections", "signUp", "user", "session", "method", "totp"} + fieldsInOrder := [...]string{"version", "resources", "elevatedPrivileges", "redirections", "signUp", "user", "session", "method", "totp", "rateLimit"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -24453,6 +25260,13 @@ func (ec *executionContext) unmarshalInputConfigAuthInsertInput(ctx context.Cont return it, err } it.Totp = data + case "rateLimit": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rateLimit")) + data, err := ec.unmarshalOConfigAuthRateLimitInsertInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimitInsertInput(ctx, v) + if err != nil { + return it, err + } + it.RateLimit = data } } @@ -25980,6 +26794,137 @@ func (ec *executionContext) unmarshalInputConfigAuthMethodWebauthnRelyingPartyIn return it, nil } +func (ec *executionContext) unmarshalInputConfigAuthRateLimitComparisonExp(ctx context.Context, obj interface{}) (model.ConfigAuthRateLimitComparisonExp, error) { + var it model.ConfigAuthRateLimitComparisonExp + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"_and", "_not", "_or", "emails", "sms", "bruteForce", "signups", "global"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "_and": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("_and")) + data, err := ec.unmarshalOConfigAuthRateLimitComparisonExp2ᚕᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimitComparisonExpᚄ(ctx, v) + if err != nil { + return it, err + } + it.And = data + case "_not": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("_not")) + data, err := ec.unmarshalOConfigAuthRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimitComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.Not = data + case "_or": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("_or")) + data, err := ec.unmarshalOConfigAuthRateLimitComparisonExp2ᚕᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimitComparisonExpᚄ(ctx, v) + if err != nil { + return it, err + } + it.Or = data + case "emails": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emails")) + data, err := ec.unmarshalOConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.Emails = data + case "sms": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sms")) + data, err := ec.unmarshalOConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.Sms = data + case "bruteForce": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("bruteForce")) + data, err := ec.unmarshalOConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.BruteForce = data + case "signups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("signups")) + data, err := ec.unmarshalOConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.Signups = data + case "global": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("global")) + data, err := ec.unmarshalOConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.Global = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputConfigAuthRateLimitInsertInput(ctx context.Context, obj interface{}) (model.ConfigAuthRateLimitInsertInput, error) { + var it model.ConfigAuthRateLimitInsertInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"emails", "sms", "bruteForce", "signups", "global"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "emails": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("emails")) + data, err := ec.unmarshalOConfigRateLimitInsertInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitInsertInput(ctx, v) + if err != nil { + return it, err + } + it.Emails = data + case "sms": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("sms")) + data, err := ec.unmarshalOConfigRateLimitInsertInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitInsertInput(ctx, v) + if err != nil { + return it, err + } + it.Sms = data + case "bruteForce": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("bruteForce")) + data, err := ec.unmarshalOConfigRateLimitInsertInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitInsertInput(ctx, v) + if err != nil { + return it, err + } + it.BruteForce = data + case "signups": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("signups")) + data, err := ec.unmarshalOConfigRateLimitInsertInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitInsertInput(ctx, v) + if err != nil { + return it, err + } + it.Signups = data + case "global": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("global")) + data, err := ec.unmarshalOConfigRateLimitInsertInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitInsertInput(ctx, v) + if err != nil { + return it, err + } + it.Global = data + } + } + + return it, nil +} + func (ec *executionContext) unmarshalInputConfigAuthRedirectionsComparisonExp(ctx context.Context, obj interface{}) (model.ConfigAuthRedirectionsComparisonExp, error) { var it model.ConfigAuthRedirectionsComparisonExp asMap := map[string]interface{}{} @@ -27901,7 +28846,7 @@ func (ec *executionContext) unmarshalInputConfigFunctionsComparisonExp(ctx conte asMap[k] = v } - fieldsInOrder := [...]string{"_and", "_not", "_or", "node", "resources"} + fieldsInOrder := [...]string{"_and", "_not", "_or", "node", "resources", "rateLimit"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -27943,6 +28888,13 @@ func (ec *executionContext) unmarshalInputConfigFunctionsComparisonExp(ctx conte return it, err } it.Resources = data + case "rateLimit": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rateLimit")) + data, err := ec.unmarshalOConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.RateLimit = data } } @@ -27956,7 +28908,7 @@ func (ec *executionContext) unmarshalInputConfigFunctionsInsertInput(ctx context asMap[k] = v } - fieldsInOrder := [...]string{"node", "resources"} + fieldsInOrder := [...]string{"node", "resources", "rateLimit"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -27977,6 +28929,13 @@ func (ec *executionContext) unmarshalInputConfigFunctionsInsertInput(ctx context return it, err } it.Resources = data + case "rateLimit": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rateLimit")) + data, err := ec.unmarshalOConfigRateLimitInsertInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitInsertInput(ctx, v) + if err != nil { + return it, err + } + it.RateLimit = data } } @@ -28694,7 +29653,7 @@ func (ec *executionContext) unmarshalInputConfigHasuraComparisonExp(ctx context. asMap[k] = v } - fieldsInOrder := [...]string{"_and", "_not", "_or", "version", "jwtSecrets", "adminSecret", "webhookSecret", "settings", "authHook", "logs", "events", "resources"} + fieldsInOrder := [...]string{"_and", "_not", "_or", "version", "jwtSecrets", "adminSecret", "webhookSecret", "settings", "authHook", "logs", "events", "resources", "rateLimit"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -28785,6 +29744,13 @@ func (ec *executionContext) unmarshalInputConfigHasuraComparisonExp(ctx context. return it, err } it.Resources = data + case "rateLimit": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rateLimit")) + data, err := ec.unmarshalOConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.RateLimit = data } } @@ -28873,7 +29839,7 @@ func (ec *executionContext) unmarshalInputConfigHasuraInsertInput(ctx context.Co asMap[k] = v } - fieldsInOrder := [...]string{"version", "jwtSecrets", "adminSecret", "webhookSecret", "settings", "authHook", "logs", "events", "resources"} + fieldsInOrder := [...]string{"version", "jwtSecrets", "adminSecret", "webhookSecret", "settings", "authHook", "logs", "events", "resources", "rateLimit"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -28943,6 +29909,13 @@ func (ec *executionContext) unmarshalInputConfigHasuraInsertInput(ctx context.Co return it, err } it.Resources = data + case "rateLimit": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rateLimit")) + data, err := ec.unmarshalOConfigRateLimitInsertInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitInsertInput(ctx, v) + if err != nil { + return it, err + } + it.RateLimit = data } } @@ -30843,6 +31816,95 @@ func (ec *executionContext) unmarshalInputConfigProviderInsertInput(ctx context. return it, nil } +func (ec *executionContext) unmarshalInputConfigRateLimitComparisonExp(ctx context.Context, obj interface{}) (model.ConfigRateLimitComparisonExp, error) { + var it model.ConfigRateLimitComparisonExp + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"_and", "_not", "_or", "limit", "interval"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "_and": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("_and")) + data, err := ec.unmarshalOConfigRateLimitComparisonExp2ᚕᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExpᚄ(ctx, v) + if err != nil { + return it, err + } + it.And = data + case "_not": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("_not")) + data, err := ec.unmarshalOConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.Not = data + case "_or": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("_or")) + data, err := ec.unmarshalOConfigRateLimitComparisonExp2ᚕᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExpᚄ(ctx, v) + if err != nil { + return it, err + } + it.Or = data + case "limit": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit")) + data, err := ec.unmarshalOConfigUint32ComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐGenericComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.Limit = data + case "interval": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("interval")) + data, err := ec.unmarshalOConfigStringComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐGenericComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.Interval = data + } + } + + return it, nil +} + +func (ec *executionContext) unmarshalInputConfigRateLimitInsertInput(ctx context.Context, obj interface{}) (model.ConfigRateLimitInsertInput, error) { + var it model.ConfigRateLimitInsertInput + asMap := map[string]interface{}{} + for k, v := range obj.(map[string]interface{}) { + asMap[k] = v + } + + fieldsInOrder := [...]string{"limit", "interval"} + for _, k := range fieldsInOrder { + v, ok := asMap[k] + if !ok { + continue + } + switch k { + case "limit": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("limit")) + data, err := ec.unmarshalNConfigUint322uint32(ctx, v) + if err != nil { + return it, err + } + it.Limit = data + case "interval": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("interval")) + data, err := ec.unmarshalNString2string(ctx, v) + if err != nil { + return it, err + } + it.Interval = data + } + } + + return it, nil +} + func (ec *executionContext) unmarshalInputConfigResourcesComparisonExp(ctx context.Context, obj interface{}) (model.ConfigResourcesComparisonExp, error) { var it model.ConfigResourcesComparisonExp asMap := map[string]interface{}{} @@ -31338,7 +32400,7 @@ func (ec *executionContext) unmarshalInputConfigRunServicePortComparisonExp(ctx asMap[k] = v } - fieldsInOrder := [...]string{"_and", "_not", "_or", "port", "type", "publish", "ingresses"} + fieldsInOrder := [...]string{"_and", "_not", "_or", "port", "type", "publish", "ingresses", "rateLimit"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -31394,6 +32456,13 @@ func (ec *executionContext) unmarshalInputConfigRunServicePortComparisonExp(ctx return it, err } it.Ingresses = data + case "rateLimit": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rateLimit")) + data, err := ec.unmarshalOConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.RateLimit = data } } @@ -31407,7 +32476,7 @@ func (ec *executionContext) unmarshalInputConfigRunServicePortInsertInput(ctx co asMap[k] = v } - fieldsInOrder := [...]string{"port", "type", "publish", "ingresses"} + fieldsInOrder := [...]string{"port", "type", "publish", "ingresses", "rateLimit"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -31442,6 +32511,13 @@ func (ec *executionContext) unmarshalInputConfigRunServicePortInsertInput(ctx co return it, err } it.Ingresses = data + case "rateLimit": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rateLimit")) + data, err := ec.unmarshalOConfigRateLimitInsertInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitInsertInput(ctx, v) + if err != nil { + return it, err + } + it.RateLimit = data } } @@ -32246,7 +33322,7 @@ func (ec *executionContext) unmarshalInputConfigStorageComparisonExp(ctx context asMap[k] = v } - fieldsInOrder := [...]string{"_and", "_not", "_or", "version", "resources", "antivirus"} + fieldsInOrder := [...]string{"_and", "_not", "_or", "version", "resources", "antivirus", "rateLimit"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -32295,6 +33371,13 @@ func (ec *executionContext) unmarshalInputConfigStorageComparisonExp(ctx context return it, err } it.Antivirus = data + case "rateLimit": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rateLimit")) + data, err := ec.unmarshalOConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx, v) + if err != nil { + return it, err + } + it.RateLimit = data } } @@ -32308,7 +33391,7 @@ func (ec *executionContext) unmarshalInputConfigStorageInsertInput(ctx context.C asMap[k] = v } - fieldsInOrder := [...]string{"version", "resources", "antivirus"} + fieldsInOrder := [...]string{"version", "resources", "antivirus", "rateLimit"} for _, k := range fieldsInOrder { v, ok := asMap[k] if !ok { @@ -32336,6 +33419,13 @@ func (ec *executionContext) unmarshalInputConfigStorageInsertInput(ctx context.C return it, err } it.Antivirus = data + case "rateLimit": + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rateLimit")) + data, err := ec.unmarshalOConfigRateLimitInsertInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitInsertInput(ctx, v) + if err != nil { + return it, err + } + it.RateLimit = data } } @@ -33804,6 +34894,8 @@ func (ec *executionContext) _ConfigAuth(ctx context.Context, sel ast.SelectionSe out.Values[i] = ec._ConfigAuth_method(ctx, field, obj) case "totp": out.Values[i] = ec._ConfigAuth_totp(ctx, field, obj) + case "rateLimit": + out.Values[i] = ec._ConfigAuth_rateLimit(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -34257,19 +35349,59 @@ func (ec *executionContext) _ConfigAuthMethodOauthWorkos(ctx context.Context, se return out } -var configAuthMethodSmsPasswordlessImplementors = []string{"ConfigAuthMethodSmsPasswordless"} +var configAuthMethodSmsPasswordlessImplementors = []string{"ConfigAuthMethodSmsPasswordless"} + +func (ec *executionContext) _ConfigAuthMethodSmsPasswordless(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigAuthMethodSmsPasswordless) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configAuthMethodSmsPasswordlessImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigAuthMethodSmsPasswordless") + case "enabled": + out.Values[i] = ec._ConfigAuthMethodSmsPasswordless_enabled(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configAuthMethodWebauthnImplementors = []string{"ConfigAuthMethodWebauthn"} -func (ec *executionContext) _ConfigAuthMethodSmsPasswordless(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigAuthMethodSmsPasswordless) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, configAuthMethodSmsPasswordlessImplementors) +func (ec *executionContext) _ConfigAuthMethodWebauthn(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigAuthMethodWebauthn) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configAuthMethodWebauthnImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("ConfigAuthMethodSmsPasswordless") + out.Values[i] = graphql.MarshalString("ConfigAuthMethodWebauthn") case "enabled": - out.Values[i] = ec._ConfigAuthMethodSmsPasswordless_enabled(ctx, field, obj) + out.Values[i] = ec._ConfigAuthMethodWebauthn_enabled(ctx, field, obj) + case "relyingParty": + out.Values[i] = ec._ConfigAuthMethodWebauthn_relyingParty(ctx, field, obj) + case "attestation": + out.Values[i] = ec._ConfigAuthMethodWebauthn_attestation(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -34293,23 +35425,19 @@ func (ec *executionContext) _ConfigAuthMethodSmsPasswordless(ctx context.Context return out } -var configAuthMethodWebauthnImplementors = []string{"ConfigAuthMethodWebauthn"} +var configAuthMethodWebauthnAttestationImplementors = []string{"ConfigAuthMethodWebauthnAttestation"} -func (ec *executionContext) _ConfigAuthMethodWebauthn(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigAuthMethodWebauthn) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, configAuthMethodWebauthnImplementors) +func (ec *executionContext) _ConfigAuthMethodWebauthnAttestation(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigAuthMethodWebauthnAttestation) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configAuthMethodWebauthnAttestationImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("ConfigAuthMethodWebauthn") - case "enabled": - out.Values[i] = ec._ConfigAuthMethodWebauthn_enabled(ctx, field, obj) - case "relyingParty": - out.Values[i] = ec._ConfigAuthMethodWebauthn_relyingParty(ctx, field, obj) - case "attestation": - out.Values[i] = ec._ConfigAuthMethodWebauthn_attestation(ctx, field, obj) + out.Values[i] = graphql.MarshalString("ConfigAuthMethodWebauthnAttestation") + case "timeout": + out.Values[i] = ec._ConfigAuthMethodWebauthnAttestation_timeout(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -34333,19 +35461,23 @@ func (ec *executionContext) _ConfigAuthMethodWebauthn(ctx context.Context, sel a return out } -var configAuthMethodWebauthnAttestationImplementors = []string{"ConfigAuthMethodWebauthnAttestation"} +var configAuthMethodWebauthnRelyingPartyImplementors = []string{"ConfigAuthMethodWebauthnRelyingParty"} -func (ec *executionContext) _ConfigAuthMethodWebauthnAttestation(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigAuthMethodWebauthnAttestation) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, configAuthMethodWebauthnAttestationImplementors) +func (ec *executionContext) _ConfigAuthMethodWebauthnRelyingParty(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigAuthMethodWebauthnRelyingParty) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configAuthMethodWebauthnRelyingPartyImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("ConfigAuthMethodWebauthnAttestation") - case "timeout": - out.Values[i] = ec._ConfigAuthMethodWebauthnAttestation_timeout(ctx, field, obj) + out.Values[i] = graphql.MarshalString("ConfigAuthMethodWebauthnRelyingParty") + case "id": + out.Values[i] = ec._ConfigAuthMethodWebauthnRelyingParty_id(ctx, field, obj) + case "name": + out.Values[i] = ec._ConfigAuthMethodWebauthnRelyingParty_name(ctx, field, obj) + case "origins": + out.Values[i] = ec._ConfigAuthMethodWebauthnRelyingParty_origins(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -34369,23 +35501,27 @@ func (ec *executionContext) _ConfigAuthMethodWebauthnAttestation(ctx context.Con return out } -var configAuthMethodWebauthnRelyingPartyImplementors = []string{"ConfigAuthMethodWebauthnRelyingParty"} +var configAuthRateLimitImplementors = []string{"ConfigAuthRateLimit"} -func (ec *executionContext) _ConfigAuthMethodWebauthnRelyingParty(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigAuthMethodWebauthnRelyingParty) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, configAuthMethodWebauthnRelyingPartyImplementors) +func (ec *executionContext) _ConfigAuthRateLimit(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigAuthRateLimit) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configAuthRateLimitImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("ConfigAuthMethodWebauthnRelyingParty") - case "id": - out.Values[i] = ec._ConfigAuthMethodWebauthnRelyingParty_id(ctx, field, obj) - case "name": - out.Values[i] = ec._ConfigAuthMethodWebauthnRelyingParty_name(ctx, field, obj) - case "origins": - out.Values[i] = ec._ConfigAuthMethodWebauthnRelyingParty_origins(ctx, field, obj) + out.Values[i] = graphql.MarshalString("ConfigAuthRateLimit") + case "emails": + out.Values[i] = ec._ConfigAuthRateLimit_emails(ctx, field, obj) + case "sms": + out.Values[i] = ec._ConfigAuthRateLimit_sms(ctx, field, obj) + case "bruteForce": + out.Values[i] = ec._ConfigAuthRateLimit_bruteForce(ctx, field, obj) + case "signups": + out.Values[i] = ec._ConfigAuthRateLimit_signups(ctx, field, obj) + case "global": + out.Values[i] = ec._ConfigAuthRateLimit_global(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -35162,6 +36298,8 @@ func (ec *executionContext) _ConfigFunctions(ctx context.Context, sel ast.Select out.Values[i] = ec._ConfigFunctions_node(ctx, field, obj) case "resources": out.Values[i] = ec._ConfigFunctions_resources(ctx, field, obj) + case "rateLimit": + out.Values[i] = ec._ConfigFunctions_rateLimit(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -35485,6 +36623,8 @@ func (ec *executionContext) _ConfigHasura(ctx context.Context, sel ast.Selection out.Values[i] = ec._ConfigHasura_events(ctx, field, obj) case "resources": out.Values[i] = ec._ConfigHasura_resources(ctx, field, obj) + case "rateLimit": + out.Values[i] = ec._ConfigHasura_rateLimit(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -35893,19 +37033,220 @@ func (ec *executionContext) _ConfigNetworking(ctx context.Context, sel ast.Selec return out } -var configObservabilityImplementors = []string{"ConfigObservability"} +var configObservabilityImplementors = []string{"ConfigObservability"} + +func (ec *executionContext) _ConfigObservability(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigObservability) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configObservabilityImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigObservability") + case "grafana": + out.Values[i] = ec._ConfigObservability_grafana(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configPostgresImplementors = []string{"ConfigPostgres"} + +func (ec *executionContext) _ConfigPostgres(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigPostgres) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configPostgresImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigPostgres") + case "version": + out.Values[i] = ec._ConfigPostgres_version(ctx, field, obj) + case "resources": + out.Values[i] = ec._ConfigPostgres_resources(ctx, field, obj) + case "settings": + out.Values[i] = ec._ConfigPostgres_settings(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configPostgresResourcesImplementors = []string{"ConfigPostgresResources"} + +func (ec *executionContext) _ConfigPostgresResources(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigPostgresResources) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configPostgresResourcesImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigPostgresResources") + case "compute": + out.Values[i] = ec._ConfigPostgresResources_compute(ctx, field, obj) + case "replicas": + out.Values[i] = ec._ConfigPostgresResources_replicas(ctx, field, obj) + case "autoscaler": + out.Values[i] = ec._ConfigPostgresResources_autoscaler(ctx, field, obj) + case "networking": + out.Values[i] = ec._ConfigPostgresResources_networking(ctx, field, obj) + case "storage": + out.Values[i] = ec._ConfigPostgresResources_storage(ctx, field, obj) + case "enablePublicAccess": + out.Values[i] = ec._ConfigPostgresResources_enablePublicAccess(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configPostgresSettingsImplementors = []string{"ConfigPostgresSettings"} + +func (ec *executionContext) _ConfigPostgresSettings(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigPostgresSettings) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configPostgresSettingsImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("ConfigPostgresSettings") + case "jit": + out.Values[i] = ec._ConfigPostgresSettings_jit(ctx, field, obj) + case "maxConnections": + out.Values[i] = ec._ConfigPostgresSettings_maxConnections(ctx, field, obj) + case "sharedBuffers": + out.Values[i] = ec._ConfigPostgresSettings_sharedBuffers(ctx, field, obj) + case "effectiveCacheSize": + out.Values[i] = ec._ConfigPostgresSettings_effectiveCacheSize(ctx, field, obj) + case "maintenanceWorkMem": + out.Values[i] = ec._ConfigPostgresSettings_maintenanceWorkMem(ctx, field, obj) + case "checkpointCompletionTarget": + out.Values[i] = ec._ConfigPostgresSettings_checkpointCompletionTarget(ctx, field, obj) + case "walBuffers": + out.Values[i] = ec._ConfigPostgresSettings_walBuffers(ctx, field, obj) + case "defaultStatisticsTarget": + out.Values[i] = ec._ConfigPostgresSettings_defaultStatisticsTarget(ctx, field, obj) + case "randomPageCost": + out.Values[i] = ec._ConfigPostgresSettings_randomPageCost(ctx, field, obj) + case "effectiveIOConcurrency": + out.Values[i] = ec._ConfigPostgresSettings_effectiveIOConcurrency(ctx, field, obj) + case "workMem": + out.Values[i] = ec._ConfigPostgresSettings_workMem(ctx, field, obj) + case "hugePages": + out.Values[i] = ec._ConfigPostgresSettings_hugePages(ctx, field, obj) + case "minWalSize": + out.Values[i] = ec._ConfigPostgresSettings_minWalSize(ctx, field, obj) + case "maxWalSize": + out.Values[i] = ec._ConfigPostgresSettings_maxWalSize(ctx, field, obj) + case "maxWorkerProcesses": + out.Values[i] = ec._ConfigPostgresSettings_maxWorkerProcesses(ctx, field, obj) + case "maxParallelWorkersPerGather": + out.Values[i] = ec._ConfigPostgresSettings_maxParallelWorkersPerGather(ctx, field, obj) + case "maxParallelWorkers": + out.Values[i] = ec._ConfigPostgresSettings_maxParallelWorkers(ctx, field, obj) + case "maxParallelMaintenanceWorkers": + out.Values[i] = ec._ConfigPostgresSettings_maxParallelMaintenanceWorkers(ctx, field, obj) + case "walLevel": + out.Values[i] = ec._ConfigPostgresSettings_walLevel(ctx, field, obj) + case "maxWalSenders": + out.Values[i] = ec._ConfigPostgresSettings_maxWalSenders(ctx, field, obj) + case "maxReplicationSlots": + out.Values[i] = ec._ConfigPostgresSettings_maxReplicationSlots(ctx, field, obj) + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var configPostgresStorageImplementors = []string{"ConfigPostgresStorage"} -func (ec *executionContext) _ConfigObservability(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigObservability) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, configObservabilityImplementors) +func (ec *executionContext) _ConfigPostgresStorage(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigPostgresStorage) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configPostgresStorageImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("ConfigObservability") - case "grafana": - out.Values[i] = ec._ConfigObservability_grafana(ctx, field, obj) + out.Values[i] = graphql.MarshalString("ConfigPostgresStorage") + case "capacity": + out.Values[i] = ec._ConfigPostgresStorage_capacity(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -35932,145 +37273,21 @@ func (ec *executionContext) _ConfigObservability(ctx context.Context, sel ast.Se return out } -var configPostgresImplementors = []string{"ConfigPostgres"} - -func (ec *executionContext) _ConfigPostgres(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigPostgres) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, configPostgresImplementors) - - out := graphql.NewFieldSet(fields) - deferred := make(map[string]*graphql.FieldSet) - for i, field := range fields { - switch field.Name { - case "__typename": - out.Values[i] = graphql.MarshalString("ConfigPostgres") - case "version": - out.Values[i] = ec._ConfigPostgres_version(ctx, field, obj) - case "resources": - out.Values[i] = ec._ConfigPostgres_resources(ctx, field, obj) - case "settings": - out.Values[i] = ec._ConfigPostgres_settings(ctx, field, obj) - default: - panic("unknown field " + strconv.Quote(field.Name)) - } - } - out.Dispatch(ctx) - if out.Invalids > 0 { - return graphql.Null - } - - atomic.AddInt32(&ec.deferred, int32(len(deferred))) - - for label, dfs := range deferred { - ec.processDeferredGroup(graphql.DeferredGroup{ - Label: label, - Path: graphql.GetPath(ctx), - FieldSet: dfs, - Context: ctx, - }) - } - - return out -} - -var configPostgresResourcesImplementors = []string{"ConfigPostgresResources"} - -func (ec *executionContext) _ConfigPostgresResources(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigPostgresResources) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, configPostgresResourcesImplementors) - - out := graphql.NewFieldSet(fields) - deferred := make(map[string]*graphql.FieldSet) - for i, field := range fields { - switch field.Name { - case "__typename": - out.Values[i] = graphql.MarshalString("ConfigPostgresResources") - case "compute": - out.Values[i] = ec._ConfigPostgresResources_compute(ctx, field, obj) - case "replicas": - out.Values[i] = ec._ConfigPostgresResources_replicas(ctx, field, obj) - case "autoscaler": - out.Values[i] = ec._ConfigPostgresResources_autoscaler(ctx, field, obj) - case "networking": - out.Values[i] = ec._ConfigPostgresResources_networking(ctx, field, obj) - case "storage": - out.Values[i] = ec._ConfigPostgresResources_storage(ctx, field, obj) - case "enablePublicAccess": - out.Values[i] = ec._ConfigPostgresResources_enablePublicAccess(ctx, field, obj) - default: - panic("unknown field " + strconv.Quote(field.Name)) - } - } - out.Dispatch(ctx) - if out.Invalids > 0 { - return graphql.Null - } - - atomic.AddInt32(&ec.deferred, int32(len(deferred))) - - for label, dfs := range deferred { - ec.processDeferredGroup(graphql.DeferredGroup{ - Label: label, - Path: graphql.GetPath(ctx), - FieldSet: dfs, - Context: ctx, - }) - } - - return out -} - -var configPostgresSettingsImplementors = []string{"ConfigPostgresSettings"} +var configProviderImplementors = []string{"ConfigProvider"} -func (ec *executionContext) _ConfigPostgresSettings(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigPostgresSettings) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, configPostgresSettingsImplementors) +func (ec *executionContext) _ConfigProvider(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigProvider) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configProviderImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("ConfigPostgresSettings") - case "jit": - out.Values[i] = ec._ConfigPostgresSettings_jit(ctx, field, obj) - case "maxConnections": - out.Values[i] = ec._ConfigPostgresSettings_maxConnections(ctx, field, obj) - case "sharedBuffers": - out.Values[i] = ec._ConfigPostgresSettings_sharedBuffers(ctx, field, obj) - case "effectiveCacheSize": - out.Values[i] = ec._ConfigPostgresSettings_effectiveCacheSize(ctx, field, obj) - case "maintenanceWorkMem": - out.Values[i] = ec._ConfigPostgresSettings_maintenanceWorkMem(ctx, field, obj) - case "checkpointCompletionTarget": - out.Values[i] = ec._ConfigPostgresSettings_checkpointCompletionTarget(ctx, field, obj) - case "walBuffers": - out.Values[i] = ec._ConfigPostgresSettings_walBuffers(ctx, field, obj) - case "defaultStatisticsTarget": - out.Values[i] = ec._ConfigPostgresSettings_defaultStatisticsTarget(ctx, field, obj) - case "randomPageCost": - out.Values[i] = ec._ConfigPostgresSettings_randomPageCost(ctx, field, obj) - case "effectiveIOConcurrency": - out.Values[i] = ec._ConfigPostgresSettings_effectiveIOConcurrency(ctx, field, obj) - case "workMem": - out.Values[i] = ec._ConfigPostgresSettings_workMem(ctx, field, obj) - case "hugePages": - out.Values[i] = ec._ConfigPostgresSettings_hugePages(ctx, field, obj) - case "minWalSize": - out.Values[i] = ec._ConfigPostgresSettings_minWalSize(ctx, field, obj) - case "maxWalSize": - out.Values[i] = ec._ConfigPostgresSettings_maxWalSize(ctx, field, obj) - case "maxWorkerProcesses": - out.Values[i] = ec._ConfigPostgresSettings_maxWorkerProcesses(ctx, field, obj) - case "maxParallelWorkersPerGather": - out.Values[i] = ec._ConfigPostgresSettings_maxParallelWorkersPerGather(ctx, field, obj) - case "maxParallelWorkers": - out.Values[i] = ec._ConfigPostgresSettings_maxParallelWorkers(ctx, field, obj) - case "maxParallelMaintenanceWorkers": - out.Values[i] = ec._ConfigPostgresSettings_maxParallelMaintenanceWorkers(ctx, field, obj) - case "walLevel": - out.Values[i] = ec._ConfigPostgresSettings_walLevel(ctx, field, obj) - case "maxWalSenders": - out.Values[i] = ec._ConfigPostgresSettings_maxWalSenders(ctx, field, obj) - case "maxReplicationSlots": - out.Values[i] = ec._ConfigPostgresSettings_maxReplicationSlots(ctx, field, obj) + out.Values[i] = graphql.MarshalString("ConfigProvider") + case "smtp": + out.Values[i] = ec._ConfigProvider_smtp(ctx, field, obj) + case "sms": + out.Values[i] = ec._ConfigProvider_sms(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -36094,60 +37311,27 @@ func (ec *executionContext) _ConfigPostgresSettings(ctx context.Context, sel ast return out } -var configPostgresStorageImplementors = []string{"ConfigPostgresStorage"} +var configRateLimitImplementors = []string{"ConfigRateLimit"} -func (ec *executionContext) _ConfigPostgresStorage(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigPostgresStorage) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, configPostgresStorageImplementors) +func (ec *executionContext) _ConfigRateLimit(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigRateLimit) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, configRateLimitImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("ConfigPostgresStorage") - case "capacity": - out.Values[i] = ec._ConfigPostgresStorage_capacity(ctx, field, obj) + out.Values[i] = graphql.MarshalString("ConfigRateLimit") + case "limit": + out.Values[i] = ec._ConfigRateLimit_limit(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "interval": + out.Values[i] = ec._ConfigRateLimit_interval(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - default: - panic("unknown field " + strconv.Quote(field.Name)) - } - } - out.Dispatch(ctx) - if out.Invalids > 0 { - return graphql.Null - } - - atomic.AddInt32(&ec.deferred, int32(len(deferred))) - - for label, dfs := range deferred { - ec.processDeferredGroup(graphql.DeferredGroup{ - Label: label, - Path: graphql.GetPath(ctx), - FieldSet: dfs, - Context: ctx, - }) - } - - return out -} - -var configProviderImplementors = []string{"ConfigProvider"} - -func (ec *executionContext) _ConfigProvider(ctx context.Context, sel ast.SelectionSet, obj *model.ConfigProvider) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, configProviderImplementors) - - out := graphql.NewFieldSet(fields) - deferred := make(map[string]*graphql.FieldSet) - for i, field := range fields { - switch field.Name { - case "__typename": - out.Values[i] = graphql.MarshalString("ConfigProvider") - case "smtp": - out.Values[i] = ec._ConfigProvider_smtp(ctx, field, obj) - case "sms": - out.Values[i] = ec._ConfigProvider_sms(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -36422,6 +37606,8 @@ func (ec *executionContext) _ConfigRunServicePort(ctx context.Context, sel ast.S out.Values[i] = ec._ConfigRunServicePort_publish(ctx, field, obj) case "ingresses": out.Values[i] = ec._ConfigRunServicePort_ingresses(ctx, field, obj) + case "rateLimit": + out.Values[i] = ec._ConfigRunServicePort_rateLimit(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -36761,6 +37947,8 @@ func (ec *executionContext) _ConfigStorage(ctx context.Context, sel ast.Selectio out.Values[i] = ec._ConfigStorage_resources(ctx, field, obj) case "antivirus": out.Values[i] = ec._ConfigStorage_antivirus(ctx, field, obj) + case "rateLimit": + out.Values[i] = ec._ConfigStorage_rateLimit(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -38144,6 +39332,11 @@ func (ec *executionContext) unmarshalNConfigAuthMethodWebauthnRelyingPartyCompar return &res, graphql.ErrorOnPath(ctx, err) } +func (ec *executionContext) unmarshalNConfigAuthRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimitComparisonExp(ctx context.Context, v interface{}) (*model.ConfigAuthRateLimitComparisonExp, error) { + res, err := ec.unmarshalInputConfigAuthRateLimitComparisonExp(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + func (ec *executionContext) unmarshalNConfigAuthRedirectionsComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRedirectionsComparisonExp(ctx context.Context, v interface{}) (*model.ConfigAuthRedirectionsComparisonExp, error) { res, err := ec.unmarshalInputConfigAuthRedirectionsComparisonExp(ctx, v) return &res, graphql.ErrorOnPath(ctx, err) @@ -38747,6 +39940,11 @@ func (ec *executionContext) unmarshalNConfigProviderComparisonExp2ᚖgithubᚗco return &res, graphql.ErrorOnPath(ctx, err) } +func (ec *executionContext) unmarshalNConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx context.Context, v interface{}) (*model.ConfigRateLimitComparisonExp, error) { + res, err := ec.unmarshalInputConfigRateLimitComparisonExp(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + func (ec *executionContext) unmarshalNConfigResourcesComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigResourcesComparisonExp(ctx context.Context, v interface{}) (*model.ConfigResourcesComparisonExp, error) { res, err := ec.unmarshalInputConfigResourcesComparisonExp(ctx, v) return &res, graphql.ErrorOnPath(ctx, err) @@ -40551,6 +41749,58 @@ func (ec *executionContext) unmarshalOConfigAuthMethodWebauthnUpdateInput2ᚖgit return res, graphql.ErrorOnPath(ctx, err) } +func (ec *executionContext) marshalOConfigAuthRateLimit2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimit(ctx context.Context, sel ast.SelectionSet, v *model.ConfigAuthRateLimit) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._ConfigAuthRateLimit(ctx, sel, v) +} + +func (ec *executionContext) unmarshalOConfigAuthRateLimitComparisonExp2ᚕᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimitComparisonExpᚄ(ctx context.Context, v interface{}) ([]*model.ConfigAuthRateLimitComparisonExp, error) { + if v == nil { + return nil, nil + } + var vSlice []interface{} + if v != nil { + vSlice = graphql.CoerceList(v) + } + var err error + res := make([]*model.ConfigAuthRateLimitComparisonExp, len(vSlice)) + for i := range vSlice { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) + res[i], err = ec.unmarshalNConfigAuthRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimitComparisonExp(ctx, vSlice[i]) + if err != nil { + return nil, err + } + } + return res, nil +} + +func (ec *executionContext) unmarshalOConfigAuthRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimitComparisonExp(ctx context.Context, v interface{}) (*model.ConfigAuthRateLimitComparisonExp, error) { + if v == nil { + return nil, nil + } + res, err := ec.unmarshalInputConfigAuthRateLimitComparisonExp(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) unmarshalOConfigAuthRateLimitInsertInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimitInsertInput(ctx context.Context, v interface{}) (*model.ConfigAuthRateLimitInsertInput, error) { + if v == nil { + return nil, nil + } + res, err := ec.unmarshalInputConfigAuthRateLimitInsertInput(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) unmarshalOConfigAuthRateLimitUpdateInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRateLimitUpdateInput(ctx context.Context, v interface{}) (*model.ConfigAuthRateLimitUpdateInput, error) { + if v == nil { + return nil, nil + } + var res = new(model.ConfigAuthRateLimitUpdateInput) + err := res.UnmarshalGQL(v) + return res, graphql.ErrorOnPath(ctx, err) +} + func (ec *executionContext) marshalOConfigAuthRedirections2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigAuthRedirections(ctx context.Context, sel ast.SelectionSet, v *model.ConfigAuthRedirections) graphql.Marshaler { if v == nil { return graphql.Null @@ -43496,6 +44746,58 @@ func (ec *executionContext) unmarshalOConfigProviderUpdateInput2ᚖgithubᚗcom return res, graphql.ErrorOnPath(ctx, err) } +func (ec *executionContext) marshalOConfigRateLimit2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimit(ctx context.Context, sel ast.SelectionSet, v *model.ConfigRateLimit) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._ConfigRateLimit(ctx, sel, v) +} + +func (ec *executionContext) unmarshalOConfigRateLimitComparisonExp2ᚕᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExpᚄ(ctx context.Context, v interface{}) ([]*model.ConfigRateLimitComparisonExp, error) { + if v == nil { + return nil, nil + } + var vSlice []interface{} + if v != nil { + vSlice = graphql.CoerceList(v) + } + var err error + res := make([]*model.ConfigRateLimitComparisonExp, len(vSlice)) + for i := range vSlice { + ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i)) + res[i], err = ec.unmarshalNConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx, vSlice[i]) + if err != nil { + return nil, err + } + } + return res, nil +} + +func (ec *executionContext) unmarshalOConfigRateLimitComparisonExp2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitComparisonExp(ctx context.Context, v interface{}) (*model.ConfigRateLimitComparisonExp, error) { + if v == nil { + return nil, nil + } + res, err := ec.unmarshalInputConfigRateLimitComparisonExp(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) unmarshalOConfigRateLimitInsertInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitInsertInput(ctx context.Context, v interface{}) (*model.ConfigRateLimitInsertInput, error) { + if v == nil { + return nil, nil + } + res, err := ec.unmarshalInputConfigRateLimitInsertInput(ctx, v) + return &res, graphql.ErrorOnPath(ctx, err) +} + +func (ec *executionContext) unmarshalOConfigRateLimitUpdateInput2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigRateLimitUpdateInput(ctx context.Context, v interface{}) (*model.ConfigRateLimitUpdateInput, error) { + if v == nil { + return nil, nil + } + var res = new(model.ConfigRateLimitUpdateInput) + err := res.UnmarshalGQL(v) + return res, graphql.ErrorOnPath(ctx, err) +} + func (ec *executionContext) marshalOConfigResources2ᚖgithubᚗcomᚋnhostᚋbeᚋservicesᚋmimirᚋmodelᚐConfigResources(ctx context.Context, sel ast.SelectionSet, v *model.ConfigResources) graphql.Marshaler { if v == nil { return graphql.Null diff --git a/vendor/github.com/nhost/be/services/mimir/graph/m_change_database_version.go b/vendor/github.com/nhost/be/services/mimir/graph/m_change_database_version.go index 73d514735..cc3571231 100644 --- a/vendor/github.com/nhost/be/services/mimir/graph/m_change_database_version.go +++ b/vendor/github.com/nhost/be/services/mimir/graph/m_change_database_version.go @@ -69,6 +69,7 @@ func (r *mutationResolver) changeDatabaseVersion( //nolint:cyclop oldApp.resolvedConfig = newApp.resolvedConfig oldApp.Config = newApp.Config + oldApp.SystemConfig = newApp.SystemConfig return true, nil } diff --git a/vendor/github.com/nhost/be/services/mimir/model/cuegraph_gen.go b/vendor/github.com/nhost/be/services/mimir/model/cuegraph_gen.go index 326d1c68f..0faed21ae 100644 --- a/vendor/github.com/nhost/be/services/mimir/model/cuegraph_gen.go +++ b/vendor/github.com/nhost/be/services/mimir/model/cuegraph_gen.go @@ -948,6 +948,8 @@ type ConfigAuth struct { Method *ConfigAuthMethod `json:"method,omitempty" toml:"method,omitempty"` Totp *ConfigAuthTotp `json:"totp,omitempty" toml:"totp,omitempty"` + + RateLimit *ConfigAuthRateLimit `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` } func (o *ConfigAuth) MarshalJSON() ([]byte, error) { @@ -979,6 +981,9 @@ func (o *ConfigAuth) MarshalJSON() ([]byte, error) { if o.Totp != nil { m["totp"] = o.Totp } + if o.RateLimit != nil { + m["rateLimit"] = o.RateLimit + } return json.Marshal(m) } @@ -1045,6 +1050,13 @@ func (o *ConfigAuth) GetTotp() *ConfigAuthTotp { return o.Totp } +func (o *ConfigAuth) GetRateLimit() *ConfigAuthRateLimit { + if o == nil { + return nil + } + return o.RateLimit +} + type ConfigAuthUpdateInput struct { Version *string `json:"version,omitempty" toml:"version,omitempty"` IsSetVersion bool `json:"-"` @@ -1064,6 +1076,8 @@ type ConfigAuthUpdateInput struct { IsSetMethod bool `json:"-"` Totp *ConfigAuthTotpUpdateInput `json:"totp,omitempty" toml:"totp,omitempty"` IsSetTotp bool `json:"-"` + RateLimit *ConfigAuthRateLimitUpdateInput `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` + IsSetRateLimit bool `json:"-"` } func (o *ConfigAuthUpdateInput) UnmarshalGQL(v interface{}) error { @@ -1168,6 +1182,16 @@ func (o *ConfigAuthUpdateInput) UnmarshalGQL(v interface{}) error { } o.IsSetTotp = true } + if x, ok := m["rateLimit"]; ok { + if x != nil { + t := &ConfigAuthRateLimitUpdateInput{} + if err := t.UnmarshalGQL(x); err != nil { + return err + } + o.RateLimit = t + } + o.IsSetRateLimit = true + } return nil } @@ -1242,6 +1266,13 @@ func (o *ConfigAuthUpdateInput) GetTotp() *ConfigAuthTotpUpdateInput { return o.Totp } +func (o *ConfigAuthUpdateInput) GetRateLimit() *ConfigAuthRateLimitUpdateInput { + if o == nil { + return nil + } + return o.RateLimit +} + func (s *ConfigAuth) Update(v *ConfigAuthUpdateInput) { if v == nil { return @@ -1329,6 +1360,16 @@ func (s *ConfigAuth) Update(v *ConfigAuthUpdateInput) { s.Totp.Update(v.Totp) } } + if v.IsSetRateLimit || v.RateLimit != nil { + if v.RateLimit == nil { + s.RateLimit = nil + } else { + if s.RateLimit == nil { + s.RateLimit = &ConfigAuthRateLimit{} + } + s.RateLimit.Update(v.RateLimit) + } + } } type ConfigAuthInsertInput struct { @@ -1341,6 +1382,7 @@ type ConfigAuthInsertInput struct { Session *ConfigAuthSessionInsertInput `json:"session,omitempty" toml:"session,omitempty"` Method *ConfigAuthMethodInsertInput `json:"method,omitempty" toml:"method,omitempty"` Totp *ConfigAuthTotpInsertInput `json:"totp,omitempty" toml:"totp,omitempty"` + RateLimit *ConfigAuthRateLimitInsertInput `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` } func (o *ConfigAuthInsertInput) GetVersion() *string { @@ -1406,6 +1448,13 @@ func (o *ConfigAuthInsertInput) GetTotp() *ConfigAuthTotpInsertInput { return o.Totp } +func (o *ConfigAuthInsertInput) GetRateLimit() *ConfigAuthRateLimitInsertInput { + if o == nil { + return nil + } + return o.RateLimit +} + func (s *ConfigAuth) Insert(v *ConfigAuthInsertInput) { s.Version = v.Version if v.Resources != nil { @@ -1456,6 +1505,12 @@ func (s *ConfigAuth) Insert(v *ConfigAuthInsertInput) { } s.Totp.Insert(v.Totp) } + if v.RateLimit != nil { + if s.RateLimit == nil { + s.RateLimit = &ConfigAuthRateLimit{} + } + s.RateLimit.Insert(v.RateLimit) + } } func (s *ConfigAuth) Clone() *ConfigAuth { @@ -1473,6 +1528,7 @@ func (s *ConfigAuth) Clone() *ConfigAuth { v.Session = s.Session.Clone() v.Method = s.Method.Clone() v.Totp = s.Totp.Clone() + v.RateLimit = s.RateLimit.Clone() return v } @@ -1489,6 +1545,7 @@ type ConfigAuthComparisonExp struct { Session *ConfigAuthSessionComparisonExp `json:"session,omitempty"` Method *ConfigAuthMethodComparisonExp `json:"method,omitempty"` Totp *ConfigAuthTotpComparisonExp `json:"totp,omitempty"` + RateLimit *ConfigAuthRateLimitComparisonExp `json:"rateLimit,omitempty"` } func (exp *ConfigAuthComparisonExp) Matches(o *ConfigAuth) bool { @@ -1506,6 +1563,7 @@ func (exp *ConfigAuthComparisonExp) Matches(o *ConfigAuth) bool { Session: &ConfigAuthSession{}, Method: &ConfigAuthMethod{}, Totp: &ConfigAuthTotp{}, + RateLimit: &ConfigAuthRateLimit{}, } } if o.Version != nil && !exp.Version.Matches(*o.Version) { @@ -1535,6 +1593,9 @@ func (exp *ConfigAuthComparisonExp) Matches(o *ConfigAuth) bool { if !exp.Totp.Matches(o.Totp) { return false } + if !exp.RateLimit.Matches(o.RateLimit) { + return false + } if exp.And != nil && !all(exp.And, o) { return false @@ -5735,6 +5796,389 @@ func (exp *ConfigAuthMethodWebauthnRelyingPartyComparisonExp) Matches(o *ConfigA return true } +type ConfigAuthRateLimit struct { + Emails *ConfigRateLimit `json:"emails,omitempty" toml:"emails,omitempty"` + + Sms *ConfigRateLimit `json:"sms,omitempty" toml:"sms,omitempty"` + + BruteForce *ConfigRateLimit `json:"bruteForce,omitempty" toml:"bruteForce,omitempty"` + + Signups *ConfigRateLimit `json:"signups,omitempty" toml:"signups,omitempty"` + + Global *ConfigRateLimit `json:"global,omitempty" toml:"global,omitempty"` +} + +func (o *ConfigAuthRateLimit) MarshalJSON() ([]byte, error) { + m := make(map[string]any) + if o.Emails != nil { + m["emails"] = o.Emails + } + if o.Sms != nil { + m["sms"] = o.Sms + } + if o.BruteForce != nil { + m["bruteForce"] = o.BruteForce + } + if o.Signups != nil { + m["signups"] = o.Signups + } + if o.Global != nil { + m["global"] = o.Global + } + return json.Marshal(m) +} + +func (o *ConfigAuthRateLimit) GetEmails() *ConfigRateLimit { + if o == nil { + return nil + } + return o.Emails +} + +func (o *ConfigAuthRateLimit) GetSms() *ConfigRateLimit { + if o == nil { + return nil + } + return o.Sms +} + +func (o *ConfigAuthRateLimit) GetBruteForce() *ConfigRateLimit { + if o == nil { + return nil + } + return o.BruteForce +} + +func (o *ConfigAuthRateLimit) GetSignups() *ConfigRateLimit { + if o == nil { + return nil + } + return o.Signups +} + +func (o *ConfigAuthRateLimit) GetGlobal() *ConfigRateLimit { + if o == nil { + return nil + } + return o.Global +} + +type ConfigAuthRateLimitUpdateInput struct { + Emails *ConfigRateLimitUpdateInput `json:"emails,omitempty" toml:"emails,omitempty"` + IsSetEmails bool `json:"-"` + Sms *ConfigRateLimitUpdateInput `json:"sms,omitempty" toml:"sms,omitempty"` + IsSetSms bool `json:"-"` + BruteForce *ConfigRateLimitUpdateInput `json:"bruteForce,omitempty" toml:"bruteForce,omitempty"` + IsSetBruteForce bool `json:"-"` + Signups *ConfigRateLimitUpdateInput `json:"signups,omitempty" toml:"signups,omitempty"` + IsSetSignups bool `json:"-"` + Global *ConfigRateLimitUpdateInput `json:"global,omitempty" toml:"global,omitempty"` + IsSetGlobal bool `json:"-"` +} + +func (o *ConfigAuthRateLimitUpdateInput) UnmarshalGQL(v interface{}) error { + m, ok := v.(map[string]any) + if !ok { + return fmt.Errorf("must be map[string]interface{}, got %T", v) + } + if x, ok := m["emails"]; ok { + if x != nil { + t := &ConfigRateLimitUpdateInput{} + if err := t.UnmarshalGQL(x); err != nil { + return err + } + o.Emails = t + } + o.IsSetEmails = true + } + if x, ok := m["sms"]; ok { + if x != nil { + t := &ConfigRateLimitUpdateInput{} + if err := t.UnmarshalGQL(x); err != nil { + return err + } + o.Sms = t + } + o.IsSetSms = true + } + if x, ok := m["bruteForce"]; ok { + if x != nil { + t := &ConfigRateLimitUpdateInput{} + if err := t.UnmarshalGQL(x); err != nil { + return err + } + o.BruteForce = t + } + o.IsSetBruteForce = true + } + if x, ok := m["signups"]; ok { + if x != nil { + t := &ConfigRateLimitUpdateInput{} + if err := t.UnmarshalGQL(x); err != nil { + return err + } + o.Signups = t + } + o.IsSetSignups = true + } + if x, ok := m["global"]; ok { + if x != nil { + t := &ConfigRateLimitUpdateInput{} + if err := t.UnmarshalGQL(x); err != nil { + return err + } + o.Global = t + } + o.IsSetGlobal = true + } + + return nil +} + +func (o *ConfigAuthRateLimitUpdateInput) MarshalGQL(w io.Writer) { + enc := json.NewEncoder(w) + if err := enc.Encode(o); err != nil { + panic(err) + } +} + +func (o *ConfigAuthRateLimitUpdateInput) GetEmails() *ConfigRateLimitUpdateInput { + if o == nil { + return nil + } + return o.Emails +} + +func (o *ConfigAuthRateLimitUpdateInput) GetSms() *ConfigRateLimitUpdateInput { + if o == nil { + return nil + } + return o.Sms +} + +func (o *ConfigAuthRateLimitUpdateInput) GetBruteForce() *ConfigRateLimitUpdateInput { + if o == nil { + return nil + } + return o.BruteForce +} + +func (o *ConfigAuthRateLimitUpdateInput) GetSignups() *ConfigRateLimitUpdateInput { + if o == nil { + return nil + } + return o.Signups +} + +func (o *ConfigAuthRateLimitUpdateInput) GetGlobal() *ConfigRateLimitUpdateInput { + if o == nil { + return nil + } + return o.Global +} + +func (s *ConfigAuthRateLimit) Update(v *ConfigAuthRateLimitUpdateInput) { + if v == nil { + return + } + if v.IsSetEmails || v.Emails != nil { + if v.Emails == nil { + s.Emails = nil + } else { + if s.Emails == nil { + s.Emails = &ConfigRateLimit{} + } + s.Emails.Update(v.Emails) + } + } + if v.IsSetSms || v.Sms != nil { + if v.Sms == nil { + s.Sms = nil + } else { + if s.Sms == nil { + s.Sms = &ConfigRateLimit{} + } + s.Sms.Update(v.Sms) + } + } + if v.IsSetBruteForce || v.BruteForce != nil { + if v.BruteForce == nil { + s.BruteForce = nil + } else { + if s.BruteForce == nil { + s.BruteForce = &ConfigRateLimit{} + } + s.BruteForce.Update(v.BruteForce) + } + } + if v.IsSetSignups || v.Signups != nil { + if v.Signups == nil { + s.Signups = nil + } else { + if s.Signups == nil { + s.Signups = &ConfigRateLimit{} + } + s.Signups.Update(v.Signups) + } + } + if v.IsSetGlobal || v.Global != nil { + if v.Global == nil { + s.Global = nil + } else { + if s.Global == nil { + s.Global = &ConfigRateLimit{} + } + s.Global.Update(v.Global) + } + } +} + +type ConfigAuthRateLimitInsertInput struct { + Emails *ConfigRateLimitInsertInput `json:"emails,omitempty" toml:"emails,omitempty"` + Sms *ConfigRateLimitInsertInput `json:"sms,omitempty" toml:"sms,omitempty"` + BruteForce *ConfigRateLimitInsertInput `json:"bruteForce,omitempty" toml:"bruteForce,omitempty"` + Signups *ConfigRateLimitInsertInput `json:"signups,omitempty" toml:"signups,omitempty"` + Global *ConfigRateLimitInsertInput `json:"global,omitempty" toml:"global,omitempty"` +} + +func (o *ConfigAuthRateLimitInsertInput) GetEmails() *ConfigRateLimitInsertInput { + if o == nil { + return nil + } + return o.Emails +} + +func (o *ConfigAuthRateLimitInsertInput) GetSms() *ConfigRateLimitInsertInput { + if o == nil { + return nil + } + return o.Sms +} + +func (o *ConfigAuthRateLimitInsertInput) GetBruteForce() *ConfigRateLimitInsertInput { + if o == nil { + return nil + } + return o.BruteForce +} + +func (o *ConfigAuthRateLimitInsertInput) GetSignups() *ConfigRateLimitInsertInput { + if o == nil { + return nil + } + return o.Signups +} + +func (o *ConfigAuthRateLimitInsertInput) GetGlobal() *ConfigRateLimitInsertInput { + if o == nil { + return nil + } + return o.Global +} + +func (s *ConfigAuthRateLimit) Insert(v *ConfigAuthRateLimitInsertInput) { + if v.Emails != nil { + if s.Emails == nil { + s.Emails = &ConfigRateLimit{} + } + s.Emails.Insert(v.Emails) + } + if v.Sms != nil { + if s.Sms == nil { + s.Sms = &ConfigRateLimit{} + } + s.Sms.Insert(v.Sms) + } + if v.BruteForce != nil { + if s.BruteForce == nil { + s.BruteForce = &ConfigRateLimit{} + } + s.BruteForce.Insert(v.BruteForce) + } + if v.Signups != nil { + if s.Signups == nil { + s.Signups = &ConfigRateLimit{} + } + s.Signups.Insert(v.Signups) + } + if v.Global != nil { + if s.Global == nil { + s.Global = &ConfigRateLimit{} + } + s.Global.Insert(v.Global) + } +} + +func (s *ConfigAuthRateLimit) Clone() *ConfigAuthRateLimit { + if s == nil { + return nil + } + + v := &ConfigAuthRateLimit{} + v.Emails = s.Emails.Clone() + v.Sms = s.Sms.Clone() + v.BruteForce = s.BruteForce.Clone() + v.Signups = s.Signups.Clone() + v.Global = s.Global.Clone() + return v +} + +type ConfigAuthRateLimitComparisonExp struct { + And []*ConfigAuthRateLimitComparisonExp `json:"_and,omitempty"` + Not *ConfigAuthRateLimitComparisonExp `json:"_not,omitempty"` + Or []*ConfigAuthRateLimitComparisonExp `json:"_or,omitempty"` + Emails *ConfigRateLimitComparisonExp `json:"emails,omitempty"` + Sms *ConfigRateLimitComparisonExp `json:"sms,omitempty"` + BruteForce *ConfigRateLimitComparisonExp `json:"bruteForce,omitempty"` + Signups *ConfigRateLimitComparisonExp `json:"signups,omitempty"` + Global *ConfigRateLimitComparisonExp `json:"global,omitempty"` +} + +func (exp *ConfigAuthRateLimitComparisonExp) Matches(o *ConfigAuthRateLimit) bool { + if exp == nil { + return true + } + + if o == nil { + o = &ConfigAuthRateLimit{ + Emails: &ConfigRateLimit{}, + Sms: &ConfigRateLimit{}, + BruteForce: &ConfigRateLimit{}, + Signups: &ConfigRateLimit{}, + Global: &ConfigRateLimit{}, + } + } + if !exp.Emails.Matches(o.Emails) { + return false + } + if !exp.Sms.Matches(o.Sms) { + return false + } + if !exp.BruteForce.Matches(o.BruteForce) { + return false + } + if !exp.Signups.Matches(o.Signups) { + return false + } + if !exp.Global.Matches(o.Global) { + return false + } + + if exp.And != nil && !all(exp.And, o) { + return false + } + + if exp.Or != nil && !or(exp.Or, o) { + return false + } + + if exp.Not != nil && exp.Not.Matches(o) { + return false + } + + return true +} + type ConfigAuthRedirections struct { // AUTH_CLIENT_URL ClientUrl *string `json:"clientUrl" toml:"clientUrl"` @@ -10116,6 +10560,8 @@ type ConfigFunctions struct { Node *ConfigFunctionsNode `json:"node,omitempty" toml:"node,omitempty"` Resources *ConfigFunctionsResources `json:"resources,omitempty" toml:"resources,omitempty"` + + RateLimit *ConfigRateLimit `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` } func (o *ConfigFunctions) MarshalJSON() ([]byte, error) { @@ -10126,6 +10572,9 @@ func (o *ConfigFunctions) MarshalJSON() ([]byte, error) { if o.Resources != nil { m["resources"] = o.Resources } + if o.RateLimit != nil { + m["rateLimit"] = o.RateLimit + } return json.Marshal(m) } @@ -10143,11 +10592,20 @@ func (o *ConfigFunctions) GetResources() *ConfigFunctionsResources { return o.Resources } +func (o *ConfigFunctions) GetRateLimit() *ConfigRateLimit { + if o == nil { + return nil + } + return o.RateLimit +} + type ConfigFunctionsUpdateInput struct { Node *ConfigFunctionsNodeUpdateInput `json:"node,omitempty" toml:"node,omitempty"` IsSetNode bool `json:"-"` Resources *ConfigFunctionsResourcesUpdateInput `json:"resources,omitempty" toml:"resources,omitempty"` IsSetResources bool `json:"-"` + RateLimit *ConfigRateLimitUpdateInput `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` + IsSetRateLimit bool `json:"-"` } func (o *ConfigFunctionsUpdateInput) UnmarshalGQL(v interface{}) error { @@ -10175,6 +10633,16 @@ func (o *ConfigFunctionsUpdateInput) UnmarshalGQL(v interface{}) error { } o.IsSetResources = true } + if x, ok := m["rateLimit"]; ok { + if x != nil { + t := &ConfigRateLimitUpdateInput{} + if err := t.UnmarshalGQL(x); err != nil { + return err + } + o.RateLimit = t + } + o.IsSetRateLimit = true + } return nil } @@ -10200,6 +10668,13 @@ func (o *ConfigFunctionsUpdateInput) GetResources() *ConfigFunctionsResourcesUpd return o.Resources } +func (o *ConfigFunctionsUpdateInput) GetRateLimit() *ConfigRateLimitUpdateInput { + if o == nil { + return nil + } + return o.RateLimit +} + func (s *ConfigFunctions) Update(v *ConfigFunctionsUpdateInput) { if v == nil { return @@ -10224,11 +10699,22 @@ func (s *ConfigFunctions) Update(v *ConfigFunctionsUpdateInput) { s.Resources.Update(v.Resources) } } + if v.IsSetRateLimit || v.RateLimit != nil { + if v.RateLimit == nil { + s.RateLimit = nil + } else { + if s.RateLimit == nil { + s.RateLimit = &ConfigRateLimit{} + } + s.RateLimit.Update(v.RateLimit) + } + } } type ConfigFunctionsInsertInput struct { Node *ConfigFunctionsNodeInsertInput `json:"node,omitempty" toml:"node,omitempty"` Resources *ConfigFunctionsResourcesInsertInput `json:"resources,omitempty" toml:"resources,omitempty"` + RateLimit *ConfigRateLimitInsertInput `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` } func (o *ConfigFunctionsInsertInput) GetNode() *ConfigFunctionsNodeInsertInput { @@ -10245,6 +10731,13 @@ func (o *ConfigFunctionsInsertInput) GetResources() *ConfigFunctionsResourcesIns return o.Resources } +func (o *ConfigFunctionsInsertInput) GetRateLimit() *ConfigRateLimitInsertInput { + if o == nil { + return nil + } + return o.RateLimit +} + func (s *ConfigFunctions) Insert(v *ConfigFunctionsInsertInput) { if v.Node != nil { if s.Node == nil { @@ -10258,6 +10751,12 @@ func (s *ConfigFunctions) Insert(v *ConfigFunctionsInsertInput) { } s.Resources.Insert(v.Resources) } + if v.RateLimit != nil { + if s.RateLimit == nil { + s.RateLimit = &ConfigRateLimit{} + } + s.RateLimit.Insert(v.RateLimit) + } } func (s *ConfigFunctions) Clone() *ConfigFunctions { @@ -10268,6 +10767,7 @@ func (s *ConfigFunctions) Clone() *ConfigFunctions { v := &ConfigFunctions{} v.Node = s.Node.Clone() v.Resources = s.Resources.Clone() + v.RateLimit = s.RateLimit.Clone() return v } @@ -10277,6 +10777,7 @@ type ConfigFunctionsComparisonExp struct { Or []*ConfigFunctionsComparisonExp `json:"_or,omitempty"` Node *ConfigFunctionsNodeComparisonExp `json:"node,omitempty"` Resources *ConfigFunctionsResourcesComparisonExp `json:"resources,omitempty"` + RateLimit *ConfigRateLimitComparisonExp `json:"rateLimit,omitempty"` } func (exp *ConfigFunctionsComparisonExp) Matches(o *ConfigFunctions) bool { @@ -10288,6 +10789,7 @@ func (exp *ConfigFunctionsComparisonExp) Matches(o *ConfigFunctions) bool { o = &ConfigFunctions{ Node: &ConfigFunctionsNode{}, Resources: &ConfigFunctionsResources{}, + RateLimit: &ConfigRateLimit{}, } } if !exp.Node.Matches(o.Node) { @@ -10296,6 +10798,9 @@ func (exp *ConfigFunctionsComparisonExp) Matches(o *ConfigFunctions) bool { if !exp.Resources.Matches(o.Resources) { return false } + if !exp.RateLimit.Matches(o.RateLimit) { + return false + } if exp.And != nil && !all(exp.And, o) { return false @@ -11418,6 +11923,8 @@ type ConfigHasura struct { Events *ConfigHasuraEvents `json:"events,omitempty" toml:"events,omitempty"` // Resources for the service Resources *ConfigResources `json:"resources,omitempty" toml:"resources,omitempty"` + + RateLimit *ConfigRateLimit `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` } func (o *ConfigHasura) MarshalJSON() ([]byte, error) { @@ -11445,6 +11952,9 @@ func (o *ConfigHasura) MarshalJSON() ([]byte, error) { if o.Resources != nil { m["resources"] = o.Resources } + if o.RateLimit != nil { + m["rateLimit"] = o.RateLimit + } return json.Marshal(m) } @@ -11511,6 +12021,13 @@ func (o *ConfigHasura) GetResources() *ConfigResources { return o.Resources } +func (o *ConfigHasura) GetRateLimit() *ConfigRateLimit { + if o == nil { + return nil + } + return o.RateLimit +} + type ConfigHasuraUpdateInput struct { Version *string `json:"version,omitempty" toml:"version,omitempty"` IsSetVersion bool `json:"-"` @@ -11530,6 +12047,8 @@ type ConfigHasuraUpdateInput struct { IsSetEvents bool `json:"-"` Resources *ConfigResourcesUpdateInput `json:"resources,omitempty" toml:"resources,omitempty"` IsSetResources bool `json:"-"` + RateLimit *ConfigRateLimitUpdateInput `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` + IsSetRateLimit bool `json:"-"` } func (o *ConfigHasuraUpdateInput) UnmarshalGQL(v interface{}) error { @@ -11657,6 +12176,16 @@ func (o *ConfigHasuraUpdateInput) UnmarshalGQL(v interface{}) error { } o.IsSetResources = true } + if x, ok := m["rateLimit"]; ok { + if x != nil { + t := &ConfigRateLimitUpdateInput{} + if err := t.UnmarshalGQL(x); err != nil { + return err + } + o.RateLimit = t + } + o.IsSetRateLimit = true + } return nil } @@ -11731,6 +12260,13 @@ func (o *ConfigHasuraUpdateInput) GetResources() *ConfigResourcesUpdateInput { return o.Resources } +func (o *ConfigHasuraUpdateInput) GetRateLimit() *ConfigRateLimitUpdateInput { + if o == nil { + return nil + } + return o.RateLimit +} + func (s *ConfigHasura) Update(v *ConfigHasuraUpdateInput) { if v == nil { return @@ -11810,6 +12346,16 @@ func (s *ConfigHasura) Update(v *ConfigHasuraUpdateInput) { s.Resources.Update(v.Resources) } } + if v.IsSetRateLimit || v.RateLimit != nil { + if v.RateLimit == nil { + s.RateLimit = nil + } else { + if s.RateLimit == nil { + s.RateLimit = &ConfigRateLimit{} + } + s.RateLimit.Update(v.RateLimit) + } + } } type ConfigHasuraInsertInput struct { @@ -11822,6 +12368,7 @@ type ConfigHasuraInsertInput struct { Logs *ConfigHasuraLogsInsertInput `json:"logs,omitempty" toml:"logs,omitempty"` Events *ConfigHasuraEventsInsertInput `json:"events,omitempty" toml:"events,omitempty"` Resources *ConfigResourcesInsertInput `json:"resources,omitempty" toml:"resources,omitempty"` + RateLimit *ConfigRateLimitInsertInput `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` } func (o *ConfigHasuraInsertInput) GetVersion() *string { @@ -11887,6 +12434,13 @@ func (o *ConfigHasuraInsertInput) GetResources() *ConfigResourcesInsertInput { return o.Resources } +func (o *ConfigHasuraInsertInput) GetRateLimit() *ConfigRateLimitInsertInput { + if o == nil { + return nil + } + return o.RateLimit +} + func (s *ConfigHasura) Insert(v *ConfigHasuraInsertInput) { s.Version = v.Version if v.JwtSecrets != nil { @@ -11929,6 +12483,12 @@ func (s *ConfigHasura) Insert(v *ConfigHasuraInsertInput) { } s.Resources.Insert(v.Resources) } + if v.RateLimit != nil { + if s.RateLimit == nil { + s.RateLimit = &ConfigRateLimit{} + } + s.RateLimit.Insert(v.RateLimit) + } } func (s *ConfigHasura) Clone() *ConfigHasura { @@ -11951,6 +12511,7 @@ func (s *ConfigHasura) Clone() *ConfigHasura { v.Logs = s.Logs.Clone() v.Events = s.Events.Clone() v.Resources = s.Resources.Clone() + v.RateLimit = s.RateLimit.Clone() return v } @@ -11967,6 +12528,7 @@ type ConfigHasuraComparisonExp struct { Logs *ConfigHasuraLogsComparisonExp `json:"logs,omitempty"` Events *ConfigHasuraEventsComparisonExp `json:"events,omitempty"` Resources *ConfigResourcesComparisonExp `json:"resources,omitempty"` + RateLimit *ConfigRateLimitComparisonExp `json:"rateLimit,omitempty"` } func (exp *ConfigHasuraComparisonExp) Matches(o *ConfigHasura) bool { @@ -11982,6 +12544,7 @@ func (exp *ConfigHasuraComparisonExp) Matches(o *ConfigHasura) bool { Logs: &ConfigHasuraLogs{}, Events: &ConfigHasuraEvents{}, Resources: &ConfigResources{}, + RateLimit: &ConfigRateLimit{}, } } if o.Version != nil && !exp.Version.Matches(*o.Version) { @@ -12020,6 +12583,9 @@ func (exp *ConfigHasuraComparisonExp) Matches(o *ConfigHasura) bool { if !exp.Resources.Matches(o.Resources) { return false } + if !exp.RateLimit.Matches(o.RateLimit) { + return false + } if exp.And != nil && !all(exp.And, o) { return false @@ -16880,6 +17446,193 @@ func (exp *ConfigProviderComparisonExp) Matches(o *ConfigProvider) bool { return true } +type ConfigRateLimit struct { + Limit uint32 `json:"limit" toml:"limit"` + + Interval string `json:"interval" toml:"interval"` +} + +func (o *ConfigRateLimit) MarshalJSON() ([]byte, error) { + m := make(map[string]any) + m["limit"] = o.Limit + m["interval"] = o.Interval + return json.Marshal(m) +} + +func (o *ConfigRateLimit) GetLimit() uint32 { + if o == nil { + o = &ConfigRateLimit{} + } + return o.Limit +} + +func (o *ConfigRateLimit) GetInterval() string { + if o == nil { + o = &ConfigRateLimit{} + } + return o.Interval +} + +type ConfigRateLimitUpdateInput struct { + Limit *uint32 `json:"limit,omitempty" toml:"limit,omitempty"` + IsSetLimit bool `json:"-"` + Interval *string `json:"interval,omitempty" toml:"interval,omitempty"` + IsSetInterval bool `json:"-"` +} + +func (o *ConfigRateLimitUpdateInput) UnmarshalGQL(v interface{}) error { + m, ok := v.(map[string]any) + if !ok { + return fmt.Errorf("must be map[string]interface{}, got %T", v) + } + if v, ok := m["limit"]; ok { + if v == nil { + o.Limit = nil + } else { + // clearly a not very efficient shortcut + b, err := json.Marshal(v) + if err != nil { + return err + } + var x uint32 + if err := json.Unmarshal(b, &x); err != nil { + return err + } + o.Limit = &x + } + o.IsSetLimit = true + } + if v, ok := m["interval"]; ok { + if v == nil { + o.Interval = nil + } else { + // clearly a not very efficient shortcut + b, err := json.Marshal(v) + if err != nil { + return err + } + var x string + if err := json.Unmarshal(b, &x); err != nil { + return err + } + o.Interval = &x + } + o.IsSetInterval = true + } + + return nil +} + +func (o *ConfigRateLimitUpdateInput) MarshalGQL(w io.Writer) { + enc := json.NewEncoder(w) + if err := enc.Encode(o); err != nil { + panic(err) + } +} + +func (o *ConfigRateLimitUpdateInput) GetLimit() *uint32 { + if o == nil { + o = &ConfigRateLimitUpdateInput{} + } + return o.Limit +} + +func (o *ConfigRateLimitUpdateInput) GetInterval() *string { + if o == nil { + o = &ConfigRateLimitUpdateInput{} + } + return o.Interval +} + +func (s *ConfigRateLimit) Update(v *ConfigRateLimitUpdateInput) { + if v == nil { + return + } + if v.IsSetLimit || v.Limit != nil { + if v.Limit != nil { + s.Limit = *v.Limit + } + } + if v.IsSetInterval || v.Interval != nil { + if v.Interval != nil { + s.Interval = *v.Interval + } + } +} + +type ConfigRateLimitInsertInput struct { + Limit uint32 `json:"limit,omitempty" toml:"limit,omitempty"` + Interval string `json:"interval,omitempty" toml:"interval,omitempty"` +} + +func (o *ConfigRateLimitInsertInput) GetLimit() uint32 { + if o == nil { + o = &ConfigRateLimitInsertInput{} + } + return o.Limit +} + +func (o *ConfigRateLimitInsertInput) GetInterval() string { + if o == nil { + o = &ConfigRateLimitInsertInput{} + } + return o.Interval +} + +func (s *ConfigRateLimit) Insert(v *ConfigRateLimitInsertInput) { + s.Limit = v.Limit + s.Interval = v.Interval +} + +func (s *ConfigRateLimit) Clone() *ConfigRateLimit { + if s == nil { + return nil + } + + v := &ConfigRateLimit{} + v.Limit = s.Limit + v.Interval = s.Interval + return v +} + +type ConfigRateLimitComparisonExp struct { + And []*ConfigRateLimitComparisonExp `json:"_and,omitempty"` + Not *ConfigRateLimitComparisonExp `json:"_not,omitempty"` + Or []*ConfigRateLimitComparisonExp `json:"_or,omitempty"` + Limit *ConfigUint32ComparisonExp `json:"limit,omitempty"` + Interval *ConfigStringComparisonExp `json:"interval,omitempty"` +} + +func (exp *ConfigRateLimitComparisonExp) Matches(o *ConfigRateLimit) bool { + if exp == nil { + return true + } + + if o == nil { + o = &ConfigRateLimit{} + } + if !exp.Limit.Matches(o.Limit) { + return false + } + if !exp.Interval.Matches(o.Interval) { + return false + } + + if exp.And != nil && !all(exp.And, o) { + return false + } + + if exp.Or != nil && !or(exp.Or, o) { + return false + } + + if exp.Not != nil && exp.Not.Matches(o) { + return false + } + + return true +} + // Resource configuration for a service type ConfigResources struct { Compute *ConfigResourcesCompute `json:"compute,omitempty" toml:"compute,omitempty"` @@ -18126,6 +18879,8 @@ type ConfigRunServicePort struct { Publish *bool `json:"publish" toml:"publish"` Ingresses []*ConfigIngress `json:"ingresses,omitempty" toml:"ingresses,omitempty"` + + RateLimit *ConfigRateLimit `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` } func (o *ConfigRunServicePort) MarshalJSON() ([]byte, error) { @@ -18138,6 +18893,9 @@ func (o *ConfigRunServicePort) MarshalJSON() ([]byte, error) { if o.Ingresses != nil { m["ingresses"] = o.Ingresses } + if o.RateLimit != nil { + m["rateLimit"] = o.RateLimit + } return json.Marshal(m) } @@ -18169,6 +18927,13 @@ func (o *ConfigRunServicePort) GetIngresses() []*ConfigIngress { return o.Ingresses } +func (o *ConfigRunServicePort) GetRateLimit() *ConfigRateLimit { + if o == nil { + return nil + } + return o.RateLimit +} + type ConfigRunServicePortUpdateInput struct { Port *uint16 `json:"port,omitempty" toml:"port,omitempty"` IsSetPort bool `json:"-"` @@ -18178,6 +18943,8 @@ type ConfigRunServicePortUpdateInput struct { IsSetPublish bool `json:"-"` Ingresses []*ConfigIngressUpdateInput `json:"ingresses,omitempty" toml:"ingresses,omitempty"` IsSetIngresses bool `json:"-"` + RateLimit *ConfigRateLimitUpdateInput `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` + IsSetRateLimit bool `json:"-"` } func (o *ConfigRunServicePortUpdateInput) UnmarshalGQL(v interface{}) error { @@ -18255,6 +19022,16 @@ func (o *ConfigRunServicePortUpdateInput) UnmarshalGQL(v interface{}) error { } o.IsSetIngresses = true } + if x, ok := m["rateLimit"]; ok { + if x != nil { + t := &ConfigRateLimitUpdateInput{} + if err := t.UnmarshalGQL(x); err != nil { + return err + } + o.RateLimit = t + } + o.IsSetRateLimit = true + } return nil } @@ -18294,6 +19071,13 @@ func (o *ConfigRunServicePortUpdateInput) GetIngresses() []*ConfigIngressUpdateI return o.Ingresses } +func (o *ConfigRunServicePortUpdateInput) GetRateLimit() *ConfigRateLimitUpdateInput { + if o == nil { + return nil + } + return o.RateLimit +} + func (s *ConfigRunServicePort) Update(v *ConfigRunServicePortUpdateInput) { if v == nil { return @@ -18323,6 +19107,16 @@ func (s *ConfigRunServicePort) Update(v *ConfigRunServicePortUpdateInput) { } } } + if v.IsSetRateLimit || v.RateLimit != nil { + if v.RateLimit == nil { + s.RateLimit = nil + } else { + if s.RateLimit == nil { + s.RateLimit = &ConfigRateLimit{} + } + s.RateLimit.Update(v.RateLimit) + } + } } type ConfigRunServicePortInsertInput struct { @@ -18330,6 +19124,7 @@ type ConfigRunServicePortInsertInput struct { Type string `json:"type,omitempty" toml:"type,omitempty"` Publish *bool `json:"publish,omitempty" toml:"publish,omitempty"` Ingresses []*ConfigIngressInsertInput `json:"ingresses,omitempty" toml:"ingresses,omitempty"` + RateLimit *ConfigRateLimitInsertInput `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` } func (o *ConfigRunServicePortInsertInput) GetPort() uint16 { @@ -18360,6 +19155,13 @@ func (o *ConfigRunServicePortInsertInput) GetIngresses() []*ConfigIngressInsertI return o.Ingresses } +func (o *ConfigRunServicePortInsertInput) GetRateLimit() *ConfigRateLimitInsertInput { + if o == nil { + return nil + } + return o.RateLimit +} + func (s *ConfigRunServicePort) Insert(v *ConfigRunServicePortInsertInput) { s.Port = v.Port s.Type = v.Type @@ -18372,6 +19174,12 @@ func (s *ConfigRunServicePort) Insert(v *ConfigRunServicePortInsertInput) { s.Ingresses[i] = v } } + if v.RateLimit != nil { + if s.RateLimit == nil { + s.RateLimit = &ConfigRateLimit{} + } + s.RateLimit.Insert(v.RateLimit) + } } func (s *ConfigRunServicePort) Clone() *ConfigRunServicePort { @@ -18389,6 +19197,7 @@ func (s *ConfigRunServicePort) Clone() *ConfigRunServicePort { v.Ingresses[i] = e.Clone() } } + v.RateLimit = s.RateLimit.Clone() return v } @@ -18400,6 +19209,7 @@ type ConfigRunServicePortComparisonExp struct { Type *ConfigStringComparisonExp `json:"type,omitempty"` Publish *ConfigBooleanComparisonExp `json:"publish,omitempty"` Ingresses *ConfigIngressComparisonExp `json:"ingresses,omitempty"` + RateLimit *ConfigRateLimitComparisonExp `json:"rateLimit,omitempty"` } func (exp *ConfigRunServicePortComparisonExp) Matches(o *ConfigRunServicePort) bool { @@ -18410,6 +19220,7 @@ func (exp *ConfigRunServicePortComparisonExp) Matches(o *ConfigRunServicePort) b if o == nil { o = &ConfigRunServicePort{ Ingresses: []*ConfigIngress{}, + RateLimit: &ConfigRateLimit{}, } } if !exp.Port.Matches(o.Port) { @@ -18433,6 +19244,9 @@ func (exp *ConfigRunServicePortComparisonExp) Matches(o *ConfigRunServicePort) b return false } } + if !exp.RateLimit.Matches(o.RateLimit) { + return false + } if exp.And != nil && !all(exp.And, o) { return false @@ -20372,6 +21186,8 @@ type ConfigStorage struct { Resources *ConfigResources `json:"resources,omitempty" toml:"resources,omitempty"` Antivirus *ConfigStorageAntivirus `json:"antivirus,omitempty" toml:"antivirus,omitempty"` + + RateLimit *ConfigRateLimit `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` } func (o *ConfigStorage) MarshalJSON() ([]byte, error) { @@ -20385,6 +21201,9 @@ func (o *ConfigStorage) MarshalJSON() ([]byte, error) { if o.Antivirus != nil { m["antivirus"] = o.Antivirus } + if o.RateLimit != nil { + m["rateLimit"] = o.RateLimit + } return json.Marshal(m) } @@ -20409,6 +21228,13 @@ func (o *ConfigStorage) GetAntivirus() *ConfigStorageAntivirus { return o.Antivirus } +func (o *ConfigStorage) GetRateLimit() *ConfigRateLimit { + if o == nil { + return nil + } + return o.RateLimit +} + type ConfigStorageUpdateInput struct { Version *string `json:"version,omitempty" toml:"version,omitempty"` IsSetVersion bool `json:"-"` @@ -20416,6 +21242,8 @@ type ConfigStorageUpdateInput struct { IsSetResources bool `json:"-"` Antivirus *ConfigStorageAntivirusUpdateInput `json:"antivirus,omitempty" toml:"antivirus,omitempty"` IsSetAntivirus bool `json:"-"` + RateLimit *ConfigRateLimitUpdateInput `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` + IsSetRateLimit bool `json:"-"` } func (o *ConfigStorageUpdateInput) UnmarshalGQL(v interface{}) error { @@ -20460,6 +21288,16 @@ func (o *ConfigStorageUpdateInput) UnmarshalGQL(v interface{}) error { } o.IsSetAntivirus = true } + if x, ok := m["rateLimit"]; ok { + if x != nil { + t := &ConfigRateLimitUpdateInput{} + if err := t.UnmarshalGQL(x); err != nil { + return err + } + o.RateLimit = t + } + o.IsSetRateLimit = true + } return nil } @@ -20492,6 +21330,13 @@ func (o *ConfigStorageUpdateInput) GetAntivirus() *ConfigStorageAntivirusUpdateI return o.Antivirus } +func (o *ConfigStorageUpdateInput) GetRateLimit() *ConfigRateLimitUpdateInput { + if o == nil { + return nil + } + return o.RateLimit +} + func (s *ConfigStorage) Update(v *ConfigStorageUpdateInput) { if v == nil { return @@ -20519,12 +21364,23 @@ func (s *ConfigStorage) Update(v *ConfigStorageUpdateInput) { s.Antivirus.Update(v.Antivirus) } } + if v.IsSetRateLimit || v.RateLimit != nil { + if v.RateLimit == nil { + s.RateLimit = nil + } else { + if s.RateLimit == nil { + s.RateLimit = &ConfigRateLimit{} + } + s.RateLimit.Update(v.RateLimit) + } + } } type ConfigStorageInsertInput struct { Version *string `json:"version,omitempty" toml:"version,omitempty"` Resources *ConfigResourcesInsertInput `json:"resources,omitempty" toml:"resources,omitempty"` Antivirus *ConfigStorageAntivirusInsertInput `json:"antivirus,omitempty" toml:"antivirus,omitempty"` + RateLimit *ConfigRateLimitInsertInput `json:"rateLimit,omitempty" toml:"rateLimit,omitempty"` } func (o *ConfigStorageInsertInput) GetVersion() *string { @@ -20548,6 +21404,13 @@ func (o *ConfigStorageInsertInput) GetAntivirus() *ConfigStorageAntivirusInsertI return o.Antivirus } +func (o *ConfigStorageInsertInput) GetRateLimit() *ConfigRateLimitInsertInput { + if o == nil { + return nil + } + return o.RateLimit +} + func (s *ConfigStorage) Insert(v *ConfigStorageInsertInput) { s.Version = v.Version if v.Resources != nil { @@ -20562,6 +21425,12 @@ func (s *ConfigStorage) Insert(v *ConfigStorageInsertInput) { } s.Antivirus.Insert(v.Antivirus) } + if v.RateLimit != nil { + if s.RateLimit == nil { + s.RateLimit = &ConfigRateLimit{} + } + s.RateLimit.Insert(v.RateLimit) + } } func (s *ConfigStorage) Clone() *ConfigStorage { @@ -20573,6 +21442,7 @@ func (s *ConfigStorage) Clone() *ConfigStorage { v.Version = s.Version v.Resources = s.Resources.Clone() v.Antivirus = s.Antivirus.Clone() + v.RateLimit = s.RateLimit.Clone() return v } @@ -20583,6 +21453,7 @@ type ConfigStorageComparisonExp struct { Version *ConfigStringComparisonExp `json:"version,omitempty"` Resources *ConfigResourcesComparisonExp `json:"resources,omitempty"` Antivirus *ConfigStorageAntivirusComparisonExp `json:"antivirus,omitempty"` + RateLimit *ConfigRateLimitComparisonExp `json:"rateLimit,omitempty"` } func (exp *ConfigStorageComparisonExp) Matches(o *ConfigStorage) bool { @@ -20594,6 +21465,7 @@ func (exp *ConfigStorageComparisonExp) Matches(o *ConfigStorage) bool { o = &ConfigStorage{ Resources: &ConfigResources{}, Antivirus: &ConfigStorageAntivirus{}, + RateLimit: &ConfigRateLimit{}, } } if o.Version != nil && !exp.Version.Matches(*o.Version) { @@ -20605,6 +21477,9 @@ func (exp *ConfigStorageComparisonExp) Matches(o *ConfigStorage) bool { if !exp.Antivirus.Matches(o.Antivirus) { return false } + if !exp.RateLimit.Matches(o.RateLimit) { + return false + } if exp.And != nil && !all(exp.And, o) { return false diff --git a/vendor/github.com/nhost/be/services/mimir/schema/appconfig/hasura_auth.go b/vendor/github.com/nhost/be/services/mimir/schema/appconfig/hasura_auth.go index f1dff1d82..ab15cc271 100644 --- a/vendor/github.com/nhost/be/services/mimir/schema/appconfig/hasura_auth.go +++ b/vendor/github.com/nhost/be/services/mimir/schema/appconfig/hasura_auth.go @@ -38,6 +38,9 @@ func HasuraAuthEnv( //nolint:funlen,cyclop,maintidx databaseURL string, databaseMigrationURL string, smtpSettings *model.ConfigSmtp, + isCustomSMTP bool, + autoScalerEnabled bool, + appID string, ) ([]EnvVar, error) { customClaims := make( map[string]string, @@ -57,6 +60,11 @@ func HasuraAuthEnv( //nolint:funlen,cyclop,maintidx return nil, fmt.Errorf("could not marshal JWT secret: %w", err) } + replicas := 1 + if !autoScalerEnabled && config.GetAuth().GetResources().GetReplicas() != nil { + replicas = int(*config.GetAuth().GetResources().GetReplicas()) + } + dbURL := databaseURL version := *config.GetAuth().GetVersion() if version != "0.0.0-dev" && CompareVersions(version, "0.30.999999") <= 0 { @@ -1356,8 +1364,106 @@ func HasuraAuthEnv( //nolint:funlen,cyclop,maintidx Value: smtpSettings.GetPassword(), IsSecret: true, }, + { + Name: "AUTH_RATE_LIMIT_ENABLE", + Value: "true", + IsSecret: false, + SecretName: "", + }, + { + Name: "AUTH_RATE_LIMIT_GLOBAL_BURST", + Value: Stringify( + config.GetAuth().GetRateLimit().GetGlobal().GetLimit() / uint32(replicas), + ), + IsSecret: false, + SecretName: "", + }, + { + Name: "AUTH_RATE_LIMIT_GLOBAL_INTERVAL", + Value: config.GetAuth().GetRateLimit().GetGlobal().GetInterval(), + IsSecret: false, + SecretName: "", + }, + { + Name: "AUTH_RATE_LIMIT_EMAIL_IS_GLOBAL", + Value: Stringify(!isCustomSMTP), + IsSecret: false, + SecretName: "", + }, + { + Name: "AUTH_RATE_LIMIT_EMAIL_BURST", + Value: Stringify( + config.GetAuth().GetRateLimit().GetEmails().GetLimit() / uint32(replicas), + ), + IsSecret: false, + SecretName: "", + }, + { + Name: "AUTH_RATE_LIMIT_EMAIL_INTERVAL", + Value: config.GetAuth().GetRateLimit().GetEmails().GetInterval(), + IsSecret: false, + SecretName: "", + }, + { + Name: "AUTH_RATE_LIMIT_SMS_BURST", + Value: Stringify( + config.GetAuth().GetRateLimit().GetSms().GetLimit() / uint32(replicas), + ), + IsSecret: false, + SecretName: "", + }, + { + Name: "AUTH_RATE_LIMIT_SMS_INTERVAL", + Value: config.GetAuth().GetRateLimit().GetSms().GetInterval(), + IsSecret: false, + SecretName: "", + }, + { + Name: "AUTH_RATE_LIMIT_BRUTE_FORCE_BURST", + Value: Stringify( + config.GetAuth().GetRateLimit().GetBruteForce().GetLimit() / uint32(replicas), + ), + IsSecret: false, + SecretName: "", + }, + { + Name: "AUTH_RATE_LIMIT_BRUTE_FORCE_INTERVAL", + Value: config.GetAuth().GetRateLimit().GetBruteForce().GetInterval(), + IsSecret: false, + SecretName: "", + }, + { + Name: "AUTH_RATE_LIMIT_SIGNUPS_BURST", + Value: Stringify( + config.GetAuth().GetRateLimit().GetSignups().GetLimit() / uint32(replicas), + ), + IsSecret: false, + SecretName: "", + }, + { + Name: "AUTH_RATE_LIMIT_SIGNUPS_INTERVAL", + Value: config.GetAuth().GetRateLimit().GetSignups().GetInterval(), + IsSecret: false, + SecretName: "", + }, }...) + if autoScalerEnabled { + env = append(env, + EnvVar{ + Name: "AUTH_RATE_LIMIT_MEMCACHE_PREFIX", + Value: appID + "/hasura-auth/", + SecretName: "", + IsSecret: false, + }, + EnvVar{ + Name: "AUTH_RATE_LIMIT_MEMCACHE_SERVER", + Value: "memcached.ingress-nginx.svc.cluster.local:11211", + SecretName: "", + IsSecret: false, + }) + } + for _, e := range config.GetGlobal().GetEnvironment() { env = append(env, EnvVar{ //nolint:exhaustruct Name: e.Name, diff --git a/vendor/github.com/nhost/be/services/mimir/schema/schema.cue b/vendor/github.com/nhost/be/services/mimir/schema/schema.cue index cfc267873..a28639009 100644 --- a/vendor/github.com/nhost/be/services/mimir/schema/schema.cue +++ b/vendor/github.com/nhost/be/services/mimir/schema/schema.cue @@ -5,6 +5,7 @@ import ( "math" "net" "strings" + "time" ) // main entrypoint to the configuration @@ -195,6 +196,8 @@ import ( // Resources for the service resources?: #Resources + + rateLimit?: #RateLimit } // APIs for hasura @@ -217,6 +220,8 @@ import ( antivirus?: { server: "tcp://run-clamav:3310" } + + rateLimit?: #RateLimit } // Configuration for functions service @@ -228,6 +233,8 @@ import ( resources?: { networking?: #Networking } + + rateLimit?: #RateLimit } // Configuration for postgres service @@ -458,6 +465,20 @@ import ( } } + rateLimit: #AuthRateLimit +} + +#RateLimit: { + limit: uint32 + interval: string & time.Duration +} + +#AuthRateLimit: { + emails: #RateLimit | *{limit: 10, interval: "1h"} + sms: #RateLimit | *{limit: 10, interval: "1h"} + bruteForce: #RateLimit | *{limit: 10, interval: "5m"} + signups: #RateLimit | *{limit: 10, interval: "5m"} + global: #RateLimit | *{limit: 100, interval: "1m"} } #StandardOauthProvider: { @@ -622,6 +643,8 @@ import ( ingresses: [#Ingress] | *[] _publish_supported_only_over_http: ( publish == false || type == "http" ) & true @cuegraph(skip) + + rateLimit?: #RateLimit } #RunServiceName: =~"^[a-z]([-a-z0-9]*[a-z0-9])?$" & strings.MinRunes(1) & strings.MaxRunes(30) diff --git a/vendor/github.com/nhost/be/services/mimir/schema/schema_gen.graphqls b/vendor/github.com/nhost/be/services/mimir/schema/schema_gen.graphqls index 56a5ff960..08ad60fde 100644 --- a/vendor/github.com/nhost/be/services/mimir/schema/schema_gen.graphqls +++ b/vendor/github.com/nhost/be/services/mimir/schema/schema_gen.graphqls @@ -291,6 +291,10 @@ type ConfigAuth { """ totp: ConfigAuthTotp + """ + + """ + rateLimit: ConfigAuthRateLimit } input ConfigAuthUpdateInput { @@ -303,6 +307,7 @@ input ConfigAuthUpdateInput { session: ConfigAuthSessionUpdateInput method: ConfigAuthMethodUpdateInput totp: ConfigAuthTotpUpdateInput + rateLimit: ConfigAuthRateLimitUpdateInput } input ConfigAuthInsertInput { @@ -315,6 +320,7 @@ input ConfigAuthInsertInput { session: ConfigAuthSessionInsertInput method: ConfigAuthMethodInsertInput totp: ConfigAuthTotpInsertInput + rateLimit: ConfigAuthRateLimitInsertInput } input ConfigAuthComparisonExp { @@ -330,6 +336,7 @@ input ConfigAuthComparisonExp { session: ConfigAuthSessionComparisonExp method: ConfigAuthMethodComparisonExp totp: ConfigAuthTotpComparisonExp + rateLimit: ConfigAuthRateLimitComparisonExp } """ @@ -958,6 +965,59 @@ input ConfigAuthMethodWebauthnRelyingPartyComparisonExp { """ +""" +type ConfigAuthRateLimit { + """ + + """ + emails: ConfigRateLimit + """ + + """ + sms: ConfigRateLimit + """ + + """ + bruteForce: ConfigRateLimit + """ + + """ + signups: ConfigRateLimit + """ + + """ + global: ConfigRateLimit +} + +input ConfigAuthRateLimitUpdateInput { + emails: ConfigRateLimitUpdateInput + sms: ConfigRateLimitUpdateInput + bruteForce: ConfigRateLimitUpdateInput + signups: ConfigRateLimitUpdateInput + global: ConfigRateLimitUpdateInput +} + +input ConfigAuthRateLimitInsertInput { + emails: ConfigRateLimitInsertInput + sms: ConfigRateLimitInsertInput + bruteForce: ConfigRateLimitInsertInput + signups: ConfigRateLimitInsertInput + global: ConfigRateLimitInsertInput +} + +input ConfigAuthRateLimitComparisonExp { + _and: [ConfigAuthRateLimitComparisonExp!] + _not: ConfigAuthRateLimitComparisonExp + _or: [ConfigAuthRateLimitComparisonExp!] + emails: ConfigRateLimitComparisonExp + sms: ConfigRateLimitComparisonExp + bruteForce: ConfigRateLimitComparisonExp + signups: ConfigRateLimitComparisonExp + global: ConfigRateLimitComparisonExp +} + +""" + """ type ConfigAuthRedirections { """ @@ -1637,16 +1697,22 @@ type ConfigFunctions { """ resources: ConfigFunctionsResources + """ + + """ + rateLimit: ConfigRateLimit } input ConfigFunctionsUpdateInput { node: ConfigFunctionsNodeUpdateInput resources: ConfigFunctionsResourcesUpdateInput + rateLimit: ConfigRateLimitUpdateInput } input ConfigFunctionsInsertInput { node: ConfigFunctionsNodeInsertInput resources: ConfigFunctionsResourcesInsertInput + rateLimit: ConfigRateLimitInsertInput } input ConfigFunctionsComparisonExp { @@ -1655,6 +1721,7 @@ input ConfigFunctionsComparisonExp { _or: [ConfigFunctionsComparisonExp!] node: ConfigFunctionsNodeComparisonExp resources: ConfigFunctionsResourcesComparisonExp + rateLimit: ConfigRateLimitComparisonExp } """ @@ -1888,6 +1955,10 @@ type ConfigHasura { Resources for the service """ resources: ConfigResources + """ + + """ + rateLimit: ConfigRateLimit } input ConfigHasuraUpdateInput { @@ -1900,6 +1971,7 @@ input ConfigHasuraUpdateInput { logs: ConfigHasuraLogsUpdateInput events: ConfigHasuraEventsUpdateInput resources: ConfigResourcesUpdateInput + rateLimit: ConfigRateLimitUpdateInput } input ConfigHasuraInsertInput { @@ -1912,6 +1984,7 @@ input ConfigHasuraInsertInput { logs: ConfigHasuraLogsInsertInput events: ConfigHasuraEventsInsertInput resources: ConfigResourcesInsertInput + rateLimit: ConfigRateLimitInsertInput } input ConfigHasuraComparisonExp { @@ -1927,6 +2000,7 @@ input ConfigHasuraComparisonExp { logs: ConfigHasuraLogsComparisonExp events: ConfigHasuraEventsComparisonExp resources: ConfigResourcesComparisonExp + rateLimit: ConfigRateLimitComparisonExp } scalar ConfigHasuraAPIs @@ -2651,6 +2725,38 @@ input ConfigProviderComparisonExp { sms: ConfigSmsComparisonExp } +""" + +""" +type ConfigRateLimit { + """ + + """ + limit: ConfigUint32! + """ + + """ + interval: String! +} + +input ConfigRateLimitUpdateInput { + limit: ConfigUint32 + interval: String +} + +input ConfigRateLimitInsertInput { + limit: ConfigUint32! + interval: String! +} + +input ConfigRateLimitComparisonExp { + _and: [ConfigRateLimitComparisonExp!] + _not: ConfigRateLimitComparisonExp + _or: [ConfigRateLimitComparisonExp!] + limit: ConfigUint32ComparisonExp + interval: ConfigStringComparisonExp +} + """ Resource configuration for a service """ @@ -2850,6 +2956,10 @@ type ConfigRunServicePort { """ ingresses: [ConfigIngress!] + """ + + """ + rateLimit: ConfigRateLimit } input ConfigRunServicePortUpdateInput { @@ -2857,6 +2967,7 @@ input ConfigRunServicePortUpdateInput { type: String publish: Boolean ingresses: [ConfigIngressUpdateInput!] + rateLimit: ConfigRateLimitUpdateInput } input ConfigRunServicePortInsertInput { @@ -2864,6 +2975,7 @@ input ConfigRunServicePortInsertInput { type: String! publish: Boolean ingresses: [ConfigIngressInsertInput!] + rateLimit: ConfigRateLimitInsertInput } input ConfigRunServicePortComparisonExp { @@ -2874,6 +2986,7 @@ input ConfigRunServicePortComparisonExp { type: ConfigStringComparisonExp publish: ConfigBooleanComparisonExp ingresses: ConfigIngressComparisonExp + rateLimit: ConfigRateLimitComparisonExp } """ @@ -3181,18 +3294,24 @@ type ConfigStorage { """ antivirus: ConfigStorageAntivirus + """ + + """ + rateLimit: ConfigRateLimit } input ConfigStorageUpdateInput { version: String resources: ConfigResourcesUpdateInput antivirus: ConfigStorageAntivirusUpdateInput + rateLimit: ConfigRateLimitUpdateInput } input ConfigStorageInsertInput { version: String resources: ConfigResourcesInsertInput antivirus: ConfigStorageAntivirusInsertInput + rateLimit: ConfigRateLimitInsertInput } input ConfigStorageComparisonExp { @@ -3202,6 +3321,7 @@ input ConfigStorageComparisonExp { version: ConfigStringComparisonExp resources: ConfigResourcesComparisonExp antivirus: ConfigStorageAntivirusComparisonExp + rateLimit: ConfigRateLimitComparisonExp } """ diff --git a/vendor/modules.txt b/vendor/modules.txt index 1743c0faa..84cff852e 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -541,7 +541,7 @@ github.com/muesli/termenv # github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 ## explicit github.com/munnerz/goautoneg -# github.com/nhost/be v0.0.0-20240806070711-58ddcca3b692 +# github.com/nhost/be v0.0.0-20240820101832-63c0798e013b ## explicit; go 1.22.4 github.com/nhost/be/lib/graphql github.com/nhost/be/lib/graphql/context