From 11bf34918eb9300aff548dfeabd5bf2724c2eeea Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Wed, 11 Mar 2026 11:55:01 +0100 Subject: [PATCH 01/25] Initial work on bulk apply using rest endpoint Co-authored-by: Vegar Sechmann Molvig --- .configs/gqlgen.yaml | 1 + AGENTS.md | 1 + integration_tests/apply.lua | 335 +++++++ integration_tests/zz_spec.lua | 7 + internal/apply/activitylog.go | 70 ++ internal/apply/apply.go | 314 +++++++ internal/apply/client.go | 132 +++ internal/apply/diff.go | 241 +++++ internal/apply/diff_test.go | 831 +++++++++++++++++ internal/apply/model.go | 34 + internal/apply/whitelist.go | 44 + internal/cmd/api/api.go | 13 +- internal/cmd/api/http.go | 4 +- internal/graph/apply.resolvers.go | 46 + .../graph/gengql/activitylog.generated.go | 8 + internal/graph/gengql/apply.generated.go | 839 ++++++++++++++++++ internal/graph/gengql/root_.generated.go | 213 +++++ internal/graph/gengql/schema.generated.go | 8 + internal/graph/schema/apply.graphqls | 65 ++ internal/integration/manager.go | 15 +- internal/integration/runner/k8s.go | 14 + internal/kubernetes/fake/fake.go | 66 ++ internal/rest/rest.go | 110 ++- 23 files changed, 3393 insertions(+), 18 deletions(-) create mode 100644 integration_tests/apply.lua create mode 100644 internal/apply/activitylog.go create mode 100644 internal/apply/apply.go create mode 100644 internal/apply/client.go create mode 100644 internal/apply/diff.go create mode 100644 internal/apply/diff_test.go create mode 100644 internal/apply/model.go create mode 100644 internal/apply/whitelist.go create mode 100644 internal/graph/apply.resolvers.go create mode 100644 internal/graph/gengql/apply.generated.go create mode 100644 internal/graph/schema/apply.graphqls diff --git a/.configs/gqlgen.yaml b/.configs/gqlgen.yaml index 20b410861..40b4d1544 100644 --- a/.configs/gqlgen.yaml +++ b/.configs/gqlgen.yaml @@ -37,6 +37,7 @@ autobind: - "github.com/99designs/gqlgen/graphql/introspection" # Without this line in the beginning, a `prelude.resolver.go` is generated - "github.com/nais/api/internal/activitylog" - "github.com/nais/api/internal/alerts" + - "github.com/nais/api/internal/apply" - "github.com/nais/api/internal/auth/authz" - "github.com/nais/api/internal/cost" - "github.com/nais/api/internal/deployment" diff --git a/AGENTS.md b/AGENTS.md index aaf6a86ca..e97ce7da7 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -36,6 +36,7 @@ go test -v -tags=integration_test -run "TestIntegration/" ./integratio 1. **Før du endrer kode**: Les relevante filer for å forstå eksisterende mønstre 2. **Etter endringer i `.graphqls`**: Kjør `mise run generate:graphql` + 1. Hvis det havner modeller i `internal/graph/model/donotuse/models_gen.go`, flytt disse til riktig pakke/domene og generer på nytt 3. **Etter endringer i `.sql`**: Kjør `mise run generate:sql` 4. **Etter alle endringer**: Kjør `mise run test` og `mise run fmt` 5. **Ved kompileringsfeil**: Sjekk at generert kode er oppdatert diff --git a/integration_tests/apply.lua b/integration_tests/apply.lua new file mode 100644 index 000000000..d173e878b --- /dev/null +++ b/integration_tests/apply.lua @@ -0,0 +1,335 @@ +local user = User.new("applyer", "apply@example.com", "apply-ext") +local nonMember = User.new("outsider", "outsider@example.com", "outsider-ext") + +local team = Team.new("apply-team", "Apply testing", "#apply-team") +team:addMember(user) + +Test.rest("create application via apply", function(t) + t.addHeader("x-user-email", user:email()) + + t.send("POST", "/api/v1/apply?cluster=dev", [[ + { + "resources": [ + { + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "metadata": { + "name": "my-app", + "namespace": "apply-team" + }, + "spec": { + "image": "example.com/my-app:v1", + "replicas": { + "min": 1, + "max": 2 + } + } + } + ] + } + ]]) + + t.check(200, { + results = { + { + resource = "Application/my-app", + namespace = "apply-team", + cluster = "dev", + status = "created", + }, + }, + }) +end) + +Test.k8s("verify resource was created in fake cluster", function(t) + t.check("nais.io/v1alpha1", "applications", "dev", "apply-team", "my-app", { + apiVersion = "nais.io/v1alpha1", + kind = "Application", + metadata = { + name = "my-app", + namespace = "apply-team", + }, + spec = { + image = "example.com/my-app:v1", + replicas = { + min = 1, + max = 2, + }, + }, + }) +end) + +Test.rest("update application via apply", function(t) + t.addHeader("x-user-email", user:email()) + + t.send("POST", "/api/v1/apply?cluster=dev", [[ + { + "resources": [ + { + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "metadata": { + "name": "my-app", + "namespace": "apply-team" + }, + "spec": { + "image": "example.com/my-app:v2", + "replicas": { + "min": 2, + "max": 4 + } + } + } + ] + } + ]]) + + t.check(200, { + results = { + { + resource = "Application/my-app", + namespace = "apply-team", + cluster = "dev", + status = "applied", + changedFields = NotNull(), + }, + }, + }) +end) + +Test.k8s("verify resource was updated in fake cluster", function(t) + t.check("nais.io/v1alpha1", "applications", "dev", "apply-team", "my-app", { + apiVersion = "nais.io/v1alpha1", + kind = "Application", + metadata = { + name = "my-app", + namespace = "apply-team", + }, + spec = { + image = "example.com/my-app:v2", + replicas = { + min = 2, + max = 4, + }, + }, + }) +end) + +Test.rest("disallowed resource kind returns 400", function(t) + t.addHeader("x-user-email", user:email()) + + t.send("POST", "/api/v1/apply?cluster=dev", [[ + { + "resources": [ + { + "apiVersion": "apps/v1", + "kind": "Deployment", + "metadata": { + "name": "my-deploy", + "namespace": "apply-team" + }, + "spec": {} + } + ] + } + ]]) + + t.check(400, { + error = Contains("disallowed resource types"), + }) +end) + +Test.rest("non-member gets authorization error", function(t) + t.addHeader("x-user-email", nonMember:email()) + + t.send("POST", "/api/v1/apply?cluster=dev", [[ + { + "resources": [ + { + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "metadata": { + "name": "sneaky-app", + "namespace": "apply-team" + }, + "spec": { + "image": "example.com/sneaky:v1" + } + } + ] + } + ]]) + + t.check(207, { + results = { + { + resource = "Application/sneaky-app", + namespace = "apply-team", + cluster = "dev", + status = "error", + error = Contains("authorization failed"), + }, + }, + }) +end) + +Test.rest("missing cluster parameter returns per-resource error", function(t) + t.addHeader("x-user-email", user:email()) + + t.send("POST", "/api/v1/apply", [[ + { + "resources": [ + { + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "metadata": { + "name": "no-cluster-app", + "namespace": "apply-team" + }, + "spec": { + "image": "example.com/app:v1" + } + } + ] + } + ]]) + + t.check(207, { + results = { + { + resource = "Application/no-cluster-app", + namespace = "apply-team", + cluster = "", + status = "error", + error = Contains("no cluster specified"), + }, + }, + }) +end) + +Test.rest("empty resources array returns 400", function(t) + t.addHeader("x-user-email", user:email()) + + t.send("POST", "/api/v1/apply?cluster=dev", [[ + { + "resources": [] + } + ]]) + + t.check(400, { + error = Contains("no resources provided"), + }) +end) + +Test.rest("cluster annotation overrides query parameter", function(t) + t.addHeader("x-user-email", user:email()) + + t.send("POST", "/api/v1/apply?cluster=dev", [[ + { + "resources": [ + { + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "metadata": { + "name": "staging-app", + "namespace": "apply-team", + "annotations": { + "nais.io/cluster": "staging" + } + }, + "spec": { + "image": "example.com/staging-app:v1" + } + } + ] + } + ]]) + + t.check(200, { + results = { + { + resource = "Application/staging-app", + namespace = "apply-team", + cluster = "staging", + status = "created", + }, + }, + }) +end) + +Test.k8s("verify resource was created in staging cluster via annotation", function(t) + t.check("nais.io/v1alpha1", "applications", "staging", "apply-team", "staging-app", { + apiVersion = "nais.io/v1alpha1", + kind = "Application", + metadata = { + name = "staging-app", + namespace = "apply-team", + annotations = { + ["nais.io/cluster"] = "staging", + }, + }, + spec = { + image = "example.com/staging-app:v1", + }, + }) +end) + +Test.rest("create naisjob via apply", function(t) + t.addHeader("x-user-email", user:email()) + + t.send("POST", "/api/v1/apply?cluster=dev", [[ + { + "resources": [ + { + "apiVersion": "nais.io/v1", + "kind": "Naisjob", + "metadata": { + "name": "my-job", + "namespace": "apply-team" + }, + "spec": { + "image": "example.com/my-job:v1", + "schedule": "0 * * * *" + } + } + ] + } + ]]) + + t.check(200, { + results = { + { + resource = "Naisjob/my-job", + namespace = "apply-team", + cluster = "dev", + status = "created", + }, + }, + }) +end) + +Test.rest("unauthenticated request returns 401", function(t) + t.send("POST", "/api/v1/apply?cluster=dev", [[ + { + "resources": [ + { + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "metadata": { + "name": "unauth-app", + "namespace": "apply-team" + }, + "spec": {} + } + ] + } + ]]) + + t.check(401, { + errors = { + { + message = "Unauthorized", + }, + }, + }) +end) diff --git a/integration_tests/zz_spec.lua b/integration_tests/zz_spec.lua index 08a33402d..b0c5aa66f 100644 --- a/integration_tests/zz_spec.lua +++ b/integration_tests/zz_spec.lua @@ -127,6 +127,13 @@ function TestFunctionTrest.send(method, path, body) print("send") end +--- Add a header to the request +---@param key string +---@param value string +function TestFunctionTrest.addHeader(key, value) + print("addHeader") +end + --- Check the response done by send ---@param status_code number ---@param resp table diff --git a/internal/apply/activitylog.go b/internal/apply/activitylog.go new file mode 100644 index 000000000..ed3dedb48 --- /dev/null +++ b/internal/apply/activitylog.go @@ -0,0 +1,70 @@ +package apply + +import ( + "fmt" + + "github.com/nais/api/internal/activitylog" +) + +const ( + // ActivityLogEntryResourceTypeApply is the resource type for apply activity log entries. + ActivityLogEntryResourceTypeApply activitylog.ActivityLogEntryResourceType = "APPLY" + + // ActivityLogEntryActionApplied is the action for a resource that was updated via apply. + ActivityLogEntryActionApplied activitylog.ActivityLogEntryAction = "APPLIED" + + // ActivityLogEntryActionCreated is the action for a resource that was created via apply. + ActivityLogEntryActionCreated activitylog.ActivityLogEntryAction = "APPLIED_NEW" +) + +func init() { + activitylog.RegisterTransformer(ActivityLogEntryResourceTypeApply, func(entry activitylog.GenericActivityLogEntry) (activitylog.ActivityLogEntry, error) { + switch entry.Action { + case ActivityLogEntryActionApplied: + data, err := activitylog.UnmarshalData[ApplyActivityLogEntryData](entry) + if err != nil { + return nil, fmt.Errorf("unmarshaling apply activity log entry data: %w", err) + } + return ApplyActivityLogEntry{ + GenericActivityLogEntry: entry.WithMessage(fmt.Sprintf("Applied %s/%s", data.Kind, entry.ResourceName)), + Data: data, + }, nil + case ActivityLogEntryActionCreated: + data, err := activitylog.UnmarshalData[ApplyActivityLogEntryData](entry) + if err != nil { + return nil, fmt.Errorf("unmarshaling apply created activity log entry data: %w", err) + } + return ApplyActivityLogEntry{ + GenericActivityLogEntry: entry.WithMessage(fmt.Sprintf("Created %s/%s", data.Kind, entry.ResourceName)), + Data: data, + }, nil + default: + return nil, fmt.Errorf("unsupported apply activity log entry action: %q", entry.Action) + } + }) + + activitylog.RegisterFilter("RESOURCE_APPLIED", ActivityLogEntryActionApplied, ActivityLogEntryResourceTypeApply) + activitylog.RegisterFilter("RESOURCE_CREATED", ActivityLogEntryActionCreated, ActivityLogEntryResourceTypeApply) +} + +// ApplyActivityLogEntryData contains the additional data stored with an apply activity log entry. +type ApplyActivityLogEntryData struct { + // Cluster is the cluster the resource was applied to. + Cluster string `json:"cluster"` + + // APIVersion is the apiVersion of the applied resource. + APIVersion string `json:"apiVersion"` + + // Kind is the kind of the applied resource. + Kind string `json:"kind"` + + // ChangedFields lists the fields that changed during the apply. + ChangedFields []FieldChange `json:"changedFields"` +} + +// ApplyActivityLogEntry is an activity log entry for an applied resource. +type ApplyActivityLogEntry struct { + activitylog.GenericActivityLogEntry + + Data *ApplyActivityLogEntryData `json:"data"` +} diff --git a/internal/apply/apply.go b/internal/apply/apply.go new file mode 100644 index 000000000..3dc483507 --- /dev/null +++ b/internal/apply/apply.go @@ -0,0 +1,314 @@ +package apply + +import ( + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "strings" + + "github.com/nais/api/internal/activitylog" + "github.com/nais/api/internal/auth/authz" + "github.com/nais/api/internal/kubernetes" + "github.com/nais/api/internal/slug" + "github.com/sirupsen/logrus" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/client-go/dynamic" +) + +const maxBodySize = 5 * 1024 * 1024 // 5 MB + +// DynamicClientFactory creates a dynamic Kubernetes client for a given cluster. +// In production this creates an impersonated client from cluster configs. +// In tests this can return fake dynamic clients. +type DynamicClientFactory func(ctx context.Context, cluster string) (dynamic.Interface, error) + +// NewImpersonatingClientFactory returns a DynamicClientFactory that creates +// impersonated dynamic clients from the provided cluster config map. +func NewImpersonatingClientFactory(clusterConfigs kubernetes.ClusterConfigMap) DynamicClientFactory { + return func(ctx context.Context, cluster string) (dynamic.Interface, error) { + return ImpersonatedClient(ctx, clusterConfigs, cluster) + } +} + +// Handler returns an http.HandlerFunc that handles apply requests. +// It validates the request body, checks authorization, applies resources +// to Kubernetes clusters via server-side apply, diffs the results, and +// writes activity log entries. +// +// The clusterConfigs map is used to validate that a cluster name exists. +// The clientFactory is used to create dynamic Kubernetes clients per cluster. +func Handler(clusterConfigs kubernetes.ClusterConfigMap, clientFactory DynamicClientFactory, log logrus.FieldLogger) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + + actor := authz.ActorFromContext(ctx) + if actor == nil { + writeError(w, http.StatusUnauthorized, "unauthorized") + return + } + + // Read and parse request body. + body, err := io.ReadAll(io.LimitReader(r.Body, maxBodySize+1)) + if err != nil { + writeError(w, http.StatusBadRequest, "unable to read request body") + return + } + if len(body) > maxBodySize { + writeError(w, http.StatusBadRequest, fmt.Sprintf("request body too large (max %d bytes)", maxBodySize)) + return + } + + var req request + if err := json.Unmarshal(body, &req); err != nil { + writeError(w, http.StatusBadRequest, "invalid JSON: "+err.Error()) + return + } + + if len(req.Resources) == 0 { + writeError(w, http.StatusBadRequest, "no resources provided") + return + } + + clusterParam := r.URL.Query().Get("cluster") + + // Phase 1: Validate all resources before applying any. + // Check that all resources are allowed kinds and have valid cluster targets. + var disallowed []string + for i, res := range req.Resources { + apiVersion := res.GetAPIVersion() + kind := res.GetKind() + if !IsAllowed(apiVersion, kind) { + disallowed = append(disallowed, fmt.Sprintf("resources[%d]: %s/%s is not an allowed resource type", i, apiVersion, kind)) + } + } + if len(disallowed) > 0 { + allowed := AllowedKinds() + allowedStrs := make([]string, len(allowed)) + for i, a := range allowed { + allowedStrs[i] = a.APIVersion + "/" + a.Kind + } + writeError(w, http.StatusBadRequest, fmt.Sprintf( + "disallowed resource types: %s. Allowed types: %s", + strings.Join(disallowed, "; "), + strings.Join(allowedStrs, ", "), + )) + return + } + + // Phase 2: Apply each resource, collecting results. + results := make([]ResourceResult, 0, len(req.Resources)) + hasErrors := false + + for _, res := range req.Resources { + result := applyOne(ctx, clusterConfigs, clientFactory, clusterParam, &res, actor, log) + if result.Status == StatusError { + hasErrors = true + } + results = append(results, result) + } + + resp := Response{Results: results} + + // Determine HTTP status code. + statusCode := http.StatusOK + if hasErrors { + statusCode = http.StatusMultiStatus + } + + writeJSON(w, statusCode, resp) + } +} + +// applyOne processes a single resource: resolves cluster, authorizes, applies, diffs, and logs. +func applyOne( + ctx context.Context, + clusterConfigs kubernetes.ClusterConfigMap, + clientFactory DynamicClientFactory, + clusterParam string, + res *unstructured.Unstructured, + actor *authz.Actor, + log logrus.FieldLogger, +) ResourceResult { + apiVersion := res.GetAPIVersion() + kind := res.GetKind() + name := res.GetName() + namespace := res.GetNamespace() + resourceID := kind + "/" + name + + // Resolve cluster: annotation takes precedence over query parameter. + cluster := clusterParam + if ann := res.GetAnnotations(); ann != nil { + if c, ok := ann["nais.io/cluster"]; ok && c != "" { + cluster = c + } + } + + if cluster == "" { + return ResourceResult{ + Resource: resourceID, + Namespace: namespace, + Status: StatusError, + Error: "no cluster specified (use ?cluster= query parameter or nais.io/cluster annotation)", + } + } + + // Validate cluster exists. + if _, ok := clusterConfigs[cluster]; !ok { + return ResourceResult{ + Resource: resourceID, + Namespace: namespace, + Cluster: cluster, + Status: StatusError, + Error: fmt.Sprintf("unknown cluster: %q", cluster), + } + } + + // Validate resource has name and namespace. + if name == "" { + return ResourceResult{ + Resource: resourceID, + Namespace: namespace, + Cluster: cluster, + Status: StatusError, + Error: "resource must have metadata.name", + } + } + if namespace == "" { + return ResourceResult{ + Resource: resourceID, + Cluster: cluster, + Status: StatusError, + Error: "resource must have metadata.namespace", + } + } + + // Authorize: derive team slug from namespace. + teamSlug := slug.Slug(namespace) + if err := authorizeResource(ctx, kind, teamSlug); err != nil { + return ResourceResult{ + Resource: resourceID, + Namespace: namespace, + Cluster: cluster, + Status: StatusError, + Error: fmt.Sprintf("authorization failed: %s", err), + } + } + + // Resolve GVR. + gvr, ok := GVRFor(apiVersion, kind) + if !ok { + return ResourceResult{ + Resource: resourceID, + Namespace: namespace, + Cluster: cluster, + Status: StatusError, + Error: fmt.Sprintf("no GVR mapping for %s/%s", apiVersion, kind), + } + } + + // Create dynamic client for cluster. + client, err := clientFactory(ctx, cluster) + if err != nil { + log.WithError(err).WithField("cluster", cluster).Error("creating dynamic client") + return ResourceResult{ + Resource: resourceID, + Namespace: namespace, + Cluster: cluster, + Status: StatusError, + Error: fmt.Sprintf("failed to create client for cluster %q: %s", cluster, err), + } + } + + // Apply the resource. + applyResult, err := ApplyResource(ctx, client, gvr, res) + if err != nil { + log.WithError(err).WithFields(logrus.Fields{ + "cluster": cluster, + "namespace": namespace, + "name": name, + "kind": kind, + }).Error("applying resource") + return ResourceResult{ + Resource: resourceID, + Namespace: namespace, + Cluster: cluster, + Status: StatusError, + Error: fmt.Sprintf("apply failed: %s", err), + } + } + + // Diff before and after. + var changes []FieldChange + status := StatusCreated + if !applyResult.Created { + status = StatusApplied + changes = Diff(applyResult.Before, applyResult.After) + } + + // Write activity log entry. + action := ActivityLogEntryActionCreated + if !applyResult.Created { + action = ActivityLogEntryActionApplied + } + + if err := activitylog.Create(ctx, activitylog.CreateInput{ + Action: action, + Actor: actor.User, + ResourceType: ActivityLogEntryResourceTypeApply, + ResourceName: name, + TeamSlug: &teamSlug, + EnvironmentName: &cluster, + Data: ApplyActivityLogEntryData{ + Cluster: cluster, + APIVersion: apiVersion, + Kind: kind, + ChangedFields: changes, + }, + }); err != nil { + log.WithError(err).WithFields(logrus.Fields{ + "cluster": cluster, + "namespace": namespace, + "name": name, + "kind": kind, + }).Error("creating activity log entry") + // Don't fail the apply because of a logging error. + } + + return ResourceResult{ + Resource: resourceID, + Namespace: namespace, + Cluster: cluster, + Status: status, + ChangedFields: changes, + } +} + +// authorizeResource checks if the current actor is authorized to apply the given kind +// to the team derived from the resource namespace. +func authorizeResource(ctx context.Context, kind string, teamSlug slug.Slug) error { + switch kind { + case "Application": + return authz.CanUpdateApplications(ctx, teamSlug) + case "Naisjob": + return authz.CanUpdateJobs(ctx, teamSlug) + default: + return fmt.Errorf("no authorization mapping for kind %q", kind) + } +} + +// request is the incoming JSON request body. +type request struct { + Resources []unstructured.Unstructured `json:"resources"` +} + +func writeJSON(w http.ResponseWriter, statusCode int, v any) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(statusCode) + _ = json.NewEncoder(w).Encode(v) +} + +func writeError(w http.ResponseWriter, statusCode int, message string) { + writeJSON(w, statusCode, map[string]string{"error": message}) +} diff --git a/internal/apply/client.go b/internal/apply/client.go new file mode 100644 index 000000000..dbd7c0145 --- /dev/null +++ b/internal/apply/client.go @@ -0,0 +1,132 @@ +package apply + +import ( + "context" + "encoding/json" + "fmt" + + "github.com/nais/api/internal/auth/authz" + "github.com/nais/api/internal/kubernetes" + apierrors "k8s.io/apimachinery/pkg/api/errors" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" + "k8s.io/apimachinery/pkg/types" + "k8s.io/client-go/dynamic" + "k8s.io/client-go/rest" +) + +const fieldManager = "nais-api" + +// ImpersonatedClient creates a dynamic Kubernetes client for the given cluster +// that impersonates the authenticated user from the context. This creates a fresh +// client per call — it does NOT reuse informers or watcher clients. +func ImpersonatedClient( + ctx context.Context, + clusterConfigs kubernetes.ClusterConfigMap, + cluster string, +) (dynamic.Interface, error) { + cfg, ok := clusterConfigs[cluster] + if !ok { + return nil, fmt.Errorf("unknown cluster: %q", cluster) + } + + if cfg == nil { + return nil, fmt.Errorf("no config available for cluster: %q", cluster) + } + + actor := authz.ActorFromContext(ctx) + if actor == nil { + return nil, fmt.Errorf("no authenticated user in context") + } + + groups, err := actor.User.GCPTeamGroups(ctx) + if err != nil { + return nil, fmt.Errorf("listing GCP groups for user: %w", err) + } + + impersonatedCfg := rest.CopyConfig(cfg) + impersonatedCfg.Impersonate = rest.ImpersonationConfig{ + UserName: actor.User.Identity(), + Groups: groups, + } + + client, err := dynamic.NewForConfig(impersonatedCfg) + if err != nil { + return nil, fmt.Errorf("creating dynamic client for cluster %q: %w", cluster, err) + } + + return client, nil +} + +// ApplyResult holds the before and after states of a server-side apply operation. +type ApplyResult struct { + // Before is the state of the object before the apply. Nil if the object did not exist. + Before *unstructured.Unstructured + // After is the state of the object after the apply. + After *unstructured.Unstructured + // Created is true if the object was created (did not exist before). + Created bool +} + +// ApplyResource performs a Kubernetes server-side apply for a single resource. +// It fetches the current state (before), applies the resource, and returns both +// before and after states so the caller can diff them. +func ApplyResource( + ctx context.Context, + client dynamic.Interface, + gvr schema.GroupVersionResource, + obj *unstructured.Unstructured, +) (*ApplyResult, error) { + namespace := obj.GetNamespace() + name := obj.GetName() + + if name == "" { + return nil, fmt.Errorf("resource must have a name") + } + if namespace == "" { + return nil, fmt.Errorf("resource must have a namespace") + } + + resourceClient := client.Resource(gvr).Namespace(namespace) + + // Step 1: Get the current state of the object (before-state). + before, err := resourceClient.Get(ctx, name, metav1.GetOptions{}) + if err != nil { + if !apierrors.IsNotFound(err) { + return nil, fmt.Errorf("getting current state of %s/%s: %w", namespace, name, err) + } + before = nil + } + + // Step 2: Marshal the object to JSON for the apply patch. + data, err := json.Marshal(obj.Object) + if err != nil { + return nil, fmt.Errorf("marshaling resource to JSON: %w", err) + } + + // Step 3: Server-side apply using PATCH with ApplyPatchType. + after, err := resourceClient.Patch( + ctx, + name, + types.ApplyPatchType, + data, + metav1.PatchOptions{ + FieldManager: fieldManager, + Force: boolPtr(true), + }, + ) + if err != nil { + return nil, fmt.Errorf("applying %s/%s: %w", namespace, name, err) + } + + return &ApplyResult{ + Before: before, + After: after, + Created: before == nil, + }, nil +} + +func boolPtr(b bool) *bool { + return &b +} diff --git a/internal/apply/diff.go b/internal/apply/diff.go new file mode 100644 index 000000000..60deb774d --- /dev/null +++ b/internal/apply/diff.go @@ -0,0 +1,241 @@ +package apply + +import ( + "fmt" + "reflect" + "slices" + "strings" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" +) + +// FieldChange represents a single field that changed between the before and after states. +type FieldChange struct { + // Field is the dot-separated path to the changed field, e.g. "spec.replicas". + Field string `json:"field"` + + // OldValue is the value before the apply. Nil if the field was added. + OldValue any `json:"oldValue,omitempty"` + + // NewValue is the value after the apply. Nil if the field was removed. + NewValue any `json:"newValue,omitempty"` +} + +// ignoredTopLevelFields are fields managed by the Kubernetes API server that +// should be excluded from diffs as they are not user-controlled. +var ignoredTopLevelFields = map[string]bool{ + "status": true, +} + +// ignoredMetadataFields are metadata fields managed by the API server. +var ignoredMetadataFields = map[string]bool{ + "resourceVersion": true, + "uid": true, + "generation": true, + "creationTimestamp": true, + "managedFields": true, + "selfLink": true, + "deletionTimestamp": true, + "deletionGracePeriodSeconds": true, +} + +// Diff compares two unstructured Kubernetes objects and returns a list of field changes. +// If before is nil, all fields in after are considered "added". +// If after is nil, all fields in before are considered "removed". +// Server-managed fields (status, metadata.resourceVersion, etc.) are excluded. +func Diff(before, after *unstructured.Unstructured) []FieldChange { + var beforeMap, afterMap map[string]any + + if before != nil { + beforeMap = before.Object + } + if after != nil { + afterMap = after.Object + } + + changes := diffMaps(beforeMap, afterMap, "") + + // Sort for deterministic output + slices.SortFunc(changes, func(a, b FieldChange) int { + return strings.Compare(a.Field, b.Field) + }) + + return changes +} + +// diffMaps recursively compares two maps and collects field changes. +func diffMaps(before, after map[string]any, prefix string) []FieldChange { + var changes []FieldChange + + // Collect all keys from both maps + allKeys := map[string]struct{}{} + for k := range before { + allKeys[k] = struct{}{} + } + for k := range after { + allKeys[k] = struct{}{} + } + + for key := range allKeys { + fieldPath := joinPath(prefix, key) + + if shouldIgnoreField(prefix, key) { + continue + } + + oldVal, oldExists := before[key] + newVal, newExists := after[key] + + switch { + case !oldExists && newExists: + // Field was added + changes = append(changes, flattenAdded(fieldPath, newVal)...) + case oldExists && !newExists: + // Field was removed + changes = append(changes, flattenRemoved(fieldPath, oldVal)...) + case oldExists && newExists: + // Field exists in both — compare values + changes = append(changes, diffValues(fieldPath, oldVal, newVal)...) + } + } + + return changes +} + +// diffValues compares two values at a given path and returns changes. +func diffValues(path string, oldVal, newVal any) []FieldChange { + // If both are maps, recurse + oldMap, oldIsMap := toMap(oldVal) + newMap, newIsMap := toMap(newVal) + if oldIsMap && newIsMap { + return diffMaps(oldMap, newMap, path) + } + + // If both are slices, compare them + oldSlice, oldIsSlice := toSlice(oldVal) + newSlice, newIsSlice := toSlice(newVal) + if oldIsSlice && newIsSlice { + return diffSlices(path, oldSlice, newSlice) + } + + // Scalar comparison + if !reflect.DeepEqual(oldVal, newVal) { + return []FieldChange{{ + Field: path, + OldValue: oldVal, + NewValue: newVal, + }} + } + + return nil +} + +// diffSlices compares two slices. If elements are maps, it compares element-by-element. +// Otherwise it compares the slices as a whole. +func diffSlices(path string, oldSlice, newSlice []any) []FieldChange { + var changes []FieldChange + + maxLen := max(len(oldSlice), len(newSlice)) + for i := range maxLen { + elemPath := fmt.Sprintf("%s[%d]", path, i) + + switch { + case i >= len(oldSlice): + changes = append(changes, flattenAdded(elemPath, newSlice[i])...) + case i >= len(newSlice): + changes = append(changes, flattenRemoved(elemPath, oldSlice[i])...) + default: + changes = append(changes, diffValues(elemPath, oldSlice[i], newSlice[i])...) + } + } + + return changes +} + +// flattenAdded returns FieldChanges for a newly added value (possibly nested). +func flattenAdded(path string, val any) []FieldChange { + if m, ok := toMap(val); ok { + var changes []FieldChange + for k, v := range m { + changes = append(changes, flattenAdded(joinPath(path, k), v)...) + } + if len(changes) == 0 { + // Empty map added + return []FieldChange{{Field: path, NewValue: val}} + } + return changes + } + + if s, ok := toSlice(val); ok { + var changes []FieldChange + for i, v := range s { + changes = append(changes, flattenAdded(fmt.Sprintf("%s[%d]", path, i), v)...) + } + if len(changes) == 0 { + return []FieldChange{{Field: path, NewValue: val}} + } + return changes + } + + return []FieldChange{{Field: path, NewValue: val}} +} + +// flattenRemoved returns FieldChanges for a removed value (possibly nested). +func flattenRemoved(path string, val any) []FieldChange { + if m, ok := toMap(val); ok { + var changes []FieldChange + for k, v := range m { + changes = append(changes, flattenRemoved(joinPath(path, k), v)...) + } + if len(changes) == 0 { + return []FieldChange{{Field: path, OldValue: val}} + } + return changes + } + + if s, ok := toSlice(val); ok { + var changes []FieldChange + for i, v := range s { + changes = append(changes, flattenRemoved(fmt.Sprintf("%s[%d]", path, i), v)...) + } + if len(changes) == 0 { + return []FieldChange{{Field: path, OldValue: val}} + } + return changes + } + + return []FieldChange{{Field: path, OldValue: val}} +} + +// shouldIgnoreField returns true if the field should be excluded from the diff. +func shouldIgnoreField(prefix, key string) bool { + if prefix == "" && ignoredTopLevelFields[key] { + return true + } + + if prefix == "metadata" && ignoredMetadataFields[key] { + return true + } + + return false +} + +// joinPath joins two path segments with a dot separator. +func joinPath(prefix, key string) string { + if prefix == "" { + return key + } + return prefix + "." + key +} + +// toMap attempts to cast a value to map[string]any. +func toMap(val any) (map[string]any, bool) { + m, ok := val.(map[string]any) + return m, ok +} + +// toSlice attempts to cast a value to []any. +func toSlice(val any) ([]any, bool) { + s, ok := val.([]any) + return s, ok +} diff --git a/internal/apply/diff_test.go b/internal/apply/diff_test.go new file mode 100644 index 000000000..5c373611a --- /dev/null +++ b/internal/apply/diff_test.go @@ -0,0 +1,831 @@ +package apply + +import ( + "testing" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" +) + +func TestDiff_BothNil(t *testing.T) { + changes := Diff(nil, nil) + if len(changes) != 0 { + t.Fatalf("expected no changes, got %d", len(changes)) + } +} + +func TestDiff_BeforeNilCreatesAdded(t *testing.T) { + after := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "metadata": map[string]any{ + "name": "my-app", + "namespace": "my-team", + }, + "spec": map[string]any{ + "image": "navikt/my-app:latest", + "replicas": int64(2), + }, + }, + } + + changes := Diff(nil, after) + if len(changes) == 0 { + t.Fatal("expected changes when before is nil") + } + + fieldMap := toFieldMap(changes) + assertFieldExists(t, fieldMap, "apiVersion") + assertFieldExists(t, fieldMap, "kind") + assertFieldExists(t, fieldMap, "metadata.name") + assertFieldExists(t, fieldMap, "metadata.namespace") + assertFieldExists(t, fieldMap, "spec.image") + assertFieldExists(t, fieldMap, "spec.replicas") + + for _, c := range changes { + if c.OldValue != nil { + t.Errorf("expected OldValue to be nil for field %q when before is nil, got %v", c.Field, c.OldValue) + } + } +} + +func TestDiff_AfterNilCreatesRemoved(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "spec": map[string]any{ + "image": "navikt/my-app:latest", + }, + }, + } + + changes := Diff(before, nil) + if len(changes) == 0 { + t.Fatal("expected changes when after is nil") + } + + for _, c := range changes { + if c.NewValue != nil { + t.Errorf("expected NewValue to be nil for field %q when after is nil, got %v", c.Field, c.NewValue) + } + } +} + +func TestDiff_IdenticalObjects(t *testing.T) { + obj := map[string]any{ + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "metadata": map[string]any{ + "name": "my-app", + "namespace": "my-team", + }, + "spec": map[string]any{ + "image": "navikt/my-app:latest", + "replicas": int64(1), + }, + } + + before := &unstructured.Unstructured{Object: deepCopyMap(obj)} + after := &unstructured.Unstructured{Object: deepCopyMap(obj)} + + changes := Diff(before, after) + if len(changes) != 0 { + t.Fatalf("expected no changes for identical objects, got %d: %+v", len(changes), changes) + } +} + +func TestDiff_ScalarFieldChanged(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "spec": map[string]any{ + "image": "navikt/my-app:v1", + "replicas": int64(1), + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "spec": map[string]any{ + "image": "navikt/my-app:v2", + "replicas": int64(3), + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + assertFieldChange(t, fieldMap, "spec.image", "navikt/my-app:v1", "navikt/my-app:v2") + assertFieldChange(t, fieldMap, "spec.replicas", int64(1), int64(3)) + + // apiVersion and kind are unchanged + if _, ok := fieldMap["apiVersion"]; ok { + t.Error("apiVersion should not appear in changes since it did not change") + } + if _, ok := fieldMap["kind"]; ok { + t.Error("kind should not appear in changes since it did not change") + } +} + +func TestDiff_FieldAdded(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "image": "navikt/my-app:v1", + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "image": "navikt/my-app:v1", + "replicas": int64(2), + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + c := fieldMap["spec.replicas"] + if c.OldValue != nil { + t.Errorf("expected OldValue to be nil, got %v", c.OldValue) + } + if c.NewValue != int64(2) { + t.Errorf("expected NewValue to be 2, got %v", c.NewValue) + } +} + +func TestDiff_FieldRemoved(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "image": "navikt/my-app:v1", + "replicas": int64(2), + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "image": "navikt/my-app:v1", + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + c := fieldMap["spec.replicas"] + if c.OldValue != int64(2) { + t.Errorf("expected OldValue to be 2, got %v", c.OldValue) + } + if c.NewValue != nil { + t.Errorf("expected NewValue to be nil, got %v", c.NewValue) + } +} + +func TestDiff_NestedMapChanged(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "resources": map[string]any{ + "limits": map[string]any{ + "cpu": "500m", + "memory": "128Mi", + }, + }, + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "resources": map[string]any{ + "limits": map[string]any{ + "cpu": "1000m", + "memory": "256Mi", + }, + }, + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 2 { + t.Fatalf("expected 2 changes, got %d: %+v", len(changes), changes) + } + + assertFieldChange(t, fieldMap, "spec.resources.limits.cpu", "500m", "1000m") + assertFieldChange(t, fieldMap, "spec.resources.limits.memory", "128Mi", "256Mi") +} + +func TestDiff_NestedMapAdded(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "image": "navikt/my-app:v1", + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "image": "navikt/my-app:v1", + "resources": map[string]any{ + "limits": map[string]any{ + "cpu": "500m", + }, + }, + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + assertFieldExists(t, fieldMap, "spec.resources.limits.cpu") +} + +func TestDiff_SliceChanged(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "ingresses": []any{ + "https://old.example.com", + }, + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "ingresses": []any{ + "https://new.example.com", + }, + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + assertFieldChange(t, fieldMap, "spec.ingresses[0]", "https://old.example.com", "https://new.example.com") +} + +func TestDiff_SliceElementAdded(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "ingresses": []any{ + "https://one.example.com", + }, + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "ingresses": []any{ + "https://one.example.com", + "https://two.example.com", + }, + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + c := fieldMap["spec.ingresses[1]"] + if c.OldValue != nil { + t.Errorf("expected OldValue to be nil, got %v", c.OldValue) + } + if c.NewValue != "https://two.example.com" { + t.Errorf("expected NewValue to be 'https://two.example.com', got %v", c.NewValue) + } +} + +func TestDiff_SliceElementRemoved(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "ingresses": []any{ + "https://one.example.com", + "https://two.example.com", + }, + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "ingresses": []any{ + "https://one.example.com", + }, + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + c := fieldMap["spec.ingresses[1]"] + if c.OldValue != "https://two.example.com" { + t.Errorf("expected OldValue to be 'https://two.example.com', got %v", c.OldValue) + } + if c.NewValue != nil { + t.Errorf("expected NewValue to be nil, got %v", c.NewValue) + } +} + +func TestDiff_SliceOfMapsChanged(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "env": []any{ + map[string]any{"name": "FOO", "value": "bar"}, + }, + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "env": []any{ + map[string]any{"name": "FOO", "value": "baz"}, + }, + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + assertFieldChange(t, fieldMap, "spec.env[0].value", "bar", "baz") +} + +func TestDiff_IgnoresStatusField(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "image": "navikt/my-app:v1", + }, + "status": map[string]any{ + "phase": "Running", + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "image": "navikt/my-app:v1", + }, + "status": map[string]any{ + "phase": "Failed", + }, + }, + } + + changes := Diff(before, after) + if len(changes) != 0 { + t.Fatalf("expected no changes (status should be ignored), got %d: %+v", len(changes), changes) + } +} + +func TestDiff_IgnoresServerManagedMetadataFields(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "my-app", + "namespace": "my-team", + "resourceVersion": "12345", + "uid": "abc-def", + "generation": int64(1), + "creationTimestamp": "2024-01-01T00:00:00Z", + "managedFields": []any{map[string]any{"manager": "kubectl"}}, + "selfLink": "/api/v1/namespaces/my-team/my-app", + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "my-app", + "namespace": "my-team", + "resourceVersion": "67890", + "uid": "xyz-123", + "generation": int64(2), + "creationTimestamp": "2024-01-02T00:00:00Z", + "managedFields": []any{map[string]any{"manager": "nais-api"}}, + "selfLink": "/api/v1/namespaces/my-team/my-app-2", + }, + }, + } + + changes := Diff(before, after) + if len(changes) != 0 { + t.Fatalf("expected no changes (server-managed metadata should be ignored), got %d: %+v", len(changes), changes) + } +} + +func TestDiff_PreservesUserMetadataFields(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "my-app", + "namespace": "my-team", + "labels": map[string]any{ + "app": "my-app", + }, + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "my-app", + "namespace": "my-team", + "labels": map[string]any{ + "app": "my-app", + "version": "v2", + }, + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + assertFieldExists(t, fieldMap, "metadata.labels.version") +} + +func TestDiff_AnnotationsChanged(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "my-app", + "annotations": map[string]any{ + "nais.io/cluster": "dev", + }, + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "my-app", + "annotations": map[string]any{ + "nais.io/cluster": "dev", + "nais.io/something": "new", + }, + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + assertFieldExists(t, fieldMap, "metadata.annotations.nais.io/something") +} + +func TestDiff_TypeChangedScalar(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "value": "a-string", + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "value": int64(42), + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + assertFieldChange(t, fieldMap, "spec.value", "a-string", int64(42)) +} + +func TestDiff_EmptyMapToPopulatedMap(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "labels": map[string]any{}, + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "labels": map[string]any{ + "app": "my-app", + }, + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + assertFieldExists(t, fieldMap, "spec.labels.app") +} + +func TestDiff_BooleanChange(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "skipCaBundle": false, + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "skipCaBundle": true, + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + assertFieldChange(t, fieldMap, "spec.skipCaBundle", false, true) +} + +func TestDiff_MultipleTopLevelChanges(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "metadata": map[string]any{ + "name": "my-app", + "namespace": "my-team", + }, + "spec": map[string]any{ + "image": "navikt/my-app:v1", + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "apiVersion": "nais.io/v1alpha1", + "kind": "Application", + "metadata": map[string]any{ + "name": "my-app", + "namespace": "other-team", + }, + "spec": map[string]any{ + "image": "navikt/my-app:v2", + }, + }, + } + + changes := Diff(before, after) + fieldMap := toFieldMap(changes) + + if len(changes) != 2 { + t.Fatalf("expected 2 changes, got %d: %+v", len(changes), changes) + } + + assertFieldChange(t, fieldMap, "metadata.namespace", "my-team", "other-team") + assertFieldChange(t, fieldMap, "spec.image", "navikt/my-app:v1", "navikt/my-app:v2") +} + +func TestDiff_ResultsAreSorted(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "z_field": "a", + "a_field": "a", + "m_field": "a", + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "z_field": "b", + "a_field": "b", + "m_field": "b", + }, + }, + } + + changes := Diff(before, after) + if len(changes) != 3 { + t.Fatalf("expected 3 changes, got %d", len(changes)) + } + + if changes[0].Field != "spec.a_field" { + t.Errorf("expected first change to be spec.a_field, got %q", changes[0].Field) + } + if changes[1].Field != "spec.m_field" { + t.Errorf("expected second change to be spec.m_field, got %q", changes[1].Field) + } + if changes[2].Field != "spec.z_field" { + t.Errorf("expected third change to be spec.z_field, got %q", changes[2].Field) + } +} + +func TestDiff_DeletionTimestampIgnored(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "my-app", + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "metadata": map[string]any{ + "name": "my-app", + "deletionTimestamp": "2024-01-01T00:00:00Z", + "deletionGracePeriodSeconds": int64(30), + }, + }, + } + + changes := Diff(before, after) + if len(changes) != 0 { + t.Fatalf("expected no changes (deletion fields should be ignored), got %d: %+v", len(changes), changes) + } +} + +func TestDiff_EmptySliceToPopulatedSlice(t *testing.T) { + before := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "ingresses": []any{}, + }, + }, + } + + after := &unstructured.Unstructured{ + Object: map[string]any{ + "spec": map[string]any{ + "ingresses": []any{ + "https://my-app.example.com", + }, + }, + }, + } + + changes := Diff(before, after) + if len(changes) != 1 { + t.Fatalf("expected 1 change, got %d: %+v", len(changes), changes) + } + + if changes[0].Field != "spec.ingresses[0]" { + t.Errorf("expected field spec.ingresses[0], got %q", changes[0].Field) + } +} + +// --- Test helpers --- + +func toFieldMap(changes []FieldChange) map[string]FieldChange { + m := make(map[string]FieldChange, len(changes)) + for _, c := range changes { + m[c.Field] = c + } + return m +} + +func assertFieldExists(t *testing.T, fieldMap map[string]FieldChange, field string) { + t.Helper() + if _, ok := fieldMap[field]; !ok { + t.Errorf("expected field %q to be present in changes, but it was not. Fields present: %v", field, fieldMapKeys(fieldMap)) + } +} + +func assertFieldChange(t *testing.T, fieldMap map[string]FieldChange, field string, expectedOld, expectedNew any) { + t.Helper() + c, ok := fieldMap[field] + if !ok { + t.Errorf("expected field %q to be present in changes, but it was not. Fields present: %v", field, fieldMapKeys(fieldMap)) + return + } + + if c.OldValue != expectedOld { + t.Errorf("field %q: expected OldValue %v (%T), got %v (%T)", field, expectedOld, expectedOld, c.OldValue, c.OldValue) + } + if c.NewValue != expectedNew { + t.Errorf("field %q: expected NewValue %v (%T), got %v (%T)", field, expectedNew, expectedNew, c.NewValue, c.NewValue) + } +} + +func fieldMapKeys(m map[string]FieldChange) []string { + keys := make([]string, 0, len(m)) + for k := range m { + keys = append(keys, k) + } + return keys +} + +func deepCopyMap(m map[string]any) map[string]any { + cp := make(map[string]any, len(m)) + for k, v := range m { + switch val := v.(type) { + case map[string]any: + cp[k] = deepCopyMap(val) + case []any: + cp[k] = deepCopySlice(val) + default: + cp[k] = v + } + } + return cp +} + +func deepCopySlice(s []any) []any { + cp := make([]any, len(s)) + for i, v := range s { + switch val := v.(type) { + case map[string]any: + cp[i] = deepCopyMap(val) + case []any: + cp[i] = deepCopySlice(val) + default: + cp[i] = v + } + } + return cp +} diff --git a/internal/apply/model.go b/internal/apply/model.go new file mode 100644 index 000000000..052a61d54 --- /dev/null +++ b/internal/apply/model.go @@ -0,0 +1,34 @@ +package apply + +// Response is the top-level response returned by the apply endpoint. +type Response struct { + Results []ResourceResult `json:"results"` +} + +// ResourceResult represents the outcome of applying a single resource. +type ResourceResult struct { + // Resource is a human-readable identifier for the resource, e.g. "Application/my-app". + Resource string `json:"resource"` + + // Namespace is the target namespace (== team slug) of the resource. + Namespace string `json:"namespace"` + + // Cluster is the target cluster the resource was applied to. + Cluster string `json:"cluster"` + + // Status is one of "created", "applied", or "error". + Status string `json:"status"` + + // ChangedFields lists the fields that were changed during the apply. + // Only populated when Status is "applied" (i.e. an update, not a create). + ChangedFields []FieldChange `json:"changedFields,omitempty"` + + // Error contains the error message if Status is "error". + Error string `json:"error,omitempty"` +} + +const ( + StatusCreated = "created" + StatusApplied = "applied" + StatusError = "error" +) diff --git a/internal/apply/whitelist.go b/internal/apply/whitelist.go new file mode 100644 index 000000000..a6bcfce68 --- /dev/null +++ b/internal/apply/whitelist.go @@ -0,0 +1,44 @@ +package apply + +import "k8s.io/apimachinery/pkg/runtime/schema" + +// AllowedResource identifies a Kubernetes resource by its apiVersion and kind. +type AllowedResource struct { + APIVersion string + Kind string +} + +// allowedResources is the single source of truth for which resources can be applied +// through the API. Each entry maps an apiVersion+kind pair to its GroupVersionResource, +// avoiding the need for a discovery client. +var allowedResources = map[AllowedResource]schema.GroupVersionResource{ + {APIVersion: "nais.io/v1alpha1", Kind: "Application"}: { + Group: "nais.io", Version: "v1alpha1", Resource: "applications", + }, + {APIVersion: "nais.io/v1", Kind: "Naisjob"}: { + Group: "nais.io", Version: "v1", Resource: "naisjobs", + }, +} + +// IsAllowed returns true if the given apiVersion and kind are in the whitelist. +func IsAllowed(apiVersion, kind string) bool { + _, ok := allowedResources[AllowedResource{APIVersion: apiVersion, Kind: kind}] + return ok +} + +// GVRFor returns the GroupVersionResource for the given apiVersion and kind. +// The second return value is false if the resource is not in the whitelist. +func GVRFor(apiVersion, kind string) (schema.GroupVersionResource, bool) { + gvr, ok := allowedResources[AllowedResource{APIVersion: apiVersion, Kind: kind}] + return gvr, ok +} + +// AllowedKinds returns a list of all allowed apiVersion+kind combinations. +// Useful for error messages. +func AllowedKinds() []AllowedResource { + kinds := make([]AllowedResource, 0, len(allowedResources)) + for k := range allowedResources { + kinds = append(kinds, k) + } + return kinds +} diff --git a/internal/cmd/api/api.go b/internal/cmd/api/api.go index ddde77ca7..960ffe43a 100644 --- a/internal/cmd/api/api.go +++ b/internal/cmd/api/api.go @@ -327,7 +327,18 @@ func run(ctx context.Context, cfg *Config, log logrus.FieldLogger) error { }) wg.Go(func() error { - return restserver.Run(ctx, cfg.RestListenAddress, pool, cfg.RestPreSharedKey, log.WithField("subsystem", "rest")) + return restserver.Run(ctx, restserver.Config{ + ListenAddress: cfg.RestListenAddress, + Pool: pool, + PreSharedKey: cfg.RestPreSharedKey, + ClusterConfigs: clusterConfig, + JWTMiddleware: jwtMiddleware, + AuthHandler: authHandler, + Fakes: restserver.Fakes{ + WithInsecureUserHeader: cfg.Fakes.WithInsecureUserHeader, + }, + Log: log.WithField("subsystem", "rest"), + }) }) wg.Go(func() error { diff --git a/internal/cmd/api/http.go b/internal/cmd/api/http.go index 63c54dde7..518ad48d9 100644 --- a/internal/cmd/api/http.go +++ b/internal/cmd/api/http.go @@ -105,7 +105,7 @@ func runHTTPServer( otelhttp.NewHandler(playground.Handler("GraphQL playground", "/graphql"), "playground"), ) - graphMiddleware, err := ConfigureGraph( + contextDependencies, err := ConfigureGraph( ctx, fakes, watchers, @@ -133,8 +133,6 @@ func runHTTPServer( return err } - contextDependencies := graphMiddleware - router.Route("/graphql", func(r chi.Router) { middlewares := []func(http.Handler) http.Handler{ contextDependencies, diff --git a/internal/graph/apply.resolvers.go b/internal/graph/apply.resolvers.go new file mode 100644 index 000000000..d7489bf93 --- /dev/null +++ b/internal/graph/apply.resolvers.go @@ -0,0 +1,46 @@ +package graph + +import ( + "context" + "fmt" + + "github.com/nais/api/internal/apply" + "github.com/nais/api/internal/graph/gengql" + "github.com/nais/api/internal/graph/model/donotuse" +) + +func (r *applyActivityLogEntryResolver) Action(ctx context.Context, obj *apply.ApplyActivityLogEntry) (string, error) { + return string(obj.GenericActivityLogEntry.Action), nil +} + +func (r *applyActivityLogEntryDataResolver) ChangedFields(ctx context.Context, obj *apply.ApplyActivityLogEntryData) ([]*donotuse.ApplyChangedField, error) { + out := make([]*donotuse.ApplyChangedField, len(obj.ChangedFields)) + for i, c := range obj.ChangedFields { + field := &donotuse.ApplyChangedField{ + Field: c.Field, + } + if c.OldValue != nil { + s := fmt.Sprintf("%v", c.OldValue) + field.OldValue = &s + } + if c.NewValue != nil { + s := fmt.Sprintf("%v", c.NewValue) + field.NewValue = &s + } + out[i] = field + } + return out, nil +} + +func (r *Resolver) ApplyActivityLogEntry() gengql.ApplyActivityLogEntryResolver { + return &applyActivityLogEntryResolver{r} +} + +func (r *Resolver) ApplyActivityLogEntryData() gengql.ApplyActivityLogEntryDataResolver { + return &applyActivityLogEntryDataResolver{r} +} + +type ( + applyActivityLogEntryResolver struct{ *Resolver } + applyActivityLogEntryDataResolver struct{ *Resolver } +) diff --git a/internal/graph/gengql/activitylog.generated.go b/internal/graph/gengql/activitylog.generated.go index 00c289a71..0b6c2c0f3 100644 --- a/internal/graph/gengql/activitylog.generated.go +++ b/internal/graph/gengql/activitylog.generated.go @@ -11,6 +11,7 @@ import ( "github.com/99designs/gqlgen/graphql" "github.com/nais/api/internal/activitylog" + "github.com/nais/api/internal/apply" "github.com/nais/api/internal/deployment/deploymentactivity" "github.com/nais/api/internal/github/repository" "github.com/nais/api/internal/graph/pagination" @@ -595,6 +596,13 @@ func (ec *executionContext) _ActivityLogEntry(ctx context.Context, sel ast.Selec return graphql.Null } return ec._ClusterAuditActivityLogEntry(ctx, sel, obj) + case apply.ApplyActivityLogEntry: + return ec._ApplyActivityLogEntry(ctx, sel, &obj) + case *apply.ApplyActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._ApplyActivityLogEntry(ctx, sel, obj) case application.ApplicationScaledActivityLogEntry: return ec._ApplicationScaledActivityLogEntry(ctx, sel, &obj) case *application.ApplicationScaledActivityLogEntry: diff --git a/internal/graph/gengql/apply.generated.go b/internal/graph/gengql/apply.generated.go new file mode 100644 index 000000000..854ff054c --- /dev/null +++ b/internal/graph/gengql/apply.generated.go @@ -0,0 +1,839 @@ +// Code generated by github.com/99designs/gqlgen, DO NOT EDIT. + +package gengql + +import ( + "context" + "errors" + "fmt" + "strconv" + "sync/atomic" + + "github.com/99designs/gqlgen/graphql" + "github.com/nais/api/internal/apply" + "github.com/nais/api/internal/graph/model/donotuse" + "github.com/vektah/gqlparser/v2/ast" +) + +// region ************************** generated!.gotpl ************************** + +type ApplyActivityLogEntryResolver interface { + Action(ctx context.Context, obj *apply.ApplyActivityLogEntry) (string, error) +} +type ApplyActivityLogEntryDataResolver interface { + ChangedFields(ctx context.Context, obj *apply.ApplyActivityLogEntryData) ([]*donotuse.ApplyChangedField, error) +} + +// endregion ************************** generated!.gotpl ************************** + +// region ***************************** args.gotpl ***************************** + +// endregion ***************************** args.gotpl ***************************** + +// region ************************** directives.gotpl ************************** + +// endregion ************************** directives.gotpl ************************** + +// region **************************** field.gotpl ***************************** + +func (ec *executionContext) _ApplyActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntry_id, + func(ctx context.Context) (any, error) { + return obj.ID(), nil + }, + nil, + ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntry", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplyActivityLogEntry_action(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntry_action, + func(ctx context.Context) (any, error) { + return ec.Resolvers.ApplyActivityLogEntry().Action(ctx, obj) + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntry_action(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntry", + Field: field, + IsMethod: true, + IsResolver: true, + 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) _ApplyActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntry_actor, + func(ctx context.Context) (any, error) { + return obj.Actor, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntry", + 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) _ApplyActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntry_createdAt, + func(ctx context.Context) (any, error) { + return obj.CreatedAt, nil + }, + nil, + ec.marshalNTime2timeᚐTime, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplyActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntry_message, + func(ctx context.Context) (any, error) { + return obj.Message, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntry", + 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) _ApplyActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntry_resourceType, + func(ctx context.Context) (any, error) { + return obj.ResourceType, nil + }, + nil, + ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplyActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntry_resourceName, + func(ctx context.Context) (any, error) { + return obj.ResourceName, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntry", + 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) _ApplyActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntry_teamSlug, + func(ctx context.Context) (any, error) { + return obj.TeamSlug, nil + }, + nil, + ec.marshalOSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Slug does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplyActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntry_environmentName, + func(ctx context.Context) (any, error) { + return obj.EnvironmentName, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntry", + 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) _ApplyActivityLogEntry_data(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntry_data, + func(ctx context.Context) (any, error) { + return obj.Data, nil + }, + nil, + ec.marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyActivityLogEntryData, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntry_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "cluster": + return ec.fieldContext_ApplyActivityLogEntryData_cluster(ctx, field) + case "apiVersion": + return ec.fieldContext_ApplyActivityLogEntryData_apiVersion(ctx, field) + case "kind": + return ec.fieldContext_ApplyActivityLogEntryData_kind(ctx, field) + case "changedFields": + return ec.fieldContext_ApplyActivityLogEntryData_changedFields(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ApplyActivityLogEntryData", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplyActivityLogEntryData_cluster(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntryData) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntryData_cluster, + func(ctx context.Context) (any, error) { + return obj.Cluster, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntryData_cluster(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntryData", + 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) _ApplyActivityLogEntryData_apiVersion(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntryData) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntryData_apiVersion, + func(ctx context.Context) (any, error) { + return obj.APIVersion, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntryData_apiVersion(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntryData", + 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) _ApplyActivityLogEntryData_kind(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntryData) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntryData_kind, + func(ctx context.Context) (any, error) { + return obj.Kind, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntryData_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntryData", + 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) _ApplyActivityLogEntryData_changedFields(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntryData) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyActivityLogEntryData_changedFields, + func(ctx context.Context) (any, error) { + return ec.Resolvers.ApplyActivityLogEntryData().ChangedFields(ctx, obj) + }, + nil, + ec.marshalNApplyChangedField2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋmodelᚋdonotuseᚐApplyChangedFieldᚄ, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyActivityLogEntryData_changedFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyActivityLogEntryData", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "field": + return ec.fieldContext_ApplyChangedField_field(ctx, field) + case "oldValue": + return ec.fieldContext_ApplyChangedField_oldValue(ctx, field) + case "newValue": + return ec.fieldContext_ApplyChangedField_newValue(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ApplyChangedField", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplyChangedField_field(ctx context.Context, field graphql.CollectedField, obj *donotuse.ApplyChangedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyChangedField_field, + func(ctx context.Context) (any, error) { + return obj.Field, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplyChangedField_field(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyChangedField", + 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) _ApplyChangedField_oldValue(ctx context.Context, field graphql.CollectedField, obj *donotuse.ApplyChangedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyChangedField_oldValue, + func(ctx context.Context) (any, error) { + return obj.OldValue, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_ApplyChangedField_oldValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyChangedField", + 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) _ApplyChangedField_newValue(ctx context.Context, field graphql.CollectedField, obj *donotuse.ApplyChangedField) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplyChangedField_newValue, + func(ctx context.Context) (any, error) { + return obj.NewValue, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_ApplyChangedField_newValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplyChangedField", + 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 +} + +// endregion **************************** field.gotpl ***************************** + +// region **************************** input.gotpl ***************************** + +// endregion **************************** input.gotpl ***************************** + +// region ************************** interface.gotpl *************************** + +// endregion ************************** interface.gotpl *************************** + +// region **************************** object.gotpl **************************** + +var applyActivityLogEntryImplementors = []string{"ApplyActivityLogEntry", "ActivityLogEntry", "Node"} + +func (ec *executionContext) _ApplyActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *apply.ApplyActivityLogEntry) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, applyActivityLogEntryImplementors) + + 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("ApplyActivityLogEntry") + case "id": + out.Values[i] = ec._ApplyActivityLogEntry_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "action": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._ApplyActivityLogEntry_action(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + case "actor": + out.Values[i] = ec._ApplyActivityLogEntry_actor(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "createdAt": + out.Values[i] = ec._ApplyActivityLogEntry_createdAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "message": + out.Values[i] = ec._ApplyActivityLogEntry_message(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "resourceType": + out.Values[i] = ec._ApplyActivityLogEntry_resourceType(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "resourceName": + out.Values[i] = ec._ApplyActivityLogEntry_resourceName(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "teamSlug": + out.Values[i] = ec._ApplyActivityLogEntry_teamSlug(ctx, field, obj) + case "environmentName": + out.Values[i] = ec._ApplyActivityLogEntry_environmentName(ctx, field, obj) + case "data": + out.Values[i] = ec._ApplyActivityLogEntry_data(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + 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 applyActivityLogEntryDataImplementors = []string{"ApplyActivityLogEntryData"} + +func (ec *executionContext) _ApplyActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, obj *apply.ApplyActivityLogEntryData) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, applyActivityLogEntryDataImplementors) + + 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("ApplyActivityLogEntryData") + case "cluster": + out.Values[i] = ec._ApplyActivityLogEntryData_cluster(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "apiVersion": + out.Values[i] = ec._ApplyActivityLogEntryData_apiVersion(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "kind": + out.Values[i] = ec._ApplyActivityLogEntryData_kind(ctx, field, obj) + if out.Values[i] == graphql.Null { + atomic.AddUint32(&out.Invalids, 1) + } + case "changedFields": + field := field + + innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._ApplyActivityLogEntryData_changedFields(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&fs.Invalids, 1) + } + return res + } + + if field.Deferrable != nil { + dfs, ok := deferred[field.Deferrable.Label] + di := 0 + if ok { + dfs.AddField(field) + di = len(dfs.Values) - 1 + } else { + dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) + deferred[field.Deferrable.Label] = dfs + } + dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { + return innerFunc(ctx, dfs) + }) + + // don't run the out.Concurrently() call below + out.Values[i] = graphql.Null + continue + } + + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + 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 applyChangedFieldImplementors = []string{"ApplyChangedField"} + +func (ec *executionContext) _ApplyChangedField(ctx context.Context, sel ast.SelectionSet, obj *donotuse.ApplyChangedField) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, applyChangedFieldImplementors) + + 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("ApplyChangedField") + case "field": + out.Values[i] = ec._ApplyChangedField_field(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "oldValue": + out.Values[i] = ec._ApplyChangedField_oldValue(ctx, field, obj) + case "newValue": + out.Values[i] = ec._ApplyChangedField_newValue(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 +} + +// endregion **************************** object.gotpl **************************** + +// region ***************************** type.gotpl ***************************** + +func (ec *executionContext) marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, v *apply.ApplyActivityLogEntryData) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._ApplyActivityLogEntryData(ctx, sel, v) +} + +func (ec *executionContext) marshalNApplyChangedField2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋmodelᚋdonotuseᚐApplyChangedFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []*donotuse.ApplyChangedField) graphql.Marshaler { + ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { + fc := graphql.GetFieldContext(ctx) + fc.Result = &v[i] + return ec.marshalNApplyChangedField2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋmodelᚋdonotuseᚐApplyChangedField(ctx, sel, v[i]) + }) + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + +func (ec *executionContext) marshalNApplyChangedField2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋmodelᚋdonotuseᚐApplyChangedField(ctx context.Context, sel ast.SelectionSet, v *donotuse.ApplyChangedField) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._ApplyChangedField(ctx, sel, v) +} + +// endregion ***************************** type.gotpl ***************************** diff --git a/internal/graph/gengql/root_.generated.go b/internal/graph/gengql/root_.generated.go index 1005e4cc4..e85030a13 100644 --- a/internal/graph/gengql/root_.generated.go +++ b/internal/graph/gengql/root_.generated.go @@ -58,6 +58,8 @@ type Config = graphql.Config[ResolverRoot, DirectiveRoot, ComplexityRoot] type ResolverRoot interface { Application() ApplicationResolver ApplicationInstance() ApplicationInstanceResolver + ApplyActivityLogEntry() ApplyActivityLogEntryResolver + ApplyActivityLogEntryData() ApplyActivityLogEntryDataResolver BigQueryDataset() BigQueryDatasetResolver Bucket() BucketResolver CVE() CVEResolver @@ -312,6 +314,32 @@ type ComplexityRoot struct { Strategies func(childComplexity int) int } + ApplyActivityLogEntry struct { + Action func(childComplexity int) int + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + Data func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int + } + + ApplyActivityLogEntryData struct { + APIVersion func(childComplexity int) int + ChangedFields func(childComplexity int) int + Cluster func(childComplexity int) int + Kind func(childComplexity int) int + } + + ApplyChangedField struct { + Field func(childComplexity int) int + NewValue func(childComplexity int) int + OldValue func(childComplexity int) int + } + AssignRoleToServiceAccountPayload struct { ServiceAccount func(childComplexity int) int } @@ -3942,6 +3970,125 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.ApplicationScaling.Strategies(childComplexity), true + case "ApplyActivityLogEntry.action": + if e.ComplexityRoot.ApplyActivityLogEntry.Action == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntry.Action(childComplexity), true + + case "ApplyActivityLogEntry.actor": + if e.ComplexityRoot.ApplyActivityLogEntry.Actor == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntry.Actor(childComplexity), true + + case "ApplyActivityLogEntry.createdAt": + if e.ComplexityRoot.ApplyActivityLogEntry.CreatedAt == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntry.CreatedAt(childComplexity), true + + case "ApplyActivityLogEntry.data": + if e.ComplexityRoot.ApplyActivityLogEntry.Data == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntry.Data(childComplexity), true + + case "ApplyActivityLogEntry.environmentName": + if e.ComplexityRoot.ApplyActivityLogEntry.EnvironmentName == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntry.EnvironmentName(childComplexity), true + + case "ApplyActivityLogEntry.id": + if e.ComplexityRoot.ApplyActivityLogEntry.ID == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntry.ID(childComplexity), true + + case "ApplyActivityLogEntry.message": + if e.ComplexityRoot.ApplyActivityLogEntry.Message == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntry.Message(childComplexity), true + + case "ApplyActivityLogEntry.resourceName": + if e.ComplexityRoot.ApplyActivityLogEntry.ResourceName == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntry.ResourceName(childComplexity), true + + case "ApplyActivityLogEntry.resourceType": + if e.ComplexityRoot.ApplyActivityLogEntry.ResourceType == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntry.ResourceType(childComplexity), true + + case "ApplyActivityLogEntry.teamSlug": + if e.ComplexityRoot.ApplyActivityLogEntry.TeamSlug == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntry.TeamSlug(childComplexity), true + + case "ApplyActivityLogEntryData.apiVersion": + if e.ComplexityRoot.ApplyActivityLogEntryData.APIVersion == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntryData.APIVersion(childComplexity), true + + case "ApplyActivityLogEntryData.changedFields": + if e.ComplexityRoot.ApplyActivityLogEntryData.ChangedFields == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntryData.ChangedFields(childComplexity), true + + case "ApplyActivityLogEntryData.cluster": + if e.ComplexityRoot.ApplyActivityLogEntryData.Cluster == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntryData.Cluster(childComplexity), true + + case "ApplyActivityLogEntryData.kind": + if e.ComplexityRoot.ApplyActivityLogEntryData.Kind == nil { + break + } + + return e.ComplexityRoot.ApplyActivityLogEntryData.Kind(childComplexity), true + + case "ApplyChangedField.field": + if e.ComplexityRoot.ApplyChangedField.Field == nil { + break + } + + return e.ComplexityRoot.ApplyChangedField.Field(childComplexity), true + + case "ApplyChangedField.newValue": + if e.ComplexityRoot.ApplyChangedField.NewValue == nil { + break + } + + return e.ComplexityRoot.ApplyChangedField.NewValue(childComplexity), true + + case "ApplyChangedField.oldValue": + if e.ComplexityRoot.ApplyChangedField.OldValue == nil { + break + } + + return e.ComplexityRoot.ApplyChangedField.OldValue(childComplexity), true + case "AssignRoleToServiceAccountPayload.serviceAccount": if e.ComplexityRoot.AssignRoleToServiceAccountPayload.ServiceAccount == nil { break @@ -17981,6 +18128,72 @@ extend enum ActivityLogActivityType { """ APPLICATION_SCALED } +`, BuiltIn: false}, + {Name: "../schema/apply.graphqls", Input: `extend enum ActivityLogEntryResourceType { + "All activity log entries related to applying resources will use this resource type." + APPLY +} + +extend enum ActivityLogActivityType { + "A resource was applied (updated)." + RESOURCE_APPLIED + + "A resource was created via apply." + RESOURCE_CREATED +} + +""" +Activity log entry for a resource that was applied. +""" +type ApplyActivityLogEntry implements ActivityLogEntry & Node { + "Unique identifier of the activity log entry." + id: ID! + "The action that was performed." + action: String! + "The identity of the actor that performed the action." + actor: String! + "The time the action was performed." + createdAt: Time! + "A human-readable message describing the action." + message: String! + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + "The name of the affected resource." + resourceName: String! + "The team that owns the affected resource." + teamSlug: Slug + "The environment the resource was applied in." + environmentName: String + + "Additional data about the apply operation." + data: ApplyActivityLogEntryData! +} + +""" +Additional data associated with an apply activity log entry. +""" +type ApplyActivityLogEntryData { + "The cluster the resource was applied to." + cluster: String! + "The apiVersion of the applied resource." + apiVersion: String! + "The kind of the applied resource." + kind: String! + "The fields that changed during the apply." + changedFields: [ApplyChangedField!]! +} + +""" +A single field that changed during an apply operation. +""" +type ApplyChangedField { + "The dot-separated path to the changed field, e.g. 'spec.replicas'." + field: String! + "The value before the apply. Null if the field was added." + oldValue: String + "The value after the apply. Null if the field was removed." + newValue: String +} `, BuiltIn: false}, {Name: "../schema/authz.graphqls", Input: `type Role implements Node { """ diff --git a/internal/graph/gengql/schema.generated.go b/internal/graph/gengql/schema.generated.go index 8e63390fe..021b638a2 100644 --- a/internal/graph/gengql/schema.generated.go +++ b/internal/graph/gengql/schema.generated.go @@ -12,6 +12,7 @@ import ( "github.com/99designs/gqlgen/graphql" activitylog1 "github.com/nais/api/internal/activitylog" "github.com/nais/api/internal/alerts" + "github.com/nais/api/internal/apply" "github.com/nais/api/internal/auth/authz" "github.com/nais/api/internal/cost" "github.com/nais/api/internal/deployment" @@ -6092,6 +6093,13 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._BigQueryDataset(ctx, sel, obj) + case apply.ApplyActivityLogEntry: + return ec._ApplyActivityLogEntry(ctx, sel, &obj) + case *apply.ApplyActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._ApplyActivityLogEntry(ctx, sel, obj) case application.ApplicationScaledActivityLogEntry: return ec._ApplicationScaledActivityLogEntry(ctx, sel, &obj) case *application.ApplicationScaledActivityLogEntry: diff --git a/internal/graph/schema/apply.graphqls b/internal/graph/schema/apply.graphqls new file mode 100644 index 000000000..2e2336377 --- /dev/null +++ b/internal/graph/schema/apply.graphqls @@ -0,0 +1,65 @@ +extend enum ActivityLogEntryResourceType { + "All activity log entries related to applying resources will use this resource type." + APPLY +} + +extend enum ActivityLogActivityType { + "A resource was applied (updated)." + RESOURCE_APPLIED + + "A resource was created via apply." + RESOURCE_CREATED +} + +""" +Activity log entry for a resource that was applied. +""" +type ApplyActivityLogEntry implements ActivityLogEntry & Node { + "Unique identifier of the activity log entry." + id: ID! + "The action that was performed." + action: String! + "The identity of the actor that performed the action." + actor: String! + "The time the action was performed." + createdAt: Time! + "A human-readable message describing the action." + message: String! + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + "The name of the affected resource." + resourceName: String! + "The team that owns the affected resource." + teamSlug: Slug + "The environment the resource was applied in." + environmentName: String + + "Additional data about the apply operation." + data: ApplyActivityLogEntryData! +} + +""" +Additional data associated with an apply activity log entry. +""" +type ApplyActivityLogEntryData { + "The cluster the resource was applied to." + cluster: String! + "The apiVersion of the applied resource." + apiVersion: String! + "The kind of the applied resource." + kind: String! + "The fields that changed during the apply." + changedFields: [ApplyChangedField!]! +} + +""" +A single field that changed during an apply operation. +""" +type ApplyChangedField { + "The dot-separated path to the changed field, e.g. 'spec.replicas'." + field: String! + "The value before the apply. Null if the field was added." + oldValue: String + "The value after the apply. Null if the field was removed." + newValue: String +} diff --git a/internal/integration/manager.go b/internal/integration/manager.go index 5d1a06572..35761c06c 100644 --- a/internal/integration/manager.go +++ b/internal/integration/manager.go @@ -43,6 +43,7 @@ import ( "github.com/testcontainers/testcontainers-go/modules/postgres" "google.golang.org/protobuf/encoding/protojson" "google.golang.org/protobuf/reflect/protoreflect" + "k8s.io/client-go/dynamic" ) type ctxKey int @@ -155,7 +156,7 @@ func newManager(_ context.Context, container *postgres.PostgresContainer, connSt return ctx, nil, nil, err } - restRunner, err := newRestRunner(ctx, pool, log) + restRunner, err := newRestRunner(ctx, pool, clusterConfig, k8sRunner, log) if err != nil { done() return ctx, nil, nil, err @@ -205,8 +206,16 @@ func newManager(_ context.Context, container *postgres.PostgresContainer, connSt } } -func newRestRunner(ctx context.Context, pool *pgxpool.Pool, logger logrus.FieldLogger) (spec.Runner, error) { - router := rest.MakeRouter(ctx, pool, logger) +func newRestRunner(ctx context.Context, pool *pgxpool.Pool, clusterConfig kubernetes.ClusterConfigMap, k8sRunner *apiRunner.K8s, logger logrus.FieldLogger) (spec.Runner, error) { + router := rest.MakeRouter(ctx, rest.Config{ + Pool: pool, + ClusterConfigs: clusterConfig, + DynamicClientFactory: func(_ context.Context, cluster string) (dynamic.Interface, error) { + return k8sRunner.DynamicClient(cluster) + }, + Fakes: rest.Fakes{WithInsecureUserHeader: true}, + Log: logger, + }) return runner.NewRestRunner(router), nil } diff --git a/internal/integration/runner/k8s.go b/internal/integration/runner/k8s.go index 153c28e59..3f66b445e 100644 --- a/internal/integration/runner/k8s.go +++ b/internal/integration/runner/k8s.go @@ -89,6 +89,20 @@ func (k *K8s) ClientCreator(cluster string) (dynamic.Interface, watcher.KindReso return c, nil, nil, nil } +// DynamicClient returns the fake dynamic client for the given cluster. +// This is used by the apply handler's DynamicClientFactory in integration tests. +func (k *K8s) DynamicClient(cluster string) (dynamic.Interface, error) { + k.lock.Lock() + defer k.lock.Unlock() + + c, ok := k.clients[cluster] + if !ok { + return nil, fmt.Errorf("cluster %q not found", cluster) + } + + return c, nil +} + func (k *K8s) check(L *lua.LState) int { apiVersion := L.CheckString(1) kind := L.CheckString(2) diff --git a/internal/kubernetes/fake/fake.go b/internal/kubernetes/fake/fake.go index 98d250028..ab0c7b6bb 100644 --- a/internal/kubernetes/fake/fake.go +++ b/internal/kubernetes/fake/fake.go @@ -287,6 +287,72 @@ func NewDynamicClient(scheme *runtime.Scheme) *dynfake.FakeDynamicClient { return true, modified, nil }) + // Add reactor for server-side apply (ApplyPatchType) support. + // This simulates SSA by treating the patch body as the full desired state, + // creating the object if it doesn't exist or replacing it if it does. + client.PrependReactor("patch", "*", func(action k8stesting.Action) (handled bool, ret runtime.Object, err error) { + patchAction, ok := action.(k8stesting.PatchAction) + if !ok { + return false, nil, nil + } + + if patchAction.GetPatchType() != types.ApplyPatchType { + return false, nil, nil + } + + gvr := patchAction.GetResource() + ns := patchAction.GetNamespace() + name := patchAction.GetName() + + // Parse the patch body as the desired object state. + desired := &unstructured.Unstructured{} + if err := json.Unmarshal(patchAction.GetPatch(), &desired.Object); err != nil { + return true, nil, fmt.Errorf("unmarshaling apply patch: %w", err) + } + + // Try to get the existing object. + existing, err := client.Tracker().Get(gvr, ns, name) + if err != nil { + // Object doesn't exist — create it. + if err := client.Tracker().Create(gvr, desired, ns); err != nil { + return true, nil, fmt.Errorf("creating object via apply: %w", err) + } + return true, desired, nil + } + + // Object exists — merge: start from existing, overlay with desired fields. + existingUnstr, ok := existing.(*unstructured.Unstructured) + if !ok { + return true, nil, fmt.Errorf("expected *unstructured.Unstructured, got %T", existing) + } + + merged := existingUnstr.DeepCopy() + // Overlay all top-level keys from desired onto merged. + for k, v := range desired.Object { + if k == "metadata" { + // Merge metadata rather than replacing it wholesale. + desiredMeta, ok1 := v.(map[string]interface{}) + existingMeta, ok2 := merged.Object["metadata"].(map[string]interface{}) + if ok1 && ok2 { + for mk, mv := range desiredMeta { + existingMeta[mk] = mv + } + merged.Object["metadata"] = existingMeta + } else { + merged.Object[k] = v + } + } else { + merged.Object[k] = v + } + } + + if err := client.Tracker().Update(gvr, merged, ns); err != nil { + return true, nil, fmt.Errorf("updating object via apply: %w", err) + } + + return true, merged, nil + }) + return client } diff --git a/internal/rest/rest.go b/internal/rest/rest.go index 23d852947..61edc3af6 100644 --- a/internal/rest/rest.go +++ b/internal/rest/rest.go @@ -8,17 +8,44 @@ import ( "github.com/go-chi/chi/v5" "github.com/jackc/pgx/v5/pgxpool" + "github.com/nais/api/internal/activitylog" + "github.com/nais/api/internal/apply" + "github.com/nais/api/internal/auth/authn" + "github.com/nais/api/internal/auth/authz" "github.com/nais/api/internal/auth/middleware" + "github.com/nais/api/internal/database" + "github.com/nais/api/internal/graph/loader" + "github.com/nais/api/internal/kubernetes" "github.com/nais/api/internal/rest/restteamsapi" + "github.com/nais/api/internal/serviceaccount" + "github.com/nais/api/internal/user" "github.com/sirupsen/logrus" "golang.org/x/sync/errgroup" ) -func Run(ctx context.Context, listenAddress string, pool *pgxpool.Pool, preSharedKey string, log logrus.FieldLogger) error { - router := MakeRouter(ctx, pool, log, middleware.PreSharedKeyAuthentication(preSharedKey)) +// Fakes contains feature flags for local development and testing. +type Fakes struct { + WithInsecureUserHeader bool +} + +// Config holds all dependencies needed by the REST server. +type Config struct { + ListenAddress string + Pool *pgxpool.Pool + PreSharedKey string + ClusterConfigs kubernetes.ClusterConfigMap + DynamicClientFactory apply.DynamicClientFactory + JWTMiddleware func(http.Handler) http.Handler + AuthHandler authn.Handler + Fakes Fakes + Log logrus.FieldLogger +} + +func Run(ctx context.Context, cfg Config) error { + router := MakeRouter(ctx, cfg) srv := &http.Server{ - Addr: listenAddress, + Addr: cfg.ListenAddress, Handler: router, ReadHeaderTimeout: 5 * time.Second, } @@ -28,32 +55,93 @@ func Run(ctx context.Context, listenAddress string, pool *pgxpool.Pool, preShare <-ctx.Done() ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() - log.Infof("REST HTTP server shutting down...") + cfg.Log.Infof("REST HTTP server shutting down...") if err := srv.Shutdown(ctx); err != nil && !errors.Is(err, context.Canceled) { - log.WithError(err).Infof("HTTP server shutdown failed") + cfg.Log.WithError(err).Infof("HTTP server shutdown failed") return err } return nil }) wg.Go(func() error { - log.Infof("REST HTTP server accepting requests on %q", listenAddress) + cfg.Log.Infof("REST HTTP server accepting requests on %q", cfg.ListenAddress) if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { - log.WithError(err).Infof("unexpected error from HTTP server") + cfg.Log.WithError(err).Infof("unexpected error from HTTP server") return err } - log.Infof("REST HTTP server finished, terminating...") + cfg.Log.Infof("REST HTTP server finished, terminating...") return nil }) return wg.Wait() } -func MakeRouter(ctx context.Context, pool *pgxpool.Pool, log logrus.FieldLogger, middlewares ...func(http.Handler) http.Handler) *chi.Mux { +func MakeRouter(ctx context.Context, cfg Config) *chi.Mux { router := chi.NewRouter() - router.Use(middlewares...) + // Existing pre-shared-key authenticated routes. + if cfg.PreSharedKey != "" { + router.Group(func(r chi.Router) { + r.Use(middleware.PreSharedKeyAuthentication(cfg.PreSharedKey)) + r.Get("/teams/{teamSlug}", restteamsapi.TeamsApiHandler(ctx, cfg.Pool, cfg.Log)) + }) + } else { + // In test mode there is no pre-shared key; mount without auth. + router.Group(func(r chi.Router) { + r.Get("/teams/{teamSlug}", restteamsapi.TeamsApiHandler(ctx, cfg.Pool, cfg.Log)) + }) + } + + // Apply route with user authentication. + if cfg.ClusterConfigs != nil { + router.Group(func(r chi.Router) { + // Context dependencies needed by authz and activitylog. + r.Use(applyContextDependencies(cfg.Pool)) + + if cfg.Fakes.WithInsecureUserHeader { + r.Use(middleware.InsecureUserHeader()) + } + + if cfg.JWTMiddleware != nil { + r.Use(cfg.JWTMiddleware) + } - router.Get("/teams/{teamSlug}", restteamsapi.TeamsApiHandler(ctx, pool, log)) + r.Use( + middleware.ApiKeyAuthentication(), + ) + + if cfg.AuthHandler != nil { + r.Use(middleware.Oauth2Authentication(cfg.AuthHandler)) + } + + r.Use( + middleware.GitHubOIDC(ctx, cfg.Log), + middleware.RequireAuthenticatedUser(), + ) + + clientFactory := cfg.DynamicClientFactory + if clientFactory == nil { + clientFactory = apply.NewImpersonatingClientFactory(cfg.ClusterConfigs) + } + + r.Post("/api/v1/apply", apply.Handler(cfg.ClusterConfigs, clientFactory, cfg.Log)) + }) + } return router } + +// applyContextDependencies returns a middleware that sets up the context with +// DB-backed loaders needed by the apply handler: database, authz, and activitylog. +// This is a minimal subset of what ConfigureGraph sets up — only what the apply +// handler actually needs. +func applyContextDependencies(pool *pgxpool.Pool) func(http.Handler) http.Handler { + setupContext := func(ctx context.Context) context.Context { + ctx = database.NewLoaderContext(ctx, pool) + ctx = user.NewLoaderContext(ctx, pool) + ctx = serviceaccount.NewLoaderContext(ctx, pool) + ctx = authz.NewLoaderContext(ctx, pool) + ctx = activitylog.NewLoaderContext(ctx, pool) + return ctx + } + return loader.Middleware(setupContext) +} From 74c312b26999c80f5dad8ae92c88550fcd5077c7 Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Wed, 11 Mar 2026 13:18:18 +0100 Subject: [PATCH 02/25] cluster -> environment --- integration_tests/apply.lua | 48 ++++---- internal/apply/activitylog.go | 3 - internal/apply/apply.go | 139 +++++++++++------------ internal/apply/client.go | 12 +- internal/apply/model.go | 15 ++- internal/graph/apply.resolvers.go | 7 +- internal/graph/gengql/apply.generated.go | 55 ++------- internal/graph/gengql/root_.generated.go | 10 -- internal/graph/schema/apply.graphqls | 2 - 9 files changed, 124 insertions(+), 167 deletions(-) diff --git a/integration_tests/apply.lua b/integration_tests/apply.lua index d173e878b..e1ebfaccd 100644 --- a/integration_tests/apply.lua +++ b/integration_tests/apply.lua @@ -7,7 +7,7 @@ team:addMember(user) Test.rest("create application via apply", function(t) t.addHeader("x-user-email", user:email()) - t.send("POST", "/api/v1/apply?cluster=dev", [[ + t.send("POST", "/api/v1/apply?environment=dev", [[ { "resources": [ { @@ -34,14 +34,14 @@ Test.rest("create application via apply", function(t) { resource = "Application/my-app", namespace = "apply-team", - cluster = "dev", + environment = "dev", status = "created", }, }, }) end) -Test.k8s("verify resource was created in fake cluster", function(t) +Test.k8s("verify resource was created in fake environment", function(t) t.check("nais.io/v1alpha1", "applications", "dev", "apply-team", "my-app", { apiVersion = "nais.io/v1alpha1", kind = "Application", @@ -62,7 +62,7 @@ end) Test.rest("update application via apply", function(t) t.addHeader("x-user-email", user:email()) - t.send("POST", "/api/v1/apply?cluster=dev", [[ + t.send("POST", "/api/v1/apply?environment=dev", [[ { "resources": [ { @@ -89,7 +89,7 @@ Test.rest("update application via apply", function(t) { resource = "Application/my-app", namespace = "apply-team", - cluster = "dev", + environment = "dev", status = "applied", changedFields = NotNull(), }, @@ -97,7 +97,7 @@ Test.rest("update application via apply", function(t) }) end) -Test.k8s("verify resource was updated in fake cluster", function(t) +Test.k8s("verify resource was updated in fake environment", function(t) t.check("nais.io/v1alpha1", "applications", "dev", "apply-team", "my-app", { apiVersion = "nais.io/v1alpha1", kind = "Application", @@ -118,7 +118,7 @@ end) Test.rest("disallowed resource kind returns 400", function(t) t.addHeader("x-user-email", user:email()) - t.send("POST", "/api/v1/apply?cluster=dev", [[ + t.send("POST", "/api/v1/apply?environment=dev", [[ { "resources": [ { @@ -142,7 +142,7 @@ end) Test.rest("non-member gets authorization error", function(t) t.addHeader("x-user-email", nonMember:email()) - t.send("POST", "/api/v1/apply?cluster=dev", [[ + t.send("POST", "/api/v1/apply?environment=dev", [[ { "resources": [ { @@ -165,7 +165,7 @@ Test.rest("non-member gets authorization error", function(t) { resource = "Application/sneaky-app", namespace = "apply-team", - cluster = "dev", + environment = "dev", status = "error", error = Contains("authorization failed"), }, @@ -173,7 +173,7 @@ Test.rest("non-member gets authorization error", function(t) }) end) -Test.rest("missing cluster parameter returns per-resource error", function(t) +Test.rest("missing environment parameter returns per-resource error", function(t) t.addHeader("x-user-email", user:email()) t.send("POST", "/api/v1/apply", [[ @@ -183,7 +183,7 @@ Test.rest("missing cluster parameter returns per-resource error", function(t) "apiVersion": "nais.io/v1alpha1", "kind": "Application", "metadata": { - "name": "no-cluster-app", + "name": "no-environment-app", "namespace": "apply-team" }, "spec": { @@ -197,11 +197,11 @@ Test.rest("missing cluster parameter returns per-resource error", function(t) t.check(207, { results = { { - resource = "Application/no-cluster-app", + resource = "Application/no-environment-app", namespace = "apply-team", - cluster = "", + environment = "", status = "error", - error = Contains("no cluster specified"), + error = Contains("no environment specified"), }, }, }) @@ -210,7 +210,7 @@ end) Test.rest("empty resources array returns 400", function(t) t.addHeader("x-user-email", user:email()) - t.send("POST", "/api/v1/apply?cluster=dev", [[ + t.send("POST", "/api/v1/apply?environment=dev", [[ { "resources": [] } @@ -221,10 +221,10 @@ Test.rest("empty resources array returns 400", function(t) }) end) -Test.rest("cluster annotation overrides query parameter", function(t) +Test.rest("environment annotation overrides query parameter", function(t) t.addHeader("x-user-email", user:email()) - t.send("POST", "/api/v1/apply?cluster=dev", [[ + t.send("POST", "/api/v1/apply?environment=dev", [[ { "resources": [ { @@ -234,7 +234,7 @@ Test.rest("cluster annotation overrides query parameter", function(t) "name": "staging-app", "namespace": "apply-team", "annotations": { - "nais.io/cluster": "staging" + "nais.io/environment": "staging" } }, "spec": { @@ -250,14 +250,14 @@ Test.rest("cluster annotation overrides query parameter", function(t) { resource = "Application/staging-app", namespace = "apply-team", - cluster = "staging", + environment = "staging", status = "created", }, }, }) end) -Test.k8s("verify resource was created in staging cluster via annotation", function(t) +Test.k8s("verify resource was created in staging environment via annotation", function(t) t.check("nais.io/v1alpha1", "applications", "staging", "apply-team", "staging-app", { apiVersion = "nais.io/v1alpha1", kind = "Application", @@ -265,7 +265,7 @@ Test.k8s("verify resource was created in staging cluster via annotation", functi name = "staging-app", namespace = "apply-team", annotations = { - ["nais.io/cluster"] = "staging", + ["nais.io/environment"] = "staging", }, }, spec = { @@ -277,7 +277,7 @@ end) Test.rest("create naisjob via apply", function(t) t.addHeader("x-user-email", user:email()) - t.send("POST", "/api/v1/apply?cluster=dev", [[ + t.send("POST", "/api/v1/apply?environment=dev", [[ { "resources": [ { @@ -301,7 +301,7 @@ Test.rest("create naisjob via apply", function(t) { resource = "Naisjob/my-job", namespace = "apply-team", - cluster = "dev", + environment = "dev", status = "created", }, }, @@ -309,7 +309,7 @@ Test.rest("create naisjob via apply", function(t) end) Test.rest("unauthenticated request returns 401", function(t) - t.send("POST", "/api/v1/apply?cluster=dev", [[ + t.send("POST", "/api/v1/apply?environment=dev", [[ { "resources": [ { diff --git a/internal/apply/activitylog.go b/internal/apply/activitylog.go index ed3dedb48..b3f257097 100644 --- a/internal/apply/activitylog.go +++ b/internal/apply/activitylog.go @@ -49,9 +49,6 @@ func init() { // ApplyActivityLogEntryData contains the additional data stored with an apply activity log entry. type ApplyActivityLogEntryData struct { - // Cluster is the cluster the resource was applied to. - Cluster string `json:"cluster"` - // APIVersion is the apiVersion of the applied resource. APIVersion string `json:"apiVersion"` diff --git a/internal/apply/apply.go b/internal/apply/apply.go index 3dc483507..896aec928 100644 --- a/internal/apply/apply.go +++ b/internal/apply/apply.go @@ -19,26 +19,26 @@ import ( const maxBodySize = 5 * 1024 * 1024 // 5 MB -// DynamicClientFactory creates a dynamic Kubernetes client for a given cluster. -// In production this creates an impersonated client from cluster configs. +// DynamicClientFactory creates a dynamic Kubernetes client for a given environment. +// In production this creates an impersonated client from environment configs. // In tests this can return fake dynamic clients. -type DynamicClientFactory func(ctx context.Context, cluster string) (dynamic.Interface, error) +type DynamicClientFactory func(ctx context.Context, environment string) (dynamic.Interface, error) // NewImpersonatingClientFactory returns a DynamicClientFactory that creates -// impersonated dynamic clients from the provided cluster config map. +// impersonated dynamic clients from the provided environment config map. func NewImpersonatingClientFactory(clusterConfigs kubernetes.ClusterConfigMap) DynamicClientFactory { - return func(ctx context.Context, cluster string) (dynamic.Interface, error) { - return ImpersonatedClient(ctx, clusterConfigs, cluster) + return func(ctx context.Context, environment string) (dynamic.Interface, error) { + return ImpersonatedClient(ctx, clusterConfigs, environment) } } // Handler returns an http.HandlerFunc that handles apply requests. // It validates the request body, checks authorization, applies resources -// to Kubernetes clusters via server-side apply, diffs the results, and +// to Kubernetes environments via server-side apply, diffs the results, and // writes activity log entries. // -// The clusterConfigs map is used to validate that a cluster name exists. -// The clientFactory is used to create dynamic Kubernetes clients per cluster. +// The clusterConfigs map is used to validate that an environment name exists. +// The clientFactory is used to create dynamic Kubernetes clients per environment. func Handler(clusterConfigs kubernetes.ClusterConfigMap, clientFactory DynamicClientFactory, log logrus.FieldLogger) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { ctx := r.Context() @@ -71,10 +71,10 @@ func Handler(clusterConfigs kubernetes.ClusterConfigMap, clientFactory DynamicCl return } - clusterParam := r.URL.Query().Get("cluster") + environmentParam := r.URL.Query().Get("environment") // Phase 1: Validate all resources before applying any. - // Check that all resources are allowed kinds and have valid cluster targets. + // Check that all resources are allowed kinds and have valid environment targets. var disallowed []string for i, res := range req.Resources { apiVersion := res.GetAPIVersion() @@ -102,7 +102,7 @@ func Handler(clusterConfigs kubernetes.ClusterConfigMap, clientFactory DynamicCl hasErrors := false for _, res := range req.Resources { - result := applyOne(ctx, clusterConfigs, clientFactory, clusterParam, &res, actor, log) + result := applyOne(ctx, clusterConfigs, clientFactory, environmentParam, &res, actor, log) if result.Status == StatusError { hasErrors = true } @@ -121,12 +121,12 @@ func Handler(clusterConfigs kubernetes.ClusterConfigMap, clientFactory DynamicCl } } -// applyOne processes a single resource: resolves cluster, authorizes, applies, diffs, and logs. +// applyOne processes a single resource: resolves environment, authorizes, applies, diffs, and logs. func applyOne( ctx context.Context, clusterConfigs kubernetes.ClusterConfigMap, clientFactory DynamicClientFactory, - clusterParam string, + environmentParam string, res *unstructured.Unstructured, actor *authz.Actor, log logrus.FieldLogger, @@ -137,50 +137,50 @@ func applyOne( namespace := res.GetNamespace() resourceID := kind + "/" + name - // Resolve cluster: annotation takes precedence over query parameter. - cluster := clusterParam + // Resolve environment: annotation takes precedence over query parameter. + environment := environmentParam if ann := res.GetAnnotations(); ann != nil { - if c, ok := ann["nais.io/cluster"]; ok && c != "" { - cluster = c + if e, ok := ann["nais.io/environment"]; ok && e != "" { + environment = e } } - if cluster == "" { + if environment == "" { return ResourceResult{ Resource: resourceID, Namespace: namespace, Status: StatusError, - Error: "no cluster specified (use ?cluster= query parameter or nais.io/cluster annotation)", + Error: "no environment specified (use ?environment= query parameter or nais.io/environment annotation)", } } - // Validate cluster exists. - if _, ok := clusterConfigs[cluster]; !ok { + // Validate environment exists. + if _, ok := clusterConfigs[environment]; !ok { return ResourceResult{ - Resource: resourceID, - Namespace: namespace, - Cluster: cluster, - Status: StatusError, - Error: fmt.Sprintf("unknown cluster: %q", cluster), + Resource: resourceID, + Namespace: namespace, + Environment: environment, + Status: StatusError, + Error: fmt.Sprintf("unknown environment: %q", environment), } } // Validate resource has name and namespace. if name == "" { return ResourceResult{ - Resource: resourceID, - Namespace: namespace, - Cluster: cluster, - Status: StatusError, - Error: "resource must have metadata.name", + Resource: resourceID, + Namespace: namespace, + Environment: environment, + Status: StatusError, + Error: "resource must have metadata.name", } } if namespace == "" { return ResourceResult{ - Resource: resourceID, - Cluster: cluster, - Status: StatusError, - Error: "resource must have metadata.namespace", + Resource: resourceID, + Environment: environment, + Status: StatusError, + Error: "resource must have metadata.namespace", } } @@ -188,11 +188,11 @@ func applyOne( teamSlug := slug.Slug(namespace) if err := authorizeResource(ctx, kind, teamSlug); err != nil { return ResourceResult{ - Resource: resourceID, - Namespace: namespace, - Cluster: cluster, - Status: StatusError, - Error: fmt.Sprintf("authorization failed: %s", err), + Resource: resourceID, + Namespace: namespace, + Environment: environment, + Status: StatusError, + Error: fmt.Sprintf("authorization failed: %s", err), } } @@ -200,24 +200,24 @@ func applyOne( gvr, ok := GVRFor(apiVersion, kind) if !ok { return ResourceResult{ - Resource: resourceID, - Namespace: namespace, - Cluster: cluster, - Status: StatusError, - Error: fmt.Sprintf("no GVR mapping for %s/%s", apiVersion, kind), + Resource: resourceID, + Namespace: namespace, + Environment: environment, + Status: StatusError, + Error: fmt.Sprintf("no GVR mapping for %s/%s", apiVersion, kind), } } - // Create dynamic client for cluster. - client, err := clientFactory(ctx, cluster) + // Create dynamic client for environment. + client, err := clientFactory(ctx, environment) if err != nil { - log.WithError(err).WithField("cluster", cluster).Error("creating dynamic client") + log.WithError(err).WithField("environment", environment).Error("creating dynamic client") return ResourceResult{ - Resource: resourceID, - Namespace: namespace, - Cluster: cluster, - Status: StatusError, - Error: fmt.Sprintf("failed to create client for cluster %q: %s", cluster, err), + Resource: resourceID, + Namespace: namespace, + Environment: environment, + Status: StatusError, + Error: fmt.Sprintf("failed to create client for environment %q: %s", environment, err), } } @@ -225,17 +225,17 @@ func applyOne( applyResult, err := ApplyResource(ctx, client, gvr, res) if err != nil { log.WithError(err).WithFields(logrus.Fields{ - "cluster": cluster, - "namespace": namespace, - "name": name, - "kind": kind, + "environment": environment, + "namespace": namespace, + "name": name, + "kind": kind, }).Error("applying resource") return ResourceResult{ - Resource: resourceID, - Namespace: namespace, - Cluster: cluster, - Status: StatusError, - Error: fmt.Sprintf("apply failed: %s", err), + Resource: resourceID, + Namespace: namespace, + Environment: environment, + Status: StatusError, + Error: fmt.Sprintf("apply failed: %s", err), } } @@ -259,19 +259,18 @@ func applyOne( ResourceType: ActivityLogEntryResourceTypeApply, ResourceName: name, TeamSlug: &teamSlug, - EnvironmentName: &cluster, + EnvironmentName: &environment, Data: ApplyActivityLogEntryData{ - Cluster: cluster, APIVersion: apiVersion, Kind: kind, ChangedFields: changes, }, }); err != nil { log.WithError(err).WithFields(logrus.Fields{ - "cluster": cluster, - "namespace": namespace, - "name": name, - "kind": kind, + "environment": environment, + "namespace": namespace, + "name": name, + "kind": kind, }).Error("creating activity log entry") // Don't fail the apply because of a logging error. } @@ -279,7 +278,7 @@ func applyOne( return ResourceResult{ Resource: resourceID, Namespace: namespace, - Cluster: cluster, + Environment: environment, Status: status, ChangedFields: changes, } diff --git a/internal/apply/client.go b/internal/apply/client.go index dbd7c0145..0fb582a62 100644 --- a/internal/apply/client.go +++ b/internal/apply/client.go @@ -18,21 +18,21 @@ import ( const fieldManager = "nais-api" -// ImpersonatedClient creates a dynamic Kubernetes client for the given cluster +// ImpersonatedClient creates a dynamic Kubernetes client for the given environment // that impersonates the authenticated user from the context. This creates a fresh // client per call — it does NOT reuse informers or watcher clients. func ImpersonatedClient( ctx context.Context, clusterConfigs kubernetes.ClusterConfigMap, - cluster string, + environment string, ) (dynamic.Interface, error) { - cfg, ok := clusterConfigs[cluster] + cfg, ok := clusterConfigs[environment] if !ok { - return nil, fmt.Errorf("unknown cluster: %q", cluster) + return nil, fmt.Errorf("unknown environment: %q", environment) } if cfg == nil { - return nil, fmt.Errorf("no config available for cluster: %q", cluster) + return nil, fmt.Errorf("no config available for environment: %q", environment) } actor := authz.ActorFromContext(ctx) @@ -53,7 +53,7 @@ func ImpersonatedClient( client, err := dynamic.NewForConfig(impersonatedCfg) if err != nil { - return nil, fmt.Errorf("creating dynamic client for cluster %q: %w", cluster, err) + return nil, fmt.Errorf("creating dynamic client for environment %q: %w", environment, err) } return client, nil diff --git a/internal/apply/model.go b/internal/apply/model.go index 052a61d54..1445bb3ce 100644 --- a/internal/apply/model.go +++ b/internal/apply/model.go @@ -13,8 +13,8 @@ type ResourceResult struct { // Namespace is the target namespace (== team slug) of the resource. Namespace string `json:"namespace"` - // Cluster is the target cluster the resource was applied to. - Cluster string `json:"cluster"` + // Environment is the target environment the resource was applied to. + Environment string `json:"environment"` // Status is one of "created", "applied", or "error". Status string `json:"status"` @@ -32,3 +32,14 @@ const ( StatusApplied = "applied" StatusError = "error" ) + +// ApplyChangedField is the GraphQL model for a single field that changed during an apply operation. +// This is the canonical type used by both the resolver and the GraphQL schema. +type ApplyChangedField struct { + // Field is the dot-separated path to the changed field, e.g. "spec.replicas". + Field string `json:"field"` + // OldValue is the value before the apply. Nil if the field was added. + OldValue *string `json:"oldValue,omitempty"` + // NewValue is the value after the apply. Nil if the field was removed. + NewValue *string `json:"newValue,omitempty"` +} diff --git a/internal/graph/apply.resolvers.go b/internal/graph/apply.resolvers.go index d7489bf93..06e19aaff 100644 --- a/internal/graph/apply.resolvers.go +++ b/internal/graph/apply.resolvers.go @@ -6,17 +6,16 @@ import ( "github.com/nais/api/internal/apply" "github.com/nais/api/internal/graph/gengql" - "github.com/nais/api/internal/graph/model/donotuse" ) func (r *applyActivityLogEntryResolver) Action(ctx context.Context, obj *apply.ApplyActivityLogEntry) (string, error) { return string(obj.GenericActivityLogEntry.Action), nil } -func (r *applyActivityLogEntryDataResolver) ChangedFields(ctx context.Context, obj *apply.ApplyActivityLogEntryData) ([]*donotuse.ApplyChangedField, error) { - out := make([]*donotuse.ApplyChangedField, len(obj.ChangedFields)) +func (r *applyActivityLogEntryDataResolver) ChangedFields(ctx context.Context, obj *apply.ApplyActivityLogEntryData) ([]*apply.ApplyChangedField, error) { + out := make([]*apply.ApplyChangedField, len(obj.ChangedFields)) for i, c := range obj.ChangedFields { - field := &donotuse.ApplyChangedField{ + field := &apply.ApplyChangedField{ Field: c.Field, } if c.OldValue != nil { diff --git a/internal/graph/gengql/apply.generated.go b/internal/graph/gengql/apply.generated.go index 854ff054c..df220a334 100644 --- a/internal/graph/gengql/apply.generated.go +++ b/internal/graph/gengql/apply.generated.go @@ -11,7 +11,6 @@ import ( "github.com/99designs/gqlgen/graphql" "github.com/nais/api/internal/apply" - "github.com/nais/api/internal/graph/model/donotuse" "github.com/vektah/gqlparser/v2/ast" ) @@ -21,7 +20,7 @@ type ApplyActivityLogEntryResolver interface { Action(ctx context.Context, obj *apply.ApplyActivityLogEntry) (string, error) } type ApplyActivityLogEntryDataResolver interface { - ChangedFields(ctx context.Context, obj *apply.ApplyActivityLogEntryData) ([]*donotuse.ApplyChangedField, error) + ChangedFields(ctx context.Context, obj *apply.ApplyActivityLogEntryData) ([]*apply.ApplyChangedField, error) } // endregion ************************** generated!.gotpl ************************** @@ -321,8 +320,6 @@ func (ec *executionContext) fieldContext_ApplyActivityLogEntry_data(_ context.Co IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { - case "cluster": - return ec.fieldContext_ApplyActivityLogEntryData_cluster(ctx, field) case "apiVersion": return ec.fieldContext_ApplyActivityLogEntryData_apiVersion(ctx, field) case "kind": @@ -336,35 +333,6 @@ func (ec *executionContext) fieldContext_ApplyActivityLogEntry_data(_ context.Co return fc, nil } -func (ec *executionContext) _ApplyActivityLogEntryData_cluster(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntryData) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, - field, - ec.fieldContext_ApplyActivityLogEntryData_cluster, - func(ctx context.Context) (any, error) { - return obj.Cluster, nil - }, - nil, - ec.marshalNString2string, - true, - true, - ) -} - -func (ec *executionContext) fieldContext_ApplyActivityLogEntryData_cluster(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { - fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntryData", - 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) _ApplyActivityLogEntryData_apiVersion(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntryData) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, @@ -433,7 +401,7 @@ func (ec *executionContext) _ApplyActivityLogEntryData_changedFields(ctx context return ec.Resolvers.ApplyActivityLogEntryData().ChangedFields(ctx, obj) }, nil, - ec.marshalNApplyChangedField2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋmodelᚋdonotuseᚐApplyChangedFieldᚄ, + ec.marshalNApplyChangedField2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyChangedFieldᚄ, true, true, ) @@ -460,7 +428,7 @@ func (ec *executionContext) fieldContext_ApplyActivityLogEntryData_changedFields return fc, nil } -func (ec *executionContext) _ApplyChangedField_field(ctx context.Context, field graphql.CollectedField, obj *donotuse.ApplyChangedField) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplyChangedField_field(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyChangedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, @@ -489,7 +457,7 @@ func (ec *executionContext) fieldContext_ApplyChangedField_field(_ context.Conte return fc, nil } -func (ec *executionContext) _ApplyChangedField_oldValue(ctx context.Context, field graphql.CollectedField, obj *donotuse.ApplyChangedField) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplyChangedField_oldValue(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyChangedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, @@ -518,7 +486,7 @@ func (ec *executionContext) fieldContext_ApplyChangedField_oldValue(_ context.Co return fc, nil } -func (ec *executionContext) _ApplyChangedField_newValue(ctx context.Context, field graphql.CollectedField, obj *donotuse.ApplyChangedField) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplyChangedField_newValue(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyChangedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, @@ -679,11 +647,6 @@ func (ec *executionContext) _ApplyActivityLogEntryData(ctx context.Context, sel switch field.Name { case "__typename": out.Values[i] = graphql.MarshalString("ApplyActivityLogEntryData") - case "cluster": - out.Values[i] = ec._ApplyActivityLogEntryData_cluster(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } case "apiVersion": out.Values[i] = ec._ApplyActivityLogEntryData_apiVersion(ctx, field, obj) if out.Values[i] == graphql.Null { @@ -755,7 +718,7 @@ func (ec *executionContext) _ApplyActivityLogEntryData(ctx context.Context, sel var applyChangedFieldImplementors = []string{"ApplyChangedField"} -func (ec *executionContext) _ApplyChangedField(ctx context.Context, sel ast.SelectionSet, obj *donotuse.ApplyChangedField) graphql.Marshaler { +func (ec *executionContext) _ApplyChangedField(ctx context.Context, sel ast.SelectionSet, obj *apply.ApplyChangedField) graphql.Marshaler { fields := graphql.CollectFields(ec.OperationContext, sel, applyChangedFieldImplementors) out := graphql.NewFieldSet(fields) @@ -810,11 +773,11 @@ func (ec *executionContext) marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋ return ec._ApplyActivityLogEntryData(ctx, sel, v) } -func (ec *executionContext) marshalNApplyChangedField2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋmodelᚋdonotuseᚐApplyChangedFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []*donotuse.ApplyChangedField) graphql.Marshaler { +func (ec *executionContext) marshalNApplyChangedField2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyChangedFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []*apply.ApplyChangedField) graphql.Marshaler { ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { fc := graphql.GetFieldContext(ctx) fc.Result = &v[i] - return ec.marshalNApplyChangedField2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋmodelᚋdonotuseᚐApplyChangedField(ctx, sel, v[i]) + return ec.marshalNApplyChangedField2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyChangedField(ctx, sel, v[i]) }) for _, e := range ret { @@ -826,7 +789,7 @@ func (ec *executionContext) marshalNApplyChangedField2ᚕᚖgithubᚗcomᚋnais return ret } -func (ec *executionContext) marshalNApplyChangedField2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋmodelᚋdonotuseᚐApplyChangedField(ctx context.Context, sel ast.SelectionSet, v *donotuse.ApplyChangedField) graphql.Marshaler { +func (ec *executionContext) marshalNApplyChangedField2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyChangedField(ctx context.Context, sel ast.SelectionSet, v *apply.ApplyChangedField) graphql.Marshaler { if v == nil { if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") diff --git a/internal/graph/gengql/root_.generated.go b/internal/graph/gengql/root_.generated.go index e85030a13..b87fee9de 100644 --- a/internal/graph/gengql/root_.generated.go +++ b/internal/graph/gengql/root_.generated.go @@ -330,7 +330,6 @@ type ComplexityRoot struct { ApplyActivityLogEntryData struct { APIVersion func(childComplexity int) int ChangedFields func(childComplexity int) int - Cluster func(childComplexity int) int Kind func(childComplexity int) int } @@ -4054,13 +4053,6 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.ApplyActivityLogEntryData.ChangedFields(childComplexity), true - case "ApplyActivityLogEntryData.cluster": - if e.ComplexityRoot.ApplyActivityLogEntryData.Cluster == nil { - break - } - - return e.ComplexityRoot.ApplyActivityLogEntryData.Cluster(childComplexity), true - case "ApplyActivityLogEntryData.kind": if e.ComplexityRoot.ApplyActivityLogEntryData.Kind == nil { break @@ -18173,8 +18165,6 @@ type ApplyActivityLogEntry implements ActivityLogEntry & Node { Additional data associated with an apply activity log entry. """ type ApplyActivityLogEntryData { - "The cluster the resource was applied to." - cluster: String! "The apiVersion of the applied resource." apiVersion: String! "The kind of the applied resource." diff --git a/internal/graph/schema/apply.graphqls b/internal/graph/schema/apply.graphqls index 2e2336377..2147045db 100644 --- a/internal/graph/schema/apply.graphqls +++ b/internal/graph/schema/apply.graphqls @@ -42,8 +42,6 @@ type ApplyActivityLogEntry implements ActivityLogEntry & Node { Additional data associated with an apply activity log entry. """ type ApplyActivityLogEntryData { - "The cluster the resource was applied to." - cluster: String! "The apiVersion of the applied resource." apiVersion: String! "The kind of the applied resource." From 14b48b79765bfb77b1997130be4ad9ee3033cb0c Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Wed, 11 Mar 2026 13:23:14 +0100 Subject: [PATCH 03/25] Use latest tester --- go.mod | 2 +- go.sum | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/go.mod b/go.mod index d9feb8aad..b118d815a 100644 --- a/go.mod +++ b/go.mod @@ -42,7 +42,7 @@ require ( github.com/nais/bifrost v0.0.0-20260106105449-911627ac2c61 github.com/nais/liberator v0.0.0-20260216142648-ee49a9372bc4 github.com/nais/pgrator/pkg/api v0.0.0-20260219115817-cf954d58c04e - github.com/nais/tester v0.1.0 + github.com/nais/tester v0.1.1 github.com/nais/unleasherator v0.0.0-20251216221129-efebc54203fe github.com/nais/v13s/pkg/api v0.0.0-20260313084546-caca6d4cd742 github.com/patrickmn/go-cache v2.1.0+incompatible diff --git a/go.sum b/go.sum index df2100fb7..62c23ce07 100644 --- a/go.sum +++ b/go.sum @@ -800,6 +800,8 @@ github.com/nais/pgrator/pkg/api v0.0.0-20260219115817-cf954d58c04e h1:FWPwIgFlNj github.com/nais/pgrator/pkg/api v0.0.0-20260219115817-cf954d58c04e/go.mod h1:iDLbi5Ss8Fs6L5+ot8jBLStR5/bdiPgblt7OsN06n50= github.com/nais/tester v0.1.0 h1:dojqSFT3RB8bPZ0Wv0QlBAa/MVPitftpkErC2awVHmU= github.com/nais/tester v0.1.0/go.mod h1:NCQMcgftHz/EXorob1XwDTOqkQmImDqr51YQ2Uea9Pc= +github.com/nais/tester v0.1.1 h1:tpJ5HKpu3mEIWX/mec0Yj0xLHEpt+MwTAsj282n0Py0= +github.com/nais/tester v0.1.1/go.mod h1:NCQMcgftHz/EXorob1XwDTOqkQmImDqr51YQ2Uea9Pc= github.com/nais/unleasherator v0.0.0-20251216221129-efebc54203fe h1:CdRVopOihru4tXVwKZjhg6C8SbPLCQYOhJKpjBZYhjg= github.com/nais/unleasherator v0.0.0-20251216221129-efebc54203fe/go.mod h1:Tiz/1If3WgcfvNhmsO5DiQC+L+1XhBG3KWbIfbjx4EU= github.com/nais/v13s/pkg/api v0.0.0-20260313084546-caca6d4cd742 h1:OQ3n3/UjTf7pO5GzxU+wWRGP3skyOqdoTruS3wm28N4= From 821cb3fa7d9b28166d697e0ae520ae127d5653fa Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Wed, 11 Mar 2026 14:06:16 +0100 Subject: [PATCH 04/25] Move activitylog to correct resources, when applicable --- integration_tests/apply.lua | 239 ++++- internal/apply/activitylog.go | 64 +- internal/apply/apply.go | 16 +- internal/graph/apply.resolvers.go | 13 +- .../graph/gengql/activitylog.generated.go | 30 +- .../graph/gengql/applications.generated.go | 862 ++++++++++++++++-- internal/graph/gengql/apply.generated.go | 410 --------- internal/graph/gengql/jobs.generated.go | 826 +++++++++++++++-- internal/graph/gengql/root_.generated.go | 448 +++++++-- internal/graph/gengql/schema.generated.go | 30 +- internal/graph/schema/applications.graphqls | 58 ++ internal/graph/schema/apply.graphqls | 40 +- internal/graph/schema/jobs.graphqls | 58 ++ internal/workload/application/activitylog.go | 45 +- internal/workload/application/queries.go | 4 +- internal/workload/job/activitylog.go | 47 +- internal/workload/job/queries.go | 4 +- 17 files changed, 2427 insertions(+), 767 deletions(-) diff --git a/integration_tests/apply.lua b/integration_tests/apply.lua index e1ebfaccd..ef60a7cfc 100644 --- a/integration_tests/apply.lua +++ b/integration_tests/apply.lua @@ -91,7 +91,23 @@ Test.rest("update application via apply", function(t) namespace = "apply-team", environment = "dev", status = "applied", - changedFields = NotNull(), + changedFields = { + { + field = "spec.image", + oldValue = "example.com/my-app:v1", + newValue = "example.com/my-app:v2", + }, + { + field = "spec.replicas.max", + oldValue = 2, + newValue = 4, + }, + { + field = "spec.replicas.min", + oldValue = 1, + newValue = 2, + }, + }, }, }, }) @@ -333,3 +349,224 @@ Test.rest("unauthenticated request returns 401", function(t) }, }) end) + +Test.gql("activity log contains ApplicationCreatedActivityLogEntry after apply", function(t) + t.addHeader("x-user-email", user:email()) + + t.query(string.format( + [[ + query { + team(slug: "%s") { + activityLog( + first: 20 + filter: { activityTypes: [RESOURCE_CREATED] } + ) { + nodes { + __typename + message + actor + resourceType + resourceName + environmentName + ... on ApplicationCreatedActivityLogEntry { + data { + apiVersion + kind + } + } + } + } + } + } + ]], + team:slug() + )) + + -- RESOURCE_CREATED is registered for both APP and JOB, so the job entry appears too. + t.check({ + data = { + team = { + activityLog = { + nodes = { + { + __typename = "JobCreatedActivityLogEntry", + message = "Job my-job created", + actor = user:email(), + resourceType = "JOB", + resourceName = "my-job", + environmentName = "dev", + }, + { + __typename = "ApplicationCreatedActivityLogEntry", + message = "Application staging-app created", + actor = user:email(), + resourceType = "APP", + resourceName = "staging-app", + environmentName = "staging", + data = { + apiVersion = "nais.io/v1alpha1", + kind = "Application", + }, + }, + { + __typename = "ApplicationCreatedActivityLogEntry", + message = "Application my-app created", + actor = user:email(), + resourceType = "APP", + resourceName = "my-app", + environmentName = "dev", + data = { + apiVersion = "nais.io/v1alpha1", + kind = "Application", + }, + }, + }, + }, + }, + }, + }) +end) + +Test.gql("activity log contains ApplicationUpdatedActivityLogEntry with changedFields after apply", function(t) + t.addHeader("x-user-email", user:email()) + + t.query(string.format( + [[ + query { + team(slug: "%s") { + activityLog( + first: 20 + filter: { activityTypes: [RESOURCE_UPDATED] } + ) { + nodes { + __typename + message + actor + resourceType + resourceName + environmentName + ... on ApplicationUpdatedActivityLogEntry { + data { + apiVersion + kind + changedFields { + field + oldValue + newValue + } + } + } + } + } + } + } + ]], + team:slug() + )) + + t.check({ + data = { + team = { + activityLog = { + nodes = { + { + __typename = "ApplicationUpdatedActivityLogEntry", + message = "Application my-app updated", + actor = user:email(), + resourceType = "APP", + resourceName = "my-app", + environmentName = "dev", + data = { + apiVersion = "nais.io/v1alpha1", + kind = "Application", + changedFields = { + { + field = "spec.image", + oldValue = "example.com/my-app:v1", + newValue = "example.com/my-app:v2", + }, + { + field = "spec.replicas.max", + oldValue = "2", + newValue = "4", + }, + { + field = "spec.replicas.min", + oldValue = "1", + newValue = "2", + }, + }, + }, + }, + }, + }, + }, + }, + }) +end) + +Test.gql("activity log contains JobCreatedActivityLogEntry after apply", function(t) + t.addHeader("x-user-email", user:email()) + + t.query(string.format( + [[ + query { + team(slug: "%s") { + activityLog( + first: 20 + filter: { activityTypes: [RESOURCE_CREATED] } + ) { + nodes { + __typename + resourceType + resourceName + environmentName + ... on JobCreatedActivityLogEntry { + data { + apiVersion + kind + } + } + } + } + } + } + ]], + team:slug() + )) + + -- RESOURCE_CREATED is registered for both JOB and APP, so application entries appear too. + -- We only assert on the first node which is the most-recently created job. + t.check({ + data = { + team = { + activityLog = { + nodes = { + { + __typename = "JobCreatedActivityLogEntry", + resourceType = "JOB", + resourceName = "my-job", + environmentName = "dev", + data = { + apiVersion = "nais.io/v1", + kind = "Naisjob", + }, + }, + { + __typename = "ApplicationCreatedActivityLogEntry", + resourceType = "APP", + resourceName = "staging-app", + environmentName = "staging", + }, + { + __typename = "ApplicationCreatedActivityLogEntry", + resourceType = "APP", + resourceName = "my-app", + environmentName = "dev", + }, + }, + }, + }, + }, + }) +end) diff --git a/internal/apply/activitylog.go b/internal/apply/activitylog.go index b3f257097..e60e58b1f 100644 --- a/internal/apply/activitylog.go +++ b/internal/apply/activitylog.go @@ -1,53 +1,25 @@ package apply import ( - "fmt" - "github.com/nais/api/internal/activitylog" ) -const ( - // ActivityLogEntryResourceTypeApply is the resource type for apply activity log entries. - ActivityLogEntryResourceTypeApply activitylog.ActivityLogEntryResourceType = "APPLY" - - // ActivityLogEntryActionApplied is the action for a resource that was updated via apply. - ActivityLogEntryActionApplied activitylog.ActivityLogEntryAction = "APPLIED" - - // ActivityLogEntryActionCreated is the action for a resource that was created via apply. - ActivityLogEntryActionCreated activitylog.ActivityLogEntryAction = "APPLIED_NEW" -) - -func init() { - activitylog.RegisterTransformer(ActivityLogEntryResourceTypeApply, func(entry activitylog.GenericActivityLogEntry) (activitylog.ActivityLogEntry, error) { - switch entry.Action { - case ActivityLogEntryActionApplied: - data, err := activitylog.UnmarshalData[ApplyActivityLogEntryData](entry) - if err != nil { - return nil, fmt.Errorf("unmarshaling apply activity log entry data: %w", err) - } - return ApplyActivityLogEntry{ - GenericActivityLogEntry: entry.WithMessage(fmt.Sprintf("Applied %s/%s", data.Kind, entry.ResourceName)), - Data: data, - }, nil - case ActivityLogEntryActionCreated: - data, err := activitylog.UnmarshalData[ApplyActivityLogEntryData](entry) - if err != nil { - return nil, fmt.Errorf("unmarshaling apply created activity log entry data: %w", err) - } - return ApplyActivityLogEntry{ - GenericActivityLogEntry: entry.WithMessage(fmt.Sprintf("Created %s/%s", data.Kind, entry.ResourceName)), - Data: data, - }, nil - default: - return nil, fmt.Errorf("unsupported apply activity log entry action: %q", entry.Action) - } - }) - - activitylog.RegisterFilter("RESOURCE_APPLIED", ActivityLogEntryActionApplied, ActivityLogEntryResourceTypeApply) - activitylog.RegisterFilter("RESOURCE_CREATED", ActivityLogEntryActionCreated, ActivityLogEntryResourceTypeApply) +// ResourceTypeForKind returns the ActivityLogEntryResourceType for the given +// Kubernetes kind, so apply entries are stored under the correct resource type +// rather than a generic APPLY type. +func ResourceTypeForKind(kind string) (activitylog.ActivityLogEntryResourceType, bool) { + switch kind { + case "Application": + return "APP", true + case "Naisjob": + return "JOB", true + default: + return "", false + } } -// ApplyActivityLogEntryData contains the additional data stored with an apply activity log entry. +// ApplyActivityLogEntryData contains the additional data stored with a resource +// created or updated via apply. type ApplyActivityLogEntryData struct { // APIVersion is the apiVersion of the applied resource. APIVersion string `json:"apiVersion"` @@ -56,12 +28,6 @@ type ApplyActivityLogEntryData struct { Kind string `json:"kind"` // ChangedFields lists the fields that changed during the apply. + // Only populated for updates. ChangedFields []FieldChange `json:"changedFields"` } - -// ApplyActivityLogEntry is an activity log entry for an applied resource. -type ApplyActivityLogEntry struct { - activitylog.GenericActivityLogEntry - - Data *ApplyActivityLogEntryData `json:"data"` -} diff --git a/internal/apply/apply.go b/internal/apply/apply.go index 896aec928..048ff6531 100644 --- a/internal/apply/apply.go +++ b/internal/apply/apply.go @@ -248,15 +248,23 @@ func applyOne( } // Write activity log entry. - action := ActivityLogEntryActionCreated + action := activitylog.ActivityLogEntryActionCreated if !applyResult.Created { - action = ActivityLogEntryActionApplied + action = activitylog.ActivityLogEntryActionUpdated } - if err := activitylog.Create(ctx, activitylog.CreateInput{ + resourceType, ok := ResourceTypeForKind(kind) + if !ok { + log.WithFields(logrus.Fields{ + "environment": environment, + "namespace": namespace, + "name": name, + "kind": kind, + }).Warn("no activity log resource type for kind, skipping activity log entry") + } else if err := activitylog.Create(ctx, activitylog.CreateInput{ Action: action, Actor: actor.User, - ResourceType: ActivityLogEntryResourceTypeApply, + ResourceType: resourceType, ResourceName: name, TeamSlug: &teamSlug, EnvironmentName: &environment, diff --git a/internal/graph/apply.resolvers.go b/internal/graph/apply.resolvers.go index 06e19aaff..b691859e3 100644 --- a/internal/graph/apply.resolvers.go +++ b/internal/graph/apply.resolvers.go @@ -8,10 +8,6 @@ import ( "github.com/nais/api/internal/graph/gengql" ) -func (r *applyActivityLogEntryResolver) Action(ctx context.Context, obj *apply.ApplyActivityLogEntry) (string, error) { - return string(obj.GenericActivityLogEntry.Action), nil -} - func (r *applyActivityLogEntryDataResolver) ChangedFields(ctx context.Context, obj *apply.ApplyActivityLogEntryData) ([]*apply.ApplyChangedField, error) { out := make([]*apply.ApplyChangedField, len(obj.ChangedFields)) for i, c := range obj.ChangedFields { @@ -31,15 +27,8 @@ func (r *applyActivityLogEntryDataResolver) ChangedFields(ctx context.Context, o return out, nil } -func (r *Resolver) ApplyActivityLogEntry() gengql.ApplyActivityLogEntryResolver { - return &applyActivityLogEntryResolver{r} -} - func (r *Resolver) ApplyActivityLogEntryData() gengql.ApplyActivityLogEntryDataResolver { return &applyActivityLogEntryDataResolver{r} } -type ( - applyActivityLogEntryResolver struct{ *Resolver } - applyActivityLogEntryDataResolver struct{ *Resolver } -) +type applyActivityLogEntryDataResolver struct{ *Resolver } diff --git a/internal/graph/gengql/activitylog.generated.go b/internal/graph/gengql/activitylog.generated.go index 0b6c2c0f3..c1893e9bc 100644 --- a/internal/graph/gengql/activitylog.generated.go +++ b/internal/graph/gengql/activitylog.generated.go @@ -11,7 +11,6 @@ import ( "github.com/99designs/gqlgen/graphql" "github.com/nais/api/internal/activitylog" - "github.com/nais/api/internal/apply" "github.com/nais/api/internal/deployment/deploymentactivity" "github.com/nais/api/internal/github/repository" "github.com/nais/api/internal/graph/pagination" @@ -533,6 +532,13 @@ func (ec *executionContext) _ActivityLogEntry(ctx context.Context, sel ast.Selec return graphql.Null } return ec._OpenSearchCreatedActivityLogEntry(ctx, sel, obj) + case job.JobUpdatedActivityLogEntry: + return ec._JobUpdatedActivityLogEntry(ctx, sel, &obj) + case *job.JobUpdatedActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._JobUpdatedActivityLogEntry(ctx, sel, obj) case job.JobTriggeredActivityLogEntry: return ec._JobTriggeredActivityLogEntry(ctx, sel, &obj) case *job.JobTriggeredActivityLogEntry: @@ -554,6 +560,13 @@ func (ec *executionContext) _ActivityLogEntry(ctx context.Context, sel ast.Selec return graphql.Null } return ec._JobDeletedActivityLogEntry(ctx, sel, obj) + case job.JobCreatedActivityLogEntry: + return ec._JobCreatedActivityLogEntry(ctx, sel, &obj) + case *job.JobCreatedActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._JobCreatedActivityLogEntry(ctx, sel, obj) case deploymentactivity.DeploymentActivityLogEntry: return ec._DeploymentActivityLogEntry(ctx, sel, &obj) case *deploymentactivity.DeploymentActivityLogEntry: @@ -596,13 +609,13 @@ func (ec *executionContext) _ActivityLogEntry(ctx context.Context, sel ast.Selec return graphql.Null } return ec._ClusterAuditActivityLogEntry(ctx, sel, obj) - case apply.ApplyActivityLogEntry: - return ec._ApplyActivityLogEntry(ctx, sel, &obj) - case *apply.ApplyActivityLogEntry: + case application.ApplicationUpdatedActivityLogEntry: + return ec._ApplicationUpdatedActivityLogEntry(ctx, sel, &obj) + case *application.ApplicationUpdatedActivityLogEntry: if obj == nil { return graphql.Null } - return ec._ApplyActivityLogEntry(ctx, sel, obj) + return ec._ApplicationUpdatedActivityLogEntry(ctx, sel, obj) case application.ApplicationScaledActivityLogEntry: return ec._ApplicationScaledActivityLogEntry(ctx, sel, &obj) case *application.ApplicationScaledActivityLogEntry: @@ -624,6 +637,13 @@ func (ec *executionContext) _ActivityLogEntry(ctx context.Context, sel ast.Selec return graphql.Null } return ec._ApplicationDeletedActivityLogEntry(ctx, sel, obj) + case application.ApplicationCreatedActivityLogEntry: + return ec._ApplicationCreatedActivityLogEntry(ctx, sel, &obj) + case *application.ApplicationCreatedActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._ApplicationCreatedActivityLogEntry(ctx, sel, obj) default: if typedObj, ok := obj.(graphql.Marshaler); ok { return typedObj diff --git a/internal/graph/gengql/applications.generated.go b/internal/graph/gengql/applications.generated.go index 11ccc7840..4ca05349f 100644 --- a/internal/graph/gengql/applications.generated.go +++ b/internal/graph/gengql/applications.generated.go @@ -1992,6 +1992,275 @@ func (ec *executionContext) fieldContext_ApplicationConnection_edges(_ context.C return fc, nil } +func (ec *executionContext) _ApplicationCreatedActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationCreatedActivityLogEntry_id, + func(ctx context.Context) (any, error) { + return obj.ID(), nil + }, + nil, + ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationCreatedActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationCreatedActivityLogEntry", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplicationCreatedActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationCreatedActivityLogEntry_actor, + func(ctx context.Context) (any, error) { + return obj.Actor, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationCreatedActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationCreatedActivityLogEntry", + 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) _ApplicationCreatedActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationCreatedActivityLogEntry_createdAt, + func(ctx context.Context) (any, error) { + return obj.CreatedAt, nil + }, + nil, + ec.marshalNTime2timeᚐTime, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationCreatedActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplicationCreatedActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationCreatedActivityLogEntry_message, + func(ctx context.Context) (any, error) { + return obj.Message, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationCreatedActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationCreatedActivityLogEntry", + 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) _ApplicationCreatedActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationCreatedActivityLogEntry_resourceType, + func(ctx context.Context) (any, error) { + return obj.ResourceType, nil + }, + nil, + ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationCreatedActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplicationCreatedActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationCreatedActivityLogEntry_resourceName, + func(ctx context.Context) (any, error) { + return obj.ResourceName, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationCreatedActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationCreatedActivityLogEntry", + 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) _ApplicationCreatedActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationCreatedActivityLogEntry_teamSlug, + func(ctx context.Context) (any, error) { + return obj.TeamSlug, nil + }, + nil, + ec.marshalNSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationCreatedActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Slug does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplicationCreatedActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationCreatedActivityLogEntry_environmentName, + func(ctx context.Context) (any, error) { + return obj.EnvironmentName, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_ApplicationCreatedActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationCreatedActivityLogEntry", + 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) _ApplicationCreatedActivityLogEntry_data(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationCreatedActivityLogEntry_data, + func(ctx context.Context) (any, error) { + return obj.Data, nil + }, + nil, + ec.marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyActivityLogEntryData, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationCreatedActivityLogEntry_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "apiVersion": + return ec.fieldContext_ApplyActivityLogEntryData_apiVersion(ctx, field) + case "kind": + return ec.fieldContext_ApplyActivityLogEntryData_kind(ctx, field) + case "changedFields": + return ec.fieldContext_ApplyActivityLogEntryData_changedFields(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ApplyActivityLogEntryData", field.Name) + }, + } + return fc, nil +} + func (ec *executionContext) _ApplicationDeletedActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationDeletedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, @@ -3301,326 +3570,595 @@ func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_creat return fc, nil } -func (ec *executionContext) _ApplicationScaledActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplicationScaledActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationScaledActivityLogEntry_message, + func(ctx context.Context) (any, error) { + return obj.Message, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationScaledActivityLogEntry", + 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) _ApplicationScaledActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationScaledActivityLogEntry_resourceType, + func(ctx context.Context) (any, error) { + return obj.ResourceType, nil + }, + nil, + ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationScaledActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplicationScaledActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationScaledActivityLogEntry_resourceName, + func(ctx context.Context) (any, error) { + return obj.ResourceName, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationScaledActivityLogEntry", + 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) _ApplicationScaledActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationScaledActivityLogEntry_teamSlug, + func(ctx context.Context) (any, error) { + return obj.TeamSlug, nil + }, + nil, + ec.marshalNSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationScaledActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Slug does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplicationScaledActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationScaledActivityLogEntry_environmentName, + func(ctx context.Context) (any, error) { + return obj.EnvironmentName, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationScaledActivityLogEntry", + 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) _ApplicationScaledActivityLogEntry_data(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationScaledActivityLogEntry_data, + func(ctx context.Context) (any, error) { + return obj.Data, nil + }, + nil, + ec.marshalNApplicationScaledActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋapplicationᚐApplicationScaledActivityLogEntryData, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationScaledActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "newSize": + return ec.fieldContext_ApplicationScaledActivityLogEntryData_newSize(ctx, field) + case "direction": + return ec.fieldContext_ApplicationScaledActivityLogEntryData_direction(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ApplicationScaledActivityLogEntryData", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplicationScaledActivityLogEntryData_newSize(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntryData) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationScaledActivityLogEntryData_newSize, + func(ctx context.Context) (any, error) { + return obj.NewSize, nil + }, + nil, + ec.marshalNInt2int, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntryData_newSize(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationScaledActivityLogEntryData", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Int does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplicationScaledActivityLogEntryData_direction(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntryData) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationScaledActivityLogEntryData_direction, + func(ctx context.Context) (any, error) { + return obj.Direction, nil + }, + nil, + ec.marshalNScalingDirection2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋapplicationᚐScalingDirection, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntryData_direction(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationScaledActivityLogEntryData", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ScalingDirection does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplicationScaling_minInstances(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaling) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_ApplicationScaling_minInstances, + func(ctx context.Context) (any, error) { + return obj.MinInstances, nil + }, + nil, + ec.marshalNInt2int, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_ApplicationScaling_minInstances(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "ApplicationScaling", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Int does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _ApplicationScaling_maxInstances(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaling) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplicationScaledActivityLogEntry_message, + ec.fieldContext_ApplicationScaling_maxInstances, func(ctx context.Context) (any, error) { - return obj.Message, nil + return obj.MaxInstances, nil }, nil, - ec.marshalNString2string, + ec.marshalNInt2int, true, true, ) } -func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ApplicationScaling_maxInstances(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplicationScaledActivityLogEntry", + Object: "ApplicationScaling", 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 nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ApplicationScaledActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplicationScaling_strategies(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaling) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplicationScaledActivityLogEntry_resourceType, + ec.fieldContext_ApplicationScaling_strategies, func(ctx context.Context) (any, error) { - return obj.ResourceType, nil + return obj.Strategies, nil }, nil, - ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, + ec.marshalNScalingStrategy2ᚕgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋapplicationᚐScalingStrategyᚄ, true, true, ) } -func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ApplicationScaling_strategies(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplicationScaledActivityLogEntry", + Object: "ApplicationScaling", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") + return nil, errors.New("field of type ScalingStrategy does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ApplicationScaledActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplicationUpdatedActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplicationScaledActivityLogEntry_resourceName, + ec.fieldContext_ApplicationUpdatedActivityLogEntry_id, func(ctx context.Context) (any, error) { - return obj.ResourceName, nil + return obj.ID(), nil }, nil, - ec.marshalNString2string, + ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, true, true, ) } -func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ApplicationUpdatedActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplicationScaledActivityLogEntry", + Object: "ApplicationUpdatedActivityLogEntry", Field: field, - IsMethod: false, + IsMethod: true, 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 nil, errors.New("field of type ID does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ApplicationScaledActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplicationUpdatedActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplicationScaledActivityLogEntry_teamSlug, + ec.fieldContext_ApplicationUpdatedActivityLogEntry_actor, func(ctx context.Context) (any, error) { - return obj.TeamSlug, nil + return obj.Actor, nil }, nil, - ec.marshalNSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ApplicationUpdatedActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplicationScaledActivityLogEntry", + Object: "ApplicationUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Slug does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ApplicationScaledActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplicationUpdatedActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplicationScaledActivityLogEntry_environmentName, + ec.fieldContext_ApplicationUpdatedActivityLogEntry_createdAt, func(ctx context.Context) (any, error) { - return obj.EnvironmentName, nil + return obj.CreatedAt, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNTime2timeᚐTime, + true, true, - false, ) } -func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ApplicationUpdatedActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplicationScaledActivityLogEntry", + Object: "ApplicationUpdatedActivityLogEntry", 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 nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ApplicationScaledActivityLogEntry_data(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplicationUpdatedActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplicationScaledActivityLogEntry_data, + ec.fieldContext_ApplicationUpdatedActivityLogEntry_message, func(ctx context.Context) (any, error) { - return obj.Data, nil + return obj.Message, nil }, nil, - ec.marshalNApplicationScaledActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋapplicationᚐApplicationScaledActivityLogEntryData, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntry_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ApplicationUpdatedActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplicationScaledActivityLogEntry", + Object: "ApplicationUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "newSize": - return ec.fieldContext_ApplicationScaledActivityLogEntryData_newSize(ctx, field) - case "direction": - return ec.fieldContext_ApplicationScaledActivityLogEntryData_direction(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type ApplicationScaledActivityLogEntryData", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ApplicationScaledActivityLogEntryData_newSize(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntryData) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplicationUpdatedActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplicationScaledActivityLogEntryData_newSize, + ec.fieldContext_ApplicationUpdatedActivityLogEntry_resourceType, func(ctx context.Context) (any, error) { - return obj.NewSize, nil + return obj.ResourceType, nil }, nil, - ec.marshalNInt2int, + ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, true, true, ) } -func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntryData_newSize(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ApplicationUpdatedActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplicationScaledActivityLogEntryData", + Object: "ApplicationUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ApplicationScaledActivityLogEntryData_direction(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaledActivityLogEntryData) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplicationUpdatedActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplicationScaledActivityLogEntryData_direction, + ec.fieldContext_ApplicationUpdatedActivityLogEntry_resourceName, func(ctx context.Context) (any, error) { - return obj.Direction, nil + return obj.ResourceName, nil }, nil, - ec.marshalNScalingDirection2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋapplicationᚐScalingDirection, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_ApplicationScaledActivityLogEntryData_direction(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ApplicationUpdatedActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplicationScaledActivityLogEntryData", + Object: "ApplicationUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type ScalingDirection does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ApplicationScaling_minInstances(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaling) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplicationUpdatedActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplicationScaling_minInstances, + ec.fieldContext_ApplicationUpdatedActivityLogEntry_teamSlug, func(ctx context.Context) (any, error) { - return obj.MinInstances, nil + return obj.TeamSlug, nil }, nil, - ec.marshalNInt2int, + ec.marshalNSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, true, true, ) } -func (ec *executionContext) fieldContext_ApplicationScaling_minInstances(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ApplicationUpdatedActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplicationScaling", + Object: "ApplicationUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + return nil, errors.New("field of type Slug does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ApplicationScaling_maxInstances(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaling) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplicationUpdatedActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplicationScaling_maxInstances, + ec.fieldContext_ApplicationUpdatedActivityLogEntry_environmentName, func(ctx context.Context) (any, error) { - return obj.MaxInstances, nil + return obj.EnvironmentName, nil }, nil, - ec.marshalNInt2int, - true, + ec.marshalOString2ᚖstring, true, + false, ) } -func (ec *executionContext) fieldContext_ApplicationScaling_maxInstances(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ApplicationUpdatedActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplicationScaling", + Object: "ApplicationUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Int does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ApplicationScaling_strategies(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationScaling) (ret graphql.Marshaler) { +func (ec *executionContext) _ApplicationUpdatedActivityLogEntry_data(ctx context.Context, field graphql.CollectedField, obj *application.ApplicationUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplicationScaling_strategies, + ec.fieldContext_ApplicationUpdatedActivityLogEntry_data, func(ctx context.Context) (any, error) { - return obj.Strategies, nil + return obj.Data, nil }, nil, - ec.marshalNScalingStrategy2ᚕgithubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋapplicationᚐScalingStrategyᚄ, + ec.marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyActivityLogEntryData, true, true, ) } -func (ec *executionContext) fieldContext_ApplicationScaling_strategies(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ApplicationUpdatedActivityLogEntry_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplicationScaling", + Object: "ApplicationUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type ScalingStrategy does not have child fields") + switch field.Name { + case "apiVersion": + return ec.fieldContext_ApplyActivityLogEntryData_apiVersion(ctx, field) + case "kind": + return ec.fieldContext_ApplyActivityLogEntryData_kind(ctx, field) + case "changedFields": + return ec.fieldContext_ApplyActivityLogEntryData_changedFields(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ApplyActivityLogEntryData", field.Name) }, } return fc, nil @@ -5537,6 +6075,82 @@ func (ec *executionContext) _ApplicationConnection(ctx context.Context, sel ast. return out } +var applicationCreatedActivityLogEntryImplementors = []string{"ApplicationCreatedActivityLogEntry", "ActivityLogEntry", "Node"} + +func (ec *executionContext) _ApplicationCreatedActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *application.ApplicationCreatedActivityLogEntry) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, applicationCreatedActivityLogEntryImplementors) + + 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("ApplicationCreatedActivityLogEntry") + case "id": + out.Values[i] = ec._ApplicationCreatedActivityLogEntry_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "actor": + out.Values[i] = ec._ApplicationCreatedActivityLogEntry_actor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createdAt": + out.Values[i] = ec._ApplicationCreatedActivityLogEntry_createdAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "message": + out.Values[i] = ec._ApplicationCreatedActivityLogEntry_message(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceType": + out.Values[i] = ec._ApplicationCreatedActivityLogEntry_resourceType(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceName": + out.Values[i] = ec._ApplicationCreatedActivityLogEntry_resourceName(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "teamSlug": + out.Values[i] = ec._ApplicationCreatedActivityLogEntry_teamSlug(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "environmentName": + out.Values[i] = ec._ApplicationCreatedActivityLogEntry_environmentName(ctx, field, obj) + case "data": + out.Values[i] = ec._ApplicationCreatedActivityLogEntry_data(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 applicationDeletedActivityLogEntryImplementors = []string{"ApplicationDeletedActivityLogEntry", "ActivityLogEntry", "Node"} func (ec *executionContext) _ApplicationDeletedActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *application.ApplicationDeletedActivityLogEntry) graphql.Marshaler { @@ -6217,6 +6831,82 @@ func (ec *executionContext) _ApplicationScaling(ctx context.Context, sel ast.Sel return out } +var applicationUpdatedActivityLogEntryImplementors = []string{"ApplicationUpdatedActivityLogEntry", "ActivityLogEntry", "Node"} + +func (ec *executionContext) _ApplicationUpdatedActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *application.ApplicationUpdatedActivityLogEntry) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, applicationUpdatedActivityLogEntryImplementors) + + 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("ApplicationUpdatedActivityLogEntry") + case "id": + out.Values[i] = ec._ApplicationUpdatedActivityLogEntry_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "actor": + out.Values[i] = ec._ApplicationUpdatedActivityLogEntry_actor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createdAt": + out.Values[i] = ec._ApplicationUpdatedActivityLogEntry_createdAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "message": + out.Values[i] = ec._ApplicationUpdatedActivityLogEntry_message(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceType": + out.Values[i] = ec._ApplicationUpdatedActivityLogEntry_resourceType(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceName": + out.Values[i] = ec._ApplicationUpdatedActivityLogEntry_resourceName(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "teamSlug": + out.Values[i] = ec._ApplicationUpdatedActivityLogEntry_teamSlug(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "environmentName": + out.Values[i] = ec._ApplicationUpdatedActivityLogEntry_environmentName(ctx, field, obj) + case "data": + out.Values[i] = ec._ApplicationUpdatedActivityLogEntry_data(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 cPUScalingStrategyImplementors = []string{"CPUScalingStrategy", "ScalingStrategy"} func (ec *executionContext) _CPUScalingStrategy(ctx context.Context, sel ast.SelectionSet, obj *application.CPUScalingStrategy) graphql.Marshaler { diff --git a/internal/graph/gengql/apply.generated.go b/internal/graph/gengql/apply.generated.go index df220a334..b827bf2ca 100644 --- a/internal/graph/gengql/apply.generated.go +++ b/internal/graph/gengql/apply.generated.go @@ -16,9 +16,6 @@ import ( // region ************************** generated!.gotpl ************************** -type ApplyActivityLogEntryResolver interface { - Action(ctx context.Context, obj *apply.ApplyActivityLogEntry) (string, error) -} type ApplyActivityLogEntryDataResolver interface { ChangedFields(ctx context.Context, obj *apply.ApplyActivityLogEntryData) ([]*apply.ApplyChangedField, error) } @@ -35,304 +32,6 @@ type ApplyActivityLogEntryDataResolver interface { // region **************************** field.gotpl ***************************** -func (ec *executionContext) _ApplyActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, - field, - ec.fieldContext_ApplyActivityLogEntry_id, - func(ctx context.Context) (any, error) { - return obj.ID(), nil - }, - nil, - ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, - true, - true, - ) -} - -func (ec *executionContext) fieldContext_ApplyActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { - fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntry", - Field: field, - IsMethod: true, - IsResolver: false, - Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type ID does not have child fields") - }, - } - return fc, nil -} - -func (ec *executionContext) _ApplyActivityLogEntry_action(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, - field, - ec.fieldContext_ApplyActivityLogEntry_action, - func(ctx context.Context) (any, error) { - return ec.Resolvers.ApplyActivityLogEntry().Action(ctx, obj) - }, - nil, - ec.marshalNString2string, - true, - true, - ) -} - -func (ec *executionContext) fieldContext_ApplyActivityLogEntry_action(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { - fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntry", - Field: field, - IsMethod: true, - IsResolver: true, - 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) _ApplyActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, - field, - ec.fieldContext_ApplyActivityLogEntry_actor, - func(ctx context.Context) (any, error) { - return obj.Actor, nil - }, - nil, - ec.marshalNString2string, - true, - true, - ) -} - -func (ec *executionContext) fieldContext_ApplyActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { - fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntry", - 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) _ApplyActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, - field, - ec.fieldContext_ApplyActivityLogEntry_createdAt, - func(ctx context.Context) (any, error) { - return obj.CreatedAt, nil - }, - nil, - ec.marshalNTime2timeᚐTime, - true, - true, - ) -} - -func (ec *executionContext) fieldContext_ApplyActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { - fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntry", - Field: field, - IsMethod: false, - IsResolver: false, - Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") - }, - } - return fc, nil -} - -func (ec *executionContext) _ApplyActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, - field, - ec.fieldContext_ApplyActivityLogEntry_message, - func(ctx context.Context) (any, error) { - return obj.Message, nil - }, - nil, - ec.marshalNString2string, - true, - true, - ) -} - -func (ec *executionContext) fieldContext_ApplyActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { - fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntry", - 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) _ApplyActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, - field, - ec.fieldContext_ApplyActivityLogEntry_resourceType, - func(ctx context.Context) (any, error) { - return obj.ResourceType, nil - }, - nil, - ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, - true, - true, - ) -} - -func (ec *executionContext) fieldContext_ApplyActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { - fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntry", - Field: field, - IsMethod: false, - IsResolver: false, - Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") - }, - } - return fc, nil -} - -func (ec *executionContext) _ApplyActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, - field, - ec.fieldContext_ApplyActivityLogEntry_resourceName, - func(ctx context.Context) (any, error) { - return obj.ResourceName, nil - }, - nil, - ec.marshalNString2string, - true, - true, - ) -} - -func (ec *executionContext) fieldContext_ApplyActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { - fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntry", - 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) _ApplyActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, - field, - ec.fieldContext_ApplyActivityLogEntry_teamSlug, - func(ctx context.Context) (any, error) { - return obj.TeamSlug, nil - }, - nil, - ec.marshalOSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, - true, - false, - ) -} - -func (ec *executionContext) fieldContext_ApplyActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { - fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntry", - Field: field, - IsMethod: false, - IsResolver: false, - Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Slug does not have child fields") - }, - } - return fc, nil -} - -func (ec *executionContext) _ApplyActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, - field, - ec.fieldContext_ApplyActivityLogEntry_environmentName, - func(ctx context.Context) (any, error) { - return obj.EnvironmentName, nil - }, - nil, - ec.marshalOString2ᚖstring, - true, - false, - ) -} - -func (ec *executionContext) fieldContext_ApplyActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { - fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntry", - 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) _ApplyActivityLogEntry_data(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntry) (ret graphql.Marshaler) { - return graphql.ResolveField( - ctx, - ec.OperationContext, - field, - ec.fieldContext_ApplyActivityLogEntry_data, - func(ctx context.Context) (any, error) { - return obj.Data, nil - }, - nil, - ec.marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyActivityLogEntryData, - true, - true, - ) -} - -func (ec *executionContext) fieldContext_ApplyActivityLogEntry_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { - fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntry", - Field: field, - IsMethod: false, - IsResolver: false, - Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "apiVersion": - return ec.fieldContext_ApplyActivityLogEntryData_apiVersion(ctx, field) - case "kind": - return ec.fieldContext_ApplyActivityLogEntryData_kind(ctx, field) - case "changedFields": - return ec.fieldContext_ApplyActivityLogEntryData_changedFields(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type ApplyActivityLogEntryData", field.Name) - }, - } - return fc, nil -} - func (ec *executionContext) _ApplyActivityLogEntryData_apiVersion(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntryData) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, @@ -527,115 +226,6 @@ func (ec *executionContext) fieldContext_ApplyChangedField_newValue(_ context.Co // region **************************** object.gotpl **************************** -var applyActivityLogEntryImplementors = []string{"ApplyActivityLogEntry", "ActivityLogEntry", "Node"} - -func (ec *executionContext) _ApplyActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *apply.ApplyActivityLogEntry) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, applyActivityLogEntryImplementors) - - 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("ApplyActivityLogEntry") - case "id": - out.Values[i] = ec._ApplyActivityLogEntry_id(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "action": - field := field - - innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._ApplyActivityLogEntry_action(ctx, field, obj) - if res == graphql.Null { - atomic.AddUint32(&fs.Invalids, 1) - } - return res - } - - if field.Deferrable != nil { - dfs, ok := deferred[field.Deferrable.Label] - di := 0 - if ok { - dfs.AddField(field) - di = len(dfs.Values) - 1 - } else { - dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) - deferred[field.Deferrable.Label] = dfs - } - dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { - return innerFunc(ctx, dfs) - }) - - // don't run the out.Concurrently() call below - out.Values[i] = graphql.Null - continue - } - - out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) - case "actor": - out.Values[i] = ec._ApplyActivityLogEntry_actor(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "createdAt": - out.Values[i] = ec._ApplyActivityLogEntry_createdAt(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "message": - out.Values[i] = ec._ApplyActivityLogEntry_message(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "resourceType": - out.Values[i] = ec._ApplyActivityLogEntry_resourceType(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "resourceName": - out.Values[i] = ec._ApplyActivityLogEntry_resourceName(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - case "teamSlug": - out.Values[i] = ec._ApplyActivityLogEntry_teamSlug(ctx, field, obj) - case "environmentName": - out.Values[i] = ec._ApplyActivityLogEntry_environmentName(ctx, field, obj) - case "data": - out.Values[i] = ec._ApplyActivityLogEntry_data(ctx, field, obj) - if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) - } - 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 applyActivityLogEntryDataImplementors = []string{"ApplyActivityLogEntryData"} func (ec *executionContext) _ApplyActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, obj *apply.ApplyActivityLogEntryData) graphql.Marshaler { diff --git a/internal/graph/gengql/jobs.generated.go b/internal/graph/gengql/jobs.generated.go index 52fe46270..aec8de055 100644 --- a/internal/graph/gengql/jobs.generated.go +++ b/internal/graph/gengql/jobs.generated.go @@ -2201,6 +2201,275 @@ func (ec *executionContext) fieldContext_JobConnection_edges(_ context.Context, return fc, nil } +func (ec *executionContext) _JobCreatedActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *job.JobCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobCreatedActivityLogEntry_id, + func(ctx context.Context) (any, error) { + return obj.ID(), nil + }, + nil, + ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobCreatedActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobCreatedActivityLogEntry", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _JobCreatedActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *job.JobCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobCreatedActivityLogEntry_actor, + func(ctx context.Context) (any, error) { + return obj.Actor, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobCreatedActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobCreatedActivityLogEntry", + 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) _JobCreatedActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *job.JobCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobCreatedActivityLogEntry_createdAt, + func(ctx context.Context) (any, error) { + return obj.CreatedAt, nil + }, + nil, + ec.marshalNTime2timeᚐTime, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobCreatedActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _JobCreatedActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *job.JobCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobCreatedActivityLogEntry_message, + func(ctx context.Context) (any, error) { + return obj.Message, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobCreatedActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobCreatedActivityLogEntry", + 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) _JobCreatedActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *job.JobCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobCreatedActivityLogEntry_resourceType, + func(ctx context.Context) (any, error) { + return obj.ResourceType, nil + }, + nil, + ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobCreatedActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _JobCreatedActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *job.JobCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobCreatedActivityLogEntry_resourceName, + func(ctx context.Context) (any, error) { + return obj.ResourceName, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobCreatedActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobCreatedActivityLogEntry", + 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) _JobCreatedActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *job.JobCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobCreatedActivityLogEntry_teamSlug, + func(ctx context.Context) (any, error) { + return obj.TeamSlug, nil + }, + nil, + ec.marshalNSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobCreatedActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Slug does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _JobCreatedActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *job.JobCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobCreatedActivityLogEntry_environmentName, + func(ctx context.Context) (any, error) { + return obj.EnvironmentName, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_JobCreatedActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobCreatedActivityLogEntry", + 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) _JobCreatedActivityLogEntry_data(ctx context.Context, field graphql.CollectedField, obj *job.JobCreatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobCreatedActivityLogEntry_data, + func(ctx context.Context) (any, error) { + return obj.Data, nil + }, + nil, + ec.marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyActivityLogEntryData, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobCreatedActivityLogEntry_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobCreatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "apiVersion": + return ec.fieldContext_ApplyActivityLogEntryData_apiVersion(ctx, field) + case "kind": + return ec.fieldContext_ApplyActivityLogEntryData_kind(ctx, field) + case "changedFields": + return ec.fieldContext_ApplyActivityLogEntryData_changedFields(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ApplyActivityLogEntryData", field.Name) + }, + } + return fc, nil +} + func (ec *executionContext) _JobDeletedActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *job.JobDeletedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, @@ -3711,31 +3980,263 @@ func (ec *executionContext) _JobRunStatus_state(ctx context.Context, field graph return obj.State, nil }, nil, - ec.marshalNJobRunState2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋjobᚐJobRunState, + ec.marshalNJobRunState2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋjobᚐJobRunState, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobRunStatus_state(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobRunStatus", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type JobRunState does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _JobRunStatus_message(ctx context.Context, field graphql.CollectedField, obj *job.JobRunStatus) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobRunStatus_message, + func(ctx context.Context) (any, error) { + return obj.Message, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobRunStatus_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobRunStatus", + 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) _JobRunTrigger_type(ctx context.Context, field graphql.CollectedField, obj *job.JobRunTrigger) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobRunTrigger_type, + func(ctx context.Context) (any, error) { + return obj.Type, nil + }, + nil, + ec.marshalNJobRunTriggerType2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋjobᚐJobRunTriggerType, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobRunTrigger_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobRunTrigger", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type JobRunTriggerType does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _JobRunTrigger_actor(ctx context.Context, field graphql.CollectedField, obj *job.JobRunTrigger) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobRunTrigger_actor, + func(ctx context.Context) (any, error) { + return obj.Actor, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_JobRunTrigger_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobRunTrigger", + 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) _JobSchedule_expression(ctx context.Context, field graphql.CollectedField, obj *job.JobSchedule) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobSchedule_expression, + func(ctx context.Context) (any, error) { + return obj.Expression, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobSchedule_expression(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobSchedule", + 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) _JobSchedule_timeZone(ctx context.Context, field graphql.CollectedField, obj *job.JobSchedule) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobSchedule_timeZone, + func(ctx context.Context) (any, error) { + return obj.TimeZone, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobSchedule_timeZone(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobSchedule", + 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) _JobTriggeredActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobTriggeredActivityLogEntry_id, + func(ctx context.Context) (any, error) { + return obj.ID(), nil + }, + nil, + ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobTriggeredActivityLogEntry", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _JobTriggeredActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobTriggeredActivityLogEntry_actor, + func(ctx context.Context) (any, error) { + return obj.Actor, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobTriggeredActivityLogEntry", + 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) _JobTriggeredActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobTriggeredActivityLogEntry_createdAt, + func(ctx context.Context) (any, error) { + return obj.CreatedAt, nil + }, + nil, + ec.marshalNTime2timeᚐTime, true, true, ) } -func (ec *executionContext) fieldContext_JobRunStatus_state(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobRunStatus", + Object: "JobTriggeredActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type JobRunState does not have child fields") + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _JobRunStatus_message(ctx context.Context, field graphql.CollectedField, obj *job.JobRunStatus) (ret graphql.Marshaler) { +func (ec *executionContext) _JobTriggeredActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobRunStatus_message, + ec.fieldContext_JobTriggeredActivityLogEntry_message, func(ctx context.Context) (any, error) { return obj.Message, nil }, @@ -3746,9 +4247,9 @@ func (ec *executionContext) _JobRunStatus_message(ctx context.Context, field gra ) } -func (ec *executionContext) fieldContext_JobRunStatus_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobRunStatus", + Object: "JobTriggeredActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -3759,54 +4260,54 @@ func (ec *executionContext) fieldContext_JobRunStatus_message(_ context.Context, return fc, nil } -func (ec *executionContext) _JobRunTrigger_type(ctx context.Context, field graphql.CollectedField, obj *job.JobRunTrigger) (ret graphql.Marshaler) { +func (ec *executionContext) _JobTriggeredActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobRunTrigger_type, + ec.fieldContext_JobTriggeredActivityLogEntry_resourceType, func(ctx context.Context) (any, error) { - return obj.Type, nil + return obj.ResourceType, nil }, nil, - ec.marshalNJobRunTriggerType2githubᚗcomᚋnaisᚋapiᚋinternalᚋworkloadᚋjobᚐJobRunTriggerType, + ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, true, true, ) } -func (ec *executionContext) fieldContext_JobRunTrigger_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobRunTrigger", + Object: "JobTriggeredActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type JobRunTriggerType does not have child fields") + return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") }, } return fc, nil } -func (ec *executionContext) _JobRunTrigger_actor(ctx context.Context, field graphql.CollectedField, obj *job.JobRunTrigger) (ret graphql.Marshaler) { +func (ec *executionContext) _JobTriggeredActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobRunTrigger_actor, + ec.fieldContext_JobTriggeredActivityLogEntry_resourceName, func(ctx context.Context) (any, error) { - return obj.Actor, nil + return obj.ResourceName, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNString2string, + true, true, - false, ) } -func (ec *executionContext) fieldContext_JobRunTrigger_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobRunTrigger", + Object: "JobTriggeredActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -3817,54 +4318,54 @@ func (ec *executionContext) fieldContext_JobRunTrigger_actor(_ context.Context, return fc, nil } -func (ec *executionContext) _JobSchedule_expression(ctx context.Context, field graphql.CollectedField, obj *job.JobSchedule) (ret graphql.Marshaler) { +func (ec *executionContext) _JobTriggeredActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobSchedule_expression, + ec.fieldContext_JobTriggeredActivityLogEntry_teamSlug, func(ctx context.Context) (any, error) { - return obj.Expression, nil + return obj.TeamSlug, nil }, nil, - ec.marshalNString2string, + ec.marshalNSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, true, true, ) } -func (ec *executionContext) fieldContext_JobSchedule_expression(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobSchedule", + Object: "JobTriggeredActivityLogEntry", 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 nil, errors.New("field of type Slug does not have child fields") }, } return fc, nil } -func (ec *executionContext) _JobSchedule_timeZone(ctx context.Context, field graphql.CollectedField, obj *job.JobSchedule) (ret graphql.Marshaler) { +func (ec *executionContext) _JobTriggeredActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobSchedule_timeZone, + ec.fieldContext_JobTriggeredActivityLogEntry_environmentName, func(ctx context.Context) (any, error) { - return obj.TimeZone, nil + return obj.EnvironmentName, nil }, nil, - ec.marshalNString2string, - true, + ec.marshalOString2ᚖstring, true, + false, ) } -func (ec *executionContext) fieldContext_JobSchedule_timeZone(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobSchedule", + Object: "JobTriggeredActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -3875,12 +4376,12 @@ func (ec *executionContext) fieldContext_JobSchedule_timeZone(_ context.Context, return fc, nil } -func (ec *executionContext) _JobTriggeredActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _JobUpdatedActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *job.JobUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobTriggeredActivityLogEntry_id, + ec.fieldContext_JobUpdatedActivityLogEntry_id, func(ctx context.Context) (any, error) { return obj.ID(), nil }, @@ -3891,9 +4392,9 @@ func (ec *executionContext) _JobTriggeredActivityLogEntry_id(ctx context.Context ) } -func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobUpdatedActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobTriggeredActivityLogEntry", + Object: "JobUpdatedActivityLogEntry", Field: field, IsMethod: true, IsResolver: false, @@ -3904,12 +4405,12 @@ func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_id(_ conte return fc, nil } -func (ec *executionContext) _JobTriggeredActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _JobUpdatedActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *job.JobUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobTriggeredActivityLogEntry_actor, + ec.fieldContext_JobUpdatedActivityLogEntry_actor, func(ctx context.Context) (any, error) { return obj.Actor, nil }, @@ -3920,9 +4421,9 @@ func (ec *executionContext) _JobTriggeredActivityLogEntry_actor(ctx context.Cont ) } -func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobUpdatedActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobTriggeredActivityLogEntry", + Object: "JobUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -3933,12 +4434,12 @@ func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_actor(_ co return fc, nil } -func (ec *executionContext) _JobTriggeredActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _JobUpdatedActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *job.JobUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobTriggeredActivityLogEntry_createdAt, + ec.fieldContext_JobUpdatedActivityLogEntry_createdAt, func(ctx context.Context) (any, error) { return obj.CreatedAt, nil }, @@ -3949,9 +4450,9 @@ func (ec *executionContext) _JobTriggeredActivityLogEntry_createdAt(ctx context. ) } -func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobUpdatedActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobTriggeredActivityLogEntry", + Object: "JobUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -3962,12 +4463,12 @@ func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_createdAt( return fc, nil } -func (ec *executionContext) _JobTriggeredActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _JobUpdatedActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *job.JobUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobTriggeredActivityLogEntry_message, + ec.fieldContext_JobUpdatedActivityLogEntry_message, func(ctx context.Context) (any, error) { return obj.Message, nil }, @@ -3978,9 +4479,9 @@ func (ec *executionContext) _JobTriggeredActivityLogEntry_message(ctx context.Co ) } -func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobUpdatedActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobTriggeredActivityLogEntry", + Object: "JobUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -3991,12 +4492,12 @@ func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_message(_ return fc, nil } -func (ec *executionContext) _JobTriggeredActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _JobUpdatedActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *job.JobUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobTriggeredActivityLogEntry_resourceType, + ec.fieldContext_JobUpdatedActivityLogEntry_resourceType, func(ctx context.Context) (any, error) { return obj.ResourceType, nil }, @@ -4007,9 +4508,9 @@ func (ec *executionContext) _JobTriggeredActivityLogEntry_resourceType(ctx conte ) } -func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobUpdatedActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobTriggeredActivityLogEntry", + Object: "JobUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -4020,12 +4521,12 @@ func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_resourceTy return fc, nil } -func (ec *executionContext) _JobTriggeredActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _JobUpdatedActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *job.JobUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobTriggeredActivityLogEntry_resourceName, + ec.fieldContext_JobUpdatedActivityLogEntry_resourceName, func(ctx context.Context) (any, error) { return obj.ResourceName, nil }, @@ -4036,9 +4537,9 @@ func (ec *executionContext) _JobTriggeredActivityLogEntry_resourceName(ctx conte ) } -func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobUpdatedActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobTriggeredActivityLogEntry", + Object: "JobUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -4049,12 +4550,12 @@ func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_resourceNa return fc, nil } -func (ec *executionContext) _JobTriggeredActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _JobUpdatedActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *job.JobUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobTriggeredActivityLogEntry_teamSlug, + ec.fieldContext_JobUpdatedActivityLogEntry_teamSlug, func(ctx context.Context) (any, error) { return obj.TeamSlug, nil }, @@ -4065,9 +4566,9 @@ func (ec *executionContext) _JobTriggeredActivityLogEntry_teamSlug(ctx context.C ) } -func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobUpdatedActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobTriggeredActivityLogEntry", + Object: "JobUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -4078,12 +4579,12 @@ func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_teamSlug(_ return fc, nil } -func (ec *executionContext) _JobTriggeredActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *job.JobTriggeredActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _JobUpdatedActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *job.JobUpdatedActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_JobTriggeredActivityLogEntry_environmentName, + ec.fieldContext_JobUpdatedActivityLogEntry_environmentName, func(ctx context.Context) (any, error) { return obj.EnvironmentName, nil }, @@ -4094,9 +4595,9 @@ func (ec *executionContext) _JobTriggeredActivityLogEntry_environmentName(ctx co ) } -func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_JobUpdatedActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "JobTriggeredActivityLogEntry", + Object: "JobUpdatedActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -4107,6 +4608,43 @@ func (ec *executionContext) fieldContext_JobTriggeredActivityLogEntry_environmen return fc, nil } +func (ec *executionContext) _JobUpdatedActivityLogEntry_data(ctx context.Context, field graphql.CollectedField, obj *job.JobUpdatedActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_JobUpdatedActivityLogEntry_data, + func(ctx context.Context) (any, error) { + return obj.Data, nil + }, + nil, + ec.marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyActivityLogEntryData, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_JobUpdatedActivityLogEntry_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobUpdatedActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "apiVersion": + return ec.fieldContext_ApplyActivityLogEntryData_apiVersion(ctx, field) + case "kind": + return ec.fieldContext_ApplyActivityLogEntryData_kind(ctx, field) + case "changedFields": + return ec.fieldContext_ApplyActivityLogEntryData_changedFields(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ApplyActivityLogEntryData", field.Name) + }, + } + return fc, nil +} + func (ec *executionContext) _TeamInventoryCountJobs_total(ctx context.Context, field graphql.CollectedField, obj *job.TeamInventoryCountJobs) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, @@ -5617,6 +6155,82 @@ func (ec *executionContext) _JobConnection(ctx context.Context, sel ast.Selectio return out } +var jobCreatedActivityLogEntryImplementors = []string{"JobCreatedActivityLogEntry", "ActivityLogEntry", "Node"} + +func (ec *executionContext) _JobCreatedActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *job.JobCreatedActivityLogEntry) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, jobCreatedActivityLogEntryImplementors) + + 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("JobCreatedActivityLogEntry") + case "id": + out.Values[i] = ec._JobCreatedActivityLogEntry_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "actor": + out.Values[i] = ec._JobCreatedActivityLogEntry_actor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createdAt": + out.Values[i] = ec._JobCreatedActivityLogEntry_createdAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "message": + out.Values[i] = ec._JobCreatedActivityLogEntry_message(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceType": + out.Values[i] = ec._JobCreatedActivityLogEntry_resourceType(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceName": + out.Values[i] = ec._JobCreatedActivityLogEntry_resourceName(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "teamSlug": + out.Values[i] = ec._JobCreatedActivityLogEntry_teamSlug(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "environmentName": + out.Values[i] = ec._JobCreatedActivityLogEntry_environmentName(ctx, field, obj) + case "data": + out.Values[i] = ec._JobCreatedActivityLogEntry_data(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 jobDeletedActivityLogEntryImplementors = []string{"JobDeletedActivityLogEntry", "ActivityLogEntry", "Node"} func (ec *executionContext) _JobDeletedActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *job.JobDeletedActivityLogEntry) graphql.Marshaler { @@ -6492,6 +7106,82 @@ func (ec *executionContext) _JobTriggeredActivityLogEntry(ctx context.Context, s return out } +var jobUpdatedActivityLogEntryImplementors = []string{"JobUpdatedActivityLogEntry", "ActivityLogEntry", "Node"} + +func (ec *executionContext) _JobUpdatedActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *job.JobUpdatedActivityLogEntry) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, jobUpdatedActivityLogEntryImplementors) + + 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("JobUpdatedActivityLogEntry") + case "id": + out.Values[i] = ec._JobUpdatedActivityLogEntry_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "actor": + out.Values[i] = ec._JobUpdatedActivityLogEntry_actor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createdAt": + out.Values[i] = ec._JobUpdatedActivityLogEntry_createdAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "message": + out.Values[i] = ec._JobUpdatedActivityLogEntry_message(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceType": + out.Values[i] = ec._JobUpdatedActivityLogEntry_resourceType(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceName": + out.Values[i] = ec._JobUpdatedActivityLogEntry_resourceName(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "teamSlug": + out.Values[i] = ec._JobUpdatedActivityLogEntry_teamSlug(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "environmentName": + out.Values[i] = ec._JobUpdatedActivityLogEntry_environmentName(ctx, field, obj) + case "data": + out.Values[i] = ec._JobUpdatedActivityLogEntry_data(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 teamInventoryCountJobsImplementors = []string{"TeamInventoryCountJobs"} func (ec *executionContext) _TeamInventoryCountJobs(ctx context.Context, sel ast.SelectionSet, obj *job.TeamInventoryCountJobs) graphql.Marshaler { diff --git a/internal/graph/gengql/root_.generated.go b/internal/graph/gengql/root_.generated.go index b87fee9de..14bd0e791 100644 --- a/internal/graph/gengql/root_.generated.go +++ b/internal/graph/gengql/root_.generated.go @@ -58,7 +58,6 @@ type Config = graphql.Config[ResolverRoot, DirectiveRoot, ComplexityRoot] type ResolverRoot interface { Application() ApplicationResolver ApplicationInstance() ApplicationInstanceResolver - ApplyActivityLogEntry() ApplyActivityLogEntryResolver ApplyActivityLogEntryData() ApplyActivityLogEntryDataResolver BigQueryDataset() BigQueryDatasetResolver Bucket() BucketResolver @@ -224,6 +223,18 @@ type ComplexityRoot struct { PageInfo func(childComplexity int) int } + ApplicationCreatedActivityLogEntry struct { + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + Data func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int + } + ApplicationDeletedActivityLogEntry struct { Actor func(childComplexity int) int CreatedAt func(childComplexity int) int @@ -314,8 +325,7 @@ type ComplexityRoot struct { Strategies func(childComplexity int) int } - ApplyActivityLogEntry struct { - Action func(childComplexity int) int + ApplicationUpdatedActivityLogEntry struct { Actor func(childComplexity int) int CreatedAt func(childComplexity int) int Data func(childComplexity int) int @@ -1001,6 +1011,18 @@ type ComplexityRoot struct { PageInfo func(childComplexity int) int } + JobCreatedActivityLogEntry struct { + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + Data func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int + } + JobDeletedActivityLogEntry struct { Actor func(childComplexity int) int CreatedAt func(childComplexity int) int @@ -1107,6 +1129,18 @@ type ComplexityRoot struct { TeamSlug func(childComplexity int) int } + JobUpdatedActivityLogEntry struct { + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + Data func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int + } + KafkaCredentials struct { AccessCert func(childComplexity int) int AccessKey func(childComplexity int) int @@ -3607,6 +3641,69 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.ApplicationConnection.PageInfo(childComplexity), true + case "ApplicationCreatedActivityLogEntry.actor": + if e.ComplexityRoot.ApplicationCreatedActivityLogEntry.Actor == nil { + break + } + + return e.ComplexityRoot.ApplicationCreatedActivityLogEntry.Actor(childComplexity), true + + case "ApplicationCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ApplicationCreatedActivityLogEntry.CreatedAt == nil { + break + } + + return e.ComplexityRoot.ApplicationCreatedActivityLogEntry.CreatedAt(childComplexity), true + + case "ApplicationCreatedActivityLogEntry.data": + if e.ComplexityRoot.ApplicationCreatedActivityLogEntry.Data == nil { + break + } + + return e.ComplexityRoot.ApplicationCreatedActivityLogEntry.Data(childComplexity), true + + case "ApplicationCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ApplicationCreatedActivityLogEntry.EnvironmentName == nil { + break + } + + return e.ComplexityRoot.ApplicationCreatedActivityLogEntry.EnvironmentName(childComplexity), true + + case "ApplicationCreatedActivityLogEntry.id": + if e.ComplexityRoot.ApplicationCreatedActivityLogEntry.ID == nil { + break + } + + return e.ComplexityRoot.ApplicationCreatedActivityLogEntry.ID(childComplexity), true + + case "ApplicationCreatedActivityLogEntry.message": + if e.ComplexityRoot.ApplicationCreatedActivityLogEntry.Message == nil { + break + } + + return e.ComplexityRoot.ApplicationCreatedActivityLogEntry.Message(childComplexity), true + + case "ApplicationCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ApplicationCreatedActivityLogEntry.ResourceName == nil { + break + } + + return e.ComplexityRoot.ApplicationCreatedActivityLogEntry.ResourceName(childComplexity), true + + case "ApplicationCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ApplicationCreatedActivityLogEntry.ResourceType == nil { + break + } + + return e.ComplexityRoot.ApplicationCreatedActivityLogEntry.ResourceType(childComplexity), true + + case "ApplicationCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ApplicationCreatedActivityLogEntry.TeamSlug == nil { + break + } + + return e.ComplexityRoot.ApplicationCreatedActivityLogEntry.TeamSlug(childComplexity), true + case "ApplicationDeletedActivityLogEntry.actor": if e.ComplexityRoot.ApplicationDeletedActivityLogEntry.Actor == nil { break @@ -3969,75 +4066,68 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.ApplicationScaling.Strategies(childComplexity), true - case "ApplyActivityLogEntry.action": - if e.ComplexityRoot.ApplyActivityLogEntry.Action == nil { + case "ApplicationUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ApplyActivityLogEntry.Action(childComplexity), true + return e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.Actor(childComplexity), true - case "ApplyActivityLogEntry.actor": - if e.ComplexityRoot.ApplyActivityLogEntry.Actor == nil { + case "ApplicationUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ApplyActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "ApplyActivityLogEntry.createdAt": - if e.ComplexityRoot.ApplyActivityLogEntry.CreatedAt == nil { + case "ApplicationUpdatedActivityLogEntry.data": + if e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ApplyActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.Data(childComplexity), true - case "ApplyActivityLogEntry.data": - if e.ComplexityRoot.ApplyActivityLogEntry.Data == nil { + case "ApplicationUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ApplyActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "ApplyActivityLogEntry.environmentName": - if e.ComplexityRoot.ApplyActivityLogEntry.EnvironmentName == nil { + case "ApplicationUpdatedActivityLogEntry.id": + if e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ApplyActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.ID(childComplexity), true - case "ApplyActivityLogEntry.id": - if e.ComplexityRoot.ApplyActivityLogEntry.ID == nil { + case "ApplicationUpdatedActivityLogEntry.message": + if e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ApplyActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.Message(childComplexity), true - case "ApplyActivityLogEntry.message": - if e.ComplexityRoot.ApplyActivityLogEntry.Message == nil { + case "ApplicationUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ApplyActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "ApplyActivityLogEntry.resourceName": - if e.ComplexityRoot.ApplyActivityLogEntry.ResourceName == nil { + case "ApplicationUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ApplyActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "ApplyActivityLogEntry.resourceType": - if e.ComplexityRoot.ApplyActivityLogEntry.ResourceType == nil { + case "ApplicationUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ApplyActivityLogEntry.ResourceType(childComplexity), true - - case "ApplyActivityLogEntry.teamSlug": - if e.ComplexityRoot.ApplyActivityLogEntry.TeamSlug == nil { - break - } - - return e.ComplexityRoot.ApplyActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.TeamSlug(childComplexity), true case "ApplyActivityLogEntryData.apiVersion": if e.ComplexityRoot.ApplyActivityLogEntryData.APIVersion == nil { @@ -6671,6 +6761,69 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.JobConnection.PageInfo(childComplexity), true + case "JobCreatedActivityLogEntry.actor": + if e.ComplexityRoot.JobCreatedActivityLogEntry.Actor == nil { + break + } + + return e.ComplexityRoot.JobCreatedActivityLogEntry.Actor(childComplexity), true + + case "JobCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.JobCreatedActivityLogEntry.CreatedAt == nil { + break + } + + return e.ComplexityRoot.JobCreatedActivityLogEntry.CreatedAt(childComplexity), true + + case "JobCreatedActivityLogEntry.data": + if e.ComplexityRoot.JobCreatedActivityLogEntry.Data == nil { + break + } + + return e.ComplexityRoot.JobCreatedActivityLogEntry.Data(childComplexity), true + + case "JobCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.JobCreatedActivityLogEntry.EnvironmentName == nil { + break + } + + return e.ComplexityRoot.JobCreatedActivityLogEntry.EnvironmentName(childComplexity), true + + case "JobCreatedActivityLogEntry.id": + if e.ComplexityRoot.JobCreatedActivityLogEntry.ID == nil { + break + } + + return e.ComplexityRoot.JobCreatedActivityLogEntry.ID(childComplexity), true + + case "JobCreatedActivityLogEntry.message": + if e.ComplexityRoot.JobCreatedActivityLogEntry.Message == nil { + break + } + + return e.ComplexityRoot.JobCreatedActivityLogEntry.Message(childComplexity), true + + case "JobCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceName == nil { + break + } + + return e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceName(childComplexity), true + + case "JobCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceType == nil { + break + } + + return e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceType(childComplexity), true + + case "JobCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobCreatedActivityLogEntry.TeamSlug == nil { + break + } + + return e.ComplexityRoot.JobCreatedActivityLogEntry.TeamSlug(childComplexity), true + case "JobDeletedActivityLogEntry.actor": if e.ComplexityRoot.JobDeletedActivityLogEntry.Actor == nil { break @@ -7082,6 +7235,69 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug(childComplexity), true + case "JobUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.Actor == nil { + break + } + + return e.ComplexityRoot.JobUpdatedActivityLogEntry.Actor(childComplexity), true + + case "JobUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.CreatedAt == nil { + break + } + + return e.ComplexityRoot.JobUpdatedActivityLogEntry.CreatedAt(childComplexity), true + + case "JobUpdatedActivityLogEntry.data": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.Data == nil { + break + } + + return e.ComplexityRoot.JobUpdatedActivityLogEntry.Data(childComplexity), true + + case "JobUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.EnvironmentName == nil { + break + } + + return e.ComplexityRoot.JobUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + + case "JobUpdatedActivityLogEntry.id": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.ID == nil { + break + } + + return e.ComplexityRoot.JobUpdatedActivityLogEntry.ID(childComplexity), true + + case "JobUpdatedActivityLogEntry.message": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.Message == nil { + break + } + + return e.ComplexityRoot.JobUpdatedActivityLogEntry.Message(childComplexity), true + + case "JobUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceName == nil { + break + } + + return e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceName(childComplexity), true + + case "JobUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceType == nil { + break + } + + return e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceType(childComplexity), true + + case "JobUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.TeamSlug == nil { + break + } + + return e.ComplexityRoot.JobUpdatedActivityLogEntry.TeamSlug(childComplexity), true + case "KafkaCredentials.accessCert": if e.ComplexityRoot.KafkaCredentials.AccessCert == nil { break @@ -18104,6 +18320,64 @@ type ApplicationScaledActivityLogEntryData { direction: ScalingDirection! } +type ApplicationCreatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the creation." + data: ApplyActivityLogEntryData! +} + +type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the update." + data: ApplyActivityLogEntryData! +} + extend enum ActivityLogActivityType { """ An application was deleted. @@ -18121,55 +18395,23 @@ extend enum ActivityLogActivityType { APPLICATION_SCALED } `, BuiltIn: false}, - {Name: "../schema/apply.graphqls", Input: `extend enum ActivityLogEntryResourceType { - "All activity log entries related to applying resources will use this resource type." - APPLY -} - -extend enum ActivityLogActivityType { - "A resource was applied (updated)." - RESOURCE_APPLIED + {Name: "../schema/apply.graphqls", Input: `extend enum ActivityLogActivityType { + "A resource was updated via apply." + RESOURCE_UPDATED "A resource was created via apply." RESOURCE_CREATED } """ -Activity log entry for a resource that was applied. -""" -type ApplyActivityLogEntry implements ActivityLogEntry & Node { - "Unique identifier of the activity log entry." - id: ID! - "The action that was performed." - action: String! - "The identity of the actor that performed the action." - actor: String! - "The time the action was performed." - createdAt: Time! - "A human-readable message describing the action." - message: String! - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! - "The name of the affected resource." - resourceName: String! - "The team that owns the affected resource." - teamSlug: Slug - "The environment the resource was applied in." - environmentName: String - - "Additional data about the apply operation." - data: ApplyActivityLogEntryData! -} - -""" -Additional data associated with an apply activity log entry. +Additional data associated with a resource created or updated via apply. """ type ApplyActivityLogEntryData { "The apiVersion of the applied resource." apiVersion: String! "The kind of the applied resource." kind: String! - "The fields that changed during the apply." + "The fields that changed during the apply. Only populated for updates." changedFields: [ApplyChangedField!]! } @@ -20672,6 +20914,64 @@ type JobRunDeletedActivityLogEntryData { runName: String! } +type JobCreatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the creation." + data: ApplyActivityLogEntryData! +} + +type JobUpdatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the update." + data: ApplyActivityLogEntryData! +} + extend enum ActivityLogActivityType { "Activity log entries related to job deletion." JOB_DELETED diff --git a/internal/graph/gengql/schema.generated.go b/internal/graph/gengql/schema.generated.go index 021b638a2..5ee061ef2 100644 --- a/internal/graph/gengql/schema.generated.go +++ b/internal/graph/gengql/schema.generated.go @@ -12,7 +12,6 @@ import ( "github.com/99designs/gqlgen/graphql" activitylog1 "github.com/nais/api/internal/activitylog" "github.com/nais/api/internal/alerts" - "github.com/nais/api/internal/apply" "github.com/nais/api/internal/auth/authz" "github.com/nais/api/internal/cost" "github.com/nais/api/internal/deployment" @@ -5967,6 +5966,13 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._KafkaTopic(ctx, sel, obj) + case job.JobUpdatedActivityLogEntry: + return ec._JobUpdatedActivityLogEntry(ctx, sel, &obj) + case *job.JobUpdatedActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._JobUpdatedActivityLogEntry(ctx, sel, obj) case job.JobTriggeredActivityLogEntry: return ec._JobTriggeredActivityLogEntry(ctx, sel, &obj) case *job.JobTriggeredActivityLogEntry: @@ -5988,6 +5994,13 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._JobDeletedActivityLogEntry(ctx, sel, obj) + case job.JobCreatedActivityLogEntry: + return ec._JobCreatedActivityLogEntry(ctx, sel, &obj) + case *job.JobCreatedActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._JobCreatedActivityLogEntry(ctx, sel, obj) case issue.InvalidSpecIssue: return ec._InvalidSpecIssue(ctx, sel, &obj) case *issue.InvalidSpecIssue: @@ -6093,13 +6106,13 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._BigQueryDataset(ctx, sel, obj) - case apply.ApplyActivityLogEntry: - return ec._ApplyActivityLogEntry(ctx, sel, &obj) - case *apply.ApplyActivityLogEntry: + case application.ApplicationUpdatedActivityLogEntry: + return ec._ApplicationUpdatedActivityLogEntry(ctx, sel, &obj) + case *application.ApplicationUpdatedActivityLogEntry: if obj == nil { return graphql.Null } - return ec._ApplyActivityLogEntry(ctx, sel, obj) + return ec._ApplicationUpdatedActivityLogEntry(ctx, sel, obj) case application.ApplicationScaledActivityLogEntry: return ec._ApplicationScaledActivityLogEntry(ctx, sel, &obj) case *application.ApplicationScaledActivityLogEntry: @@ -6121,6 +6134,13 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._ApplicationDeletedActivityLogEntry(ctx, sel, obj) + case application.ApplicationCreatedActivityLogEntry: + return ec._ApplicationCreatedActivityLogEntry(ctx, sel, &obj) + case *application.ApplicationCreatedActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._ApplicationCreatedActivityLogEntry(ctx, sel, obj) case vulnerability.WorkloadVulnerabilitySummary: return ec._WorkloadVulnerabilitySummary(ctx, sel, &obj) case *vulnerability.WorkloadVulnerabilitySummary: diff --git a/internal/graph/schema/applications.graphqls b/internal/graph/schema/applications.graphqls index e11ca7c28..099926d69 100644 --- a/internal/graph/schema/applications.graphqls +++ b/internal/graph/schema/applications.graphqls @@ -717,6 +717,64 @@ type ApplicationScaledActivityLogEntryData { direction: ScalingDirection! } +type ApplicationCreatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the creation." + data: ApplyActivityLogEntryData! +} + +type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the update." + data: ApplyActivityLogEntryData! +} + extend enum ActivityLogActivityType { """ An application was deleted. diff --git a/internal/graph/schema/apply.graphqls b/internal/graph/schema/apply.graphqls index 2147045db..6ac27a617 100644 --- a/internal/graph/schema/apply.graphqls +++ b/internal/graph/schema/apply.graphqls @@ -1,52 +1,20 @@ -extend enum ActivityLogEntryResourceType { - "All activity log entries related to applying resources will use this resource type." - APPLY -} - extend enum ActivityLogActivityType { - "A resource was applied (updated)." - RESOURCE_APPLIED + "A resource was updated via apply." + RESOURCE_UPDATED "A resource was created via apply." RESOURCE_CREATED } """ -Activity log entry for a resource that was applied. -""" -type ApplyActivityLogEntry implements ActivityLogEntry & Node { - "Unique identifier of the activity log entry." - id: ID! - "The action that was performed." - action: String! - "The identity of the actor that performed the action." - actor: String! - "The time the action was performed." - createdAt: Time! - "A human-readable message describing the action." - message: String! - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! - "The name of the affected resource." - resourceName: String! - "The team that owns the affected resource." - teamSlug: Slug - "The environment the resource was applied in." - environmentName: String - - "Additional data about the apply operation." - data: ApplyActivityLogEntryData! -} - -""" -Additional data associated with an apply activity log entry. +Additional data associated with a resource created or updated via apply. """ type ApplyActivityLogEntryData { "The apiVersion of the applied resource." apiVersion: String! "The kind of the applied resource." kind: String! - "The fields that changed during the apply." + "The fields that changed during the apply. Only populated for updates." changedFields: [ApplyChangedField!]! } diff --git a/internal/graph/schema/jobs.graphqls b/internal/graph/schema/jobs.graphqls index 519201c13..0244c6e85 100644 --- a/internal/graph/schema/jobs.graphqls +++ b/internal/graph/schema/jobs.graphqls @@ -512,6 +512,64 @@ type JobRunDeletedActivityLogEntryData { runName: String! } +type JobCreatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the creation." + data: ApplyActivityLogEntryData! +} + +type JobUpdatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the update." + data: ApplyActivityLogEntryData! +} + extend enum ActivityLogActivityType { "Activity log entries related to job deletion." JOB_DELETED diff --git a/internal/workload/application/activitylog.go b/internal/workload/application/activitylog.go index 40d19fb04..aa04fee40 100644 --- a/internal/workload/application/activitylog.go +++ b/internal/workload/application/activitylog.go @@ -4,18 +4,19 @@ import ( "fmt" "github.com/nais/api/internal/activitylog" + "github.com/nais/api/internal/apply" "github.com/nais/api/internal/deployment/deploymentactivity" ) const ( - activityLogEntryResourceTypeApplication activitylog.ActivityLogEntryResourceType = "APP" + ActivityLogEntryResourceTypeApplication activitylog.ActivityLogEntryResourceType = "APP" activityLogEntryActionRestartApplication activitylog.ActivityLogEntryAction = "RESTARTED" activityLogEntryActionAutoScaleApplication activitylog.ActivityLogEntryAction = "AUTOSCALE" ) func init() { - activitylog.RegisterTransformer(activityLogEntryResourceTypeApplication, func(entry activitylog.GenericActivityLogEntry) (activitylog.ActivityLogEntry, error) { + activitylog.RegisterTransformer(ActivityLogEntryResourceTypeApplication, func(entry activitylog.GenericActivityLogEntry) (activitylog.ActivityLogEntry, error) { switch entry.Action { case activityLogEntryActionRestartApplication: if entry.TeamSlug == nil { @@ -55,15 +56,35 @@ func init() { GenericActivityLogEntry: entry.WithMessage("Application deployed"), Data: data, }, nil + case activitylog.ActivityLogEntryActionCreated: + data, err := activitylog.UnmarshalData[apply.ApplyActivityLogEntryData](entry) + if err != nil { + return nil, fmt.Errorf("transforming application created activity log entry data: %w", err) + } + return ApplicationCreatedActivityLogEntry{ + GenericActivityLogEntry: entry.WithMessage(fmt.Sprintf("Application %s created", entry.ResourceName)), + Data: data, + }, nil + case activitylog.ActivityLogEntryActionUpdated: + data, err := activitylog.UnmarshalData[apply.ApplyActivityLogEntryData](entry) + if err != nil { + return nil, fmt.Errorf("transforming application updated activity log entry data: %w", err) + } + return ApplicationUpdatedActivityLogEntry{ + GenericActivityLogEntry: entry.WithMessage(fmt.Sprintf("Application %s updated", entry.ResourceName)), + Data: data, + }, nil default: return nil, fmt.Errorf("unsupported application activity log entry action: %q", entry.Action) } }) - activitylog.RegisterFilter("APPLICATION_DELETED", activitylog.ActivityLogEntryActionDeleted, activityLogEntryResourceTypeApplication) - activitylog.RegisterFilter("APPLICATION_RESTARTED", activityLogEntryActionRestartApplication, activityLogEntryResourceTypeApplication) - activitylog.RegisterFilter("APPLICATION_SCALED", activityLogEntryActionAutoScaleApplication, activityLogEntryResourceTypeApplication) - activitylog.RegisterFilter("DEPLOYMENT", deploymentactivity.ActivityLogEntryActionDeployment, activityLogEntryResourceTypeApplication) + activitylog.RegisterFilter("APPLICATION_DELETED", activitylog.ActivityLogEntryActionDeleted, ActivityLogEntryResourceTypeApplication) + activitylog.RegisterFilter("APPLICATION_RESTARTED", activityLogEntryActionRestartApplication, ActivityLogEntryResourceTypeApplication) + activitylog.RegisterFilter("APPLICATION_SCALED", activityLogEntryActionAutoScaleApplication, ActivityLogEntryResourceTypeApplication) + activitylog.RegisterFilter("DEPLOYMENT", deploymentactivity.ActivityLogEntryActionDeployment, ActivityLogEntryResourceTypeApplication) + activitylog.RegisterFilter("RESOURCE_CREATED", activitylog.ActivityLogEntryActionCreated, ActivityLogEntryResourceTypeApplication) + activitylog.RegisterFilter("RESOURCE_UPDATED", activitylog.ActivityLogEntryActionUpdated, ActivityLogEntryResourceTypeApplication) } type ApplicationRestartedActivityLogEntry struct { @@ -84,3 +105,15 @@ type ApplicationScaledActivityLogEntryData struct { NewSize int `json:"newSize,string"` Direction ScalingDirection `json:"direction"` } + +type ApplicationCreatedActivityLogEntry struct { + activitylog.GenericActivityLogEntry + + Data *apply.ApplyActivityLogEntryData `json:"data"` +} + +type ApplicationUpdatedActivityLogEntry struct { + activitylog.GenericActivityLogEntry + + Data *apply.ApplyActivityLogEntryData `json:"data"` +} diff --git a/internal/workload/application/queries.go b/internal/workload/application/queries.go index edf1f3607..2c14c9436 100644 --- a/internal/workload/application/queries.go +++ b/internal/workload/application/queries.go @@ -116,7 +116,7 @@ func Delete(ctx context.Context, teamSlug slug.Slug, environmentName, name strin if err := activitylog.Create(ctx, activitylog.CreateInput{ Action: activitylog.ActivityLogEntryActionDeleted, - ResourceType: activityLogEntryResourceTypeApplication, + ResourceType: ActivityLogEntryResourceTypeApplication, TeamSlug: &teamSlug, EnvironmentName: &environmentName, ResourceName: name, @@ -151,7 +151,7 @@ func Restart(ctx context.Context, teamSlug slug.Slug, environmentName, name stri return activitylog.Create(ctx, activitylog.CreateInput{ Action: activityLogEntryActionRestartApplication, - ResourceType: activityLogEntryResourceTypeApplication, + ResourceType: ActivityLogEntryResourceTypeApplication, TeamSlug: &teamSlug, EnvironmentName: &environmentName, ResourceName: name, diff --git a/internal/workload/job/activitylog.go b/internal/workload/job/activitylog.go index 3476eb1d3..4854bd60f 100644 --- a/internal/workload/job/activitylog.go +++ b/internal/workload/job/activitylog.go @@ -4,17 +4,18 @@ import ( "fmt" "github.com/nais/api/internal/activitylog" + "github.com/nais/api/internal/apply" "github.com/nais/api/internal/deployment/deploymentactivity" ) const ( - activityLogEntryResourceTypeJob activitylog.ActivityLogEntryResourceType = "JOB" + ActivityLogEntryResourceTypeJob activitylog.ActivityLogEntryResourceType = "JOB" activityLogEntryActionTriggerJob activitylog.ActivityLogEntryAction = "TRIGGER_JOB" activityLogEntryActionDeleteJobRun activitylog.ActivityLogEntryAction = "DELETE_JOB_RUN" ) func init() { - activitylog.RegisterTransformer(activityLogEntryResourceTypeJob, func(entry activitylog.GenericActivityLogEntry) (activitylog.ActivityLogEntry, error) { + activitylog.RegisterTransformer(ActivityLogEntryResourceTypeJob, func(entry activitylog.GenericActivityLogEntry) (activitylog.ActivityLogEntry, error) { switch entry.Action { case activityLogEntryActionTriggerJob: return JobTriggeredActivityLogEntry{ @@ -46,21 +47,41 @@ func init() { case deploymentactivity.ActivityLogEntryActionDeployment: data, err := activitylog.UnmarshalData[deploymentactivity.DeploymentActivityLogEntryData](entry) if err != nil { - return nil, fmt.Errorf("transforming job scaled activity log entry data: %w", err) + return nil, fmt.Errorf("transforming job deployment activity log entry data: %w", err) } return deploymentactivity.DeploymentActivityLogEntry{ GenericActivityLogEntry: entry.WithMessage("Job deployed"), Data: data, }, nil + case activitylog.ActivityLogEntryActionCreated: + data, err := activitylog.UnmarshalData[apply.ApplyActivityLogEntryData](entry) + if err != nil { + return nil, fmt.Errorf("transforming job created activity log entry data: %w", err) + } + return JobCreatedActivityLogEntry{ + GenericActivityLogEntry: entry.WithMessage(fmt.Sprintf("Job %s created", entry.ResourceName)), + Data: data, + }, nil + case activitylog.ActivityLogEntryActionUpdated: + data, err := activitylog.UnmarshalData[apply.ApplyActivityLogEntryData](entry) + if err != nil { + return nil, fmt.Errorf("transforming job updated activity log entry data: %w", err) + } + return JobUpdatedActivityLogEntry{ + GenericActivityLogEntry: entry.WithMessage(fmt.Sprintf("Job %s updated", entry.ResourceName)), + Data: data, + }, nil default: return nil, fmt.Errorf("unsupported job activity log entry action: %q", entry.Action) } }) - activitylog.RegisterFilter("JOB_DELETED", activitylog.ActivityLogEntryActionDeleted, activityLogEntryResourceTypeJob) - activitylog.RegisterFilter("JOB_RUN_DELETED", activityLogEntryActionDeleteJobRun, activityLogEntryResourceTypeJob) - activitylog.RegisterFilter("JOB_TRIGGERED", activityLogEntryActionTriggerJob, activityLogEntryResourceTypeJob) - activitylog.RegisterFilter("DEPLOYMENT", deploymentactivity.ActivityLogEntryActionDeployment, activityLogEntryResourceTypeJob) + activitylog.RegisterFilter("JOB_DELETED", activitylog.ActivityLogEntryActionDeleted, ActivityLogEntryResourceTypeJob) + activitylog.RegisterFilter("JOB_RUN_DELETED", activityLogEntryActionDeleteJobRun, ActivityLogEntryResourceTypeJob) + activitylog.RegisterFilter("JOB_TRIGGERED", activityLogEntryActionTriggerJob, ActivityLogEntryResourceTypeJob) + activitylog.RegisterFilter("DEPLOYMENT", deploymentactivity.ActivityLogEntryActionDeployment, ActivityLogEntryResourceTypeJob) + activitylog.RegisterFilter("RESOURCE_CREATED", activitylog.ActivityLogEntryActionCreated, ActivityLogEntryResourceTypeJob) + activitylog.RegisterFilter("RESOURCE_UPDATED", activitylog.ActivityLogEntryActionUpdated, ActivityLogEntryResourceTypeJob) } type JobTriggeredActivityLogEntry struct { @@ -79,3 +100,15 @@ type JobRunDeletedActivityLogEntry struct { activitylog.GenericActivityLogEntry Data *JobRunDeletedActivityLogEntryData } + +type JobCreatedActivityLogEntry struct { + activitylog.GenericActivityLogEntry + + Data *apply.ApplyActivityLogEntryData `json:"data"` +} + +type JobUpdatedActivityLogEntry struct { + activitylog.GenericActivityLogEntry + + Data *apply.ApplyActivityLogEntryData `json:"data"` +} diff --git a/internal/workload/job/queries.go b/internal/workload/job/queries.go index ba83a7acd..1093c3e52 100644 --- a/internal/workload/job/queries.go +++ b/internal/workload/job/queries.go @@ -170,7 +170,7 @@ func Delete(ctx context.Context, teamSlug slug.Slug, environmentName, name strin if err := activitylog.Create(ctx, activitylog.CreateInput{ Action: activitylog.ActivityLogEntryActionDeleted, Actor: authz.ActorFromContext(ctx).User, - ResourceType: activityLogEntryResourceTypeJob, + ResourceType: ActivityLogEntryResourceTypeJob, ResourceName: name, EnvironmentName: &environmentName, TeamSlug: &teamSlug, @@ -250,7 +250,7 @@ func Trigger(ctx context.Context, teamSlug slug.Slug, environmentName, name, run if err := activitylog.Create(ctx, activitylog.CreateInput{ Action: activityLogEntryActionTriggerJob, Actor: authz.ActorFromContext(ctx).User, - ResourceType: activityLogEntryResourceTypeJob, + ResourceType: ActivityLogEntryResourceTypeJob, ResourceName: name, EnvironmentName: &environmentName, TeamSlug: &teamSlug, From f4237b0d9ceadb317cd51d968f8ebadf2fc78fae Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Thu, 12 Mar 2026 11:58:45 +0100 Subject: [PATCH 05/25] Refactor apply activity log to support unknown resource types - Move resource activity log types to activitylog package - Add fallback transformer for unknown resource kinds - Unify changed field representation and string conversion - Update GraphQL schema and resolvers for new types - Require pre-shared key for team API in integration tests - Update apply endpoint to use path parameters for team and environment --- integration_tests/apply.lua | 134 +- integration_tests/teamapi.lua | 3 + internal/activitylog/queries.go | 5 +- internal/activitylog/resource.go | 105 + internal/apply/activitylog.go | 33 - internal/apply/apply.go | 122 +- internal/apply/diff.go | 76 +- internal/apply/diff_test.go | 47 +- internal/apply/model.go | 18 +- internal/graph/apply.resolvers.go | 34 - .../graph/gengql/activitylog.generated.go | 7 + .../graph/gengql/applications.generated.go | 20 +- internal/graph/gengql/apply.generated.go | 501 +- internal/graph/gengql/jobs.generated.go | 20 +- internal/graph/gengql/root_.generated.go | 9434 ++++++++--------- internal/graph/gengql/schema.generated.go | 17 +- internal/graph/schema/applications.graphqls | 4 +- internal/graph/schema/apply.graphqls | 39 +- internal/graph/schema/jobs.graphqls | 4 +- internal/integration/manager.go | 3 + internal/rest/rest.go | 7 +- internal/workload/application/activitylog.go | 10 +- internal/workload/job/activitylog.go | 10 +- 23 files changed, 4864 insertions(+), 5789 deletions(-) create mode 100644 internal/activitylog/resource.go delete mode 100644 internal/apply/activitylog.go delete mode 100644 internal/graph/apply.resolvers.go diff --git a/integration_tests/apply.lua b/integration_tests/apply.lua index ef60a7cfc..70ea15a1a 100644 --- a/integration_tests/apply.lua +++ b/integration_tests/apply.lua @@ -7,7 +7,7 @@ team:addMember(user) Test.rest("create application via apply", function(t) t.addHeader("x-user-email", user:email()) - t.send("POST", "/api/v1/apply?environment=dev", [[ + t.send("POST", "/api/v1/teams/apply-team/environments/dev/apply", [[ { "resources": [ { @@ -33,7 +33,6 @@ Test.rest("create application via apply", function(t) results = { { resource = "Application/my-app", - namespace = "apply-team", environment = "dev", status = "created", }, @@ -62,7 +61,7 @@ end) Test.rest("update application via apply", function(t) t.addHeader("x-user-email", user:email()) - t.send("POST", "/api/v1/apply?environment=dev", [[ + t.send("POST", "/api/v1/teams/apply-team/environments/dev/apply", [[ { "resources": [ { @@ -88,7 +87,6 @@ Test.rest("update application via apply", function(t) results = { { resource = "Application/my-app", - namespace = "apply-team", environment = "dev", status = "applied", changedFields = { @@ -99,13 +97,13 @@ Test.rest("update application via apply", function(t) }, { field = "spec.replicas.max", - oldValue = 2, - newValue = 4, + oldValue = "2", + newValue = "4", }, { field = "spec.replicas.min", - oldValue = 1, - newValue = 2, + oldValue = "1", + newValue = "2", }, }, }, @@ -134,7 +132,7 @@ end) Test.rest("disallowed resource kind returns 400", function(t) t.addHeader("x-user-email", user:email()) - t.send("POST", "/api/v1/apply?environment=dev", [[ + t.send("POST", "/api/v1/teams/apply-team/environments/dev/apply", [[ { "resources": [ { @@ -158,7 +156,7 @@ end) Test.rest("non-member gets authorization error", function(t) t.addHeader("x-user-email", nonMember:email()) - t.send("POST", "/api/v1/apply?environment=dev", [[ + t.send("POST", "/api/v1/teams/apply-team/environments/dev/apply", [[ { "resources": [ { @@ -176,11 +174,10 @@ Test.rest("non-member gets authorization error", function(t) } ]]) - t.check(207, { + t.check(200, { results = { { resource = "Application/sneaky-app", - namespace = "apply-team", environment = "dev", status = "error", error = Contains("authorization failed"), @@ -189,44 +186,10 @@ Test.rest("non-member gets authorization error", function(t) }) end) -Test.rest("missing environment parameter returns per-resource error", function(t) - t.addHeader("x-user-email", user:email()) - - t.send("POST", "/api/v1/apply", [[ - { - "resources": [ - { - "apiVersion": "nais.io/v1alpha1", - "kind": "Application", - "metadata": { - "name": "no-environment-app", - "namespace": "apply-team" - }, - "spec": { - "image": "example.com/app:v1" - } - } - ] - } - ]]) - - t.check(207, { - results = { - { - resource = "Application/no-environment-app", - namespace = "apply-team", - environment = "", - status = "error", - error = Contains("no environment specified"), - }, - }, - }) -end) - Test.rest("empty resources array returns 400", function(t) t.addHeader("x-user-email", user:email()) - t.send("POST", "/api/v1/apply?environment=dev", [[ + t.send("POST", "/api/v1/teams/apply-team/environments/dev/apply", [[ { "resources": [] } @@ -237,63 +200,10 @@ Test.rest("empty resources array returns 400", function(t) }) end) -Test.rest("environment annotation overrides query parameter", function(t) - t.addHeader("x-user-email", user:email()) - - t.send("POST", "/api/v1/apply?environment=dev", [[ - { - "resources": [ - { - "apiVersion": "nais.io/v1alpha1", - "kind": "Application", - "metadata": { - "name": "staging-app", - "namespace": "apply-team", - "annotations": { - "nais.io/environment": "staging" - } - }, - "spec": { - "image": "example.com/staging-app:v1" - } - } - ] - } - ]]) - - t.check(200, { - results = { - { - resource = "Application/staging-app", - namespace = "apply-team", - environment = "staging", - status = "created", - }, - }, - }) -end) - -Test.k8s("verify resource was created in staging environment via annotation", function(t) - t.check("nais.io/v1alpha1", "applications", "staging", "apply-team", "staging-app", { - apiVersion = "nais.io/v1alpha1", - kind = "Application", - metadata = { - name = "staging-app", - namespace = "apply-team", - annotations = { - ["nais.io/environment"] = "staging", - }, - }, - spec = { - image = "example.com/staging-app:v1", - }, - }) -end) - Test.rest("create naisjob via apply", function(t) t.addHeader("x-user-email", user:email()) - t.send("POST", "/api/v1/apply?environment=dev", [[ + t.send("POST", "/api/v1/teams/apply-team/environments/dev/apply", [[ { "resources": [ { @@ -316,7 +226,6 @@ Test.rest("create naisjob via apply", function(t) results = { { resource = "Naisjob/my-job", - namespace = "apply-team", environment = "dev", status = "created", }, @@ -325,7 +234,7 @@ Test.rest("create naisjob via apply", function(t) end) Test.rest("unauthenticated request returns 401", function(t) - t.send("POST", "/api/v1/apply?environment=dev", [[ + t.send("POST", "/api/v1/teams/apply-team/environments/dev/apply", [[ { "resources": [ { @@ -396,18 +305,6 @@ Test.gql("activity log contains ApplicationCreatedActivityLogEntry after apply", resourceName = "my-job", environmentName = "dev", }, - { - __typename = "ApplicationCreatedActivityLogEntry", - message = "Application staging-app created", - actor = user:email(), - resourceType = "APP", - resourceName = "staging-app", - environmentName = "staging", - data = { - apiVersion = "nais.io/v1alpha1", - kind = "Application", - }, - }, { __typename = "ApplicationCreatedActivityLogEntry", message = "Application my-app created", @@ -536,7 +433,6 @@ Test.gql("activity log contains JobCreatedActivityLogEntry after apply", functio )) -- RESOURCE_CREATED is registered for both JOB and APP, so application entries appear too. - -- We only assert on the first node which is the most-recently created job. t.check({ data = { team = { @@ -552,12 +448,6 @@ Test.gql("activity log contains JobCreatedActivityLogEntry after apply", functio kind = "Naisjob", }, }, - { - __typename = "ApplicationCreatedActivityLogEntry", - resourceType = "APP", - resourceName = "staging-app", - environmentName = "staging", - }, { __typename = "ApplicationCreatedActivityLogEntry", resourceType = "APP", diff --git a/integration_tests/teamapi.lua b/integration_tests/teamapi.lua index c06060269..a60d6fe55 100644 --- a/integration_tests/teamapi.lua +++ b/integration_tests/teamapi.lua @@ -14,6 +14,7 @@ otherTeam:addOwner(not_a_member) Test.rest("list team members", function(t) + t.addHeader("Authorization", "Bearer test-pre-shared-key") t.send("GET", string.format("/teams/%s", teamName)) t.check(200, { member = { @@ -24,6 +25,7 @@ Test.rest("list team members", function(t) end) Test.rest("list unknown team", function(t) + t.addHeader("Authorization", "Bearer test-pre-shared-key") t.send("GET", "/teams/no-such-team") t.check(404, { errorMessage = "team not found", @@ -33,6 +35,7 @@ end) Test.rest("invalid team slug", function(t) + t.addHeader("Authorization", "Bearer test-pre-shared-key") t.send("GET", "/teams/invalid-ø-slug") t.check(400, { errorMessage = "A team slug must match the following pattern: \"^[a-z](-?[a-z0-9]+)+$\".", diff --git a/internal/activitylog/queries.go b/internal/activitylog/queries.go index 7bfc33618..cfbfdd13e 100644 --- a/internal/activitylog/queries.go +++ b/internal/activitylog/queries.go @@ -163,7 +163,10 @@ func toGraphActivityLogEntry(row *activitylogsql.ActivityLogCombinedView) (Activ transformer, ok := knownTransformers[ActivityLogEntryResourceType(row.ResourceType)] if !ok { - return nil, fmt.Errorf("no transformer registered for activity log resource type: %q", row.ResourceType) + if fallbackTransformer == nil { + return nil, fmt.Errorf("no transformer registered for activity log resource type: %q", row.ResourceType) + } + return fallbackTransformer(entry) } return transformer(entry) diff --git a/internal/activitylog/resource.go b/internal/activitylog/resource.go new file mode 100644 index 000000000..88f6f2d13 --- /dev/null +++ b/internal/activitylog/resource.go @@ -0,0 +1,105 @@ +package activitylog + +import ( + "fmt" + "sync" +) + +var ( + kindResourceTypes = map[string]ActivityLogEntryResourceType{} + kindResourceTypesMu sync.RWMutex +) + +// RegisterKindResourceType registers a mapping from a Kubernetes kind string +// (e.g. "Application") to an ActivityLogEntryResourceType (e.g. "APP"). +// Domain packages call this in their init() so that the apply handler can +// resolve the correct resource type without importing the domain package. +// Panics if the same kind is registered twice. +func RegisterKindResourceType(kind string, resourceType ActivityLogEntryResourceType) { + kindResourceTypesMu.Lock() + defer kindResourceTypesMu.Unlock() + if _, ok := kindResourceTypes[kind]; ok { + panic("kind resource type already registered: " + kind) + } + kindResourceTypes[kind] = resourceType +} + +// ResourceTypeForKind returns the ActivityLogEntryResourceType for the given +// Kubernetes kind, falling back to the kind itself (uppercased) if no mapping +// has been registered. The bool is false only when the kind is empty. +func ResourceTypeForKind(kind string) (ActivityLogEntryResourceType, bool) { + if kind == "" { + return "", false + } + kindResourceTypesMu.RLock() + rt, ok := kindResourceTypes[kind] + kindResourceTypesMu.RUnlock() + if ok { + return rt, true + } + // Unknown kind — use the kind string itself as the resource type so that + // the fallback transformer can handle it. + return ActivityLogEntryResourceType(kind), true +} + +// ResourceChangedField represents a single field that changed during a resource apply operation. +type ResourceChangedField struct { + // Field is the dot-separated path to the changed field, e.g. "spec.replicas". + Field string `json:"field"` + + // OldValue is the string representation of the value before the apply. Nil if the field was added. + OldValue *string `json:"oldValue,omitempty"` + + // NewValue is the string representation of the value after the apply. Nil if the field was removed. + NewValue *string `json:"newValue,omitempty"` +} + +// ResourceActivityLogEntryData contains the additional data stored with a resource +// created or updated via apply. +type ResourceActivityLogEntryData struct { + // APIVersion is the apiVersion of the applied resource. + APIVersion string `json:"apiVersion"` + + // Kind is the kind of the applied resource. + Kind string `json:"kind"` + + // ChangedFields lists the fields that changed during the apply. + // Only populated for updates. + ChangedFields []ResourceChangedField `json:"changedFields"` +} + +// UnsupportedResourceActivityLogEntry is used for resource types that do not have +// a dedicated transformer registered — i.e. kinds that are not modelled in the +// GraphQL API. The uppercase Kind string is used directly as the resource type. +type UnsupportedResourceActivityLogEntry struct { + GenericActivityLogEntry + + Data *ResourceActivityLogEntryData `json:"data"` +} + +var fallbackTransformer Transformer + +// RegisterFallbackTransformer registers a transformer that is called when no +// specific transformer has been registered for a resource type. Only one fallback +// may be registered; a second call panics. +func RegisterFallbackTransformer(t Transformer) { + if fallbackTransformer != nil { + panic("fallback transformer already registered") + } + fallbackTransformer = t +} + +func init() { + RegisterFallbackTransformer(func(entry GenericActivityLogEntry) (ActivityLogEntry, error) { + data, err := UnmarshalData[ResourceActivityLogEntryData](entry) + if err != nil { + return nil, fmt.Errorf("transforming unsupported resource activity log entry data: %w", err) + } + return UnsupportedResourceActivityLogEntry{ + GenericActivityLogEntry: entry.WithMessage( + fmt.Sprintf("%s %s %s", entry.ResourceName, entry.Action, entry.ResourceType), + ), + Data: data, + }, nil + }) +} diff --git a/internal/apply/activitylog.go b/internal/apply/activitylog.go deleted file mode 100644 index e60e58b1f..000000000 --- a/internal/apply/activitylog.go +++ /dev/null @@ -1,33 +0,0 @@ -package apply - -import ( - "github.com/nais/api/internal/activitylog" -) - -// ResourceTypeForKind returns the ActivityLogEntryResourceType for the given -// Kubernetes kind, so apply entries are stored under the correct resource type -// rather than a generic APPLY type. -func ResourceTypeForKind(kind string) (activitylog.ActivityLogEntryResourceType, bool) { - switch kind { - case "Application": - return "APP", true - case "Naisjob": - return "JOB", true - default: - return "", false - } -} - -// ApplyActivityLogEntryData contains the additional data stored with a resource -// created or updated via apply. -type ApplyActivityLogEntryData struct { - // APIVersion is the apiVersion of the applied resource. - APIVersion string `json:"apiVersion"` - - // Kind is the kind of the applied resource. - Kind string `json:"kind"` - - // ChangedFields lists the fields that changed during the apply. - // Only populated for updates. - ChangedFields []FieldChange `json:"changedFields"` -} diff --git a/internal/apply/apply.go b/internal/apply/apply.go index 048ff6531..79de49654 100644 --- a/internal/apply/apply.go +++ b/internal/apply/apply.go @@ -37,17 +37,17 @@ func NewImpersonatingClientFactory(clusterConfigs kubernetes.ClusterConfigMap) D // to Kubernetes environments via server-side apply, diffs the results, and // writes activity log entries. // +// The team slug and environment are read from URL path parameters. // The clusterConfigs map is used to validate that an environment name exists. // The clientFactory is used to create dynamic Kubernetes clients per environment. func Handler(clusterConfigs kubernetes.ClusterConfigMap, clientFactory DynamicClientFactory, log logrus.FieldLogger) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { ctx := r.Context() + teamSlug := slug.Slug(r.PathValue("teamSlug")) + environment := r.PathValue("environment") + actor := authz.ActorFromContext(ctx) - if actor == nil { - writeError(w, http.StatusUnauthorized, "unauthorized") - return - } // Read and parse request body. body, err := io.ReadAll(io.LimitReader(r.Body, maxBodySize+1)) @@ -71,10 +71,7 @@ func Handler(clusterConfigs kubernetes.ClusterConfigMap, clientFactory DynamicCl return } - environmentParam := r.URL.Query().Get("environment") - // Phase 1: Validate all resources before applying any. - // Check that all resources are allowed kinds and have valid environment targets. var disallowed []string for i, res := range req.Resources { apiVersion := res.GetAPIVersion() @@ -84,49 +81,29 @@ func Handler(clusterConfigs kubernetes.ClusterConfigMap, clientFactory DynamicCl } } if len(disallowed) > 0 { - allowed := AllowedKinds() - allowedStrs := make([]string, len(allowed)) - for i, a := range allowed { - allowedStrs[i] = a.APIVersion + "/" + a.Kind - } - writeError(w, http.StatusBadRequest, fmt.Sprintf( - "disallowed resource types: %s. Allowed types: %s", - strings.Join(disallowed, "; "), - strings.Join(allowedStrs, ", "), - )) + writeError(w, http.StatusBadRequest, fmt.Sprintf("disallowed resource types: %s", strings.Join(disallowed, "; "))) return } // Phase 2: Apply each resource, collecting results. results := make([]ResourceResult, 0, len(req.Resources)) - hasErrors := false for _, res := range req.Resources { - result := applyOne(ctx, clusterConfigs, clientFactory, environmentParam, &res, actor, log) - if result.Status == StatusError { - hasErrors = true - } + result := applyOne(ctx, clusterConfigs, clientFactory, teamSlug, environment, &res, actor, log) results = append(results, result) } - resp := Response{Results: results} - - // Determine HTTP status code. - statusCode := http.StatusOK - if hasErrors { - statusCode = http.StatusMultiStatus - } - - writeJSON(w, statusCode, resp) + writeJSON(w, http.StatusOK, Response{Results: results}) } } -// applyOne processes a single resource: resolves environment, authorizes, applies, diffs, and logs. +// applyOne processes a single resource: authorizes, applies, diffs, and logs. func applyOne( ctx context.Context, clusterConfigs kubernetes.ClusterConfigMap, clientFactory DynamicClientFactory, - environmentParam string, + teamSlug slug.Slug, + environment string, res *unstructured.Unstructured, actor *authz.Actor, log logrus.FieldLogger, @@ -134,62 +111,39 @@ func applyOne( apiVersion := res.GetAPIVersion() kind := res.GetKind() name := res.GetName() - namespace := res.GetNamespace() resourceID := kind + "/" + name - // Resolve environment: annotation takes precedence over query parameter. - environment := environmentParam - if ann := res.GetAnnotations(); ann != nil { - if e, ok := ann["nais.io/environment"]; ok && e != "" { - environment = e - } - } - - if environment == "" { - return ResourceResult{ - Resource: resourceID, - Namespace: namespace, - Status: StatusError, - Error: "no environment specified (use ?environment= query parameter or nais.io/environment annotation)", - } - } + log = log.WithFields(logrus.Fields{ + "environment": environment, + "team": teamSlug, + "name": name, + "kind": kind, + }) // Validate environment exists. if _, ok := clusterConfigs[environment]; !ok { return ResourceResult{ Resource: resourceID, - Namespace: namespace, Environment: environment, Status: StatusError, Error: fmt.Sprintf("unknown environment: %q", environment), } } - // Validate resource has name and namespace. + // Validate resource has a name. if name == "" { return ResourceResult{ Resource: resourceID, - Namespace: namespace, Environment: environment, Status: StatusError, Error: "resource must have metadata.name", } } - if namespace == "" { - return ResourceResult{ - Resource: resourceID, - Environment: environment, - Status: StatusError, - Error: "resource must have metadata.namespace", - } - } - // Authorize: derive team slug from namespace. - teamSlug := slug.Slug(namespace) + // Authorize the actor for this team and kind. if err := authorizeResource(ctx, kind, teamSlug); err != nil { return ResourceResult{ Resource: resourceID, - Namespace: namespace, Environment: environment, Status: StatusError, Error: fmt.Sprintf("authorization failed: %s", err), @@ -201,20 +155,21 @@ func applyOne( if !ok { return ResourceResult{ Resource: resourceID, - Namespace: namespace, Environment: environment, Status: StatusError, Error: fmt.Sprintf("no GVR mapping for %s/%s", apiVersion, kind), } } + // Force the namespace to match the team slug from the URL. + res.SetNamespace(string(teamSlug)) + // Create dynamic client for environment. client, err := clientFactory(ctx, environment) if err != nil { - log.WithError(err).WithField("environment", environment).Error("creating dynamic client") + log.WithError(err).Error("creating dynamic client") return ResourceResult{ Resource: resourceID, - Namespace: namespace, Environment: environment, Status: StatusError, Error: fmt.Sprintf("failed to create client for environment %q: %s", environment, err), @@ -224,15 +179,9 @@ func applyOne( // Apply the resource. applyResult, err := ApplyResource(ctx, client, gvr, res) if err != nil { - log.WithError(err).WithFields(logrus.Fields{ - "environment": environment, - "namespace": namespace, - "name": name, - "kind": kind, - }).Error("applying resource") + log.WithError(err).Error("applying resource") return ResourceResult{ Resource: resourceID, - Namespace: namespace, Environment: environment, Status: StatusError, Error: fmt.Sprintf("apply failed: %s", err), @@ -240,7 +189,7 @@ func applyOne( } // Diff before and after. - var changes []FieldChange + var changes []activitylog.ResourceChangedField status := StatusCreated if !applyResult.Created { status = StatusApplied @@ -253,39 +202,26 @@ func applyOne( action = activitylog.ActivityLogEntryActionUpdated } - resourceType, ok := ResourceTypeForKind(kind) - if !ok { - log.WithFields(logrus.Fields{ - "environment": environment, - "namespace": namespace, - "name": name, - "kind": kind, - }).Warn("no activity log resource type for kind, skipping activity log entry") - } else if err := activitylog.Create(ctx, activitylog.CreateInput{ + resourceType, _ := activitylog.ResourceTypeForKind(kind) + if err := activitylog.Create(ctx, activitylog.CreateInput{ Action: action, Actor: actor.User, ResourceType: resourceType, ResourceName: name, TeamSlug: &teamSlug, EnvironmentName: &environment, - Data: ApplyActivityLogEntryData{ + Data: activitylog.ResourceActivityLogEntryData{ APIVersion: apiVersion, Kind: kind, ChangedFields: changes, }, }); err != nil { - log.WithError(err).WithFields(logrus.Fields{ - "environment": environment, - "namespace": namespace, - "name": name, - "kind": kind, - }).Error("creating activity log entry") + log.WithError(err).Error("creating activity log entry") // Don't fail the apply because of a logging error. } return ResourceResult{ Resource: resourceID, - Namespace: namespace, Environment: environment, Status: status, ChangedFields: changes, @@ -293,7 +229,7 @@ func applyOne( } // authorizeResource checks if the current actor is authorized to apply the given kind -// to the team derived from the resource namespace. +// to the team from the URL. func authorizeResource(ctx context.Context, kind string, teamSlug slug.Slug) error { switch kind { case "Application": diff --git a/internal/apply/diff.go b/internal/apply/diff.go index 60deb774d..364f6d66c 100644 --- a/internal/apply/diff.go +++ b/internal/apply/diff.go @@ -2,25 +2,13 @@ package apply import ( "fmt" - "reflect" "slices" "strings" + "github.com/nais/api/internal/activitylog" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" ) -// FieldChange represents a single field that changed between the before and after states. -type FieldChange struct { - // Field is the dot-separated path to the changed field, e.g. "spec.replicas". - Field string `json:"field"` - - // OldValue is the value before the apply. Nil if the field was added. - OldValue any `json:"oldValue,omitempty"` - - // NewValue is the value after the apply. Nil if the field was removed. - NewValue any `json:"newValue,omitempty"` -} - // ignoredTopLevelFields are fields managed by the Kubernetes API server that // should be excluded from diffs as they are not user-controlled. var ignoredTopLevelFields = map[string]bool{ @@ -43,7 +31,7 @@ var ignoredMetadataFields = map[string]bool{ // If before is nil, all fields in after are considered "added". // If after is nil, all fields in before are considered "removed". // Server-managed fields (status, metadata.resourceVersion, etc.) are excluded. -func Diff(before, after *unstructured.Unstructured) []FieldChange { +func Diff(before, after *unstructured.Unstructured) []activitylog.ResourceChangedField { var beforeMap, afterMap map[string]any if before != nil { @@ -56,7 +44,7 @@ func Diff(before, after *unstructured.Unstructured) []FieldChange { changes := diffMaps(beforeMap, afterMap, "") // Sort for deterministic output - slices.SortFunc(changes, func(a, b FieldChange) int { + slices.SortFunc(changes, func(a, b activitylog.ResourceChangedField) int { return strings.Compare(a.Field, b.Field) }) @@ -64,8 +52,8 @@ func Diff(before, after *unstructured.Unstructured) []FieldChange { } // diffMaps recursively compares two maps and collects field changes. -func diffMaps(before, after map[string]any, prefix string) []FieldChange { - var changes []FieldChange +func diffMaps(before, after map[string]any, prefix string) []activitylog.ResourceChangedField { + var changes []activitylog.ResourceChangedField // Collect all keys from both maps allKeys := map[string]struct{}{} @@ -103,7 +91,7 @@ func diffMaps(before, after map[string]any, prefix string) []FieldChange { } // diffValues compares two values at a given path and returns changes. -func diffValues(path string, oldVal, newVal any) []FieldChange { +func diffValues(path string, oldVal, newVal any) []activitylog.ResourceChangedField { // If both are maps, recurse oldMap, oldIsMap := toMap(oldVal) newMap, newIsMap := toMap(newVal) @@ -119,11 +107,13 @@ func diffValues(path string, oldVal, newVal any) []FieldChange { } // Scalar comparison - if !reflect.DeepEqual(oldVal, newVal) { - return []FieldChange{{ + oldStr := stringify(oldVal) + newStr := stringify(newVal) + if oldStr != newStr { + return []activitylog.ResourceChangedField{{ Field: path, - OldValue: oldVal, - NewValue: newVal, + OldValue: &oldStr, + NewValue: &newStr, }} } @@ -132,8 +122,8 @@ func diffValues(path string, oldVal, newVal any) []FieldChange { // diffSlices compares two slices. If elements are maps, it compares element-by-element. // Otherwise it compares the slices as a whole. -func diffSlices(path string, oldSlice, newSlice []any) []FieldChange { - var changes []FieldChange +func diffSlices(path string, oldSlice, newSlice []any) []activitylog.ResourceChangedField { + var changes []activitylog.ResourceChangedField maxLen := max(len(oldSlice), len(newSlice)) for i := range maxLen { @@ -153,58 +143,64 @@ func diffSlices(path string, oldSlice, newSlice []any) []FieldChange { } // flattenAdded returns FieldChanges for a newly added value (possibly nested). -func flattenAdded(path string, val any) []FieldChange { +func flattenAdded(path string, val any) []activitylog.ResourceChangedField { if m, ok := toMap(val); ok { - var changes []FieldChange + var changes []activitylog.ResourceChangedField for k, v := range m { changes = append(changes, flattenAdded(joinPath(path, k), v)...) } if len(changes) == 0 { // Empty map added - return []FieldChange{{Field: path, NewValue: val}} + s := stringify(val) + return []activitylog.ResourceChangedField{{Field: path, NewValue: &s}} } return changes } if s, ok := toSlice(val); ok { - var changes []FieldChange + var changes []activitylog.ResourceChangedField for i, v := range s { changes = append(changes, flattenAdded(fmt.Sprintf("%s[%d]", path, i), v)...) } if len(changes) == 0 { - return []FieldChange{{Field: path, NewValue: val}} + s := stringify(val) + return []activitylog.ResourceChangedField{{Field: path, NewValue: &s}} } return changes } - return []FieldChange{{Field: path, NewValue: val}} + s := stringify(val) + return []activitylog.ResourceChangedField{{Field: path, NewValue: &s}} } // flattenRemoved returns FieldChanges for a removed value (possibly nested). -func flattenRemoved(path string, val any) []FieldChange { +func flattenRemoved(path string, val any) []activitylog.ResourceChangedField { if m, ok := toMap(val); ok { - var changes []FieldChange + var changes []activitylog.ResourceChangedField for k, v := range m { changes = append(changes, flattenRemoved(joinPath(path, k), v)...) } if len(changes) == 0 { - return []FieldChange{{Field: path, OldValue: val}} + s := stringify(val) + return []activitylog.ResourceChangedField{{Field: path, OldValue: &s}} } return changes } if s, ok := toSlice(val); ok { - var changes []FieldChange + var changes []activitylog.ResourceChangedField for i, v := range s { changes = append(changes, flattenRemoved(fmt.Sprintf("%s[%d]", path, i), v)...) } if len(changes) == 0 { - return []FieldChange{{Field: path, OldValue: val}} + s := stringify(val) + return []activitylog.ResourceChangedField{{Field: path, OldValue: &s}} } return changes } - return []FieldChange{{Field: path, OldValue: val}} + s := stringify(val) + return []activitylog.ResourceChangedField{{Field: path, OldValue: &s}} } // shouldIgnoreField returns true if the field should be excluded from the diff. @@ -239,3 +235,11 @@ func toSlice(val any) ([]any, bool) { s, ok := val.([]any) return s, ok } + +// stringify converts any value to its string representation. +func stringify(v any) string { + if v == nil { + return "" + } + return fmt.Sprintf("%v", v) +} diff --git a/internal/apply/diff_test.go b/internal/apply/diff_test.go index 5c373611a..9fd0ca184 100644 --- a/internal/apply/diff_test.go +++ b/internal/apply/diff_test.go @@ -1,8 +1,10 @@ package apply import ( + "fmt" "testing" + "github.com/nais/api/internal/activitylog" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" ) @@ -162,8 +164,8 @@ func TestDiff_FieldAdded(t *testing.T) { if c.OldValue != nil { t.Errorf("expected OldValue to be nil, got %v", c.OldValue) } - if c.NewValue != int64(2) { - t.Errorf("expected NewValue to be 2, got %v", c.NewValue) + if c.NewValue == nil || *c.NewValue != "2" { + t.Errorf("expected NewValue to be %q, got %v", "2", c.NewValue) } } @@ -193,8 +195,8 @@ func TestDiff_FieldRemoved(t *testing.T) { } c := fieldMap["spec.replicas"] - if c.OldValue != int64(2) { - t.Errorf("expected OldValue to be 2, got %v", c.OldValue) + if c.OldValue == nil || *c.OldValue != "2" { + t.Errorf("expected OldValue to be %q, got %v", "2", c.OldValue) } if c.NewValue != nil { t.Errorf("expected NewValue to be nil, got %v", c.NewValue) @@ -335,8 +337,8 @@ func TestDiff_SliceElementAdded(t *testing.T) { if c.OldValue != nil { t.Errorf("expected OldValue to be nil, got %v", c.OldValue) } - if c.NewValue != "https://two.example.com" { - t.Errorf("expected NewValue to be 'https://two.example.com', got %v", c.NewValue) + if c.NewValue == nil || *c.NewValue != "https://two.example.com" { + t.Errorf("expected NewValue to be %q, got %v", "https://two.example.com", c.NewValue) } } @@ -370,8 +372,8 @@ func TestDiff_SliceElementRemoved(t *testing.T) { } c := fieldMap["spec.ingresses[1]"] - if c.OldValue != "https://two.example.com" { - t.Errorf("expected OldValue to be 'https://two.example.com', got %v", c.OldValue) + if c.OldValue == nil || *c.OldValue != "https://two.example.com" { + t.Errorf("expected OldValue to be %q, got %v", "https://two.example.com", c.OldValue) } if c.NewValue != nil { t.Errorf("expected NewValue to be nil, got %v", c.NewValue) @@ -761,22 +763,22 @@ func TestDiff_EmptySliceToPopulatedSlice(t *testing.T) { // --- Test helpers --- -func toFieldMap(changes []FieldChange) map[string]FieldChange { - m := make(map[string]FieldChange, len(changes)) +func toFieldMap(changes []activitylog.ResourceChangedField) map[string]activitylog.ResourceChangedField { + m := make(map[string]activitylog.ResourceChangedField, len(changes)) for _, c := range changes { m[c.Field] = c } return m } -func assertFieldExists(t *testing.T, fieldMap map[string]FieldChange, field string) { +func assertFieldExists(t *testing.T, fieldMap map[string]activitylog.ResourceChangedField, field string) { t.Helper() if _, ok := fieldMap[field]; !ok { t.Errorf("expected field %q to be present in changes, but it was not. Fields present: %v", field, fieldMapKeys(fieldMap)) } } -func assertFieldChange(t *testing.T, fieldMap map[string]FieldChange, field string, expectedOld, expectedNew any) { +func assertFieldChange(t *testing.T, fieldMap map[string]activitylog.ResourceChangedField, field string, expectedOld, expectedNew any) { t.Helper() c, ok := fieldMap[field] if !ok { @@ -784,15 +786,26 @@ func assertFieldChange(t *testing.T, fieldMap map[string]FieldChange, field stri return } - if c.OldValue != expectedOld { - t.Errorf("field %q: expected OldValue %v (%T), got %v (%T)", field, expectedOld, expectedOld, c.OldValue, c.OldValue) + wantOld := fmt.Sprintf("%v", expectedOld) + wantNew := fmt.Sprintf("%v", expectedNew) + + if c.OldValue == nil || *c.OldValue != wantOld { + got := "" + if c.OldValue != nil { + got = *c.OldValue + } + t.Errorf("field %q: expected OldValue %q, got %q", field, wantOld, got) } - if c.NewValue != expectedNew { - t.Errorf("field %q: expected NewValue %v (%T), got %v (%T)", field, expectedNew, expectedNew, c.NewValue, c.NewValue) + if c.NewValue == nil || *c.NewValue != wantNew { + got := "" + if c.NewValue != nil { + got = *c.NewValue + } + t.Errorf("field %q: expected NewValue %q, got %q", field, wantNew, got) } } -func fieldMapKeys(m map[string]FieldChange) []string { +func fieldMapKeys(m map[string]activitylog.ResourceChangedField) []string { keys := make([]string, 0, len(m)) for k := range m { keys = append(keys, k) diff --git a/internal/apply/model.go b/internal/apply/model.go index 1445bb3ce..8047fbe63 100644 --- a/internal/apply/model.go +++ b/internal/apply/model.go @@ -1,5 +1,7 @@ package apply +import "github.com/nais/api/internal/activitylog" + // Response is the top-level response returned by the apply endpoint. type Response struct { Results []ResourceResult `json:"results"` @@ -10,9 +12,6 @@ type ResourceResult struct { // Resource is a human-readable identifier for the resource, e.g. "Application/my-app". Resource string `json:"resource"` - // Namespace is the target namespace (== team slug) of the resource. - Namespace string `json:"namespace"` - // Environment is the target environment the resource was applied to. Environment string `json:"environment"` @@ -21,7 +20,7 @@ type ResourceResult struct { // ChangedFields lists the fields that were changed during the apply. // Only populated when Status is "applied" (i.e. an update, not a create). - ChangedFields []FieldChange `json:"changedFields,omitempty"` + ChangedFields []activitylog.ResourceChangedField `json:"changedFields,omitempty"` // Error contains the error message if Status is "error". Error string `json:"error,omitempty"` @@ -32,14 +31,3 @@ const ( StatusApplied = "applied" StatusError = "error" ) - -// ApplyChangedField is the GraphQL model for a single field that changed during an apply operation. -// This is the canonical type used by both the resolver and the GraphQL schema. -type ApplyChangedField struct { - // Field is the dot-separated path to the changed field, e.g. "spec.replicas". - Field string `json:"field"` - // OldValue is the value before the apply. Nil if the field was added. - OldValue *string `json:"oldValue,omitempty"` - // NewValue is the value after the apply. Nil if the field was removed. - NewValue *string `json:"newValue,omitempty"` -} diff --git a/internal/graph/apply.resolvers.go b/internal/graph/apply.resolvers.go deleted file mode 100644 index b691859e3..000000000 --- a/internal/graph/apply.resolvers.go +++ /dev/null @@ -1,34 +0,0 @@ -package graph - -import ( - "context" - "fmt" - - "github.com/nais/api/internal/apply" - "github.com/nais/api/internal/graph/gengql" -) - -func (r *applyActivityLogEntryDataResolver) ChangedFields(ctx context.Context, obj *apply.ApplyActivityLogEntryData) ([]*apply.ApplyChangedField, error) { - out := make([]*apply.ApplyChangedField, len(obj.ChangedFields)) - for i, c := range obj.ChangedFields { - field := &apply.ApplyChangedField{ - Field: c.Field, - } - if c.OldValue != nil { - s := fmt.Sprintf("%v", c.OldValue) - field.OldValue = &s - } - if c.NewValue != nil { - s := fmt.Sprintf("%v", c.NewValue) - field.NewValue = &s - } - out[i] = field - } - return out, nil -} - -func (r *Resolver) ApplyActivityLogEntryData() gengql.ApplyActivityLogEntryDataResolver { - return &applyActivityLogEntryDataResolver{r} -} - -type applyActivityLogEntryDataResolver struct{ *Resolver } diff --git a/internal/graph/gengql/activitylog.generated.go b/internal/graph/gengql/activitylog.generated.go index c1893e9bc..d8adbed27 100644 --- a/internal/graph/gengql/activitylog.generated.go +++ b/internal/graph/gengql/activitylog.generated.go @@ -280,6 +280,13 @@ func (ec *executionContext) _ActivityLogEntry(ctx context.Context, sel ast.Selec return graphql.Null } return ec._ValkeyCreatedActivityLogEntry(ctx, sel, obj) + case activitylog.UnsupportedResourceActivityLogEntry: + return ec._UnsupportedResourceActivityLogEntry(ctx, sel, &obj) + case *activitylog.UnsupportedResourceActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._UnsupportedResourceActivityLogEntry(ctx, sel, obj) case unleash.UnleashInstanceUpdatedActivityLogEntry: return ec._UnleashInstanceUpdatedActivityLogEntry(ctx, sel, &obj) case *unleash.UnleashInstanceUpdatedActivityLogEntry: diff --git a/internal/graph/gengql/applications.generated.go b/internal/graph/gengql/applications.generated.go index 4ca05349f..c070ed0c9 100644 --- a/internal/graph/gengql/applications.generated.go +++ b/internal/graph/gengql/applications.generated.go @@ -2234,7 +2234,7 @@ func (ec *executionContext) _ApplicationCreatedActivityLogEntry_data(ctx context return obj.Data, nil }, nil, - ec.marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyActivityLogEntryData, + ec.marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData, true, true, ) @@ -2249,13 +2249,13 @@ func (ec *executionContext) fieldContext_ApplicationCreatedActivityLogEntry_data Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "apiVersion": - return ec.fieldContext_ApplyActivityLogEntryData_apiVersion(ctx, field) + return ec.fieldContext_ResourceActivityLogEntryData_apiVersion(ctx, field) case "kind": - return ec.fieldContext_ApplyActivityLogEntryData_kind(ctx, field) + return ec.fieldContext_ResourceActivityLogEntryData_kind(ctx, field) case "changedFields": - return ec.fieldContext_ApplyActivityLogEntryData_changedFields(ctx, field) + return ec.fieldContext_ResourceActivityLogEntryData_changedFields(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type ApplyActivityLogEntryData", field.Name) + return nil, fmt.Errorf("no field named %q was found under type ResourceActivityLogEntryData", field.Name) }, } return fc, nil @@ -4137,7 +4137,7 @@ func (ec *executionContext) _ApplicationUpdatedActivityLogEntry_data(ctx context return obj.Data, nil }, nil, - ec.marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyActivityLogEntryData, + ec.marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData, true, true, ) @@ -4152,13 +4152,13 @@ func (ec *executionContext) fieldContext_ApplicationUpdatedActivityLogEntry_data Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "apiVersion": - return ec.fieldContext_ApplyActivityLogEntryData_apiVersion(ctx, field) + return ec.fieldContext_ResourceActivityLogEntryData_apiVersion(ctx, field) case "kind": - return ec.fieldContext_ApplyActivityLogEntryData_kind(ctx, field) + return ec.fieldContext_ResourceActivityLogEntryData_kind(ctx, field) case "changedFields": - return ec.fieldContext_ApplyActivityLogEntryData_changedFields(ctx, field) + return ec.fieldContext_ResourceActivityLogEntryData_changedFields(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type ApplyActivityLogEntryData", field.Name) + return nil, fmt.Errorf("no field named %q was found under type ResourceActivityLogEntryData", field.Name) }, } return fc, nil diff --git a/internal/graph/gengql/apply.generated.go b/internal/graph/gengql/apply.generated.go index b827bf2ca..216ae75a9 100644 --- a/internal/graph/gengql/apply.generated.go +++ b/internal/graph/gengql/apply.generated.go @@ -10,16 +10,12 @@ import ( "sync/atomic" "github.com/99designs/gqlgen/graphql" - "github.com/nais/api/internal/apply" + "github.com/nais/api/internal/activitylog" "github.com/vektah/gqlparser/v2/ast" ) // region ************************** generated!.gotpl ************************** -type ApplyActivityLogEntryDataResolver interface { - ChangedFields(ctx context.Context, obj *apply.ApplyActivityLogEntryData) ([]*apply.ApplyChangedField, error) -} - // endregion ************************** generated!.gotpl ************************** // region ***************************** args.gotpl ***************************** @@ -32,12 +28,12 @@ type ApplyActivityLogEntryDataResolver interface { // region **************************** field.gotpl ***************************** -func (ec *executionContext) _ApplyActivityLogEntryData_apiVersion(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntryData) (ret graphql.Marshaler) { +func (ec *executionContext) _ResourceActivityLogEntryData_apiVersion(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceActivityLogEntryData) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplyActivityLogEntryData_apiVersion, + ec.fieldContext_ResourceActivityLogEntryData_apiVersion, func(ctx context.Context) (any, error) { return obj.APIVersion, nil }, @@ -48,9 +44,9 @@ func (ec *executionContext) _ApplyActivityLogEntryData_apiVersion(ctx context.Co ) } -func (ec *executionContext) fieldContext_ApplyActivityLogEntryData_apiVersion(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_apiVersion(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntryData", + Object: "ResourceActivityLogEntryData", Field: field, IsMethod: false, IsResolver: false, @@ -61,12 +57,12 @@ func (ec *executionContext) fieldContext_ApplyActivityLogEntryData_apiVersion(_ return fc, nil } -func (ec *executionContext) _ApplyActivityLogEntryData_kind(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntryData) (ret graphql.Marshaler) { +func (ec *executionContext) _ResourceActivityLogEntryData_kind(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceActivityLogEntryData) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplyActivityLogEntryData_kind, + ec.fieldContext_ResourceActivityLogEntryData_kind, func(ctx context.Context) (any, error) { return obj.Kind, nil }, @@ -77,9 +73,9 @@ func (ec *executionContext) _ApplyActivityLogEntryData_kind(ctx context.Context, ) } -func (ec *executionContext) fieldContext_ApplyActivityLogEntryData_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntryData", + Object: "ResourceActivityLogEntryData", Field: field, IsMethod: false, IsResolver: false, @@ -90,49 +86,49 @@ func (ec *executionContext) fieldContext_ApplyActivityLogEntryData_kind(_ contex return fc, nil } -func (ec *executionContext) _ApplyActivityLogEntryData_changedFields(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyActivityLogEntryData) (ret graphql.Marshaler) { +func (ec *executionContext) _ResourceActivityLogEntryData_changedFields(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceActivityLogEntryData) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplyActivityLogEntryData_changedFields, + ec.fieldContext_ResourceActivityLogEntryData_changedFields, func(ctx context.Context) (any, error) { - return ec.Resolvers.ApplyActivityLogEntryData().ChangedFields(ctx, obj) + return obj.ChangedFields, nil }, nil, - ec.marshalNApplyChangedField2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyChangedFieldᚄ, + ec.marshalNResourceChangedField2ᚕgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceChangedFieldᚄ, true, true, ) } -func (ec *executionContext) fieldContext_ApplyActivityLogEntryData_changedFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_changedFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplyActivityLogEntryData", + Object: "ResourceActivityLogEntryData", Field: field, - IsMethod: true, - IsResolver: true, + IsMethod: false, + IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "field": - return ec.fieldContext_ApplyChangedField_field(ctx, field) + return ec.fieldContext_ResourceChangedField_field(ctx, field) case "oldValue": - return ec.fieldContext_ApplyChangedField_oldValue(ctx, field) + return ec.fieldContext_ResourceChangedField_oldValue(ctx, field) case "newValue": - return ec.fieldContext_ApplyChangedField_newValue(ctx, field) + return ec.fieldContext_ResourceChangedField_newValue(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type ApplyChangedField", field.Name) + return nil, fmt.Errorf("no field named %q was found under type ResourceChangedField", field.Name) }, } return fc, nil } -func (ec *executionContext) _ApplyChangedField_field(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyChangedField) (ret graphql.Marshaler) { +func (ec *executionContext) _ResourceChangedField_field(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceChangedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplyChangedField_field, + ec.fieldContext_ResourceChangedField_field, func(ctx context.Context) (any, error) { return obj.Field, nil }, @@ -143,9 +139,9 @@ func (ec *executionContext) _ApplyChangedField_field(ctx context.Context, field ) } -func (ec *executionContext) fieldContext_ApplyChangedField_field(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ResourceChangedField_field(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplyChangedField", + Object: "ResourceChangedField", Field: field, IsMethod: false, IsResolver: false, @@ -156,12 +152,12 @@ func (ec *executionContext) fieldContext_ApplyChangedField_field(_ context.Conte return fc, nil } -func (ec *executionContext) _ApplyChangedField_oldValue(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyChangedField) (ret graphql.Marshaler) { +func (ec *executionContext) _ResourceChangedField_oldValue(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceChangedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplyChangedField_oldValue, + ec.fieldContext_ResourceChangedField_oldValue, func(ctx context.Context) (any, error) { return obj.OldValue, nil }, @@ -172,9 +168,9 @@ func (ec *executionContext) _ApplyChangedField_oldValue(ctx context.Context, fie ) } -func (ec *executionContext) fieldContext_ApplyChangedField_oldValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ResourceChangedField_oldValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplyChangedField", + Object: "ResourceChangedField", Field: field, IsMethod: false, IsResolver: false, @@ -185,12 +181,12 @@ func (ec *executionContext) fieldContext_ApplyChangedField_oldValue(_ context.Co return fc, nil } -func (ec *executionContext) _ApplyChangedField_newValue(ctx context.Context, field graphql.CollectedField, obj *apply.ApplyChangedField) (ret graphql.Marshaler) { +func (ec *executionContext) _ResourceChangedField_newValue(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceChangedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ApplyChangedField_newValue, + ec.fieldContext_ResourceChangedField_newValue, func(ctx context.Context) (any, error) { return obj.NewValue, nil }, @@ -201,9 +197,9 @@ func (ec *executionContext) _ApplyChangedField_newValue(ctx context.Context, fie ) } -func (ec *executionContext) fieldContext_ApplyChangedField_newValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ResourceChangedField_newValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ApplyChangedField", + Object: "ResourceChangedField", Field: field, IsMethod: false, IsResolver: false, @@ -214,6 +210,275 @@ func (ec *executionContext) fieldContext_ApplyChangedField_newValue(_ context.Co return fc, nil } +func (ec *executionContext) _UnsupportedResourceActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_UnsupportedResourceActivityLogEntry_id, + func(ctx context.Context) (any, error) { + return obj.ID(), nil + }, + nil, + ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "UnsupportedResourceActivityLogEntry", + Field: field, + IsMethod: true, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _UnsupportedResourceActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_UnsupportedResourceActivityLogEntry_actor, + func(ctx context.Context) (any, error) { + return obj.Actor, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "UnsupportedResourceActivityLogEntry", + 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) _UnsupportedResourceActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_UnsupportedResourceActivityLogEntry_createdAt, + func(ctx context.Context) (any, error) { + return obj.CreatedAt, nil + }, + nil, + ec.marshalNTime2timeᚐTime, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "UnsupportedResourceActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _UnsupportedResourceActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_UnsupportedResourceActivityLogEntry_message, + func(ctx context.Context) (any, error) { + return obj.Message, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "UnsupportedResourceActivityLogEntry", + 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) _UnsupportedResourceActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_UnsupportedResourceActivityLogEntry_resourceType, + func(ctx context.Context) (any, error) { + return obj.ResourceType, nil + }, + nil, + ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "UnsupportedResourceActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _UnsupportedResourceActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_UnsupportedResourceActivityLogEntry_resourceName, + func(ctx context.Context) (any, error) { + return obj.ResourceName, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "UnsupportedResourceActivityLogEntry", + 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) _UnsupportedResourceActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_UnsupportedResourceActivityLogEntry_teamSlug, + func(ctx context.Context) (any, error) { + return obj.TeamSlug, nil + }, + nil, + ec.marshalOSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "UnsupportedResourceActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Slug does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _UnsupportedResourceActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_UnsupportedResourceActivityLogEntry_environmentName, + func(ctx context.Context) (any, error) { + return obj.EnvironmentName, nil + }, + nil, + ec.marshalOString2ᚖstring, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "UnsupportedResourceActivityLogEntry", + 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) _UnsupportedResourceActivityLogEntry_data(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_UnsupportedResourceActivityLogEntry_data, + func(ctx context.Context) (any, error) { + return obj.Data, nil + }, + nil, + ec.marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "UnsupportedResourceActivityLogEntry", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "apiVersion": + return ec.fieldContext_ResourceActivityLogEntryData_apiVersion(ctx, field) + case "kind": + return ec.fieldContext_ResourceActivityLogEntryData_kind(ctx, field) + case "changedFields": + return ec.fieldContext_ResourceActivityLogEntryData_changedFields(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ResourceActivityLogEntryData", field.Name) + }, + } + return fc, nil +} + // endregion **************************** field.gotpl ***************************** // region **************************** input.gotpl ***************************** @@ -226,63 +491,32 @@ func (ec *executionContext) fieldContext_ApplyChangedField_newValue(_ context.Co // region **************************** object.gotpl **************************** -var applyActivityLogEntryDataImplementors = []string{"ApplyActivityLogEntryData"} +var resourceActivityLogEntryDataImplementors = []string{"ResourceActivityLogEntryData"} -func (ec *executionContext) _ApplyActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, obj *apply.ApplyActivityLogEntryData) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, applyActivityLogEntryDataImplementors) +func (ec *executionContext) _ResourceActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, obj *activitylog.ResourceActivityLogEntryData) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, resourceActivityLogEntryDataImplementors) 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("ApplyActivityLogEntryData") + out.Values[i] = graphql.MarshalString("ResourceActivityLogEntryData") case "apiVersion": - out.Values[i] = ec._ApplyActivityLogEntryData_apiVersion(ctx, field, obj) + out.Values[i] = ec._ResourceActivityLogEntryData_apiVersion(ctx, field, obj) if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) + out.Invalids++ } case "kind": - out.Values[i] = ec._ApplyActivityLogEntryData_kind(ctx, field, obj) + out.Values[i] = ec._ResourceActivityLogEntryData_kind(ctx, field, obj) if out.Values[i] == graphql.Null { - atomic.AddUint32(&out.Invalids, 1) + out.Invalids++ } case "changedFields": - field := field - - innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) { - defer func() { - if r := recover(); r != nil { - ec.Error(ctx, ec.Recover(ctx, r)) - } - }() - res = ec._ApplyActivityLogEntryData_changedFields(ctx, field, obj) - if res == graphql.Null { - atomic.AddUint32(&fs.Invalids, 1) - } - return res - } - - if field.Deferrable != nil { - dfs, ok := deferred[field.Deferrable.Label] - di := 0 - if ok { - dfs.AddField(field) - di = len(dfs.Values) - 1 - } else { - dfs = graphql.NewFieldSet([]graphql.CollectedField{field}) - deferred[field.Deferrable.Label] = dfs - } - dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler { - return innerFunc(ctx, dfs) - }) - - // don't run the out.Concurrently() call below - out.Values[i] = graphql.Null - continue + out.Values[i] = ec._ResourceActivityLogEntryData_changedFields(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ } - - out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -306,26 +540,99 @@ func (ec *executionContext) _ApplyActivityLogEntryData(ctx context.Context, sel return out } -var applyChangedFieldImplementors = []string{"ApplyChangedField"} +var resourceChangedFieldImplementors = []string{"ResourceChangedField"} -func (ec *executionContext) _ApplyChangedField(ctx context.Context, sel ast.SelectionSet, obj *apply.ApplyChangedField) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, applyChangedFieldImplementors) +func (ec *executionContext) _ResourceChangedField(ctx context.Context, sel ast.SelectionSet, obj *activitylog.ResourceChangedField) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, resourceChangedFieldImplementors) 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("ApplyChangedField") + out.Values[i] = graphql.MarshalString("ResourceChangedField") case "field": - out.Values[i] = ec._ApplyChangedField_field(ctx, field, obj) + out.Values[i] = ec._ResourceChangedField_field(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "oldValue": - out.Values[i] = ec._ApplyChangedField_oldValue(ctx, field, obj) + out.Values[i] = ec._ResourceChangedField_oldValue(ctx, field, obj) case "newValue": - out.Values[i] = ec._ApplyChangedField_newValue(ctx, field, obj) + out.Values[i] = ec._ResourceChangedField_newValue(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 unsupportedResourceActivityLogEntryImplementors = []string{"UnsupportedResourceActivityLogEntry", "ActivityLogEntry", "Node"} + +func (ec *executionContext) _UnsupportedResourceActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *activitylog.UnsupportedResourceActivityLogEntry) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, unsupportedResourceActivityLogEntryImplementors) + + 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("UnsupportedResourceActivityLogEntry") + case "id": + out.Values[i] = ec._UnsupportedResourceActivityLogEntry_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "actor": + out.Values[i] = ec._UnsupportedResourceActivityLogEntry_actor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createdAt": + out.Values[i] = ec._UnsupportedResourceActivityLogEntry_createdAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "message": + out.Values[i] = ec._UnsupportedResourceActivityLogEntry_message(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceType": + out.Values[i] = ec._UnsupportedResourceActivityLogEntry_resourceType(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceName": + out.Values[i] = ec._UnsupportedResourceActivityLogEntry_resourceName(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "teamSlug": + out.Values[i] = ec._UnsupportedResourceActivityLogEntry_teamSlug(ctx, field, obj) + case "environmentName": + out.Values[i] = ec._UnsupportedResourceActivityLogEntry_environmentName(ctx, field, obj) + case "data": + out.Values[i] = ec._UnsupportedResourceActivityLogEntry_data(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -353,21 +660,25 @@ func (ec *executionContext) _ApplyChangedField(ctx context.Context, sel ast.Sele // region ***************************** type.gotpl ***************************** -func (ec *executionContext) marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, v *apply.ApplyActivityLogEntryData) graphql.Marshaler { +func (ec *executionContext) marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, v *activitylog.ResourceActivityLogEntryData) graphql.Marshaler { if v == nil { if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") } return graphql.Null } - return ec._ApplyActivityLogEntryData(ctx, sel, v) + return ec._ResourceActivityLogEntryData(ctx, sel, v) +} + +func (ec *executionContext) marshalNResourceChangedField2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceChangedField(ctx context.Context, sel ast.SelectionSet, v activitylog.ResourceChangedField) graphql.Marshaler { + return ec._ResourceChangedField(ctx, sel, &v) } -func (ec *executionContext) marshalNApplyChangedField2ᚕᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyChangedFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []*apply.ApplyChangedField) graphql.Marshaler { +func (ec *executionContext) marshalNResourceChangedField2ᚕgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceChangedFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []activitylog.ResourceChangedField) graphql.Marshaler { ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler { fc := graphql.GetFieldContext(ctx) fc.Result = &v[i] - return ec.marshalNApplyChangedField2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyChangedField(ctx, sel, v[i]) + return ec.marshalNResourceChangedField2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceChangedField(ctx, sel, v[i]) }) for _, e := range ret { @@ -379,14 +690,4 @@ func (ec *executionContext) marshalNApplyChangedField2ᚕᚖgithubᚗcomᚋnais return ret } -func (ec *executionContext) marshalNApplyChangedField2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyChangedField(ctx context.Context, sel ast.SelectionSet, v *apply.ApplyChangedField) graphql.Marshaler { - if v == nil { - if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { - graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") - } - return graphql.Null - } - return ec._ApplyChangedField(ctx, sel, v) -} - // endregion ***************************** type.gotpl ***************************** diff --git a/internal/graph/gengql/jobs.generated.go b/internal/graph/gengql/jobs.generated.go index aec8de055..14d4ce374 100644 --- a/internal/graph/gengql/jobs.generated.go +++ b/internal/graph/gengql/jobs.generated.go @@ -2443,7 +2443,7 @@ func (ec *executionContext) _JobCreatedActivityLogEntry_data(ctx context.Context return obj.Data, nil }, nil, - ec.marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyActivityLogEntryData, + ec.marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData, true, true, ) @@ -2458,13 +2458,13 @@ func (ec *executionContext) fieldContext_JobCreatedActivityLogEntry_data(_ conte Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "apiVersion": - return ec.fieldContext_ApplyActivityLogEntryData_apiVersion(ctx, field) + return ec.fieldContext_ResourceActivityLogEntryData_apiVersion(ctx, field) case "kind": - return ec.fieldContext_ApplyActivityLogEntryData_kind(ctx, field) + return ec.fieldContext_ResourceActivityLogEntryData_kind(ctx, field) case "changedFields": - return ec.fieldContext_ApplyActivityLogEntryData_changedFields(ctx, field) + return ec.fieldContext_ResourceActivityLogEntryData_changedFields(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type ApplyActivityLogEntryData", field.Name) + return nil, fmt.Errorf("no field named %q was found under type ResourceActivityLogEntryData", field.Name) }, } return fc, nil @@ -4618,7 +4618,7 @@ func (ec *executionContext) _JobUpdatedActivityLogEntry_data(ctx context.Context return obj.Data, nil }, nil, - ec.marshalNApplyActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋapplyᚐApplyActivityLogEntryData, + ec.marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData, true, true, ) @@ -4633,13 +4633,13 @@ func (ec *executionContext) fieldContext_JobUpdatedActivityLogEntry_data(_ conte Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "apiVersion": - return ec.fieldContext_ApplyActivityLogEntryData_apiVersion(ctx, field) + return ec.fieldContext_ResourceActivityLogEntryData_apiVersion(ctx, field) case "kind": - return ec.fieldContext_ApplyActivityLogEntryData_kind(ctx, field) + return ec.fieldContext_ResourceActivityLogEntryData_kind(ctx, field) case "changedFields": - return ec.fieldContext_ApplyActivityLogEntryData_changedFields(ctx, field) + return ec.fieldContext_ResourceActivityLogEntryData_changedFields(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type ApplyActivityLogEntryData", field.Name) + return nil, fmt.Errorf("no field named %q was found under type ResourceActivityLogEntryData", field.Name) }, } return fc, nil diff --git a/internal/graph/gengql/root_.generated.go b/internal/graph/gengql/root_.generated.go index 14bd0e791..64fcbfd2d 100644 --- a/internal/graph/gengql/root_.generated.go +++ b/internal/graph/gengql/root_.generated.go @@ -40,7 +40,6 @@ import ( "github.com/nais/api/internal/vulnerability" "github.com/nais/api/internal/workload" "github.com/nais/api/internal/workload/application" - "github.com/nais/api/internal/workload/configmap" "github.com/nais/api/internal/workload/job" "github.com/nais/api/internal/workload/podlog" "github.com/nais/api/internal/workload/secret" @@ -58,11 +57,9 @@ type Config = graphql.Config[ResolverRoot, DirectiveRoot, ComplexityRoot] type ResolverRoot interface { Application() ApplicationResolver ApplicationInstance() ApplicationInstanceResolver - ApplyActivityLogEntryData() ApplyActivityLogEntryDataResolver BigQueryDataset() BigQueryDatasetResolver Bucket() BucketResolver CVE() CVEResolver - Config() ConfigResolver ContainerImage() ContainerImageResolver ContainerImageWorkloadReference() ContainerImageWorkloadReferenceResolver CurrentUnitPrices() CurrentUnitPricesResolver @@ -152,10 +149,6 @@ type ComplexityRoot struct { Node func(childComplexity int) int } - AddConfigValuePayload struct { - Config func(childComplexity int) int - } - AddRepositoryToTeamPayload struct { Repository func(childComplexity int) int } @@ -188,7 +181,6 @@ type ComplexityRoot struct { AuthIntegrations func(childComplexity int) int BigQueryDatasets func(childComplexity int, orderBy *bigquery.BigQueryDatasetOrder) int Buckets func(childComplexity int, orderBy *bucket.BucketOrder) int - Configs func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int Cost func(childComplexity int) int DeletionStartedAt func(childComplexity int) int Deployments func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int @@ -337,18 +329,6 @@ type ComplexityRoot struct { TeamSlug func(childComplexity int) int } - ApplyActivityLogEntryData struct { - APIVersion func(childComplexity int) int - ChangedFields func(childComplexity int) int - Kind func(childComplexity int) int - } - - ApplyChangedField struct { - Field func(childComplexity int) int - NewValue func(childComplexity int) int - OldValue func(childComplexity int) int - } - AssignRoleToServiceAccountPayload struct { ServiceAccount func(childComplexity int) int } @@ -477,80 +457,6 @@ type ComplexityRoot struct { ResourceKind func(childComplexity int) int } - Config struct { - ActivityLog func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, filter *activitylog.ActivityLogFilter) int - Applications func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int - ID func(childComplexity int) int - Jobs func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int - LastModifiedAt func(childComplexity int) int - LastModifiedBy func(childComplexity int) int - Name func(childComplexity int) int - Team func(childComplexity int) int - TeamEnvironment func(childComplexity int) int - Values func(childComplexity int) int - Workloads func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int - } - - ConfigConnection struct { - Edges func(childComplexity int) int - Nodes func(childComplexity int) int - PageInfo func(childComplexity int) int - } - - ConfigCreatedActivityLogEntry struct { - Actor func(childComplexity int) int - CreatedAt func(childComplexity int) int - EnvironmentName func(childComplexity int) int - ID func(childComplexity int) int - Message func(childComplexity int) int - ResourceName func(childComplexity int) int - ResourceType func(childComplexity int) int - TeamSlug func(childComplexity int) int - } - - ConfigDeletedActivityLogEntry struct { - Actor func(childComplexity int) int - CreatedAt func(childComplexity int) int - EnvironmentName func(childComplexity int) int - ID func(childComplexity int) int - Message func(childComplexity int) int - ResourceName func(childComplexity int) int - ResourceType func(childComplexity int) int - TeamSlug func(childComplexity int) int - } - - ConfigEdge struct { - Cursor func(childComplexity int) int - Node func(childComplexity int) int - } - - ConfigUpdatedActivityLogEntry struct { - Actor func(childComplexity int) int - CreatedAt func(childComplexity int) int - Data func(childComplexity int) int - EnvironmentName func(childComplexity int) int - ID func(childComplexity int) int - Message func(childComplexity int) int - ResourceName func(childComplexity int) int - ResourceType func(childComplexity int) int - TeamSlug func(childComplexity int) int - } - - ConfigUpdatedActivityLogEntryData struct { - UpdatedFields func(childComplexity int) int - } - - ConfigUpdatedActivityLogEntryDataUpdatedField struct { - Field func(childComplexity int) int - NewValue func(childComplexity int) int - OldValue func(childComplexity int) int - } - - ConfigValue struct { - Name func(childComplexity int) int - Value func(childComplexity int) int - } - ConfirmTeamDeletionPayload struct { DeletionStarted func(childComplexity int) int } @@ -585,10 +491,6 @@ type ComplexityRoot struct { Series func(childComplexity int) int } - CreateConfigPayload struct { - Config func(childComplexity int) int - } - CreateKafkaCredentialsPayload struct { Credentials func(childComplexity int) int } @@ -631,25 +533,6 @@ type ComplexityRoot struct { Valkey func(childComplexity int) int } - CredentialsActivityLogEntry struct { - Actor func(childComplexity int) int - CreatedAt func(childComplexity int) int - Data func(childComplexity int) int - EnvironmentName func(childComplexity int) int - ID func(childComplexity int) int - Message func(childComplexity int) int - ResourceName func(childComplexity int) int - ResourceType func(childComplexity int) int - TeamSlug func(childComplexity int) int - } - - CredentialsActivityLogEntryData struct { - InstanceName func(childComplexity int) int - Permission func(childComplexity int) int - ServiceType func(childComplexity int) int - TTL func(childComplexity int) int - } - CurrentUnitPrices struct { CPU func(childComplexity int) int Memory func(childComplexity int) int @@ -660,10 +543,6 @@ type ComplexityRoot struct { Team func(childComplexity int) int } - DeleteConfigPayload struct { - ConfigDeleted func(childComplexity int) int - } - DeleteJobPayload struct { Success func(childComplexity int) int Team func(childComplexity int) int @@ -977,7 +856,6 @@ type ComplexityRoot struct { AuthIntegrations func(childComplexity int) int BigQueryDatasets func(childComplexity int, orderBy *bigquery.BigQueryDatasetOrder) int Buckets func(childComplexity int, orderBy *bucket.BucketOrder) int - Configs func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int Cost func(childComplexity int) int DeletionStartedAt func(childComplexity int) int Deployments func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int @@ -1280,7 +1158,6 @@ type ComplexityRoot struct { } Mutation struct { - AddConfigValue func(childComplexity int, input configmap.AddConfigValueInput) int AddRepositoryToTeam func(childComplexity int, input repository.AddRepositoryToTeamInput) int AddSecretValue func(childComplexity int, input secret.AddSecretValueInput) int AddTeamMember func(childComplexity int, input team.AddTeamMemberInput) int @@ -1289,7 +1166,6 @@ type ComplexityRoot struct { ChangeDeploymentKey func(childComplexity int, input deployment.ChangeDeploymentKeyInput) int ConfigureReconciler func(childComplexity int, input reconciler.ConfigureReconcilerInput) int ConfirmTeamDeletion func(childComplexity int, input team.ConfirmTeamDeletionInput) int - CreateConfig func(childComplexity int, input configmap.CreateConfigInput) int CreateKafkaCredentials func(childComplexity int, input aivencredentials.CreateKafkaCredentialsInput) int CreateOpenSearch func(childComplexity int, input opensearch.CreateOpenSearchInput) int CreateOpenSearchCredentials func(childComplexity int, input aivencredentials.CreateOpenSearchCredentialsInput) int @@ -1301,7 +1177,6 @@ type ComplexityRoot struct { CreateValkey func(childComplexity int, input valkey.CreateValkeyInput) int CreateValkeyCredentials func(childComplexity int, input aivencredentials.CreateValkeyCredentialsInput) int DeleteApplication func(childComplexity int, input application.DeleteApplicationInput) int - DeleteConfig func(childComplexity int, input configmap.DeleteConfigInput) int DeleteJob func(childComplexity int, input job.DeleteJobInput) int DeleteJobRun func(childComplexity int, input job.DeleteJobRunInput) int DeleteOpenSearch func(childComplexity int, input opensearch.DeleteOpenSearchInput) int @@ -1313,7 +1188,6 @@ type ComplexityRoot struct { DisableReconciler func(childComplexity int, input reconciler.DisableReconcilerInput) int EnableReconciler func(childComplexity int, input reconciler.EnableReconcilerInput) int GrantPostgresAccess func(childComplexity int, input postgres.GrantPostgresAccessInput) int - RemoveConfigValue func(childComplexity int, input configmap.RemoveConfigValueInput) int RemoveRepositoryFromTeam func(childComplexity int, input repository.RemoveRepositoryFromTeamInput) int RemoveSecretValue func(childComplexity int, input secret.RemoveSecretValueInput) int RemoveTeamMember func(childComplexity int, input team.RemoveTeamMemberInput) int @@ -1325,7 +1199,6 @@ type ComplexityRoot struct { StartOpenSearchMaintenance func(childComplexity int, input servicemaintenance.StartOpenSearchMaintenanceInput) int StartValkeyMaintenance func(childComplexity int, input servicemaintenance.StartValkeyMaintenanceInput) int TriggerJob func(childComplexity int, input job.TriggerJobInput) int - UpdateConfigValue func(childComplexity int, input configmap.UpdateConfigValueInput) int UpdateImageVulnerability func(childComplexity int, input vulnerability.UpdateImageVulnerabilityInput) int UpdateOpenSearch func(childComplexity int, input opensearch.UpdateOpenSearchInput) int UpdateSecretValue func(childComplexity int, input secret.UpdateSecretValueInput) int @@ -1716,10 +1589,6 @@ type ComplexityRoot struct { Node func(childComplexity int) int } - RemoveConfigValuePayload struct { - Config func(childComplexity int) int - } - RemoveRepositoryFromTeamPayload struct { Success func(childComplexity int) int } @@ -1776,6 +1645,18 @@ type ComplexityRoot struct { Key func(childComplexity int) int } + ResourceActivityLogEntryData struct { + APIVersion func(childComplexity int) int + ChangedFields func(childComplexity int) int + Kind func(childComplexity int) int + } + + ResourceChangedField struct { + Field func(childComplexity int) int + NewValue func(childComplexity int) int + OldValue func(childComplexity int) int + } + RestartApplicationPayload struct { Application func(childComplexity int) int } @@ -2318,7 +2199,6 @@ type ComplexityRoot struct { Applications func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *application.ApplicationOrder, filter *application.TeamApplicationsFilter) int BigQueryDatasets func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *bigquery.BigQueryDatasetOrder) int Buckets func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *bucket.BucketOrder) int - Configs func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *configmap.ConfigOrder, filter *configmap.ConfigFilter) int Cost func(childComplexity int) int DeleteKey func(childComplexity int, key string) int DeletionInProgress func(childComplexity int) int @@ -2452,7 +2332,6 @@ type ComplexityRoot struct { Application func(childComplexity int, name string) int BigQueryDataset func(childComplexity int, name string) int Bucket func(childComplexity int, name string) int - Config func(childComplexity int, name string) int Cost func(childComplexity int) int Environment func(childComplexity int) int GCPProjectID func(childComplexity int) int @@ -2533,10 +2412,6 @@ type ComplexityRoot struct { Total func(childComplexity int) int } - TeamInventoryCountConfigs struct { - Total func(childComplexity int) int - } - TeamInventoryCountJobs struct { Total func(childComplexity int) int } @@ -2569,7 +2444,6 @@ type ComplexityRoot struct { Applications func(childComplexity int) int BigQueryDatasets func(childComplexity int) int Buckets func(childComplexity int) int - Configs func(childComplexity int) int Jobs func(childComplexity int) int KafkaTopics func(childComplexity int) int OpenSearches func(childComplexity int) int @@ -2821,8 +2695,16 @@ type ComplexityRoot struct { Unleash func(childComplexity int) int } - UpdateConfigValuePayload struct { - Config func(childComplexity int) int + UnsupportedResourceActivityLogEntry struct { + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + Data func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int } UpdateImageVulnerabilityPayload struct { @@ -3263,13 +3145,6 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.ActivityLogEntryEdge.Node(childComplexity), true - case "AddConfigValuePayload.config": - if e.ComplexityRoot.AddConfigValuePayload.Config == nil { - break - } - - return e.ComplexityRoot.AddConfigValuePayload.Config(childComplexity), true - case "AddRepositoryToTeamPayload.repository": if e.ComplexityRoot.AddRepositoryToTeamPayload.Repository == nil { break @@ -3376,18 +3251,6 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.Application.Buckets(childComplexity, args["orderBy"].(*bucket.BucketOrder)), true - case "Application.configs": - if e.ComplexityRoot.Application.Configs == nil { - break - } - - args, err := ec.field_Application_configs_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Application.Configs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "Application.cost": if e.ComplexityRoot.Application.Cost == nil { break @@ -4129,48 +3992,6 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.ApplicationUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "ApplyActivityLogEntryData.apiVersion": - if e.ComplexityRoot.ApplyActivityLogEntryData.APIVersion == nil { - break - } - - return e.ComplexityRoot.ApplyActivityLogEntryData.APIVersion(childComplexity), true - - case "ApplyActivityLogEntryData.changedFields": - if e.ComplexityRoot.ApplyActivityLogEntryData.ChangedFields == nil { - break - } - - return e.ComplexityRoot.ApplyActivityLogEntryData.ChangedFields(childComplexity), true - - case "ApplyActivityLogEntryData.kind": - if e.ComplexityRoot.ApplyActivityLogEntryData.Kind == nil { - break - } - - return e.ComplexityRoot.ApplyActivityLogEntryData.Kind(childComplexity), true - - case "ApplyChangedField.field": - if e.ComplexityRoot.ApplyChangedField.Field == nil { - break - } - - return e.ComplexityRoot.ApplyChangedField.Field(childComplexity), true - - case "ApplyChangedField.newValue": - if e.ComplexityRoot.ApplyChangedField.NewValue == nil { - break - } - - return e.ComplexityRoot.ApplyChangedField.NewValue(childComplexity), true - - case "ApplyChangedField.oldValue": - if e.ComplexityRoot.ApplyChangedField.OldValue == nil { - break - } - - return e.ComplexityRoot.ApplyChangedField.OldValue(childComplexity), true - case "AssignRoleToServiceAccountPayload.serviceAccount": if e.ComplexityRoot.AssignRoleToServiceAccountPayload.ServiceAccount == nil { break @@ -4657,9409 +4478,8880 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.ClusterAuditActivityLogEntryData.ResourceKind(childComplexity), true - case "Config.activityLog": - if e.ComplexityRoot.Config.ActivityLog == nil { + case "ConfirmTeamDeletionPayload.deletionStarted": + if e.ComplexityRoot.ConfirmTeamDeletionPayload.DeletionStarted == nil { break } - args, err := ec.field_Config_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Config.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.ConfirmTeamDeletionPayload.DeletionStarted(childComplexity), true - case "Config.applications": - if e.ComplexityRoot.Config.Applications == nil { + case "ContainerImage.activityLog": + if e.ComplexityRoot.ContainerImage.ActivityLog == nil { break } - args, err := ec.field_Config_applications_args(ctx, rawArgs) + args, err := ec.field_ContainerImage_activityLog_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Config.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - - case "Config.id": - if e.ComplexityRoot.Config.ID == nil { - break - } - - return e.ComplexityRoot.Config.ID(childComplexity), true + return e.ComplexityRoot.ContainerImage.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "Config.jobs": - if e.ComplexityRoot.Config.Jobs == nil { + case "ContainerImage.hasSBOM": + if e.ComplexityRoot.ContainerImage.HasSbom == nil { break } - args, err := ec.field_Config_jobs_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Config.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ContainerImage.HasSbom(childComplexity), true - case "Config.lastModifiedAt": - if e.ComplexityRoot.Config.LastModifiedAt == nil { + case "ContainerImage.id": + if e.ComplexityRoot.ContainerImage.ID == nil { break } - return e.ComplexityRoot.Config.LastModifiedAt(childComplexity), true + return e.ComplexityRoot.ContainerImage.ID(childComplexity), true - case "Config.lastModifiedBy": - if e.ComplexityRoot.Config.LastModifiedBy == nil { + case "ContainerImage.name": + if e.ComplexityRoot.ContainerImage.Name == nil { break } - return e.ComplexityRoot.Config.LastModifiedBy(childComplexity), true + return e.ComplexityRoot.ContainerImage.Name(childComplexity), true - case "Config.name": - if e.ComplexityRoot.Config.Name == nil { + case "ContainerImage.tag": + if e.ComplexityRoot.ContainerImage.Tag == nil { break } - return e.ComplexityRoot.Config.Name(childComplexity), true + return e.ComplexityRoot.ContainerImage.Tag(childComplexity), true - case "Config.team": - if e.ComplexityRoot.Config.Team == nil { + case "ContainerImage.vulnerabilities": + if e.ComplexityRoot.ContainerImage.Vulnerabilities == nil { break } - return e.ComplexityRoot.Config.Team(childComplexity), true - - case "Config.teamEnvironment": - if e.ComplexityRoot.Config.TeamEnvironment == nil { - break + args, err := ec.field_ContainerImage_vulnerabilities_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Config.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.ContainerImage.Vulnerabilities(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*vulnerability.ImageVulnerabilityFilter), args["orderBy"].(*vulnerability.ImageVulnerabilityOrder)), true - case "Config.values": - if e.ComplexityRoot.Config.Values == nil { + case "ContainerImage.vulnerabilitySummary": + if e.ComplexityRoot.ContainerImage.VulnerabilitySummary == nil { break } - return e.ComplexityRoot.Config.Values(childComplexity), true + return e.ComplexityRoot.ContainerImage.VulnerabilitySummary(childComplexity), true - case "Config.workloads": - if e.ComplexityRoot.Config.Workloads == nil { + case "ContainerImage.workloadReferences": + if e.ComplexityRoot.ContainerImage.WorkloadReferences == nil { break } - args, err := ec.field_Config_workloads_args(ctx, rawArgs) + args, err := ec.field_ContainerImage_workloadReferences_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Config.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ContainerImage.WorkloadReferences(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ConfigConnection.edges": - if e.ComplexityRoot.ConfigConnection.Edges == nil { + case "ContainerImageWorkloadReference.workload": + if e.ComplexityRoot.ContainerImageWorkloadReference.Workload == nil { break } - return e.ComplexityRoot.ConfigConnection.Edges(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReference.Workload(childComplexity), true - case "ConfigConnection.nodes": - if e.ComplexityRoot.ConfigConnection.Nodes == nil { + case "ContainerImageWorkloadReferenceConnection.edges": + if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Edges == nil { break } - return e.ComplexityRoot.ConfigConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Edges(childComplexity), true - case "ConfigConnection.pageInfo": - if e.ComplexityRoot.ConfigConnection.PageInfo == nil { + case "ContainerImageWorkloadReferenceConnection.nodes": + if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Nodes == nil { break } - return e.ComplexityRoot.ConfigConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Nodes(childComplexity), true - case "ConfigCreatedActivityLogEntry.actor": - if e.ComplexityRoot.ConfigCreatedActivityLogEntry.Actor == nil { + case "ContainerImageWorkloadReferenceConnection.pageInfo": + if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.PageInfo == nil { break } - return e.ComplexityRoot.ConfigCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.PageInfo(childComplexity), true - case "ConfigCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ConfigCreatedActivityLogEntry.CreatedAt == nil { + case "ContainerImageWorkloadReferenceEdge.cursor": + if e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Cursor == nil { break } - return e.ComplexityRoot.ConfigCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Cursor(childComplexity), true - case "ConfigCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ConfigCreatedActivityLogEntry.EnvironmentName == nil { + case "ContainerImageWorkloadReferenceEdge.node": + if e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Node == nil { break } - return e.ComplexityRoot.ConfigCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Node(childComplexity), true - case "ConfigCreatedActivityLogEntry.id": - if e.ComplexityRoot.ConfigCreatedActivityLogEntry.ID == nil { + case "CostMonthlySummary.series": + if e.ComplexityRoot.CostMonthlySummary.Series == nil { break } - return e.ComplexityRoot.ConfigCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.CostMonthlySummary.Series(childComplexity), true - case "ConfigCreatedActivityLogEntry.message": - if e.ComplexityRoot.ConfigCreatedActivityLogEntry.Message == nil { + case "CreateKafkaCredentialsPayload.credentials": + if e.ComplexityRoot.CreateKafkaCredentialsPayload.Credentials == nil { break } - return e.ComplexityRoot.ConfigCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.CreateKafkaCredentialsPayload.Credentials(childComplexity), true - case "ConfigCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ConfigCreatedActivityLogEntry.ResourceName == nil { + case "CreateOpenSearchCredentialsPayload.credentials": + if e.ComplexityRoot.CreateOpenSearchCredentialsPayload.Credentials == nil { break } - return e.ComplexityRoot.ConfigCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.CreateOpenSearchCredentialsPayload.Credentials(childComplexity), true - case "ConfigCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ConfigCreatedActivityLogEntry.ResourceType == nil { + case "CreateOpenSearchPayload.openSearch": + if e.ComplexityRoot.CreateOpenSearchPayload.OpenSearch == nil { break } - return e.ComplexityRoot.ConfigCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.CreateOpenSearchPayload.OpenSearch(childComplexity), true - case "ConfigCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ConfigCreatedActivityLogEntry.TeamSlug == nil { + case "CreateSecretPayload.secret": + if e.ComplexityRoot.CreateSecretPayload.Secret == nil { break } - return e.ComplexityRoot.ConfigCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.CreateSecretPayload.Secret(childComplexity), true - case "ConfigDeletedActivityLogEntry.actor": - if e.ComplexityRoot.ConfigDeletedActivityLogEntry.Actor == nil { + case "CreateServiceAccountPayload.serviceAccount": + if e.ComplexityRoot.CreateServiceAccountPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.ConfigDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.CreateServiceAccountPayload.ServiceAccount(childComplexity), true - case "ConfigDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.ConfigDeletedActivityLogEntry.CreatedAt == nil { + case "CreateServiceAccountTokenPayload.secret": + if e.ComplexityRoot.CreateServiceAccountTokenPayload.Secret == nil { break } - return e.ComplexityRoot.ConfigDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.CreateServiceAccountTokenPayload.Secret(childComplexity), true - case "ConfigDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.ConfigDeletedActivityLogEntry.EnvironmentName == nil { + case "CreateServiceAccountTokenPayload.serviceAccount": + if e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.ConfigDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccount(childComplexity), true - case "ConfigDeletedActivityLogEntry.id": - if e.ComplexityRoot.ConfigDeletedActivityLogEntry.ID == nil { + case "CreateServiceAccountTokenPayload.serviceAccountToken": + if e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccountToken == nil { break } - return e.ComplexityRoot.ConfigDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccountToken(childComplexity), true - case "ConfigDeletedActivityLogEntry.message": - if e.ComplexityRoot.ConfigDeletedActivityLogEntry.Message == nil { + case "CreateTeamPayload.team": + if e.ComplexityRoot.CreateTeamPayload.Team == nil { break } - return e.ComplexityRoot.ConfigDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.CreateTeamPayload.Team(childComplexity), true - case "ConfigDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.ConfigDeletedActivityLogEntry.ResourceName == nil { + case "CreateUnleashForTeamPayload.unleash": + if e.ComplexityRoot.CreateUnleashForTeamPayload.Unleash == nil { break } - return e.ComplexityRoot.ConfigDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.CreateUnleashForTeamPayload.Unleash(childComplexity), true - case "ConfigDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.ConfigDeletedActivityLogEntry.ResourceType == nil { + case "CreateValkeyCredentialsPayload.credentials": + if e.ComplexityRoot.CreateValkeyCredentialsPayload.Credentials == nil { break } - return e.ComplexityRoot.ConfigDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.CreateValkeyCredentialsPayload.Credentials(childComplexity), true - case "ConfigDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ConfigDeletedActivityLogEntry.TeamSlug == nil { + case "CreateValkeyPayload.valkey": + if e.ComplexityRoot.CreateValkeyPayload.Valkey == nil { break } - return e.ComplexityRoot.ConfigDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.CreateValkeyPayload.Valkey(childComplexity), true - case "ConfigEdge.cursor": - if e.ComplexityRoot.ConfigEdge.Cursor == nil { + case "CurrentUnitPrices.cpu": + if e.ComplexityRoot.CurrentUnitPrices.CPU == nil { break } - return e.ComplexityRoot.ConfigEdge.Cursor(childComplexity), true + return e.ComplexityRoot.CurrentUnitPrices.CPU(childComplexity), true - case "ConfigEdge.node": - if e.ComplexityRoot.ConfigEdge.Node == nil { + case "CurrentUnitPrices.memory": + if e.ComplexityRoot.CurrentUnitPrices.Memory == nil { break } - return e.ComplexityRoot.ConfigEdge.Node(childComplexity), true + return e.ComplexityRoot.CurrentUnitPrices.Memory(childComplexity), true - case "ConfigUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Actor == nil { + case "DeleteApplicationPayload.success": + if e.ComplexityRoot.DeleteApplicationPayload.Success == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.DeleteApplicationPayload.Success(childComplexity), true - case "ConfigUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.CreatedAt == nil { + case "DeleteApplicationPayload.team": + if e.ComplexityRoot.DeleteApplicationPayload.Team == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.DeleteApplicationPayload.Team(childComplexity), true - case "ConfigUpdatedActivityLogEntry.data": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Data == nil { + case "DeleteJobPayload.success": + if e.ComplexityRoot.DeleteJobPayload.Success == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.DeleteJobPayload.Success(childComplexity), true - case "ConfigUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.EnvironmentName == nil { + case "DeleteJobPayload.team": + if e.ComplexityRoot.DeleteJobPayload.Team == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.DeleteJobPayload.Team(childComplexity), true - case "ConfigUpdatedActivityLogEntry.id": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ID == nil { + case "DeleteJobRunPayload.job": + if e.ComplexityRoot.DeleteJobRunPayload.Job == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.DeleteJobRunPayload.Job(childComplexity), true - case "ConfigUpdatedActivityLogEntry.message": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Message == nil { + case "DeleteJobRunPayload.success": + if e.ComplexityRoot.DeleteJobRunPayload.Success == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.DeleteJobRunPayload.Success(childComplexity), true - case "ConfigUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ResourceName == nil { + case "DeleteOpenSearchPayload.openSearchDeleted": + if e.ComplexityRoot.DeleteOpenSearchPayload.OpenSearchDeleted == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.DeleteOpenSearchPayload.OpenSearchDeleted(childComplexity), true - case "ConfigUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ResourceType == nil { + case "DeleteSecretPayload.secretDeleted": + if e.ComplexityRoot.DeleteSecretPayload.SecretDeleted == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.DeleteSecretPayload.SecretDeleted(childComplexity), true - case "ConfigUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.TeamSlug == nil { + case "DeleteServiceAccountPayload.serviceAccountDeleted": + if e.ComplexityRoot.DeleteServiceAccountPayload.ServiceAccountDeleted == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.DeleteServiceAccountPayload.ServiceAccountDeleted(childComplexity), true - case "ConfigUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntryData.UpdatedFields == nil { + case "DeleteServiceAccountTokenPayload.serviceAccount": + if e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccount(childComplexity), true - case "ConfigUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "DeleteServiceAccountTokenPayload.serviceAccountTokenDeleted": + if e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccountTokenDeleted == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccountTokenDeleted(childComplexity), true - case "ConfigUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "DeleteUnleashInstancePayload.unleashDeleted": + if e.ComplexityRoot.DeleteUnleashInstancePayload.UnleashDeleted == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.DeleteUnleashInstancePayload.UnleashDeleted(childComplexity), true - case "ConfigUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "DeleteValkeyPayload.valkeyDeleted": + if e.ComplexityRoot.DeleteValkeyPayload.ValkeyDeleted == nil { break } - return e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.DeleteValkeyPayload.ValkeyDeleted(childComplexity), true - case "ConfigValue.name": - if e.ComplexityRoot.ConfigValue.Name == nil { + case "Deployment.commitSha": + if e.ComplexityRoot.Deployment.CommitSha == nil { break } - return e.ComplexityRoot.ConfigValue.Name(childComplexity), true + return e.ComplexityRoot.Deployment.CommitSha(childComplexity), true - case "ConfigValue.value": - if e.ComplexityRoot.ConfigValue.Value == nil { + case "Deployment.createdAt": + if e.ComplexityRoot.Deployment.CreatedAt == nil { break } - return e.ComplexityRoot.ConfigValue.Value(childComplexity), true + return e.ComplexityRoot.Deployment.CreatedAt(childComplexity), true - case "ConfirmTeamDeletionPayload.deletionStarted": - if e.ComplexityRoot.ConfirmTeamDeletionPayload.DeletionStarted == nil { + case "Deployment.deployerUsername": + if e.ComplexityRoot.Deployment.DeployerUsername == nil { break } - return e.ComplexityRoot.ConfirmTeamDeletionPayload.DeletionStarted(childComplexity), true + return e.ComplexityRoot.Deployment.DeployerUsername(childComplexity), true - case "ContainerImage.activityLog": - if e.ComplexityRoot.ContainerImage.ActivityLog == nil { + case "Deployment.environmentName": + if e.ComplexityRoot.Deployment.EnvironmentName == nil { break } - args, err := ec.field_ContainerImage_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.ContainerImage.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.Deployment.EnvironmentName(childComplexity), true - case "ContainerImage.hasSBOM": - if e.ComplexityRoot.ContainerImage.HasSbom == nil { + case "Deployment.id": + if e.ComplexityRoot.Deployment.ID == nil { break } - return e.ComplexityRoot.ContainerImage.HasSbom(childComplexity), true + return e.ComplexityRoot.Deployment.ID(childComplexity), true - case "ContainerImage.id": - if e.ComplexityRoot.ContainerImage.ID == nil { + case "Deployment.repository": + if e.ComplexityRoot.Deployment.Repository == nil { break } - return e.ComplexityRoot.ContainerImage.ID(childComplexity), true + return e.ComplexityRoot.Deployment.Repository(childComplexity), true - case "ContainerImage.name": - if e.ComplexityRoot.ContainerImage.Name == nil { + case "Deployment.resources": + if e.ComplexityRoot.Deployment.Resources == nil { break } - return e.ComplexityRoot.ContainerImage.Name(childComplexity), true - - case "ContainerImage.tag": - if e.ComplexityRoot.ContainerImage.Tag == nil { - break + args, err := ec.field_Deployment_resources_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ContainerImage.Tag(childComplexity), true + return e.ComplexityRoot.Deployment.Resources(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ContainerImage.vulnerabilities": - if e.ComplexityRoot.ContainerImage.Vulnerabilities == nil { + case "Deployment.statuses": + if e.ComplexityRoot.Deployment.Statuses == nil { break } - args, err := ec.field_ContainerImage_vulnerabilities_args(ctx, rawArgs) + args, err := ec.field_Deployment_statuses_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.ContainerImage.Vulnerabilities(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*vulnerability.ImageVulnerabilityFilter), args["orderBy"].(*vulnerability.ImageVulnerabilityOrder)), true + return e.ComplexityRoot.Deployment.Statuses(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ContainerImage.vulnerabilitySummary": - if e.ComplexityRoot.ContainerImage.VulnerabilitySummary == nil { + case "Deployment.teamSlug": + if e.ComplexityRoot.Deployment.TeamSlug == nil { break } - return e.ComplexityRoot.ContainerImage.VulnerabilitySummary(childComplexity), true + return e.ComplexityRoot.Deployment.TeamSlug(childComplexity), true - case "ContainerImage.workloadReferences": - if e.ComplexityRoot.ContainerImage.WorkloadReferences == nil { + case "Deployment.triggerUrl": + if e.ComplexityRoot.Deployment.TriggerUrl == nil { break } - args, err := ec.field_ContainerImage_workloadReferences_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.ContainerImage.WorkloadReferences(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Deployment.TriggerUrl(childComplexity), true - case "ContainerImageWorkloadReference.workload": - if e.ComplexityRoot.ContainerImageWorkloadReference.Workload == nil { + case "DeploymentActivityLogEntry.actor": + if e.ComplexityRoot.DeploymentActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReference.Workload(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.Actor(childComplexity), true - case "ContainerImageWorkloadReferenceConnection.edges": - if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Edges == nil { + case "DeploymentActivityLogEntry.createdAt": + if e.ComplexityRoot.DeploymentActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Edges(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.CreatedAt(childComplexity), true - case "ContainerImageWorkloadReferenceConnection.nodes": - if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Nodes == nil { + case "DeploymentActivityLogEntry.data": + if e.ComplexityRoot.DeploymentActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.Data(childComplexity), true - case "ContainerImageWorkloadReferenceConnection.pageInfo": - if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.PageInfo == nil { + case "DeploymentActivityLogEntry.environmentName": + if e.ComplexityRoot.DeploymentActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.EnvironmentName(childComplexity), true - case "ContainerImageWorkloadReferenceEdge.cursor": - if e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Cursor == nil { + case "DeploymentActivityLogEntry.id": + if e.ComplexityRoot.DeploymentActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.ID(childComplexity), true - case "ContainerImageWorkloadReferenceEdge.node": - if e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Node == nil { + case "DeploymentActivityLogEntry.message": + if e.ComplexityRoot.DeploymentActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Node(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.Message(childComplexity), true - case "CostMonthlySummary.series": - if e.ComplexityRoot.CostMonthlySummary.Series == nil { + case "DeploymentActivityLogEntry.resourceName": + if e.ComplexityRoot.DeploymentActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.CostMonthlySummary.Series(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.ResourceName(childComplexity), true - case "CreateConfigPayload.config": - if e.ComplexityRoot.CreateConfigPayload.Config == nil { + case "DeploymentActivityLogEntry.resourceType": + if e.ComplexityRoot.DeploymentActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.CreateConfigPayload.Config(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.ResourceType(childComplexity), true - case "CreateKafkaCredentialsPayload.credentials": - if e.ComplexityRoot.CreateKafkaCredentialsPayload.Credentials == nil { + case "DeploymentActivityLogEntry.teamSlug": + if e.ComplexityRoot.DeploymentActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.CreateKafkaCredentialsPayload.Credentials(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.TeamSlug(childComplexity), true - case "CreateOpenSearchCredentialsPayload.credentials": - if e.ComplexityRoot.CreateOpenSearchCredentialsPayload.Credentials == nil { + case "DeploymentActivityLogEntryData.triggerURL": + if e.ComplexityRoot.DeploymentActivityLogEntryData.TriggerURL == nil { break } - return e.ComplexityRoot.CreateOpenSearchCredentialsPayload.Credentials(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntryData.TriggerURL(childComplexity), true - case "CreateOpenSearchPayload.openSearch": - if e.ComplexityRoot.CreateOpenSearchPayload.OpenSearch == nil { + case "DeploymentConnection.edges": + if e.ComplexityRoot.DeploymentConnection.Edges == nil { break } - return e.ComplexityRoot.CreateOpenSearchPayload.OpenSearch(childComplexity), true + return e.ComplexityRoot.DeploymentConnection.Edges(childComplexity), true - case "CreateSecretPayload.secret": - if e.ComplexityRoot.CreateSecretPayload.Secret == nil { + case "DeploymentConnection.nodes": + if e.ComplexityRoot.DeploymentConnection.Nodes == nil { break } - return e.ComplexityRoot.CreateSecretPayload.Secret(childComplexity), true + return e.ComplexityRoot.DeploymentConnection.Nodes(childComplexity), true - case "CreateServiceAccountPayload.serviceAccount": - if e.ComplexityRoot.CreateServiceAccountPayload.ServiceAccount == nil { + case "DeploymentConnection.pageInfo": + if e.ComplexityRoot.DeploymentConnection.PageInfo == nil { break } - return e.ComplexityRoot.CreateServiceAccountPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.DeploymentConnection.PageInfo(childComplexity), true - case "CreateServiceAccountTokenPayload.secret": - if e.ComplexityRoot.CreateServiceAccountTokenPayload.Secret == nil { + case "DeploymentEdge.cursor": + if e.ComplexityRoot.DeploymentEdge.Cursor == nil { break } - return e.ComplexityRoot.CreateServiceAccountTokenPayload.Secret(childComplexity), true + return e.ComplexityRoot.DeploymentEdge.Cursor(childComplexity), true - case "CreateServiceAccountTokenPayload.serviceAccount": - if e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccount == nil { + case "DeploymentEdge.node": + if e.ComplexityRoot.DeploymentEdge.Node == nil { break } - return e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.DeploymentEdge.Node(childComplexity), true - case "CreateServiceAccountTokenPayload.serviceAccountToken": - if e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccountToken == nil { + case "DeploymentKey.created": + if e.ComplexityRoot.DeploymentKey.Created == nil { break } - return e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccountToken(childComplexity), true + return e.ComplexityRoot.DeploymentKey.Created(childComplexity), true - case "CreateTeamPayload.team": - if e.ComplexityRoot.CreateTeamPayload.Team == nil { + case "DeploymentKey.expires": + if e.ComplexityRoot.DeploymentKey.Expires == nil { break } - return e.ComplexityRoot.CreateTeamPayload.Team(childComplexity), true + return e.ComplexityRoot.DeploymentKey.Expires(childComplexity), true - case "CreateUnleashForTeamPayload.unleash": - if e.ComplexityRoot.CreateUnleashForTeamPayload.Unleash == nil { + case "DeploymentKey.id": + if e.ComplexityRoot.DeploymentKey.ID == nil { break } - return e.ComplexityRoot.CreateUnleashForTeamPayload.Unleash(childComplexity), true + return e.ComplexityRoot.DeploymentKey.ID(childComplexity), true - case "CreateValkeyCredentialsPayload.credentials": - if e.ComplexityRoot.CreateValkeyCredentialsPayload.Credentials == nil { + case "DeploymentKey.key": + if e.ComplexityRoot.DeploymentKey.Key == nil { break } - return e.ComplexityRoot.CreateValkeyCredentialsPayload.Credentials(childComplexity), true + return e.ComplexityRoot.DeploymentKey.Key(childComplexity), true - case "CreateValkeyPayload.valkey": - if e.ComplexityRoot.CreateValkeyPayload.Valkey == nil { + case "DeploymentResource.id": + if e.ComplexityRoot.DeploymentResource.ID == nil { break } - return e.ComplexityRoot.CreateValkeyPayload.Valkey(childComplexity), true + return e.ComplexityRoot.DeploymentResource.ID(childComplexity), true - case "CredentialsActivityLogEntry.actor": - if e.ComplexityRoot.CredentialsActivityLogEntry.Actor == nil { + case "DeploymentResource.kind": + if e.ComplexityRoot.DeploymentResource.Kind == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.DeploymentResource.Kind(childComplexity), true - case "CredentialsActivityLogEntry.createdAt": - if e.ComplexityRoot.CredentialsActivityLogEntry.CreatedAt == nil { + case "DeploymentResource.name": + if e.ComplexityRoot.DeploymentResource.Name == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.DeploymentResource.Name(childComplexity), true - case "CredentialsActivityLogEntry.data": - if e.ComplexityRoot.CredentialsActivityLogEntry.Data == nil { + case "DeploymentResourceConnection.edges": + if e.ComplexityRoot.DeploymentResourceConnection.Edges == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.DeploymentResourceConnection.Edges(childComplexity), true - case "CredentialsActivityLogEntry.environmentName": - if e.ComplexityRoot.CredentialsActivityLogEntry.EnvironmentName == nil { + case "DeploymentResourceConnection.nodes": + if e.ComplexityRoot.DeploymentResourceConnection.Nodes == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.DeploymentResourceConnection.Nodes(childComplexity), true - case "CredentialsActivityLogEntry.id": - if e.ComplexityRoot.CredentialsActivityLogEntry.ID == nil { + case "DeploymentResourceConnection.pageInfo": + if e.ComplexityRoot.DeploymentResourceConnection.PageInfo == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.DeploymentResourceConnection.PageInfo(childComplexity), true - case "CredentialsActivityLogEntry.message": - if e.ComplexityRoot.CredentialsActivityLogEntry.Message == nil { + case "DeploymentResourceEdge.cursor": + if e.ComplexityRoot.DeploymentResourceEdge.Cursor == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.DeploymentResourceEdge.Cursor(childComplexity), true - case "CredentialsActivityLogEntry.resourceName": - if e.ComplexityRoot.CredentialsActivityLogEntry.ResourceName == nil { + case "DeploymentResourceEdge.node": + if e.ComplexityRoot.DeploymentResourceEdge.Node == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.DeploymentResourceEdge.Node(childComplexity), true - case "CredentialsActivityLogEntry.resourceType": - if e.ComplexityRoot.CredentialsActivityLogEntry.ResourceType == nil { + case "DeploymentStatus.createdAt": + if e.ComplexityRoot.DeploymentStatus.CreatedAt == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.DeploymentStatus.CreatedAt(childComplexity), true - case "CredentialsActivityLogEntry.teamSlug": - if e.ComplexityRoot.CredentialsActivityLogEntry.TeamSlug == nil { + case "DeploymentStatus.id": + if e.ComplexityRoot.DeploymentStatus.ID == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.DeploymentStatus.ID(childComplexity), true - case "CredentialsActivityLogEntryData.instanceName": - if e.ComplexityRoot.CredentialsActivityLogEntryData.InstanceName == nil { + case "DeploymentStatus.message": + if e.ComplexityRoot.DeploymentStatus.Message == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntryData.InstanceName(childComplexity), true + return e.ComplexityRoot.DeploymentStatus.Message(childComplexity), true - case "CredentialsActivityLogEntryData.permission": - if e.ComplexityRoot.CredentialsActivityLogEntryData.Permission == nil { + case "DeploymentStatus.state": + if e.ComplexityRoot.DeploymentStatus.State == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntryData.Permission(childComplexity), true + return e.ComplexityRoot.DeploymentStatus.State(childComplexity), true - case "CredentialsActivityLogEntryData.serviceType": - if e.ComplexityRoot.CredentialsActivityLogEntryData.ServiceType == nil { + case "DeploymentStatusConnection.edges": + if e.ComplexityRoot.DeploymentStatusConnection.Edges == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntryData.ServiceType(childComplexity), true + return e.ComplexityRoot.DeploymentStatusConnection.Edges(childComplexity), true - case "CredentialsActivityLogEntryData.ttl": - if e.ComplexityRoot.CredentialsActivityLogEntryData.TTL == nil { + case "DeploymentStatusConnection.nodes": + if e.ComplexityRoot.DeploymentStatusConnection.Nodes == nil { break } - return e.ComplexityRoot.CredentialsActivityLogEntryData.TTL(childComplexity), true + return e.ComplexityRoot.DeploymentStatusConnection.Nodes(childComplexity), true - case "CurrentUnitPrices.cpu": - if e.ComplexityRoot.CurrentUnitPrices.CPU == nil { + case "DeploymentStatusConnection.pageInfo": + if e.ComplexityRoot.DeploymentStatusConnection.PageInfo == nil { break } - return e.ComplexityRoot.CurrentUnitPrices.CPU(childComplexity), true + return e.ComplexityRoot.DeploymentStatusConnection.PageInfo(childComplexity), true - case "CurrentUnitPrices.memory": - if e.ComplexityRoot.CurrentUnitPrices.Memory == nil { + case "DeploymentStatusEdge.cursor": + if e.ComplexityRoot.DeploymentStatusEdge.Cursor == nil { break } - return e.ComplexityRoot.CurrentUnitPrices.Memory(childComplexity), true + return e.ComplexityRoot.DeploymentStatusEdge.Cursor(childComplexity), true - case "DeleteApplicationPayload.success": - if e.ComplexityRoot.DeleteApplicationPayload.Success == nil { + case "DeploymentStatusEdge.node": + if e.ComplexityRoot.DeploymentStatusEdge.Node == nil { break } - return e.ComplexityRoot.DeleteApplicationPayload.Success(childComplexity), true + return e.ComplexityRoot.DeploymentStatusEdge.Node(childComplexity), true - case "DeleteApplicationPayload.team": - if e.ComplexityRoot.DeleteApplicationPayload.Team == nil { + case "DeprecatedIngressIssue.application": + if e.ComplexityRoot.DeprecatedIngressIssue.Application == nil { break } - return e.ComplexityRoot.DeleteApplicationPayload.Team(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.Application(childComplexity), true - case "DeleteConfigPayload.configDeleted": - if e.ComplexityRoot.DeleteConfigPayload.ConfigDeleted == nil { + case "DeprecatedIngressIssue.id": + if e.ComplexityRoot.DeprecatedIngressIssue.ID == nil { break } - return e.ComplexityRoot.DeleteConfigPayload.ConfigDeleted(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.ID(childComplexity), true - case "DeleteJobPayload.success": - if e.ComplexityRoot.DeleteJobPayload.Success == nil { + case "DeprecatedIngressIssue.ingresses": + if e.ComplexityRoot.DeprecatedIngressIssue.Ingresses == nil { break } - return e.ComplexityRoot.DeleteJobPayload.Success(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.Ingresses(childComplexity), true - case "DeleteJobPayload.team": - if e.ComplexityRoot.DeleteJobPayload.Team == nil { + case "DeprecatedIngressIssue.message": + if e.ComplexityRoot.DeprecatedIngressIssue.Message == nil { break } - return e.ComplexityRoot.DeleteJobPayload.Team(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.Message(childComplexity), true - case "DeleteJobRunPayload.job": - if e.ComplexityRoot.DeleteJobRunPayload.Job == nil { + case "DeprecatedIngressIssue.severity": + if e.ComplexityRoot.DeprecatedIngressIssue.Severity == nil { break } - return e.ComplexityRoot.DeleteJobRunPayload.Job(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.Severity(childComplexity), true - case "DeleteJobRunPayload.success": - if e.ComplexityRoot.DeleteJobRunPayload.Success == nil { + case "DeprecatedIngressIssue.teamEnvironment": + if e.ComplexityRoot.DeprecatedIngressIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.DeleteJobRunPayload.Success(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.TeamEnvironment(childComplexity), true - case "DeleteOpenSearchPayload.openSearchDeleted": - if e.ComplexityRoot.DeleteOpenSearchPayload.OpenSearchDeleted == nil { + case "DeprecatedRegistryIssue.id": + if e.ComplexityRoot.DeprecatedRegistryIssue.ID == nil { break } - return e.ComplexityRoot.DeleteOpenSearchPayload.OpenSearchDeleted(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.ID(childComplexity), true - case "DeleteSecretPayload.secretDeleted": - if e.ComplexityRoot.DeleteSecretPayload.SecretDeleted == nil { + case "DeprecatedRegistryIssue.message": + if e.ComplexityRoot.DeprecatedRegistryIssue.Message == nil { break } - return e.ComplexityRoot.DeleteSecretPayload.SecretDeleted(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.Message(childComplexity), true - case "DeleteServiceAccountPayload.serviceAccountDeleted": - if e.ComplexityRoot.DeleteServiceAccountPayload.ServiceAccountDeleted == nil { + case "DeprecatedRegistryIssue.severity": + if e.ComplexityRoot.DeprecatedRegistryIssue.Severity == nil { break } - return e.ComplexityRoot.DeleteServiceAccountPayload.ServiceAccountDeleted(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.Severity(childComplexity), true - case "DeleteServiceAccountTokenPayload.serviceAccount": - if e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccount == nil { + case "DeprecatedRegistryIssue.teamEnvironment": + if e.ComplexityRoot.DeprecatedRegistryIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.TeamEnvironment(childComplexity), true - case "DeleteServiceAccountTokenPayload.serviceAccountTokenDeleted": - if e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccountTokenDeleted == nil { + case "DeprecatedRegistryIssue.workload": + if e.ComplexityRoot.DeprecatedRegistryIssue.Workload == nil { break } - return e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccountTokenDeleted(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.Workload(childComplexity), true - case "DeleteUnleashInstancePayload.unleashDeleted": - if e.ComplexityRoot.DeleteUnleashInstancePayload.UnleashDeleted == nil { + case "EntraIDAuthIntegration.name": + if e.ComplexityRoot.EntraIDAuthIntegration.Name == nil { break } - return e.ComplexityRoot.DeleteUnleashInstancePayload.UnleashDeleted(childComplexity), true + return e.ComplexityRoot.EntraIDAuthIntegration.Name(childComplexity), true - case "DeleteValkeyPayload.valkeyDeleted": - if e.ComplexityRoot.DeleteValkeyPayload.ValkeyDeleted == nil { + case "Environment.id": + if e.ComplexityRoot.Environment.ID == nil { break } - return e.ComplexityRoot.DeleteValkeyPayload.ValkeyDeleted(childComplexity), true + return e.ComplexityRoot.Environment.ID(childComplexity), true - case "Deployment.commitSha": - if e.ComplexityRoot.Deployment.CommitSha == nil { + case "Environment.metrics": + if e.ComplexityRoot.Environment.Metrics == nil { break } - return e.ComplexityRoot.Deployment.CommitSha(childComplexity), true - - case "Deployment.createdAt": - if e.ComplexityRoot.Deployment.CreatedAt == nil { - break + args, err := ec.field_Environment_metrics_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Deployment.CreatedAt(childComplexity), true + return e.ComplexityRoot.Environment.Metrics(childComplexity, args["input"].(metrics.MetricsQueryInput)), true - case "Deployment.deployerUsername": - if e.ComplexityRoot.Deployment.DeployerUsername == nil { + case "Environment.name": + if e.ComplexityRoot.Environment.Name == nil { break } - return e.ComplexityRoot.Deployment.DeployerUsername(childComplexity), true + return e.ComplexityRoot.Environment.Name(childComplexity), true - case "Deployment.environmentName": - if e.ComplexityRoot.Deployment.EnvironmentName == nil { + case "Environment.workloads": + if e.ComplexityRoot.Environment.Workloads == nil { break } - return e.ComplexityRoot.Deployment.EnvironmentName(childComplexity), true - - case "Deployment.id": - if e.ComplexityRoot.Deployment.ID == nil { - break + args, err := ec.field_Environment_workloads_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Deployment.ID(childComplexity), true + return e.ComplexityRoot.Environment.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*workload.EnvironmentWorkloadOrder)), true - case "Deployment.repository": - if e.ComplexityRoot.Deployment.Repository == nil { + case "EnvironmentConnection.edges": + if e.ComplexityRoot.EnvironmentConnection.Edges == nil { break } - return e.ComplexityRoot.Deployment.Repository(childComplexity), true + return e.ComplexityRoot.EnvironmentConnection.Edges(childComplexity), true - case "Deployment.resources": - if e.ComplexityRoot.Deployment.Resources == nil { + case "EnvironmentConnection.nodes": + if e.ComplexityRoot.EnvironmentConnection.Nodes == nil { break } - args, err := ec.field_Deployment_resources_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Deployment.Resources(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.EnvironmentConnection.Nodes(childComplexity), true - case "Deployment.statuses": - if e.ComplexityRoot.Deployment.Statuses == nil { + case "EnvironmentConnection.pageInfo": + if e.ComplexityRoot.EnvironmentConnection.PageInfo == nil { break } - args, err := ec.field_Deployment_statuses_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Deployment.Statuses(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.EnvironmentConnection.PageInfo(childComplexity), true - case "Deployment.teamSlug": - if e.ComplexityRoot.Deployment.TeamSlug == nil { + case "EnvironmentEdge.cursor": + if e.ComplexityRoot.EnvironmentEdge.Cursor == nil { break } - return e.ComplexityRoot.Deployment.TeamSlug(childComplexity), true + return e.ComplexityRoot.EnvironmentEdge.Cursor(childComplexity), true - case "Deployment.triggerUrl": - if e.ComplexityRoot.Deployment.TriggerUrl == nil { + case "EnvironmentEdge.node": + if e.ComplexityRoot.EnvironmentEdge.Node == nil { break } - return e.ComplexityRoot.Deployment.TriggerUrl(childComplexity), true + return e.ComplexityRoot.EnvironmentEdge.Node(childComplexity), true - case "DeploymentActivityLogEntry.actor": - if e.ComplexityRoot.DeploymentActivityLogEntry.Actor == nil { + case "ExternalIngressCriticalVulnerabilityIssue.cvssScore": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.CvssScore == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.CvssScore(childComplexity), true - case "DeploymentActivityLogEntry.createdAt": - if e.ComplexityRoot.DeploymentActivityLogEntry.CreatedAt == nil { + case "ExternalIngressCriticalVulnerabilityIssue.id": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.ID == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.ID(childComplexity), true - case "DeploymentActivityLogEntry.data": - if e.ComplexityRoot.DeploymentActivityLogEntry.Data == nil { + case "ExternalIngressCriticalVulnerabilityIssue.ingresses": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Ingresses == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Ingresses(childComplexity), true - case "DeploymentActivityLogEntry.environmentName": - if e.ComplexityRoot.DeploymentActivityLogEntry.EnvironmentName == nil { + case "ExternalIngressCriticalVulnerabilityIssue.message": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Message == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Message(childComplexity), true - case "DeploymentActivityLogEntry.id": - if e.ComplexityRoot.DeploymentActivityLogEntry.ID == nil { + case "ExternalIngressCriticalVulnerabilityIssue.severity": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Severity == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Severity(childComplexity), true - case "DeploymentActivityLogEntry.message": - if e.ComplexityRoot.DeploymentActivityLogEntry.Message == nil { + case "ExternalIngressCriticalVulnerabilityIssue.teamEnvironment": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.TeamEnvironment(childComplexity), true - case "DeploymentActivityLogEntry.resourceName": - if e.ComplexityRoot.DeploymentActivityLogEntry.ResourceName == nil { + case "ExternalIngressCriticalVulnerabilityIssue.workload": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Workload == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Workload(childComplexity), true - case "DeploymentActivityLogEntry.resourceType": - if e.ComplexityRoot.DeploymentActivityLogEntry.ResourceType == nil { + case "ExternalNetworkPolicyHost.ports": + if e.ComplexityRoot.ExternalNetworkPolicyHost.Ports == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ExternalNetworkPolicyHost.Ports(childComplexity), true - case "DeploymentActivityLogEntry.teamSlug": - if e.ComplexityRoot.DeploymentActivityLogEntry.TeamSlug == nil { + case "ExternalNetworkPolicyHost.target": + if e.ComplexityRoot.ExternalNetworkPolicyHost.Target == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ExternalNetworkPolicyHost.Target(childComplexity), true - case "DeploymentActivityLogEntryData.triggerURL": - if e.ComplexityRoot.DeploymentActivityLogEntryData.TriggerURL == nil { + case "ExternalNetworkPolicyIpv4.ports": + if e.ComplexityRoot.ExternalNetworkPolicyIpv4.Ports == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntryData.TriggerURL(childComplexity), true + return e.ComplexityRoot.ExternalNetworkPolicyIpv4.Ports(childComplexity), true - case "DeploymentConnection.edges": - if e.ComplexityRoot.DeploymentConnection.Edges == nil { + case "ExternalNetworkPolicyIpv4.target": + if e.ComplexityRoot.ExternalNetworkPolicyIpv4.Target == nil { break } - return e.ComplexityRoot.DeploymentConnection.Edges(childComplexity), true + return e.ComplexityRoot.ExternalNetworkPolicyIpv4.Target(childComplexity), true - case "DeploymentConnection.nodes": - if e.ComplexityRoot.DeploymentConnection.Nodes == nil { + case "FailedSynchronizationIssue.id": + if e.ComplexityRoot.FailedSynchronizationIssue.ID == nil { break } - return e.ComplexityRoot.DeploymentConnection.Nodes(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.ID(childComplexity), true - case "DeploymentConnection.pageInfo": - if e.ComplexityRoot.DeploymentConnection.PageInfo == nil { + case "FailedSynchronizationIssue.message": + if e.ComplexityRoot.FailedSynchronizationIssue.Message == nil { break } - return e.ComplexityRoot.DeploymentConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.Message(childComplexity), true - case "DeploymentEdge.cursor": - if e.ComplexityRoot.DeploymentEdge.Cursor == nil { + case "FailedSynchronizationIssue.severity": + if e.ComplexityRoot.FailedSynchronizationIssue.Severity == nil { break } - return e.ComplexityRoot.DeploymentEdge.Cursor(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.Severity(childComplexity), true - case "DeploymentEdge.node": - if e.ComplexityRoot.DeploymentEdge.Node == nil { + case "FailedSynchronizationIssue.teamEnvironment": + if e.ComplexityRoot.FailedSynchronizationIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.DeploymentEdge.Node(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.TeamEnvironment(childComplexity), true - case "DeploymentKey.created": - if e.ComplexityRoot.DeploymentKey.Created == nil { + case "FailedSynchronizationIssue.workload": + if e.ComplexityRoot.FailedSynchronizationIssue.Workload == nil { break } - return e.ComplexityRoot.DeploymentKey.Created(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.Workload(childComplexity), true - case "DeploymentKey.expires": - if e.ComplexityRoot.DeploymentKey.Expires == nil { + case "FeatureKafka.enabled": + if e.ComplexityRoot.FeatureKafka.Enabled == nil { break } - return e.ComplexityRoot.DeploymentKey.Expires(childComplexity), true + return e.ComplexityRoot.FeatureKafka.Enabled(childComplexity), true - case "DeploymentKey.id": - if e.ComplexityRoot.DeploymentKey.ID == nil { + case "FeatureKafka.id": + if e.ComplexityRoot.FeatureKafka.ID == nil { break } - return e.ComplexityRoot.DeploymentKey.ID(childComplexity), true + return e.ComplexityRoot.FeatureKafka.ID(childComplexity), true - case "DeploymentKey.key": - if e.ComplexityRoot.DeploymentKey.Key == nil { + case "FeatureOpenSearch.enabled": + if e.ComplexityRoot.FeatureOpenSearch.Enabled == nil { break } - return e.ComplexityRoot.DeploymentKey.Key(childComplexity), true + return e.ComplexityRoot.FeatureOpenSearch.Enabled(childComplexity), true - case "DeploymentResource.id": - if e.ComplexityRoot.DeploymentResource.ID == nil { + case "FeatureOpenSearch.id": + if e.ComplexityRoot.FeatureOpenSearch.ID == nil { break } - return e.ComplexityRoot.DeploymentResource.ID(childComplexity), true + return e.ComplexityRoot.FeatureOpenSearch.ID(childComplexity), true - case "DeploymentResource.kind": - if e.ComplexityRoot.DeploymentResource.Kind == nil { + case "FeatureUnleash.enabled": + if e.ComplexityRoot.FeatureUnleash.Enabled == nil { break } - return e.ComplexityRoot.DeploymentResource.Kind(childComplexity), true + return e.ComplexityRoot.FeatureUnleash.Enabled(childComplexity), true - case "DeploymentResource.name": - if e.ComplexityRoot.DeploymentResource.Name == nil { + case "FeatureUnleash.id": + if e.ComplexityRoot.FeatureUnleash.ID == nil { break } - return e.ComplexityRoot.DeploymentResource.Name(childComplexity), true + return e.ComplexityRoot.FeatureUnleash.ID(childComplexity), true - case "DeploymentResourceConnection.edges": - if e.ComplexityRoot.DeploymentResourceConnection.Edges == nil { + case "FeatureValkey.enabled": + if e.ComplexityRoot.FeatureValkey.Enabled == nil { break } - return e.ComplexityRoot.DeploymentResourceConnection.Edges(childComplexity), true + return e.ComplexityRoot.FeatureValkey.Enabled(childComplexity), true - case "DeploymentResourceConnection.nodes": - if e.ComplexityRoot.DeploymentResourceConnection.Nodes == nil { + case "FeatureValkey.id": + if e.ComplexityRoot.FeatureValkey.ID == nil { break } - return e.ComplexityRoot.DeploymentResourceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.FeatureValkey.ID(childComplexity), true - case "DeploymentResourceConnection.pageInfo": - if e.ComplexityRoot.DeploymentResourceConnection.PageInfo == nil { + case "Features.id": + if e.ComplexityRoot.Features.ID == nil { break } - return e.ComplexityRoot.DeploymentResourceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Features.ID(childComplexity), true - case "DeploymentResourceEdge.cursor": - if e.ComplexityRoot.DeploymentResourceEdge.Cursor == nil { + case "Features.kafka": + if e.ComplexityRoot.Features.Kafka == nil { break } - return e.ComplexityRoot.DeploymentResourceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Features.Kafka(childComplexity), true - case "DeploymentResourceEdge.node": - if e.ComplexityRoot.DeploymentResourceEdge.Node == nil { + case "Features.openSearch": + if e.ComplexityRoot.Features.OpenSearch == nil { break } - return e.ComplexityRoot.DeploymentResourceEdge.Node(childComplexity), true + return e.ComplexityRoot.Features.OpenSearch(childComplexity), true - case "DeploymentStatus.createdAt": - if e.ComplexityRoot.DeploymentStatus.CreatedAt == nil { + case "Features.unleash": + if e.ComplexityRoot.Features.Unleash == nil { break } - return e.ComplexityRoot.DeploymentStatus.CreatedAt(childComplexity), true + return e.ComplexityRoot.Features.Unleash(childComplexity), true - case "DeploymentStatus.id": - if e.ComplexityRoot.DeploymentStatus.ID == nil { + case "Features.valkey": + if e.ComplexityRoot.Features.Valkey == nil { break } - return e.ComplexityRoot.DeploymentStatus.ID(childComplexity), true + return e.ComplexityRoot.Features.Valkey(childComplexity), true - case "DeploymentStatus.message": - if e.ComplexityRoot.DeploymentStatus.Message == nil { + case "GrantPostgresAccessPayload.error": + if e.ComplexityRoot.GrantPostgresAccessPayload.Error == nil { break } - return e.ComplexityRoot.DeploymentStatus.Message(childComplexity), true + return e.ComplexityRoot.GrantPostgresAccessPayload.Error(childComplexity), true - case "DeploymentStatus.state": - if e.ComplexityRoot.DeploymentStatus.State == nil { + case "IDPortenAuthIntegration.name": + if e.ComplexityRoot.IDPortenAuthIntegration.Name == nil { break } - return e.ComplexityRoot.DeploymentStatus.State(childComplexity), true + return e.ComplexityRoot.IDPortenAuthIntegration.Name(childComplexity), true - case "DeploymentStatusConnection.edges": - if e.ComplexityRoot.DeploymentStatusConnection.Edges == nil { + case "ImageVulnerability.cvssScore": + if e.ComplexityRoot.ImageVulnerability.CvssScore == nil { break } - return e.ComplexityRoot.DeploymentStatusConnection.Edges(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.CvssScore(childComplexity), true - case "DeploymentStatusConnection.nodes": - if e.ComplexityRoot.DeploymentStatusConnection.Nodes == nil { + case "ImageVulnerability.description": + if e.ComplexityRoot.ImageVulnerability.Description == nil { break } - return e.ComplexityRoot.DeploymentStatusConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.Description(childComplexity), true - case "DeploymentStatusConnection.pageInfo": - if e.ComplexityRoot.DeploymentStatusConnection.PageInfo == nil { + case "ImageVulnerability.id": + if e.ComplexityRoot.ImageVulnerability.ID == nil { break } - return e.ComplexityRoot.DeploymentStatusConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.ID(childComplexity), true - case "DeploymentStatusEdge.cursor": - if e.ComplexityRoot.DeploymentStatusEdge.Cursor == nil { + case "ImageVulnerability.identifier": + if e.ComplexityRoot.ImageVulnerability.Identifier == nil { break } - return e.ComplexityRoot.DeploymentStatusEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.Identifier(childComplexity), true - case "DeploymentStatusEdge.node": - if e.ComplexityRoot.DeploymentStatusEdge.Node == nil { + case "ImageVulnerability.package": + if e.ComplexityRoot.ImageVulnerability.Package == nil { break } - return e.ComplexityRoot.DeploymentStatusEdge.Node(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.Package(childComplexity), true - case "DeprecatedIngressIssue.application": - if e.ComplexityRoot.DeprecatedIngressIssue.Application == nil { + case "ImageVulnerability.severity": + if e.ComplexityRoot.ImageVulnerability.Severity == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.Application(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.Severity(childComplexity), true - case "DeprecatedIngressIssue.id": - if e.ComplexityRoot.DeprecatedIngressIssue.ID == nil { + case "ImageVulnerability.severitySince": + if e.ComplexityRoot.ImageVulnerability.SeveritySince == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.ID(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.SeveritySince(childComplexity), true - case "DeprecatedIngressIssue.ingresses": - if e.ComplexityRoot.DeprecatedIngressIssue.Ingresses == nil { + case "ImageVulnerability.suppression": + if e.ComplexityRoot.ImageVulnerability.Suppression == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.Ingresses(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.Suppression(childComplexity), true - case "DeprecatedIngressIssue.message": - if e.ComplexityRoot.DeprecatedIngressIssue.Message == nil { + case "ImageVulnerability.vulnerabilityDetailsLink": + if e.ComplexityRoot.ImageVulnerability.VulnerabilityDetailsLink == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.Message(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.VulnerabilityDetailsLink(childComplexity), true - case "DeprecatedIngressIssue.severity": - if e.ComplexityRoot.DeprecatedIngressIssue.Severity == nil { + case "ImageVulnerabilityConnection.edges": + if e.ComplexityRoot.ImageVulnerabilityConnection.Edges == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.Severity(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityConnection.Edges(childComplexity), true - case "DeprecatedIngressIssue.teamEnvironment": - if e.ComplexityRoot.DeprecatedIngressIssue.TeamEnvironment == nil { + case "ImageVulnerabilityConnection.nodes": + if e.ComplexityRoot.ImageVulnerabilityConnection.Nodes == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityConnection.Nodes(childComplexity), true - case "DeprecatedRegistryIssue.id": - if e.ComplexityRoot.DeprecatedRegistryIssue.ID == nil { + case "ImageVulnerabilityConnection.pageInfo": + if e.ComplexityRoot.ImageVulnerabilityConnection.PageInfo == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.ID(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityConnection.PageInfo(childComplexity), true - case "DeprecatedRegistryIssue.message": - if e.ComplexityRoot.DeprecatedRegistryIssue.Message == nil { + case "ImageVulnerabilityEdge.cursor": + if e.ComplexityRoot.ImageVulnerabilityEdge.Cursor == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.Message(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityEdge.Cursor(childComplexity), true - case "DeprecatedRegistryIssue.severity": - if e.ComplexityRoot.DeprecatedRegistryIssue.Severity == nil { + case "ImageVulnerabilityEdge.node": + if e.ComplexityRoot.ImageVulnerabilityEdge.Node == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.Severity(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityEdge.Node(childComplexity), true - case "DeprecatedRegistryIssue.teamEnvironment": - if e.ComplexityRoot.DeprecatedRegistryIssue.TeamEnvironment == nil { + case "ImageVulnerabilityHistory.samples": + if e.ComplexityRoot.ImageVulnerabilityHistory.Samples == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityHistory.Samples(childComplexity), true - case "DeprecatedRegistryIssue.workload": - if e.ComplexityRoot.DeprecatedRegistryIssue.Workload == nil { + case "ImageVulnerabilitySample.date": + if e.ComplexityRoot.ImageVulnerabilitySample.Date == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.Workload(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySample.Date(childComplexity), true - case "EntraIDAuthIntegration.name": - if e.ComplexityRoot.EntraIDAuthIntegration.Name == nil { + case "ImageVulnerabilitySample.summary": + if e.ComplexityRoot.ImageVulnerabilitySample.Summary == nil { break } - return e.ComplexityRoot.EntraIDAuthIntegration.Name(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySample.Summary(childComplexity), true - case "Environment.id": - if e.ComplexityRoot.Environment.ID == nil { + case "ImageVulnerabilitySummary.critical": + if e.ComplexityRoot.ImageVulnerabilitySummary.Critical == nil { break } - return e.ComplexityRoot.Environment.ID(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Critical(childComplexity), true - case "Environment.metrics": - if e.ComplexityRoot.Environment.Metrics == nil { + case "ImageVulnerabilitySummary.high": + if e.ComplexityRoot.ImageVulnerabilitySummary.High == nil { break } - args, err := ec.field_Environment_metrics_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Environment.Metrics(childComplexity, args["input"].(metrics.MetricsQueryInput)), true + return e.ComplexityRoot.ImageVulnerabilitySummary.High(childComplexity), true - case "Environment.name": - if e.ComplexityRoot.Environment.Name == nil { + case "ImageVulnerabilitySummary.lastUpdated": + if e.ComplexityRoot.ImageVulnerabilitySummary.LastUpdated == nil { break } - return e.ComplexityRoot.Environment.Name(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.LastUpdated(childComplexity), true - case "Environment.workloads": - if e.ComplexityRoot.Environment.Workloads == nil { + case "ImageVulnerabilitySummary.low": + if e.ComplexityRoot.ImageVulnerabilitySummary.Low == nil { break } - args, err := ec.field_Environment_workloads_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Environment.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*workload.EnvironmentWorkloadOrder)), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Low(childComplexity), true - case "EnvironmentConnection.edges": - if e.ComplexityRoot.EnvironmentConnection.Edges == nil { + case "ImageVulnerabilitySummary.medium": + if e.ComplexityRoot.ImageVulnerabilitySummary.Medium == nil { break } - return e.ComplexityRoot.EnvironmentConnection.Edges(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Medium(childComplexity), true - case "EnvironmentConnection.nodes": - if e.ComplexityRoot.EnvironmentConnection.Nodes == nil { + case "ImageVulnerabilitySummary.riskScore": + if e.ComplexityRoot.ImageVulnerabilitySummary.RiskScore == nil { break } - return e.ComplexityRoot.EnvironmentConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.RiskScore(childComplexity), true - case "EnvironmentConnection.pageInfo": - if e.ComplexityRoot.EnvironmentConnection.PageInfo == nil { + case "ImageVulnerabilitySummary.total": + if e.ComplexityRoot.ImageVulnerabilitySummary.Total == nil { break } - return e.ComplexityRoot.EnvironmentConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Total(childComplexity), true - case "EnvironmentEdge.cursor": - if e.ComplexityRoot.EnvironmentEdge.Cursor == nil { + case "ImageVulnerabilitySummary.unassigned": + if e.ComplexityRoot.ImageVulnerabilitySummary.Unassigned == nil { break } - return e.ComplexityRoot.EnvironmentEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Unassigned(childComplexity), true - case "EnvironmentEdge.node": - if e.ComplexityRoot.EnvironmentEdge.Node == nil { + case "ImageVulnerabilitySuppression.reason": + if e.ComplexityRoot.ImageVulnerabilitySuppression.Reason == nil { break } - return e.ComplexityRoot.EnvironmentEdge.Node(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySuppression.Reason(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.cvssScore": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.CvssScore == nil { + case "ImageVulnerabilitySuppression.state": + if e.ComplexityRoot.ImageVulnerabilitySuppression.State == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.CvssScore(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySuppression.State(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.id": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.ID == nil { + case "InboundNetworkPolicy.rules": + if e.ComplexityRoot.InboundNetworkPolicy.Rules == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.ID(childComplexity), true + return e.ComplexityRoot.InboundNetworkPolicy.Rules(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.ingresses": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Ingresses == nil { + case "Ingress.metrics": + if e.ComplexityRoot.Ingress.Metrics == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Ingresses(childComplexity), true + return e.ComplexityRoot.Ingress.Metrics(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.message": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Message == nil { + case "Ingress.type": + if e.ComplexityRoot.Ingress.Type == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Message(childComplexity), true + return e.ComplexityRoot.Ingress.Type(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.severity": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Severity == nil { + case "Ingress.url": + if e.ComplexityRoot.Ingress.URL == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Severity(childComplexity), true + return e.ComplexityRoot.Ingress.URL(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.teamEnvironment": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.TeamEnvironment == nil { + case "IngressMetricSample.timestamp": + if e.ComplexityRoot.IngressMetricSample.Timestamp == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.IngressMetricSample.Timestamp(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.workload": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Workload == nil { + case "IngressMetricSample.value": + if e.ComplexityRoot.IngressMetricSample.Value == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Workload(childComplexity), true + return e.ComplexityRoot.IngressMetricSample.Value(childComplexity), true - case "ExternalNetworkPolicyHost.ports": - if e.ComplexityRoot.ExternalNetworkPolicyHost.Ports == nil { + case "IngressMetrics.errorsPerSecond": + if e.ComplexityRoot.IngressMetrics.ErrorsPerSecond == nil { break } - return e.ComplexityRoot.ExternalNetworkPolicyHost.Ports(childComplexity), true + return e.ComplexityRoot.IngressMetrics.ErrorsPerSecond(childComplexity), true - case "ExternalNetworkPolicyHost.target": - if e.ComplexityRoot.ExternalNetworkPolicyHost.Target == nil { + case "IngressMetrics.requestsPerSecond": + if e.ComplexityRoot.IngressMetrics.RequestsPerSecond == nil { break } - return e.ComplexityRoot.ExternalNetworkPolicyHost.Target(childComplexity), true + return e.ComplexityRoot.IngressMetrics.RequestsPerSecond(childComplexity), true - case "ExternalNetworkPolicyIpv4.ports": - if e.ComplexityRoot.ExternalNetworkPolicyIpv4.Ports == nil { + case "IngressMetrics.series": + if e.ComplexityRoot.IngressMetrics.Series == nil { break } - return e.ComplexityRoot.ExternalNetworkPolicyIpv4.Ports(childComplexity), true - - case "ExternalNetworkPolicyIpv4.target": - if e.ComplexityRoot.ExternalNetworkPolicyIpv4.Target == nil { - break + args, err := ec.field_IngressMetrics_series_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ExternalNetworkPolicyIpv4.Target(childComplexity), true + return e.ComplexityRoot.IngressMetrics.Series(childComplexity, args["input"].(application.IngressMetricsInput)), true - case "FailedSynchronizationIssue.id": - if e.ComplexityRoot.FailedSynchronizationIssue.ID == nil { + case "InvalidSpecIssue.id": + if e.ComplexityRoot.InvalidSpecIssue.ID == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.ID(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.ID(childComplexity), true - case "FailedSynchronizationIssue.message": - if e.ComplexityRoot.FailedSynchronizationIssue.Message == nil { + case "InvalidSpecIssue.message": + if e.ComplexityRoot.InvalidSpecIssue.Message == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.Message(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.Message(childComplexity), true - case "FailedSynchronizationIssue.severity": - if e.ComplexityRoot.FailedSynchronizationIssue.Severity == nil { + case "InvalidSpecIssue.severity": + if e.ComplexityRoot.InvalidSpecIssue.Severity == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.Severity(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.Severity(childComplexity), true - case "FailedSynchronizationIssue.teamEnvironment": - if e.ComplexityRoot.FailedSynchronizationIssue.TeamEnvironment == nil { + case "InvalidSpecIssue.teamEnvironment": + if e.ComplexityRoot.InvalidSpecIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.TeamEnvironment(childComplexity), true - case "FailedSynchronizationIssue.workload": - if e.ComplexityRoot.FailedSynchronizationIssue.Workload == nil { + case "InvalidSpecIssue.workload": + if e.ComplexityRoot.InvalidSpecIssue.Workload == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.Workload(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.Workload(childComplexity), true - case "FeatureKafka.enabled": - if e.ComplexityRoot.FeatureKafka.Enabled == nil { + case "IssueConnection.edges": + if e.ComplexityRoot.IssueConnection.Edges == nil { break } - return e.ComplexityRoot.FeatureKafka.Enabled(childComplexity), true + return e.ComplexityRoot.IssueConnection.Edges(childComplexity), true - case "FeatureKafka.id": - if e.ComplexityRoot.FeatureKafka.ID == nil { + case "IssueConnection.nodes": + if e.ComplexityRoot.IssueConnection.Nodes == nil { break } - return e.ComplexityRoot.FeatureKafka.ID(childComplexity), true + return e.ComplexityRoot.IssueConnection.Nodes(childComplexity), true - case "FeatureOpenSearch.enabled": - if e.ComplexityRoot.FeatureOpenSearch.Enabled == nil { + case "IssueConnection.pageInfo": + if e.ComplexityRoot.IssueConnection.PageInfo == nil { break } - return e.ComplexityRoot.FeatureOpenSearch.Enabled(childComplexity), true + return e.ComplexityRoot.IssueConnection.PageInfo(childComplexity), true - case "FeatureOpenSearch.id": - if e.ComplexityRoot.FeatureOpenSearch.ID == nil { + case "IssueEdge.cursor": + if e.ComplexityRoot.IssueEdge.Cursor == nil { break } - return e.ComplexityRoot.FeatureOpenSearch.ID(childComplexity), true + return e.ComplexityRoot.IssueEdge.Cursor(childComplexity), true - case "FeatureUnleash.enabled": - if e.ComplexityRoot.FeatureUnleash.Enabled == nil { + case "IssueEdge.node": + if e.ComplexityRoot.IssueEdge.Node == nil { break } - return e.ComplexityRoot.FeatureUnleash.Enabled(childComplexity), true + return e.ComplexityRoot.IssueEdge.Node(childComplexity), true - case "FeatureUnleash.id": - if e.ComplexityRoot.FeatureUnleash.ID == nil { + case "Job.activityLog": + if e.ComplexityRoot.Job.ActivityLog == nil { break } - return e.ComplexityRoot.FeatureUnleash.ID(childComplexity), true - - case "FeatureValkey.enabled": - if e.ComplexityRoot.FeatureValkey.Enabled == nil { - break + args, err := ec.field_Job_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.FeatureValkey.Enabled(childComplexity), true + return e.ComplexityRoot.Job.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "FeatureValkey.id": - if e.ComplexityRoot.FeatureValkey.ID == nil { + case "Job.authIntegrations": + if e.ComplexityRoot.Job.AuthIntegrations == nil { break } - return e.ComplexityRoot.FeatureValkey.ID(childComplexity), true + return e.ComplexityRoot.Job.AuthIntegrations(childComplexity), true - case "Features.id": - if e.ComplexityRoot.Features.ID == nil { + case "Job.bigQueryDatasets": + if e.ComplexityRoot.Job.BigQueryDatasets == nil { break } - return e.ComplexityRoot.Features.ID(childComplexity), true - - case "Features.kafka": - if e.ComplexityRoot.Features.Kafka == nil { - break + args, err := ec.field_Job_bigQueryDatasets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Features.Kafka(childComplexity), true + return e.ComplexityRoot.Job.BigQueryDatasets(childComplexity, args["orderBy"].(*bigquery.BigQueryDatasetOrder)), true - case "Features.openSearch": - if e.ComplexityRoot.Features.OpenSearch == nil { + case "Job.buckets": + if e.ComplexityRoot.Job.Buckets == nil { break } - return e.ComplexityRoot.Features.OpenSearch(childComplexity), true - - case "Features.unleash": - if e.ComplexityRoot.Features.Unleash == nil { - break + args, err := ec.field_Job_buckets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Features.Unleash(childComplexity), true + return e.ComplexityRoot.Job.Buckets(childComplexity, args["orderBy"].(*bucket.BucketOrder)), true - case "Features.valkey": - if e.ComplexityRoot.Features.Valkey == nil { + case "Job.cost": + if e.ComplexityRoot.Job.Cost == nil { break } - return e.ComplexityRoot.Features.Valkey(childComplexity), true + return e.ComplexityRoot.Job.Cost(childComplexity), true - case "GrantPostgresAccessPayload.error": - if e.ComplexityRoot.GrantPostgresAccessPayload.Error == nil { + case "Job.deletionStartedAt": + if e.ComplexityRoot.Job.DeletionStartedAt == nil { break } - return e.ComplexityRoot.GrantPostgresAccessPayload.Error(childComplexity), true + return e.ComplexityRoot.Job.DeletionStartedAt(childComplexity), true - case "IDPortenAuthIntegration.name": - if e.ComplexityRoot.IDPortenAuthIntegration.Name == nil { + case "Job.deployments": + if e.ComplexityRoot.Job.Deployments == nil { break } - return e.ComplexityRoot.IDPortenAuthIntegration.Name(childComplexity), true - - case "ImageVulnerability.cvssScore": - if e.ComplexityRoot.ImageVulnerability.CvssScore == nil { - break + args, err := ec.field_Job_deployments_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ImageVulnerability.CvssScore(childComplexity), true + return e.ComplexityRoot.Job.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ImageVulnerability.description": - if e.ComplexityRoot.ImageVulnerability.Description == nil { + case "Job.environment": + if e.ComplexityRoot.Job.Environment == nil { break } - return e.ComplexityRoot.ImageVulnerability.Description(childComplexity), true + return e.ComplexityRoot.Job.Environment(childComplexity), true - case "ImageVulnerability.id": - if e.ComplexityRoot.ImageVulnerability.ID == nil { + case "Job.id": + if e.ComplexityRoot.Job.ID == nil { break } - return e.ComplexityRoot.ImageVulnerability.ID(childComplexity), true + return e.ComplexityRoot.Job.ID(childComplexity), true - case "ImageVulnerability.identifier": - if e.ComplexityRoot.ImageVulnerability.Identifier == nil { + case "Job.image": + if e.ComplexityRoot.Job.Image == nil { break } - return e.ComplexityRoot.ImageVulnerability.Identifier(childComplexity), true + return e.ComplexityRoot.Job.Image(childComplexity), true - case "ImageVulnerability.package": - if e.ComplexityRoot.ImageVulnerability.Package == nil { + case "Job.imageVulnerabilityHistory": + if e.ComplexityRoot.Job.ImageVulnerabilityHistory == nil { break } - return e.ComplexityRoot.ImageVulnerability.Package(childComplexity), true + args, err := ec.field_Job_imageVulnerabilityHistory_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "ImageVulnerability.severity": - if e.ComplexityRoot.ImageVulnerability.Severity == nil { + return e.ComplexityRoot.Job.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true + + case "Job.issues": + if e.ComplexityRoot.Job.Issues == nil { break } - return e.ComplexityRoot.ImageVulnerability.Severity(childComplexity), true - - case "ImageVulnerability.severitySince": - if e.ComplexityRoot.ImageVulnerability.SeveritySince == nil { - break + args, err := ec.field_Job_issues_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ImageVulnerability.SeveritySince(childComplexity), true + return e.ComplexityRoot.Job.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true - case "ImageVulnerability.suppression": - if e.ComplexityRoot.ImageVulnerability.Suppression == nil { + case "Job.kafkaTopicAcls": + if e.ComplexityRoot.Job.KafkaTopicAcls == nil { break } - return e.ComplexityRoot.ImageVulnerability.Suppression(childComplexity), true - - case "ImageVulnerability.vulnerabilityDetailsLink": - if e.ComplexityRoot.ImageVulnerability.VulnerabilityDetailsLink == nil { - break + args, err := ec.field_Job_kafkaTopicAcls_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ImageVulnerability.VulnerabilityDetailsLink(childComplexity), true + return e.ComplexityRoot.Job.KafkaTopicAcls(childComplexity, args["orderBy"].(*kafkatopic.KafkaTopicACLOrder)), true - case "ImageVulnerabilityConnection.edges": - if e.ComplexityRoot.ImageVulnerabilityConnection.Edges == nil { + case "Job.logDestinations": + if e.ComplexityRoot.Job.LogDestinations == nil { break } - return e.ComplexityRoot.ImageVulnerabilityConnection.Edges(childComplexity), true + return e.ComplexityRoot.Job.LogDestinations(childComplexity), true - case "ImageVulnerabilityConnection.nodes": - if e.ComplexityRoot.ImageVulnerabilityConnection.Nodes == nil { + case "Job.manifest": + if e.ComplexityRoot.Job.Manifest == nil { break } - return e.ComplexityRoot.ImageVulnerabilityConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Job.Manifest(childComplexity), true - case "ImageVulnerabilityConnection.pageInfo": - if e.ComplexityRoot.ImageVulnerabilityConnection.PageInfo == nil { + case "Job.name": + if e.ComplexityRoot.Job.Name == nil { break } - return e.ComplexityRoot.ImageVulnerabilityConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Job.Name(childComplexity), true - case "ImageVulnerabilityEdge.cursor": - if e.ComplexityRoot.ImageVulnerabilityEdge.Cursor == nil { + case "Job.networkPolicy": + if e.ComplexityRoot.Job.NetworkPolicy == nil { break } - return e.ComplexityRoot.ImageVulnerabilityEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Job.NetworkPolicy(childComplexity), true - case "ImageVulnerabilityEdge.node": - if e.ComplexityRoot.ImageVulnerabilityEdge.Node == nil { + case "Job.openSearch": + if e.ComplexityRoot.Job.OpenSearch == nil { break } - return e.ComplexityRoot.ImageVulnerabilityEdge.Node(childComplexity), true + return e.ComplexityRoot.Job.OpenSearch(childComplexity), true - case "ImageVulnerabilityHistory.samples": - if e.ComplexityRoot.ImageVulnerabilityHistory.Samples == nil { + case "Job.postgresInstances": + if e.ComplexityRoot.Job.PostgresInstances == nil { break } - return e.ComplexityRoot.ImageVulnerabilityHistory.Samples(childComplexity), true - - case "ImageVulnerabilitySample.date": - if e.ComplexityRoot.ImageVulnerabilitySample.Date == nil { - break + args, err := ec.field_Job_postgresInstances_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ImageVulnerabilitySample.Date(childComplexity), true + return e.ComplexityRoot.Job.PostgresInstances(childComplexity, args["orderBy"].(*postgres.PostgresInstanceOrder)), true - case "ImageVulnerabilitySample.summary": - if e.ComplexityRoot.ImageVulnerabilitySample.Summary == nil { + case "Job.resources": + if e.ComplexityRoot.Job.Resources == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySample.Summary(childComplexity), true + return e.ComplexityRoot.Job.Resources(childComplexity), true - case "ImageVulnerabilitySummary.critical": - if e.ComplexityRoot.ImageVulnerabilitySummary.Critical == nil { + case "Job.runs": + if e.ComplexityRoot.Job.Runs == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Critical(childComplexity), true - - case "ImageVulnerabilitySummary.high": - if e.ComplexityRoot.ImageVulnerabilitySummary.High == nil { - break + args, err := ec.field_Job_runs_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ImageVulnerabilitySummary.High(childComplexity), true + return e.ComplexityRoot.Job.Runs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ImageVulnerabilitySummary.lastUpdated": - if e.ComplexityRoot.ImageVulnerabilitySummary.LastUpdated == nil { + case "Job.sqlInstances": + if e.ComplexityRoot.Job.SQLInstances == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.LastUpdated(childComplexity), true - - case "ImageVulnerabilitySummary.low": - if e.ComplexityRoot.ImageVulnerabilitySummary.Low == nil { - break + args, err := ec.field_Job_sqlInstances_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ImageVulnerabilitySummary.Low(childComplexity), true + return e.ComplexityRoot.Job.SQLInstances(childComplexity, args["orderBy"].(*sqlinstance.SQLInstanceOrder)), true - case "ImageVulnerabilitySummary.medium": - if e.ComplexityRoot.ImageVulnerabilitySummary.Medium == nil { + case "Job.schedule": + if e.ComplexityRoot.Job.Schedule == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Medium(childComplexity), true + return e.ComplexityRoot.Job.Schedule(childComplexity), true - case "ImageVulnerabilitySummary.riskScore": - if e.ComplexityRoot.ImageVulnerabilitySummary.RiskScore == nil { + case "Job.secrets": + if e.ComplexityRoot.Job.Secrets == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.RiskScore(childComplexity), true - - case "ImageVulnerabilitySummary.total": - if e.ComplexityRoot.ImageVulnerabilitySummary.Total == nil { - break + args, err := ec.field_Job_secrets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ImageVulnerabilitySummary.Total(childComplexity), true + return e.ComplexityRoot.Job.Secrets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ImageVulnerabilitySummary.unassigned": - if e.ComplexityRoot.ImageVulnerabilitySummary.Unassigned == nil { + case "Job.state": + if e.ComplexityRoot.Job.State == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Unassigned(childComplexity), true + return e.ComplexityRoot.Job.State(childComplexity), true - case "ImageVulnerabilitySuppression.reason": - if e.ComplexityRoot.ImageVulnerabilitySuppression.Reason == nil { + case "Job.team": + if e.ComplexityRoot.Job.Team == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySuppression.Reason(childComplexity), true + return e.ComplexityRoot.Job.Team(childComplexity), true - case "ImageVulnerabilitySuppression.state": - if e.ComplexityRoot.ImageVulnerabilitySuppression.State == nil { + case "Job.teamEnvironment": + if e.ComplexityRoot.Job.TeamEnvironment == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySuppression.State(childComplexity), true + return e.ComplexityRoot.Job.TeamEnvironment(childComplexity), true - case "InboundNetworkPolicy.rules": - if e.ComplexityRoot.InboundNetworkPolicy.Rules == nil { + case "Job.valkeys": + if e.ComplexityRoot.Job.Valkeys == nil { break } - return e.ComplexityRoot.InboundNetworkPolicy.Rules(childComplexity), true - - case "Ingress.metrics": - if e.ComplexityRoot.Ingress.Metrics == nil { - break + args, err := ec.field_Job_valkeys_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Ingress.Metrics(childComplexity), true + return e.ComplexityRoot.Job.Valkeys(childComplexity, args["orderBy"].(*valkey.ValkeyOrder)), true - case "Ingress.type": - if e.ComplexityRoot.Ingress.Type == nil { + case "Job.vulnerabilityFixHistory": + if e.ComplexityRoot.Job.VulnerabilityFixHistory == nil { break } - return e.ComplexityRoot.Ingress.Type(childComplexity), true - - case "Ingress.url": - if e.ComplexityRoot.Ingress.URL == nil { - break + args, err := ec.field_Job_vulnerabilityFixHistory_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Ingress.URL(childComplexity), true + return e.ComplexityRoot.Job.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true - case "IngressMetricSample.timestamp": - if e.ComplexityRoot.IngressMetricSample.Timestamp == nil { + case "JobConnection.edges": + if e.ComplexityRoot.JobConnection.Edges == nil { break } - return e.ComplexityRoot.IngressMetricSample.Timestamp(childComplexity), true + return e.ComplexityRoot.JobConnection.Edges(childComplexity), true - case "IngressMetricSample.value": - if e.ComplexityRoot.IngressMetricSample.Value == nil { + case "JobConnection.nodes": + if e.ComplexityRoot.JobConnection.Nodes == nil { break } - return e.ComplexityRoot.IngressMetricSample.Value(childComplexity), true + return e.ComplexityRoot.JobConnection.Nodes(childComplexity), true - case "IngressMetrics.errorsPerSecond": - if e.ComplexityRoot.IngressMetrics.ErrorsPerSecond == nil { + case "JobConnection.pageInfo": + if e.ComplexityRoot.JobConnection.PageInfo == nil { break } - return e.ComplexityRoot.IngressMetrics.ErrorsPerSecond(childComplexity), true + return e.ComplexityRoot.JobConnection.PageInfo(childComplexity), true - case "IngressMetrics.requestsPerSecond": - if e.ComplexityRoot.IngressMetrics.RequestsPerSecond == nil { + case "JobCreatedActivityLogEntry.actor": + if e.ComplexityRoot.JobCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.IngressMetrics.RequestsPerSecond(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.Actor(childComplexity), true - case "IngressMetrics.series": - if e.ComplexityRoot.IngressMetrics.Series == nil { + case "JobCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.JobCreatedActivityLogEntry.CreatedAt == nil { break } - args, err := ec.field_IngressMetrics_series_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.IngressMetrics.Series(childComplexity, args["input"].(application.IngressMetricsInput)), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "InvalidSpecIssue.id": - if e.ComplexityRoot.InvalidSpecIssue.ID == nil { + case "JobCreatedActivityLogEntry.data": + if e.ComplexityRoot.JobCreatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.ID(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.Data(childComplexity), true - case "InvalidSpecIssue.message": - if e.ComplexityRoot.InvalidSpecIssue.Message == nil { + case "JobCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.JobCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.Message(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "InvalidSpecIssue.severity": - if e.ComplexityRoot.InvalidSpecIssue.Severity == nil { + case "JobCreatedActivityLogEntry.id": + if e.ComplexityRoot.JobCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.Severity(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.ID(childComplexity), true - case "InvalidSpecIssue.teamEnvironment": - if e.ComplexityRoot.InvalidSpecIssue.TeamEnvironment == nil { + case "JobCreatedActivityLogEntry.message": + if e.ComplexityRoot.JobCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.Message(childComplexity), true - case "InvalidSpecIssue.workload": - if e.ComplexityRoot.InvalidSpecIssue.Workload == nil { + case "JobCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.Workload(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceName(childComplexity), true - case "IssueConnection.edges": - if e.ComplexityRoot.IssueConnection.Edges == nil { + case "JobCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.IssueConnection.Edges(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceType(childComplexity), true - case "IssueConnection.nodes": - if e.ComplexityRoot.IssueConnection.Nodes == nil { + case "JobCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.IssueConnection.Nodes(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "IssueConnection.pageInfo": - if e.ComplexityRoot.IssueConnection.PageInfo == nil { + case "JobDeletedActivityLogEntry.actor": + if e.ComplexityRoot.JobDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.IssueConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.Actor(childComplexity), true - case "IssueEdge.cursor": - if e.ComplexityRoot.IssueEdge.Cursor == nil { + case "JobDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.JobDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.IssueEdge.Cursor(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "IssueEdge.node": - if e.ComplexityRoot.IssueEdge.Node == nil { + case "JobDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.JobDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.IssueEdge.Node(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "Job.activityLog": - if e.ComplexityRoot.Job.ActivityLog == nil { + case "JobDeletedActivityLogEntry.id": + if e.ComplexityRoot.JobDeletedActivityLogEntry.ID == nil { break } - args, err := ec.field_Job_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.ID(childComplexity), true - case "Job.authIntegrations": - if e.ComplexityRoot.Job.AuthIntegrations == nil { + case "JobDeletedActivityLogEntry.message": + if e.ComplexityRoot.JobDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.Job.AuthIntegrations(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.Message(childComplexity), true - case "Job.bigQueryDatasets": - if e.ComplexityRoot.Job.BigQueryDatasets == nil { + case "JobDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceName == nil { break } - args, err := ec.field_Job_bigQueryDatasets_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.BigQueryDatasets(childComplexity, args["orderBy"].(*bigquery.BigQueryDatasetOrder)), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceName(childComplexity), true - case "Job.buckets": - if e.ComplexityRoot.Job.Buckets == nil { + case "JobDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceType == nil { break } - args, err := ec.field_Job_buckets_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Buckets(childComplexity, args["orderBy"].(*bucket.BucketOrder)), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceType(childComplexity), true - case "Job.configs": - if e.ComplexityRoot.Job.Configs == nil { + case "JobDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobDeletedActivityLogEntry.TeamSlug == nil { break } - args, err := ec.field_Job_configs_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Configs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "Job.cost": - if e.ComplexityRoot.Job.Cost == nil { + case "JobEdge.cursor": + if e.ComplexityRoot.JobEdge.Cursor == nil { break } - return e.ComplexityRoot.Job.Cost(childComplexity), true + return e.ComplexityRoot.JobEdge.Cursor(childComplexity), true - case "Job.deletionStartedAt": - if e.ComplexityRoot.Job.DeletionStartedAt == nil { + case "JobEdge.node": + if e.ComplexityRoot.JobEdge.Node == nil { break } - return e.ComplexityRoot.Job.DeletionStartedAt(childComplexity), true + return e.ComplexityRoot.JobEdge.Node(childComplexity), true - case "Job.deployments": - if e.ComplexityRoot.Job.Deployments == nil { + case "JobManifest.content": + if e.ComplexityRoot.JobManifest.Content == nil { break } - args, err := ec.field_Job_deployments_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.JobManifest.Content(childComplexity), true + + case "JobResources.limits": + if e.ComplexityRoot.JobResources.Limits == nil { + break } - return e.ComplexityRoot.Job.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.JobResources.Limits(childComplexity), true - case "Job.environment": - if e.ComplexityRoot.Job.Environment == nil { + case "JobResources.requests": + if e.ComplexityRoot.JobResources.Requests == nil { break } - return e.ComplexityRoot.Job.Environment(childComplexity), true + return e.ComplexityRoot.JobResources.Requests(childComplexity), true - case "Job.id": - if e.ComplexityRoot.Job.ID == nil { + case "JobRun.completionTime": + if e.ComplexityRoot.JobRun.CompletionTime == nil { break } - return e.ComplexityRoot.Job.ID(childComplexity), true + return e.ComplexityRoot.JobRun.CompletionTime(childComplexity), true - case "Job.image": - if e.ComplexityRoot.Job.Image == nil { + case "JobRun.duration": + if e.ComplexityRoot.JobRun.Duration == nil { break } - return e.ComplexityRoot.Job.Image(childComplexity), true + return e.ComplexityRoot.JobRun.Duration(childComplexity), true - case "Job.imageVulnerabilityHistory": - if e.ComplexityRoot.Job.ImageVulnerabilityHistory == nil { + case "JobRun.id": + if e.ComplexityRoot.JobRun.ID == nil { break } - args, err := ec.field_Job_imageVulnerabilityHistory_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.JobRun.ID(childComplexity), true + + case "JobRun.image": + if e.ComplexityRoot.JobRun.Image == nil { + break } - return e.ComplexityRoot.Job.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.JobRun.Image(childComplexity), true - case "Job.issues": - if e.ComplexityRoot.Job.Issues == nil { + case "JobRun.instances": + if e.ComplexityRoot.JobRun.Instances == nil { break } - args, err := ec.field_Job_issues_args(ctx, rawArgs) + args, err := ec.field_JobRun_instances_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Job.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + return e.ComplexityRoot.JobRun.Instances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "Job.kafkaTopicAcls": - if e.ComplexityRoot.Job.KafkaTopicAcls == nil { + case "JobRun.name": + if e.ComplexityRoot.JobRun.Name == nil { break } - args, err := ec.field_Job_kafkaTopicAcls_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.KafkaTopicAcls(childComplexity, args["orderBy"].(*kafkatopic.KafkaTopicACLOrder)), true + return e.ComplexityRoot.JobRun.Name(childComplexity), true - case "Job.logDestinations": - if e.ComplexityRoot.Job.LogDestinations == nil { + case "JobRun.startTime": + if e.ComplexityRoot.JobRun.StartTime == nil { break } - return e.ComplexityRoot.Job.LogDestinations(childComplexity), true + return e.ComplexityRoot.JobRun.StartTime(childComplexity), true - case "Job.manifest": - if e.ComplexityRoot.Job.Manifest == nil { + case "JobRun.status": + if e.ComplexityRoot.JobRun.Status == nil { break } - return e.ComplexityRoot.Job.Manifest(childComplexity), true + return e.ComplexityRoot.JobRun.Status(childComplexity), true - case "Job.name": - if e.ComplexityRoot.Job.Name == nil { + case "JobRun.trigger": + if e.ComplexityRoot.JobRun.Trigger == nil { break } - return e.ComplexityRoot.Job.Name(childComplexity), true + return e.ComplexityRoot.JobRun.Trigger(childComplexity), true - case "Job.networkPolicy": - if e.ComplexityRoot.Job.NetworkPolicy == nil { + case "JobRunConnection.edges": + if e.ComplexityRoot.JobRunConnection.Edges == nil { break } - return e.ComplexityRoot.Job.NetworkPolicy(childComplexity), true + return e.ComplexityRoot.JobRunConnection.Edges(childComplexity), true - case "Job.openSearch": - if e.ComplexityRoot.Job.OpenSearch == nil { + case "JobRunConnection.nodes": + if e.ComplexityRoot.JobRunConnection.Nodes == nil { break } - return e.ComplexityRoot.Job.OpenSearch(childComplexity), true + return e.ComplexityRoot.JobRunConnection.Nodes(childComplexity), true - case "Job.postgresInstances": - if e.ComplexityRoot.Job.PostgresInstances == nil { + case "JobRunConnection.pageInfo": + if e.ComplexityRoot.JobRunConnection.PageInfo == nil { break } - args, err := ec.field_Job_postgresInstances_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.JobRunConnection.PageInfo(childComplexity), true + + case "JobRunDeletedActivityLogEntry.actor": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.Actor == nil { + break } - return e.ComplexityRoot.Job.PostgresInstances(childComplexity, args["orderBy"].(*postgres.PostgresInstanceOrder)), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.Actor(childComplexity), true - case "Job.resources": - if e.ComplexityRoot.Job.Resources == nil { + case "JobRunDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.Job.Resources(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "Job.runs": - if e.ComplexityRoot.Job.Runs == nil { + case "JobRunDeletedActivityLogEntry.data": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.Data == nil { break } - args, err := ec.field_Job_runs_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.Data(childComplexity), true + + case "JobRunDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.EnvironmentName == nil { + break } - return e.ComplexityRoot.Job.Runs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "Job.sqlInstances": - if e.ComplexityRoot.Job.SQLInstances == nil { + case "JobRunDeletedActivityLogEntry.id": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.ID == nil { break } - args, err := ec.field_Job_sqlInstances_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.ID(childComplexity), true + + case "JobRunDeletedActivityLogEntry.message": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.Message == nil { + break } - return e.ComplexityRoot.Job.SQLInstances(childComplexity, args["orderBy"].(*sqlinstance.SQLInstanceOrder)), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.Message(childComplexity), true - case "Job.schedule": - if e.ComplexityRoot.Job.Schedule == nil { + case "JobRunDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.Job.Schedule(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceName(childComplexity), true - case "Job.secrets": - if e.ComplexityRoot.Job.Secrets == nil { + case "JobRunDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceType == nil { break } - args, err := ec.field_Job_secrets_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceType(childComplexity), true + + case "JobRunDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.TeamSlug == nil { + break } - return e.ComplexityRoot.Job.Secrets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "Job.state": - if e.ComplexityRoot.Job.State == nil { + case "JobRunDeletedActivityLogEntryData.runName": + if e.ComplexityRoot.JobRunDeletedActivityLogEntryData.RunName == nil { break } - return e.ComplexityRoot.Job.State(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntryData.RunName(childComplexity), true - case "Job.team": - if e.ComplexityRoot.Job.Team == nil { + case "JobRunEdge.cursor": + if e.ComplexityRoot.JobRunEdge.Cursor == nil { break } - return e.ComplexityRoot.Job.Team(childComplexity), true + return e.ComplexityRoot.JobRunEdge.Cursor(childComplexity), true - case "Job.teamEnvironment": - if e.ComplexityRoot.Job.TeamEnvironment == nil { + case "JobRunEdge.node": + if e.ComplexityRoot.JobRunEdge.Node == nil { break } - return e.ComplexityRoot.Job.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.JobRunEdge.Node(childComplexity), true - case "Job.valkeys": - if e.ComplexityRoot.Job.Valkeys == nil { + case "JobRunInstance.id": + if e.ComplexityRoot.JobRunInstance.ID == nil { break } - args, err := ec.field_Job_valkeys_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Valkeys(childComplexity, args["orderBy"].(*valkey.ValkeyOrder)), true + return e.ComplexityRoot.JobRunInstance.ID(childComplexity), true - case "Job.vulnerabilityFixHistory": - if e.ComplexityRoot.Job.VulnerabilityFixHistory == nil { + case "JobRunInstance.name": + if e.ComplexityRoot.JobRunInstance.Name == nil { break } - args, err := ec.field_Job_vulnerabilityFixHistory_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.JobRunInstance.Name(childComplexity), true - case "JobConnection.edges": - if e.ComplexityRoot.JobConnection.Edges == nil { + case "JobRunInstanceConnection.edges": + if e.ComplexityRoot.JobRunInstanceConnection.Edges == nil { break } - return e.ComplexityRoot.JobConnection.Edges(childComplexity), true + return e.ComplexityRoot.JobRunInstanceConnection.Edges(childComplexity), true - case "JobConnection.nodes": - if e.ComplexityRoot.JobConnection.Nodes == nil { + case "JobRunInstanceConnection.nodes": + if e.ComplexityRoot.JobRunInstanceConnection.Nodes == nil { break } - return e.ComplexityRoot.JobConnection.Nodes(childComplexity), true + return e.ComplexityRoot.JobRunInstanceConnection.Nodes(childComplexity), true - case "JobConnection.pageInfo": - if e.ComplexityRoot.JobConnection.PageInfo == nil { + case "JobRunInstanceConnection.pageInfo": + if e.ComplexityRoot.JobRunInstanceConnection.PageInfo == nil { break } - return e.ComplexityRoot.JobConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.JobRunInstanceConnection.PageInfo(childComplexity), true - case "JobCreatedActivityLogEntry.actor": - if e.ComplexityRoot.JobCreatedActivityLogEntry.Actor == nil { + case "JobRunInstanceEdge.cursor": + if e.ComplexityRoot.JobRunInstanceEdge.Cursor == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.JobRunInstanceEdge.Cursor(childComplexity), true - case "JobCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.JobCreatedActivityLogEntry.CreatedAt == nil { + case "JobRunInstanceEdge.node": + if e.ComplexityRoot.JobRunInstanceEdge.Node == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.JobRunInstanceEdge.Node(childComplexity), true - case "JobCreatedActivityLogEntry.data": - if e.ComplexityRoot.JobCreatedActivityLogEntry.Data == nil { + case "JobRunStatus.message": + if e.ComplexityRoot.JobRunStatus.Message == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.JobRunStatus.Message(childComplexity), true - case "JobCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.JobCreatedActivityLogEntry.EnvironmentName == nil { + case "JobRunStatus.state": + if e.ComplexityRoot.JobRunStatus.State == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.JobRunStatus.State(childComplexity), true - case "JobCreatedActivityLogEntry.id": - if e.ComplexityRoot.JobCreatedActivityLogEntry.ID == nil { + case "JobRunTrigger.actor": + if e.ComplexityRoot.JobRunTrigger.Actor == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.JobRunTrigger.Actor(childComplexity), true - case "JobCreatedActivityLogEntry.message": - if e.ComplexityRoot.JobCreatedActivityLogEntry.Message == nil { + case "JobRunTrigger.type": + if e.ComplexityRoot.JobRunTrigger.Type == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.JobRunTrigger.Type(childComplexity), true - case "JobCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceName == nil { + case "JobSchedule.expression": + if e.ComplexityRoot.JobSchedule.Expression == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.JobSchedule.Expression(childComplexity), true - case "JobCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceType == nil { + case "JobSchedule.timeZone": + if e.ComplexityRoot.JobSchedule.TimeZone == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.JobSchedule.TimeZone(childComplexity), true - case "JobCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.JobCreatedActivityLogEntry.TeamSlug == nil { + case "JobTriggeredActivityLogEntry.actor": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.Actor(childComplexity), true - case "JobDeletedActivityLogEntry.actor": - if e.ComplexityRoot.JobDeletedActivityLogEntry.Actor == nil { + case "JobTriggeredActivityLogEntry.createdAt": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.CreatedAt(childComplexity), true - case "JobDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.JobDeletedActivityLogEntry.CreatedAt == nil { + case "JobTriggeredActivityLogEntry.environmentName": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.EnvironmentName(childComplexity), true - case "JobDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.JobDeletedActivityLogEntry.EnvironmentName == nil { + case "JobTriggeredActivityLogEntry.id": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.ID(childComplexity), true - case "JobDeletedActivityLogEntry.id": - if e.ComplexityRoot.JobDeletedActivityLogEntry.ID == nil { + case "JobTriggeredActivityLogEntry.message": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.Message(childComplexity), true - case "JobDeletedActivityLogEntry.message": - if e.ComplexityRoot.JobDeletedActivityLogEntry.Message == nil { + case "JobTriggeredActivityLogEntry.resourceName": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceName(childComplexity), true - case "JobDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceName == nil { + case "JobTriggeredActivityLogEntry.resourceType": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceType(childComplexity), true - case "JobDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceType == nil { + case "JobTriggeredActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug(childComplexity), true - case "JobDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.JobDeletedActivityLogEntry.TeamSlug == nil { + case "JobUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.Actor(childComplexity), true - case "JobEdge.cursor": - if e.ComplexityRoot.JobEdge.Cursor == nil { + case "JobUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.JobEdge.Cursor(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "JobEdge.node": - if e.ComplexityRoot.JobEdge.Node == nil { + case "JobUpdatedActivityLogEntry.data": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.JobEdge.Node(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.Data(childComplexity), true - case "JobManifest.content": - if e.ComplexityRoot.JobManifest.Content == nil { + case "JobUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.JobManifest.Content(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "JobResources.limits": - if e.ComplexityRoot.JobResources.Limits == nil { + case "JobUpdatedActivityLogEntry.id": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.JobResources.Limits(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.ID(childComplexity), true - case "JobResources.requests": - if e.ComplexityRoot.JobResources.Requests == nil { + case "JobUpdatedActivityLogEntry.message": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.JobResources.Requests(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.Message(childComplexity), true - case "JobRun.completionTime": - if e.ComplexityRoot.JobRun.CompletionTime == nil { + case "JobUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.JobRun.CompletionTime(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "JobRun.duration": - if e.ComplexityRoot.JobRun.Duration == nil { + case "JobUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.JobRun.Duration(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "JobRun.id": - if e.ComplexityRoot.JobRun.ID == nil { + case "JobUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.JobRun.ID(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "JobRun.image": - if e.ComplexityRoot.JobRun.Image == nil { + case "KafkaCredentials.accessCert": + if e.ComplexityRoot.KafkaCredentials.AccessCert == nil { break } - return e.ComplexityRoot.JobRun.Image(childComplexity), true + return e.ComplexityRoot.KafkaCredentials.AccessCert(childComplexity), true - case "JobRun.instances": - if e.ComplexityRoot.JobRun.Instances == nil { + case "KafkaCredentials.accessKey": + if e.ComplexityRoot.KafkaCredentials.AccessKey == nil { break } - args, err := ec.field_JobRun_instances_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.JobRun.Instances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.KafkaCredentials.AccessKey(childComplexity), true - case "JobRun.name": - if e.ComplexityRoot.JobRun.Name == nil { + case "KafkaCredentials.brokers": + if e.ComplexityRoot.KafkaCredentials.Brokers == nil { break } - return e.ComplexityRoot.JobRun.Name(childComplexity), true + return e.ComplexityRoot.KafkaCredentials.Brokers(childComplexity), true - case "JobRun.startTime": - if e.ComplexityRoot.JobRun.StartTime == nil { + case "KafkaCredentials.caCert": + if e.ComplexityRoot.KafkaCredentials.CaCert == nil { break } - return e.ComplexityRoot.JobRun.StartTime(childComplexity), true + return e.ComplexityRoot.KafkaCredentials.CaCert(childComplexity), true - case "JobRun.status": - if e.ComplexityRoot.JobRun.Status == nil { + case "KafkaCredentials.schemaRegistry": + if e.ComplexityRoot.KafkaCredentials.SchemaRegistry == nil { break } - return e.ComplexityRoot.JobRun.Status(childComplexity), true + return e.ComplexityRoot.KafkaCredentials.SchemaRegistry(childComplexity), true - case "JobRun.trigger": - if e.ComplexityRoot.JobRun.Trigger == nil { + case "KafkaCredentials.username": + if e.ComplexityRoot.KafkaCredentials.Username == nil { break } - return e.ComplexityRoot.JobRun.Trigger(childComplexity), true + return e.ComplexityRoot.KafkaCredentials.Username(childComplexity), true - case "JobRunConnection.edges": - if e.ComplexityRoot.JobRunConnection.Edges == nil { + case "KafkaLagScalingStrategy.consumerGroup": + if e.ComplexityRoot.KafkaLagScalingStrategy.ConsumerGroup == nil { break } - return e.ComplexityRoot.JobRunConnection.Edges(childComplexity), true + return e.ComplexityRoot.KafkaLagScalingStrategy.ConsumerGroup(childComplexity), true - case "JobRunConnection.nodes": - if e.ComplexityRoot.JobRunConnection.Nodes == nil { + case "KafkaLagScalingStrategy.threshold": + if e.ComplexityRoot.KafkaLagScalingStrategy.Threshold == nil { break } - return e.ComplexityRoot.JobRunConnection.Nodes(childComplexity), true + return e.ComplexityRoot.KafkaLagScalingStrategy.Threshold(childComplexity), true - case "JobRunConnection.pageInfo": - if e.ComplexityRoot.JobRunConnection.PageInfo == nil { + case "KafkaLagScalingStrategy.topicName": + if e.ComplexityRoot.KafkaLagScalingStrategy.TopicName == nil { break } - return e.ComplexityRoot.JobRunConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.KafkaLagScalingStrategy.TopicName(childComplexity), true - case "JobRunDeletedActivityLogEntry.actor": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.Actor == nil { + case "KafkaTopic.acl": + if e.ComplexityRoot.KafkaTopic.ACL == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.Actor(childComplexity), true - - case "JobRunDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_KafkaTopic_acl_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.KafkaTopic.ACL(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*kafkatopic.KafkaTopicACLFilter), args["orderBy"].(*kafkatopic.KafkaTopicACLOrder)), true - case "JobRunDeletedActivityLogEntry.data": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.Data == nil { + case "KafkaTopic.configuration": + if e.ComplexityRoot.KafkaTopic.Configuration == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.KafkaTopic.Configuration(childComplexity), true - case "JobRunDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.EnvironmentName == nil { + case "KafkaTopic.environment": + if e.ComplexityRoot.KafkaTopic.Environment == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.KafkaTopic.Environment(childComplexity), true - case "JobRunDeletedActivityLogEntry.id": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.ID == nil { + case "KafkaTopic.id": + if e.ComplexityRoot.KafkaTopic.ID == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.KafkaTopic.ID(childComplexity), true - case "JobRunDeletedActivityLogEntry.message": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.Message == nil { + case "KafkaTopic.name": + if e.ComplexityRoot.KafkaTopic.Name == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.KafkaTopic.Name(childComplexity), true - case "JobRunDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceName == nil { + case "KafkaTopic.pool": + if e.ComplexityRoot.KafkaTopic.Pool == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.KafkaTopic.Pool(childComplexity), true - case "JobRunDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceType == nil { + case "KafkaTopic.team": + if e.ComplexityRoot.KafkaTopic.Team == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.KafkaTopic.Team(childComplexity), true - case "JobRunDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.TeamSlug == nil { + case "KafkaTopic.teamEnvironment": + if e.ComplexityRoot.KafkaTopic.TeamEnvironment == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.KafkaTopic.TeamEnvironment(childComplexity), true - case "JobRunDeletedActivityLogEntryData.runName": - if e.ComplexityRoot.JobRunDeletedActivityLogEntryData.RunName == nil { + case "KafkaTopicAcl.access": + if e.ComplexityRoot.KafkaTopicAcl.Access == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntryData.RunName(childComplexity), true + return e.ComplexityRoot.KafkaTopicAcl.Access(childComplexity), true - case "JobRunEdge.cursor": - if e.ComplexityRoot.JobRunEdge.Cursor == nil { + case "KafkaTopicAcl.team": + if e.ComplexityRoot.KafkaTopicAcl.Team == nil { break } - return e.ComplexityRoot.JobRunEdge.Cursor(childComplexity), true + return e.ComplexityRoot.KafkaTopicAcl.Team(childComplexity), true - case "JobRunEdge.node": - if e.ComplexityRoot.JobRunEdge.Node == nil { + case "KafkaTopicAcl.teamName": + if e.ComplexityRoot.KafkaTopicAcl.TeamName == nil { break } - return e.ComplexityRoot.JobRunEdge.Node(childComplexity), true + return e.ComplexityRoot.KafkaTopicAcl.TeamName(childComplexity), true - case "JobRunInstance.id": - if e.ComplexityRoot.JobRunInstance.ID == nil { + case "KafkaTopicAcl.topic": + if e.ComplexityRoot.KafkaTopicAcl.Topic == nil { break } - return e.ComplexityRoot.JobRunInstance.ID(childComplexity), true + return e.ComplexityRoot.KafkaTopicAcl.Topic(childComplexity), true - case "JobRunInstance.name": - if e.ComplexityRoot.JobRunInstance.Name == nil { + case "KafkaTopicAcl.workload": + if e.ComplexityRoot.KafkaTopicAcl.Workload == nil { break } - return e.ComplexityRoot.JobRunInstance.Name(childComplexity), true + return e.ComplexityRoot.KafkaTopicAcl.Workload(childComplexity), true - case "JobRunInstanceConnection.edges": - if e.ComplexityRoot.JobRunInstanceConnection.Edges == nil { + case "KafkaTopicAcl.workloadName": + if e.ComplexityRoot.KafkaTopicAcl.WorkloadName == nil { break } - return e.ComplexityRoot.JobRunInstanceConnection.Edges(childComplexity), true + return e.ComplexityRoot.KafkaTopicAcl.WorkloadName(childComplexity), true - case "JobRunInstanceConnection.nodes": - if e.ComplexityRoot.JobRunInstanceConnection.Nodes == nil { + case "KafkaTopicAclConnection.edges": + if e.ComplexityRoot.KafkaTopicAclConnection.Edges == nil { break } - return e.ComplexityRoot.JobRunInstanceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.KafkaTopicAclConnection.Edges(childComplexity), true - case "JobRunInstanceConnection.pageInfo": - if e.ComplexityRoot.JobRunInstanceConnection.PageInfo == nil { + case "KafkaTopicAclConnection.nodes": + if e.ComplexityRoot.KafkaTopicAclConnection.Nodes == nil { break } - return e.ComplexityRoot.JobRunInstanceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.KafkaTopicAclConnection.Nodes(childComplexity), true - case "JobRunInstanceEdge.cursor": - if e.ComplexityRoot.JobRunInstanceEdge.Cursor == nil { + case "KafkaTopicAclConnection.pageInfo": + if e.ComplexityRoot.KafkaTopicAclConnection.PageInfo == nil { break } - return e.ComplexityRoot.JobRunInstanceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.KafkaTopicAclConnection.PageInfo(childComplexity), true - case "JobRunInstanceEdge.node": - if e.ComplexityRoot.JobRunInstanceEdge.Node == nil { + case "KafkaTopicAclEdge.cursor": + if e.ComplexityRoot.KafkaTopicAclEdge.Cursor == nil { break } - return e.ComplexityRoot.JobRunInstanceEdge.Node(childComplexity), true + return e.ComplexityRoot.KafkaTopicAclEdge.Cursor(childComplexity), true - case "JobRunStatus.message": - if e.ComplexityRoot.JobRunStatus.Message == nil { + case "KafkaTopicAclEdge.node": + if e.ComplexityRoot.KafkaTopicAclEdge.Node == nil { break } - return e.ComplexityRoot.JobRunStatus.Message(childComplexity), true + return e.ComplexityRoot.KafkaTopicAclEdge.Node(childComplexity), true - case "JobRunStatus.state": - if e.ComplexityRoot.JobRunStatus.State == nil { + case "KafkaTopicConfiguration.cleanupPolicy": + if e.ComplexityRoot.KafkaTopicConfiguration.CleanupPolicy == nil { break } - return e.ComplexityRoot.JobRunStatus.State(childComplexity), true + return e.ComplexityRoot.KafkaTopicConfiguration.CleanupPolicy(childComplexity), true - case "JobRunTrigger.actor": - if e.ComplexityRoot.JobRunTrigger.Actor == nil { + case "KafkaTopicConfiguration.maxMessageBytes": + if e.ComplexityRoot.KafkaTopicConfiguration.MaxMessageBytes == nil { break } - return e.ComplexityRoot.JobRunTrigger.Actor(childComplexity), true + return e.ComplexityRoot.KafkaTopicConfiguration.MaxMessageBytes(childComplexity), true - case "JobRunTrigger.type": - if e.ComplexityRoot.JobRunTrigger.Type == nil { + case "KafkaTopicConfiguration.minimumInSyncReplicas": + if e.ComplexityRoot.KafkaTopicConfiguration.MinimumInSyncReplicas == nil { break } - return e.ComplexityRoot.JobRunTrigger.Type(childComplexity), true + return e.ComplexityRoot.KafkaTopicConfiguration.MinimumInSyncReplicas(childComplexity), true - case "JobSchedule.expression": - if e.ComplexityRoot.JobSchedule.Expression == nil { + case "KafkaTopicConfiguration.partitions": + if e.ComplexityRoot.KafkaTopicConfiguration.Partitions == nil { break } - return e.ComplexityRoot.JobSchedule.Expression(childComplexity), true + return e.ComplexityRoot.KafkaTopicConfiguration.Partitions(childComplexity), true - case "JobSchedule.timeZone": - if e.ComplexityRoot.JobSchedule.TimeZone == nil { + case "KafkaTopicConfiguration.replication": + if e.ComplexityRoot.KafkaTopicConfiguration.Replication == nil { break } - return e.ComplexityRoot.JobSchedule.TimeZone(childComplexity), true + return e.ComplexityRoot.KafkaTopicConfiguration.Replication(childComplexity), true - case "JobTriggeredActivityLogEntry.actor": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.Actor == nil { + case "KafkaTopicConfiguration.retentionBytes": + if e.ComplexityRoot.KafkaTopicConfiguration.RetentionBytes == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.KafkaTopicConfiguration.RetentionBytes(childComplexity), true - case "JobTriggeredActivityLogEntry.createdAt": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.CreatedAt == nil { + case "KafkaTopicConfiguration.retentionHours": + if e.ComplexityRoot.KafkaTopicConfiguration.RetentionHours == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.KafkaTopicConfiguration.RetentionHours(childComplexity), true - case "JobTriggeredActivityLogEntry.environmentName": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.EnvironmentName == nil { + case "KafkaTopicConfiguration.segmentHours": + if e.ComplexityRoot.KafkaTopicConfiguration.SegmentHours == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.KafkaTopicConfiguration.SegmentHours(childComplexity), true - case "JobTriggeredActivityLogEntry.id": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.ID == nil { + case "KafkaTopicConnection.edges": + if e.ComplexityRoot.KafkaTopicConnection.Edges == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.KafkaTopicConnection.Edges(childComplexity), true - case "JobTriggeredActivityLogEntry.message": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.Message == nil { + case "KafkaTopicConnection.nodes": + if e.ComplexityRoot.KafkaTopicConnection.Nodes == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.KafkaTopicConnection.Nodes(childComplexity), true - case "JobTriggeredActivityLogEntry.resourceName": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceName == nil { + case "KafkaTopicConnection.pageInfo": + if e.ComplexityRoot.KafkaTopicConnection.PageInfo == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.KafkaTopicConnection.PageInfo(childComplexity), true - case "JobTriggeredActivityLogEntry.resourceType": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceType == nil { + case "KafkaTopicEdge.cursor": + if e.ComplexityRoot.KafkaTopicEdge.Cursor == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.KafkaTopicEdge.Cursor(childComplexity), true - case "JobTriggeredActivityLogEntry.teamSlug": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug == nil { + case "KafkaTopicEdge.node": + if e.ComplexityRoot.KafkaTopicEdge.Node == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.KafkaTopicEdge.Node(childComplexity), true - case "JobUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.Actor == nil { + case "LastRunFailedIssue.id": + if e.ComplexityRoot.LastRunFailedIssue.ID == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.LastRunFailedIssue.ID(childComplexity), true - case "JobUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.CreatedAt == nil { + case "LastRunFailedIssue.job": + if e.ComplexityRoot.LastRunFailedIssue.Job == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.LastRunFailedIssue.Job(childComplexity), true - case "JobUpdatedActivityLogEntry.data": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.Data == nil { + case "LastRunFailedIssue.message": + if e.ComplexityRoot.LastRunFailedIssue.Message == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.LastRunFailedIssue.Message(childComplexity), true - case "JobUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.EnvironmentName == nil { + case "LastRunFailedIssue.severity": + if e.ComplexityRoot.LastRunFailedIssue.Severity == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.LastRunFailedIssue.Severity(childComplexity), true - case "JobUpdatedActivityLogEntry.id": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.ID == nil { + case "LastRunFailedIssue.teamEnvironment": + if e.ComplexityRoot.LastRunFailedIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.LastRunFailedIssue.TeamEnvironment(childComplexity), true - case "JobUpdatedActivityLogEntry.message": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.Message == nil { + case "LogDestinationGeneric.id": + if e.ComplexityRoot.LogDestinationGeneric.ID == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.LogDestinationGeneric.ID(childComplexity), true - case "JobUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceName == nil { + case "LogDestinationGeneric.name": + if e.ComplexityRoot.LogDestinationGeneric.Name == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.LogDestinationGeneric.Name(childComplexity), true - case "JobUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceType == nil { + case "LogDestinationLoki.grafanaURL": + if e.ComplexityRoot.LogDestinationLoki.GrafanaURL == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.LogDestinationLoki.GrafanaURL(childComplexity), true - case "JobUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.TeamSlug == nil { + case "LogDestinationLoki.id": + if e.ComplexityRoot.LogDestinationLoki.ID == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.LogDestinationLoki.ID(childComplexity), true - case "KafkaCredentials.accessCert": - if e.ComplexityRoot.KafkaCredentials.AccessCert == nil { + case "LogDestinationSecureLogs.id": + if e.ComplexityRoot.LogDestinationSecureLogs.ID == nil { break } - return e.ComplexityRoot.KafkaCredentials.AccessCert(childComplexity), true + return e.ComplexityRoot.LogDestinationSecureLogs.ID(childComplexity), true - case "KafkaCredentials.accessKey": - if e.ComplexityRoot.KafkaCredentials.AccessKey == nil { + case "LogLine.labels": + if e.ComplexityRoot.LogLine.Labels == nil { break } - return e.ComplexityRoot.KafkaCredentials.AccessKey(childComplexity), true + return e.ComplexityRoot.LogLine.Labels(childComplexity), true - case "KafkaCredentials.brokers": - if e.ComplexityRoot.KafkaCredentials.Brokers == nil { + case "LogLine.message": + if e.ComplexityRoot.LogLine.Message == nil { break } - return e.ComplexityRoot.KafkaCredentials.Brokers(childComplexity), true + return e.ComplexityRoot.LogLine.Message(childComplexity), true - case "KafkaCredentials.caCert": - if e.ComplexityRoot.KafkaCredentials.CaCert == nil { + case "LogLine.time": + if e.ComplexityRoot.LogLine.Time == nil { break } - return e.ComplexityRoot.KafkaCredentials.CaCert(childComplexity), true + return e.ComplexityRoot.LogLine.Time(childComplexity), true - case "KafkaCredentials.schemaRegistry": - if e.ComplexityRoot.KafkaCredentials.SchemaRegistry == nil { + case "LogLineLabel.key": + if e.ComplexityRoot.LogLineLabel.Key == nil { break } - return e.ComplexityRoot.KafkaCredentials.SchemaRegistry(childComplexity), true + return e.ComplexityRoot.LogLineLabel.Key(childComplexity), true - case "KafkaCredentials.username": - if e.ComplexityRoot.KafkaCredentials.Username == nil { + case "LogLineLabel.value": + if e.ComplexityRoot.LogLineLabel.Value == nil { break } - return e.ComplexityRoot.KafkaCredentials.Username(childComplexity), true + return e.ComplexityRoot.LogLineLabel.Value(childComplexity), true - case "KafkaLagScalingStrategy.consumerGroup": - if e.ComplexityRoot.KafkaLagScalingStrategy.ConsumerGroup == nil { + case "MaintenanceWindow.dayOfWeek": + if e.ComplexityRoot.MaintenanceWindow.DayOfWeek == nil { break } - return e.ComplexityRoot.KafkaLagScalingStrategy.ConsumerGroup(childComplexity), true + return e.ComplexityRoot.MaintenanceWindow.DayOfWeek(childComplexity), true - case "KafkaLagScalingStrategy.threshold": - if e.ComplexityRoot.KafkaLagScalingStrategy.Threshold == nil { + case "MaintenanceWindow.timeOfDay": + if e.ComplexityRoot.MaintenanceWindow.TimeOfDay == nil { break } - return e.ComplexityRoot.KafkaLagScalingStrategy.Threshold(childComplexity), true + return e.ComplexityRoot.MaintenanceWindow.TimeOfDay(childComplexity), true - case "KafkaLagScalingStrategy.topicName": - if e.ComplexityRoot.KafkaLagScalingStrategy.TopicName == nil { + case "MaskinportenAuthIntegration.name": + if e.ComplexityRoot.MaskinportenAuthIntegration.Name == nil { break } - return e.ComplexityRoot.KafkaLagScalingStrategy.TopicName(childComplexity), true + return e.ComplexityRoot.MaskinportenAuthIntegration.Name(childComplexity), true - case "KafkaTopic.acl": - if e.ComplexityRoot.KafkaTopic.ACL == nil { + case "MetricLabel.name": + if e.ComplexityRoot.MetricLabel.Name == nil { break } - args, err := ec.field_KafkaTopic_acl_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.KafkaTopic.ACL(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*kafkatopic.KafkaTopicACLFilter), args["orderBy"].(*kafkatopic.KafkaTopicACLOrder)), true + return e.ComplexityRoot.MetricLabel.Name(childComplexity), true - case "KafkaTopic.configuration": - if e.ComplexityRoot.KafkaTopic.Configuration == nil { + case "MetricLabel.value": + if e.ComplexityRoot.MetricLabel.Value == nil { break } - return e.ComplexityRoot.KafkaTopic.Configuration(childComplexity), true + return e.ComplexityRoot.MetricLabel.Value(childComplexity), true - case "KafkaTopic.environment": - if e.ComplexityRoot.KafkaTopic.Environment == nil { + case "MetricSeries.labels": + if e.ComplexityRoot.MetricSeries.Labels == nil { break } - return e.ComplexityRoot.KafkaTopic.Environment(childComplexity), true + return e.ComplexityRoot.MetricSeries.Labels(childComplexity), true - case "KafkaTopic.id": - if e.ComplexityRoot.KafkaTopic.ID == nil { + case "MetricSeries.values": + if e.ComplexityRoot.MetricSeries.Values == nil { break } - return e.ComplexityRoot.KafkaTopic.ID(childComplexity), true + return e.ComplexityRoot.MetricSeries.Values(childComplexity), true - case "KafkaTopic.name": - if e.ComplexityRoot.KafkaTopic.Name == nil { + case "MetricValue.timestamp": + if e.ComplexityRoot.MetricValue.Timestamp == nil { break } - return e.ComplexityRoot.KafkaTopic.Name(childComplexity), true + return e.ComplexityRoot.MetricValue.Timestamp(childComplexity), true - case "KafkaTopic.pool": - if e.ComplexityRoot.KafkaTopic.Pool == nil { + case "MetricValue.value": + if e.ComplexityRoot.MetricValue.Value == nil { break } - return e.ComplexityRoot.KafkaTopic.Pool(childComplexity), true + return e.ComplexityRoot.MetricValue.Value(childComplexity), true - case "KafkaTopic.team": - if e.ComplexityRoot.KafkaTopic.Team == nil { + case "MetricsQueryResult.series": + if e.ComplexityRoot.MetricsQueryResult.Series == nil { break } - return e.ComplexityRoot.KafkaTopic.Team(childComplexity), true + return e.ComplexityRoot.MetricsQueryResult.Series(childComplexity), true - case "KafkaTopic.teamEnvironment": - if e.ComplexityRoot.KafkaTopic.TeamEnvironment == nil { + case "MetricsQueryResult.warnings": + if e.ComplexityRoot.MetricsQueryResult.Warnings == nil { break } - return e.ComplexityRoot.KafkaTopic.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.MetricsQueryResult.Warnings(childComplexity), true - case "KafkaTopicAcl.access": - if e.ComplexityRoot.KafkaTopicAcl.Access == nil { + case "MissingSbomIssue.id": + if e.ComplexityRoot.MissingSbomIssue.ID == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.Access(childComplexity), true + return e.ComplexityRoot.MissingSbomIssue.ID(childComplexity), true - case "KafkaTopicAcl.team": - if e.ComplexityRoot.KafkaTopicAcl.Team == nil { + case "MissingSbomIssue.message": + if e.ComplexityRoot.MissingSbomIssue.Message == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.Team(childComplexity), true + return e.ComplexityRoot.MissingSbomIssue.Message(childComplexity), true - case "KafkaTopicAcl.teamName": - if e.ComplexityRoot.KafkaTopicAcl.TeamName == nil { + case "MissingSbomIssue.severity": + if e.ComplexityRoot.MissingSbomIssue.Severity == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.TeamName(childComplexity), true + return e.ComplexityRoot.MissingSbomIssue.Severity(childComplexity), true - case "KafkaTopicAcl.topic": - if e.ComplexityRoot.KafkaTopicAcl.Topic == nil { + case "MissingSbomIssue.teamEnvironment": + if e.ComplexityRoot.MissingSbomIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.Topic(childComplexity), true + return e.ComplexityRoot.MissingSbomIssue.TeamEnvironment(childComplexity), true - case "KafkaTopicAcl.workload": - if e.ComplexityRoot.KafkaTopicAcl.Workload == nil { + case "MissingSbomIssue.workload": + if e.ComplexityRoot.MissingSbomIssue.Workload == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.Workload(childComplexity), true + return e.ComplexityRoot.MissingSbomIssue.Workload(childComplexity), true - case "KafkaTopicAcl.workloadName": - if e.ComplexityRoot.KafkaTopicAcl.WorkloadName == nil { + case "Mutation.addRepositoryToTeam": + if e.ComplexityRoot.Mutation.AddRepositoryToTeam == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.WorkloadName(childComplexity), true - - case "KafkaTopicAclConnection.edges": - if e.ComplexityRoot.KafkaTopicAclConnection.Edges == nil { - break + args, err := ec.field_Mutation_addRepositoryToTeam_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.KafkaTopicAclConnection.Edges(childComplexity), true + return e.ComplexityRoot.Mutation.AddRepositoryToTeam(childComplexity, args["input"].(repository.AddRepositoryToTeamInput)), true - case "KafkaTopicAclConnection.nodes": - if e.ComplexityRoot.KafkaTopicAclConnection.Nodes == nil { + case "Mutation.addSecretValue": + if e.ComplexityRoot.Mutation.AddSecretValue == nil { break } - return e.ComplexityRoot.KafkaTopicAclConnection.Nodes(childComplexity), true - - case "KafkaTopicAclConnection.pageInfo": - if e.ComplexityRoot.KafkaTopicAclConnection.PageInfo == nil { - break + args, err := ec.field_Mutation_addSecretValue_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.KafkaTopicAclConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Mutation.AddSecretValue(childComplexity, args["input"].(secret.AddSecretValueInput)), true - case "KafkaTopicAclEdge.cursor": - if e.ComplexityRoot.KafkaTopicAclEdge.Cursor == nil { + case "Mutation.addTeamMember": + if e.ComplexityRoot.Mutation.AddTeamMember == nil { break } - return e.ComplexityRoot.KafkaTopicAclEdge.Cursor(childComplexity), true - - case "KafkaTopicAclEdge.node": - if e.ComplexityRoot.KafkaTopicAclEdge.Node == nil { - break + args, err := ec.field_Mutation_addTeamMember_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.KafkaTopicAclEdge.Node(childComplexity), true + return e.ComplexityRoot.Mutation.AddTeamMember(childComplexity, args["input"].(team.AddTeamMemberInput)), true - case "KafkaTopicConfiguration.cleanupPolicy": - if e.ComplexityRoot.KafkaTopicConfiguration.CleanupPolicy == nil { + case "Mutation.allowTeamAccessToUnleash": + if e.ComplexityRoot.Mutation.AllowTeamAccessToUnleash == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.CleanupPolicy(childComplexity), true - - case "KafkaTopicConfiguration.maxMessageBytes": - if e.ComplexityRoot.KafkaTopicConfiguration.MaxMessageBytes == nil { - break + args, err := ec.field_Mutation_allowTeamAccessToUnleash_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.KafkaTopicConfiguration.MaxMessageBytes(childComplexity), true + return e.ComplexityRoot.Mutation.AllowTeamAccessToUnleash(childComplexity, args["input"].(unleash.AllowTeamAccessToUnleashInput)), true - case "KafkaTopicConfiguration.minimumInSyncReplicas": - if e.ComplexityRoot.KafkaTopicConfiguration.MinimumInSyncReplicas == nil { + case "Mutation.assignRoleToServiceAccount": + if e.ComplexityRoot.Mutation.AssignRoleToServiceAccount == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.MinimumInSyncReplicas(childComplexity), true - - case "KafkaTopicConfiguration.partitions": - if e.ComplexityRoot.KafkaTopicConfiguration.Partitions == nil { - break + args, err := ec.field_Mutation_assignRoleToServiceAccount_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.KafkaTopicConfiguration.Partitions(childComplexity), true + return e.ComplexityRoot.Mutation.AssignRoleToServiceAccount(childComplexity, args["input"].(serviceaccount.AssignRoleToServiceAccountInput)), true - case "KafkaTopicConfiguration.replication": - if e.ComplexityRoot.KafkaTopicConfiguration.Replication == nil { + case "Mutation.changeDeploymentKey": + if e.ComplexityRoot.Mutation.ChangeDeploymentKey == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.Replication(childComplexity), true - - case "KafkaTopicConfiguration.retentionBytes": - if e.ComplexityRoot.KafkaTopicConfiguration.RetentionBytes == nil { - break + args, err := ec.field_Mutation_changeDeploymentKey_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.KafkaTopicConfiguration.RetentionBytes(childComplexity), true + return e.ComplexityRoot.Mutation.ChangeDeploymentKey(childComplexity, args["input"].(deployment.ChangeDeploymentKeyInput)), true - case "KafkaTopicConfiguration.retentionHours": - if e.ComplexityRoot.KafkaTopicConfiguration.RetentionHours == nil { + case "Mutation.configureReconciler": + if e.ComplexityRoot.Mutation.ConfigureReconciler == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.RetentionHours(childComplexity), true - - case "KafkaTopicConfiguration.segmentHours": - if e.ComplexityRoot.KafkaTopicConfiguration.SegmentHours == nil { - break + args, err := ec.field_Mutation_configureReconciler_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.KafkaTopicConfiguration.SegmentHours(childComplexity), true + return e.ComplexityRoot.Mutation.ConfigureReconciler(childComplexity, args["input"].(reconciler.ConfigureReconcilerInput)), true - case "KafkaTopicConnection.edges": - if e.ComplexityRoot.KafkaTopicConnection.Edges == nil { + case "Mutation.confirmTeamDeletion": + if e.ComplexityRoot.Mutation.ConfirmTeamDeletion == nil { break } - return e.ComplexityRoot.KafkaTopicConnection.Edges(childComplexity), true - - case "KafkaTopicConnection.nodes": - if e.ComplexityRoot.KafkaTopicConnection.Nodes == nil { - break + args, err := ec.field_Mutation_confirmTeamDeletion_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.KafkaTopicConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Mutation.ConfirmTeamDeletion(childComplexity, args["input"].(team.ConfirmTeamDeletionInput)), true - case "KafkaTopicConnection.pageInfo": - if e.ComplexityRoot.KafkaTopicConnection.PageInfo == nil { + case "Mutation.createKafkaCredentials": + if e.ComplexityRoot.Mutation.CreateKafkaCredentials == nil { break } - return e.ComplexityRoot.KafkaTopicConnection.PageInfo(childComplexity), true - - case "KafkaTopicEdge.cursor": - if e.ComplexityRoot.KafkaTopicEdge.Cursor == nil { - break + args, err := ec.field_Mutation_createKafkaCredentials_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.KafkaTopicEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Mutation.CreateKafkaCredentials(childComplexity, args["input"].(aivencredentials.CreateKafkaCredentialsInput)), true - case "KafkaTopicEdge.node": - if e.ComplexityRoot.KafkaTopicEdge.Node == nil { + case "Mutation.createOpenSearch": + if e.ComplexityRoot.Mutation.CreateOpenSearch == nil { break } - return e.ComplexityRoot.KafkaTopicEdge.Node(childComplexity), true - - case "LastRunFailedIssue.id": - if e.ComplexityRoot.LastRunFailedIssue.ID == nil { - break + args, err := ec.field_Mutation_createOpenSearch_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.LastRunFailedIssue.ID(childComplexity), true + return e.ComplexityRoot.Mutation.CreateOpenSearch(childComplexity, args["input"].(opensearch.CreateOpenSearchInput)), true - case "LastRunFailedIssue.job": - if e.ComplexityRoot.LastRunFailedIssue.Job == nil { + case "Mutation.createOpenSearchCredentials": + if e.ComplexityRoot.Mutation.CreateOpenSearchCredentials == nil { break } - return e.ComplexityRoot.LastRunFailedIssue.Job(childComplexity), true - - case "LastRunFailedIssue.message": - if e.ComplexityRoot.LastRunFailedIssue.Message == nil { - break + args, err := ec.field_Mutation_createOpenSearchCredentials_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.LastRunFailedIssue.Message(childComplexity), true + return e.ComplexityRoot.Mutation.CreateOpenSearchCredentials(childComplexity, args["input"].(aivencredentials.CreateOpenSearchCredentialsInput)), true - case "LastRunFailedIssue.severity": - if e.ComplexityRoot.LastRunFailedIssue.Severity == nil { + case "Mutation.createSecret": + if e.ComplexityRoot.Mutation.CreateSecret == nil { break } - return e.ComplexityRoot.LastRunFailedIssue.Severity(childComplexity), true - - case "LastRunFailedIssue.teamEnvironment": - if e.ComplexityRoot.LastRunFailedIssue.TeamEnvironment == nil { - break + args, err := ec.field_Mutation_createSecret_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.LastRunFailedIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.Mutation.CreateSecret(childComplexity, args["input"].(secret.CreateSecretInput)), true - case "LogDestinationGeneric.id": - if e.ComplexityRoot.LogDestinationGeneric.ID == nil { + case "Mutation.createServiceAccount": + if e.ComplexityRoot.Mutation.CreateServiceAccount == nil { break } - return e.ComplexityRoot.LogDestinationGeneric.ID(childComplexity), true - - case "LogDestinationGeneric.name": - if e.ComplexityRoot.LogDestinationGeneric.Name == nil { - break + args, err := ec.field_Mutation_createServiceAccount_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.LogDestinationGeneric.Name(childComplexity), true + return e.ComplexityRoot.Mutation.CreateServiceAccount(childComplexity, args["input"].(serviceaccount.CreateServiceAccountInput)), true - case "LogDestinationLoki.grafanaURL": - if e.ComplexityRoot.LogDestinationLoki.GrafanaURL == nil { + case "Mutation.createServiceAccountToken": + if e.ComplexityRoot.Mutation.CreateServiceAccountToken == nil { break } - return e.ComplexityRoot.LogDestinationLoki.GrafanaURL(childComplexity), true - - case "LogDestinationLoki.id": - if e.ComplexityRoot.LogDestinationLoki.ID == nil { - break + args, err := ec.field_Mutation_createServiceAccountToken_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.LogDestinationLoki.ID(childComplexity), true + return e.ComplexityRoot.Mutation.CreateServiceAccountToken(childComplexity, args["input"].(serviceaccount.CreateServiceAccountTokenInput)), true - case "LogDestinationSecureLogs.id": - if e.ComplexityRoot.LogDestinationSecureLogs.ID == nil { + case "Mutation.createTeam": + if e.ComplexityRoot.Mutation.CreateTeam == nil { break } - return e.ComplexityRoot.LogDestinationSecureLogs.ID(childComplexity), true - - case "LogLine.labels": - if e.ComplexityRoot.LogLine.Labels == nil { - break + args, err := ec.field_Mutation_createTeam_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.LogLine.Labels(childComplexity), true + return e.ComplexityRoot.Mutation.CreateTeam(childComplexity, args["input"].(team.CreateTeamInput)), true - case "LogLine.message": - if e.ComplexityRoot.LogLine.Message == nil { + case "Mutation.createUnleashForTeam": + if e.ComplexityRoot.Mutation.CreateUnleashForTeam == nil { break } - return e.ComplexityRoot.LogLine.Message(childComplexity), true - - case "LogLine.time": - if e.ComplexityRoot.LogLine.Time == nil { - break + args, err := ec.field_Mutation_createUnleashForTeam_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.LogLine.Time(childComplexity), true + return e.ComplexityRoot.Mutation.CreateUnleashForTeam(childComplexity, args["input"].(unleash.CreateUnleashForTeamInput)), true - case "LogLineLabel.key": - if e.ComplexityRoot.LogLineLabel.Key == nil { + case "Mutation.createValkey": + if e.ComplexityRoot.Mutation.CreateValkey == nil { break } - return e.ComplexityRoot.LogLineLabel.Key(childComplexity), true - - case "LogLineLabel.value": - if e.ComplexityRoot.LogLineLabel.Value == nil { - break + args, err := ec.field_Mutation_createValkey_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.LogLineLabel.Value(childComplexity), true + return e.ComplexityRoot.Mutation.CreateValkey(childComplexity, args["input"].(valkey.CreateValkeyInput)), true - case "MaintenanceWindow.dayOfWeek": - if e.ComplexityRoot.MaintenanceWindow.DayOfWeek == nil { + case "Mutation.createValkeyCredentials": + if e.ComplexityRoot.Mutation.CreateValkeyCredentials == nil { break } - return e.ComplexityRoot.MaintenanceWindow.DayOfWeek(childComplexity), true - - case "MaintenanceWindow.timeOfDay": - if e.ComplexityRoot.MaintenanceWindow.TimeOfDay == nil { - break + args, err := ec.field_Mutation_createValkeyCredentials_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.MaintenanceWindow.TimeOfDay(childComplexity), true + return e.ComplexityRoot.Mutation.CreateValkeyCredentials(childComplexity, args["input"].(aivencredentials.CreateValkeyCredentialsInput)), true - case "MaskinportenAuthIntegration.name": - if e.ComplexityRoot.MaskinportenAuthIntegration.Name == nil { + case "Mutation.deleteApplication": + if e.ComplexityRoot.Mutation.DeleteApplication == nil { break } - return e.ComplexityRoot.MaskinportenAuthIntegration.Name(childComplexity), true - - case "MetricLabel.name": - if e.ComplexityRoot.MetricLabel.Name == nil { - break + args, err := ec.field_Mutation_deleteApplication_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.MetricLabel.Name(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteApplication(childComplexity, args["input"].(application.DeleteApplicationInput)), true - case "MetricLabel.value": - if e.ComplexityRoot.MetricLabel.Value == nil { + case "Mutation.deleteJob": + if e.ComplexityRoot.Mutation.DeleteJob == nil { break } - return e.ComplexityRoot.MetricLabel.Value(childComplexity), true - - case "MetricSeries.labels": - if e.ComplexityRoot.MetricSeries.Labels == nil { - break + args, err := ec.field_Mutation_deleteJob_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.MetricSeries.Labels(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteJob(childComplexity, args["input"].(job.DeleteJobInput)), true - case "MetricSeries.values": - if e.ComplexityRoot.MetricSeries.Values == nil { + case "Mutation.deleteJobRun": + if e.ComplexityRoot.Mutation.DeleteJobRun == nil { break } - return e.ComplexityRoot.MetricSeries.Values(childComplexity), true - - case "MetricValue.timestamp": - if e.ComplexityRoot.MetricValue.Timestamp == nil { - break + args, err := ec.field_Mutation_deleteJobRun_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.MetricValue.Timestamp(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteJobRun(childComplexity, args["input"].(job.DeleteJobRunInput)), true - case "MetricValue.value": - if e.ComplexityRoot.MetricValue.Value == nil { + case "Mutation.deleteOpenSearch": + if e.ComplexityRoot.Mutation.DeleteOpenSearch == nil { break } - return e.ComplexityRoot.MetricValue.Value(childComplexity), true - - case "MetricsQueryResult.series": - if e.ComplexityRoot.MetricsQueryResult.Series == nil { - break + args, err := ec.field_Mutation_deleteOpenSearch_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.MetricsQueryResult.Series(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteOpenSearch(childComplexity, args["input"].(opensearch.DeleteOpenSearchInput)), true - case "MetricsQueryResult.warnings": - if e.ComplexityRoot.MetricsQueryResult.Warnings == nil { + case "Mutation.deleteSecret": + if e.ComplexityRoot.Mutation.DeleteSecret == nil { break } - return e.ComplexityRoot.MetricsQueryResult.Warnings(childComplexity), true - - case "MissingSbomIssue.id": - if e.ComplexityRoot.MissingSbomIssue.ID == nil { - break + args, err := ec.field_Mutation_deleteSecret_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.MissingSbomIssue.ID(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteSecret(childComplexity, args["input"].(secret.DeleteSecretInput)), true - case "MissingSbomIssue.message": - if e.ComplexityRoot.MissingSbomIssue.Message == nil { + case "Mutation.deleteServiceAccount": + if e.ComplexityRoot.Mutation.DeleteServiceAccount == nil { break } - return e.ComplexityRoot.MissingSbomIssue.Message(childComplexity), true - - case "MissingSbomIssue.severity": - if e.ComplexityRoot.MissingSbomIssue.Severity == nil { - break + args, err := ec.field_Mutation_deleteServiceAccount_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.MissingSbomIssue.Severity(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteServiceAccount(childComplexity, args["input"].(serviceaccount.DeleteServiceAccountInput)), true - case "MissingSbomIssue.teamEnvironment": - if e.ComplexityRoot.MissingSbomIssue.TeamEnvironment == nil { + case "Mutation.deleteServiceAccountToken": + if e.ComplexityRoot.Mutation.DeleteServiceAccountToken == nil { break } - return e.ComplexityRoot.MissingSbomIssue.TeamEnvironment(childComplexity), true - - case "MissingSbomIssue.workload": - if e.ComplexityRoot.MissingSbomIssue.Workload == nil { - break + args, err := ec.field_Mutation_deleteServiceAccountToken_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.MissingSbomIssue.Workload(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteServiceAccountToken(childComplexity, args["input"].(serviceaccount.DeleteServiceAccountTokenInput)), true - case "Mutation.addConfigValue": - if e.ComplexityRoot.Mutation.AddConfigValue == nil { + case "Mutation.deleteUnleashInstance": + if e.ComplexityRoot.Mutation.DeleteUnleashInstance == nil { break } - args, err := ec.field_Mutation_addConfigValue_args(ctx, rawArgs) + args, err := ec.field_Mutation_deleteUnleashInstance_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.AddConfigValue(childComplexity, args["input"].(configmap.AddConfigValueInput)), true + return e.ComplexityRoot.Mutation.DeleteUnleashInstance(childComplexity, args["input"].(unleash.DeleteUnleashInstanceInput)), true - case "Mutation.addRepositoryToTeam": - if e.ComplexityRoot.Mutation.AddRepositoryToTeam == nil { + case "Mutation.deleteValkey": + if e.ComplexityRoot.Mutation.DeleteValkey == nil { break } - args, err := ec.field_Mutation_addRepositoryToTeam_args(ctx, rawArgs) + args, err := ec.field_Mutation_deleteValkey_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.AddRepositoryToTeam(childComplexity, args["input"].(repository.AddRepositoryToTeamInput)), true + return e.ComplexityRoot.Mutation.DeleteValkey(childComplexity, args["input"].(valkey.DeleteValkeyInput)), true - case "Mutation.addSecretValue": - if e.ComplexityRoot.Mutation.AddSecretValue == nil { + case "Mutation.disableReconciler": + if e.ComplexityRoot.Mutation.DisableReconciler == nil { break } - args, err := ec.field_Mutation_addSecretValue_args(ctx, rawArgs) + args, err := ec.field_Mutation_disableReconciler_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.AddSecretValue(childComplexity, args["input"].(secret.AddSecretValueInput)), true + return e.ComplexityRoot.Mutation.DisableReconciler(childComplexity, args["input"].(reconciler.DisableReconcilerInput)), true - case "Mutation.addTeamMember": - if e.ComplexityRoot.Mutation.AddTeamMember == nil { + case "Mutation.enableReconciler": + if e.ComplexityRoot.Mutation.EnableReconciler == nil { break } - args, err := ec.field_Mutation_addTeamMember_args(ctx, rawArgs) + args, err := ec.field_Mutation_enableReconciler_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.AddTeamMember(childComplexity, args["input"].(team.AddTeamMemberInput)), true + return e.ComplexityRoot.Mutation.EnableReconciler(childComplexity, args["input"].(reconciler.EnableReconcilerInput)), true - case "Mutation.allowTeamAccessToUnleash": - if e.ComplexityRoot.Mutation.AllowTeamAccessToUnleash == nil { + case "Mutation.grantPostgresAccess": + if e.ComplexityRoot.Mutation.GrantPostgresAccess == nil { break } - args, err := ec.field_Mutation_allowTeamAccessToUnleash_args(ctx, rawArgs) + args, err := ec.field_Mutation_grantPostgresAccess_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.AllowTeamAccessToUnleash(childComplexity, args["input"].(unleash.AllowTeamAccessToUnleashInput)), true + return e.ComplexityRoot.Mutation.GrantPostgresAccess(childComplexity, args["input"].(postgres.GrantPostgresAccessInput)), true - case "Mutation.assignRoleToServiceAccount": - if e.ComplexityRoot.Mutation.AssignRoleToServiceAccount == nil { - break + case "Mutation.removeRepositoryFromTeam": + if e.ComplexityRoot.Mutation.RemoveRepositoryFromTeam == nil { + break } - args, err := ec.field_Mutation_assignRoleToServiceAccount_args(ctx, rawArgs) + args, err := ec.field_Mutation_removeRepositoryFromTeam_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.AssignRoleToServiceAccount(childComplexity, args["input"].(serviceaccount.AssignRoleToServiceAccountInput)), true + return e.ComplexityRoot.Mutation.RemoveRepositoryFromTeam(childComplexity, args["input"].(repository.RemoveRepositoryFromTeamInput)), true - case "Mutation.changeDeploymentKey": - if e.ComplexityRoot.Mutation.ChangeDeploymentKey == nil { + case "Mutation.removeSecretValue": + if e.ComplexityRoot.Mutation.RemoveSecretValue == nil { break } - args, err := ec.field_Mutation_changeDeploymentKey_args(ctx, rawArgs) + args, err := ec.field_Mutation_removeSecretValue_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.ChangeDeploymentKey(childComplexity, args["input"].(deployment.ChangeDeploymentKeyInput)), true + return e.ComplexityRoot.Mutation.RemoveSecretValue(childComplexity, args["input"].(secret.RemoveSecretValueInput)), true - case "Mutation.configureReconciler": - if e.ComplexityRoot.Mutation.ConfigureReconciler == nil { + case "Mutation.removeTeamMember": + if e.ComplexityRoot.Mutation.RemoveTeamMember == nil { break } - args, err := ec.field_Mutation_configureReconciler_args(ctx, rawArgs) + args, err := ec.field_Mutation_removeTeamMember_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.ConfigureReconciler(childComplexity, args["input"].(reconciler.ConfigureReconcilerInput)), true + return e.ComplexityRoot.Mutation.RemoveTeamMember(childComplexity, args["input"].(team.RemoveTeamMemberInput)), true - case "Mutation.confirmTeamDeletion": - if e.ComplexityRoot.Mutation.ConfirmTeamDeletion == nil { + case "Mutation.requestTeamDeletion": + if e.ComplexityRoot.Mutation.RequestTeamDeletion == nil { break } - args, err := ec.field_Mutation_confirmTeamDeletion_args(ctx, rawArgs) + args, err := ec.field_Mutation_requestTeamDeletion_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.ConfirmTeamDeletion(childComplexity, args["input"].(team.ConfirmTeamDeletionInput)), true + return e.ComplexityRoot.Mutation.RequestTeamDeletion(childComplexity, args["input"].(team.RequestTeamDeletionInput)), true - case "Mutation.createConfig": - if e.ComplexityRoot.Mutation.CreateConfig == nil { + case "Mutation.restartApplication": + if e.ComplexityRoot.Mutation.RestartApplication == nil { break } - args, err := ec.field_Mutation_createConfig_args(ctx, rawArgs) + args, err := ec.field_Mutation_restartApplication_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.CreateConfig(childComplexity, args["input"].(configmap.CreateConfigInput)), true + return e.ComplexityRoot.Mutation.RestartApplication(childComplexity, args["input"].(application.RestartApplicationInput)), true - case "Mutation.createKafkaCredentials": - if e.ComplexityRoot.Mutation.CreateKafkaCredentials == nil { + case "Mutation.revokeRoleFromServiceAccount": + if e.ComplexityRoot.Mutation.RevokeRoleFromServiceAccount == nil { break } - args, err := ec.field_Mutation_createKafkaCredentials_args(ctx, rawArgs) + args, err := ec.field_Mutation_revokeRoleFromServiceAccount_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.CreateKafkaCredentials(childComplexity, args["input"].(aivencredentials.CreateKafkaCredentialsInput)), true + return e.ComplexityRoot.Mutation.RevokeRoleFromServiceAccount(childComplexity, args["input"].(serviceaccount.RevokeRoleFromServiceAccountInput)), true - case "Mutation.createOpenSearch": - if e.ComplexityRoot.Mutation.CreateOpenSearch == nil { + case "Mutation.revokeTeamAccessToUnleash": + if e.ComplexityRoot.Mutation.RevokeTeamAccessToUnleash == nil { break } - args, err := ec.field_Mutation_createOpenSearch_args(ctx, rawArgs) + args, err := ec.field_Mutation_revokeTeamAccessToUnleash_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.CreateOpenSearch(childComplexity, args["input"].(opensearch.CreateOpenSearchInput)), true + return e.ComplexityRoot.Mutation.RevokeTeamAccessToUnleash(childComplexity, args["input"].(unleash.RevokeTeamAccessToUnleashInput)), true - case "Mutation.createOpenSearchCredentials": - if e.ComplexityRoot.Mutation.CreateOpenSearchCredentials == nil { + case "Mutation.setTeamMemberRole": + if e.ComplexityRoot.Mutation.SetTeamMemberRole == nil { break } - args, err := ec.field_Mutation_createOpenSearchCredentials_args(ctx, rawArgs) + args, err := ec.field_Mutation_setTeamMemberRole_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.CreateOpenSearchCredentials(childComplexity, args["input"].(aivencredentials.CreateOpenSearchCredentialsInput)), true + return e.ComplexityRoot.Mutation.SetTeamMemberRole(childComplexity, args["input"].(team.SetTeamMemberRoleInput)), true - case "Mutation.createSecret": - if e.ComplexityRoot.Mutation.CreateSecret == nil { + case "Mutation.startOpenSearchMaintenance": + if e.ComplexityRoot.Mutation.StartOpenSearchMaintenance == nil { break } - args, err := ec.field_Mutation_createSecret_args(ctx, rawArgs) + args, err := ec.field_Mutation_startOpenSearchMaintenance_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.CreateSecret(childComplexity, args["input"].(secret.CreateSecretInput)), true + return e.ComplexityRoot.Mutation.StartOpenSearchMaintenance(childComplexity, args["input"].(servicemaintenance.StartOpenSearchMaintenanceInput)), true - case "Mutation.createServiceAccount": - if e.ComplexityRoot.Mutation.CreateServiceAccount == nil { + case "Mutation.startValkeyMaintenance": + if e.ComplexityRoot.Mutation.StartValkeyMaintenance == nil { break } - args, err := ec.field_Mutation_createServiceAccount_args(ctx, rawArgs) + args, err := ec.field_Mutation_startValkeyMaintenance_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.CreateServiceAccount(childComplexity, args["input"].(serviceaccount.CreateServiceAccountInput)), true + return e.ComplexityRoot.Mutation.StartValkeyMaintenance(childComplexity, args["input"].(servicemaintenance.StartValkeyMaintenanceInput)), true - case "Mutation.createServiceAccountToken": - if e.ComplexityRoot.Mutation.CreateServiceAccountToken == nil { + case "Mutation.triggerJob": + if e.ComplexityRoot.Mutation.TriggerJob == nil { break } - args, err := ec.field_Mutation_createServiceAccountToken_args(ctx, rawArgs) + args, err := ec.field_Mutation_triggerJob_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.CreateServiceAccountToken(childComplexity, args["input"].(serviceaccount.CreateServiceAccountTokenInput)), true + return e.ComplexityRoot.Mutation.TriggerJob(childComplexity, args["input"].(job.TriggerJobInput)), true - case "Mutation.createTeam": - if e.ComplexityRoot.Mutation.CreateTeam == nil { + case "Mutation.updateImageVulnerability": + if e.ComplexityRoot.Mutation.UpdateImageVulnerability == nil { break } - args, err := ec.field_Mutation_createTeam_args(ctx, rawArgs) + args, err := ec.field_Mutation_updateImageVulnerability_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.CreateTeam(childComplexity, args["input"].(team.CreateTeamInput)), true + return e.ComplexityRoot.Mutation.UpdateImageVulnerability(childComplexity, args["input"].(vulnerability.UpdateImageVulnerabilityInput)), true - case "Mutation.createUnleashForTeam": - if e.ComplexityRoot.Mutation.CreateUnleashForTeam == nil { + case "Mutation.updateOpenSearch": + if e.ComplexityRoot.Mutation.UpdateOpenSearch == nil { break } - args, err := ec.field_Mutation_createUnleashForTeam_args(ctx, rawArgs) + args, err := ec.field_Mutation_updateOpenSearch_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.CreateUnleashForTeam(childComplexity, args["input"].(unleash.CreateUnleashForTeamInput)), true + return e.ComplexityRoot.Mutation.UpdateOpenSearch(childComplexity, args["input"].(opensearch.UpdateOpenSearchInput)), true - case "Mutation.createValkey": - if e.ComplexityRoot.Mutation.CreateValkey == nil { + case "Mutation.updateSecretValue": + if e.ComplexityRoot.Mutation.UpdateSecretValue == nil { break } - args, err := ec.field_Mutation_createValkey_args(ctx, rawArgs) + args, err := ec.field_Mutation_updateSecretValue_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.CreateValkey(childComplexity, args["input"].(valkey.CreateValkeyInput)), true + return e.ComplexityRoot.Mutation.UpdateSecretValue(childComplexity, args["input"].(secret.UpdateSecretValueInput)), true - case "Mutation.createValkeyCredentials": - if e.ComplexityRoot.Mutation.CreateValkeyCredentials == nil { + case "Mutation.updateServiceAccount": + if e.ComplexityRoot.Mutation.UpdateServiceAccount == nil { break } - args, err := ec.field_Mutation_createValkeyCredentials_args(ctx, rawArgs) + args, err := ec.field_Mutation_updateServiceAccount_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.CreateValkeyCredentials(childComplexity, args["input"].(aivencredentials.CreateValkeyCredentialsInput)), true + return e.ComplexityRoot.Mutation.UpdateServiceAccount(childComplexity, args["input"].(serviceaccount.UpdateServiceAccountInput)), true - case "Mutation.deleteApplication": - if e.ComplexityRoot.Mutation.DeleteApplication == nil { + case "Mutation.updateServiceAccountToken": + if e.ComplexityRoot.Mutation.UpdateServiceAccountToken == nil { break } - args, err := ec.field_Mutation_deleteApplication_args(ctx, rawArgs) + args, err := ec.field_Mutation_updateServiceAccountToken_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.DeleteApplication(childComplexity, args["input"].(application.DeleteApplicationInput)), true + return e.ComplexityRoot.Mutation.UpdateServiceAccountToken(childComplexity, args["input"].(serviceaccount.UpdateServiceAccountTokenInput)), true - case "Mutation.deleteConfig": - if e.ComplexityRoot.Mutation.DeleteConfig == nil { + case "Mutation.updateTeam": + if e.ComplexityRoot.Mutation.UpdateTeam == nil { break } - args, err := ec.field_Mutation_deleteConfig_args(ctx, rawArgs) + args, err := ec.field_Mutation_updateTeam_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.DeleteConfig(childComplexity, args["input"].(configmap.DeleteConfigInput)), true + return e.ComplexityRoot.Mutation.UpdateTeam(childComplexity, args["input"].(team.UpdateTeamInput)), true - case "Mutation.deleteJob": - if e.ComplexityRoot.Mutation.DeleteJob == nil { + case "Mutation.updateTeamEnvironment": + if e.ComplexityRoot.Mutation.UpdateTeamEnvironment == nil { break } - args, err := ec.field_Mutation_deleteJob_args(ctx, rawArgs) + args, err := ec.field_Mutation_updateTeamEnvironment_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.DeleteJob(childComplexity, args["input"].(job.DeleteJobInput)), true + return e.ComplexityRoot.Mutation.UpdateTeamEnvironment(childComplexity, args["input"].(team.UpdateTeamEnvironmentInput)), true - case "Mutation.deleteJobRun": - if e.ComplexityRoot.Mutation.DeleteJobRun == nil { + case "Mutation.updateUnleashInstance": + if e.ComplexityRoot.Mutation.UpdateUnleashInstance == nil { break } - args, err := ec.field_Mutation_deleteJobRun_args(ctx, rawArgs) + args, err := ec.field_Mutation_updateUnleashInstance_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.DeleteJobRun(childComplexity, args["input"].(job.DeleteJobRunInput)), true + return e.ComplexityRoot.Mutation.UpdateUnleashInstance(childComplexity, args["input"].(unleash.UpdateUnleashInstanceInput)), true - case "Mutation.deleteOpenSearch": - if e.ComplexityRoot.Mutation.DeleteOpenSearch == nil { + case "Mutation.updateValkey": + if e.ComplexityRoot.Mutation.UpdateValkey == nil { break } - args, err := ec.field_Mutation_deleteOpenSearch_args(ctx, rawArgs) + args, err := ec.field_Mutation_updateValkey_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.DeleteOpenSearch(childComplexity, args["input"].(opensearch.DeleteOpenSearchInput)), true + return e.ComplexityRoot.Mutation.UpdateValkey(childComplexity, args["input"].(valkey.UpdateValkeyInput)), true - case "Mutation.deleteSecret": - if e.ComplexityRoot.Mutation.DeleteSecret == nil { + case "Mutation.viewSecretValues": + if e.ComplexityRoot.Mutation.ViewSecretValues == nil { break } - args, err := ec.field_Mutation_deleteSecret_args(ctx, rawArgs) + args, err := ec.field_Mutation_viewSecretValues_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.DeleteSecret(childComplexity, args["input"].(secret.DeleteSecretInput)), true + return e.ComplexityRoot.Mutation.ViewSecretValues(childComplexity, args["input"].(secret.ViewSecretValuesInput)), true - case "Mutation.deleteServiceAccount": - if e.ComplexityRoot.Mutation.DeleteServiceAccount == nil { + case "NetworkPolicy.inbound": + if e.ComplexityRoot.NetworkPolicy.Inbound == nil { break } - args, err := ec.field_Mutation_deleteServiceAccount_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.NetworkPolicy.Inbound(childComplexity), true + + case "NetworkPolicy.outbound": + if e.ComplexityRoot.NetworkPolicy.Outbound == nil { + break } - return e.ComplexityRoot.Mutation.DeleteServiceAccount(childComplexity, args["input"].(serviceaccount.DeleteServiceAccountInput)), true + return e.ComplexityRoot.NetworkPolicy.Outbound(childComplexity), true - case "Mutation.deleteServiceAccountToken": - if e.ComplexityRoot.Mutation.DeleteServiceAccountToken == nil { + case "NetworkPolicyRule.mutual": + if e.ComplexityRoot.NetworkPolicyRule.Mutual == nil { break } - args, err := ec.field_Mutation_deleteServiceAccountToken_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.NetworkPolicyRule.Mutual(childComplexity), true + + case "NetworkPolicyRule.targetTeam": + if e.ComplexityRoot.NetworkPolicyRule.TargetTeam == nil { + break } - return e.ComplexityRoot.Mutation.DeleteServiceAccountToken(childComplexity, args["input"].(serviceaccount.DeleteServiceAccountTokenInput)), true + return e.ComplexityRoot.NetworkPolicyRule.TargetTeam(childComplexity), true - case "Mutation.deleteUnleashInstance": - if e.ComplexityRoot.Mutation.DeleteUnleashInstance == nil { + case "NetworkPolicyRule.targetTeamSlug": + if e.ComplexityRoot.NetworkPolicyRule.TargetTeamSlug == nil { break } - args, err := ec.field_Mutation_deleteUnleashInstance_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.NetworkPolicyRule.TargetTeamSlug(childComplexity), true + + case "NetworkPolicyRule.targetWorkload": + if e.ComplexityRoot.NetworkPolicyRule.TargetWorkload == nil { + break } - return e.ComplexityRoot.Mutation.DeleteUnleashInstance(childComplexity, args["input"].(unleash.DeleteUnleashInstanceInput)), true + return e.ComplexityRoot.NetworkPolicyRule.TargetWorkload(childComplexity), true - case "Mutation.deleteValkey": - if e.ComplexityRoot.Mutation.DeleteValkey == nil { + case "NetworkPolicyRule.targetWorkloadName": + if e.ComplexityRoot.NetworkPolicyRule.TargetWorkloadName == nil { break } - args, err := ec.field_Mutation_deleteValkey_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.NetworkPolicyRule.TargetWorkloadName(childComplexity), true + + case "NoRunningInstancesIssue.id": + if e.ComplexityRoot.NoRunningInstancesIssue.ID == nil { + break } - return e.ComplexityRoot.Mutation.DeleteValkey(childComplexity, args["input"].(valkey.DeleteValkeyInput)), true + return e.ComplexityRoot.NoRunningInstancesIssue.ID(childComplexity), true - case "Mutation.disableReconciler": - if e.ComplexityRoot.Mutation.DisableReconciler == nil { + case "NoRunningInstancesIssue.message": + if e.ComplexityRoot.NoRunningInstancesIssue.Message == nil { break } - args, err := ec.field_Mutation_disableReconciler_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.NoRunningInstancesIssue.Message(childComplexity), true + + case "NoRunningInstancesIssue.severity": + if e.ComplexityRoot.NoRunningInstancesIssue.Severity == nil { + break } - return e.ComplexityRoot.Mutation.DisableReconciler(childComplexity, args["input"].(reconciler.DisableReconcilerInput)), true + return e.ComplexityRoot.NoRunningInstancesIssue.Severity(childComplexity), true - case "Mutation.enableReconciler": - if e.ComplexityRoot.Mutation.EnableReconciler == nil { + case "NoRunningInstancesIssue.teamEnvironment": + if e.ComplexityRoot.NoRunningInstancesIssue.TeamEnvironment == nil { break } - args, err := ec.field_Mutation_enableReconciler_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.NoRunningInstancesIssue.TeamEnvironment(childComplexity), true + + case "NoRunningInstancesIssue.workload": + if e.ComplexityRoot.NoRunningInstancesIssue.Workload == nil { + break } - return e.ComplexityRoot.Mutation.EnableReconciler(childComplexity, args["input"].(reconciler.EnableReconcilerInput)), true + return e.ComplexityRoot.NoRunningInstancesIssue.Workload(childComplexity), true - case "Mutation.grantPostgresAccess": - if e.ComplexityRoot.Mutation.GrantPostgresAccess == nil { + case "OpenSearch.access": + if e.ComplexityRoot.OpenSearch.Access == nil { break } - args, err := ec.field_Mutation_grantPostgresAccess_args(ctx, rawArgs) + args, err := ec.field_OpenSearch_access_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.GrantPostgresAccess(childComplexity, args["input"].(postgres.GrantPostgresAccessInput)), true + return e.ComplexityRoot.OpenSearch.Access(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*opensearch.OpenSearchAccessOrder)), true - case "Mutation.removeConfigValue": - if e.ComplexityRoot.Mutation.RemoveConfigValue == nil { + case "OpenSearch.activityLog": + if e.ComplexityRoot.OpenSearch.ActivityLog == nil { break } - args, err := ec.field_Mutation_removeConfigValue_args(ctx, rawArgs) + args, err := ec.field_OpenSearch_activityLog_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.RemoveConfigValue(childComplexity, args["input"].(configmap.RemoveConfigValueInput)), true + return e.ComplexityRoot.OpenSearch.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "Mutation.removeRepositoryFromTeam": - if e.ComplexityRoot.Mutation.RemoveRepositoryFromTeam == nil { + case "OpenSearch.cost": + if e.ComplexityRoot.OpenSearch.Cost == nil { break } - args, err := ec.field_Mutation_removeRepositoryFromTeam_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Mutation.RemoveRepositoryFromTeam(childComplexity, args["input"].(repository.RemoveRepositoryFromTeamInput)), true + return e.ComplexityRoot.OpenSearch.Cost(childComplexity), true - case "Mutation.removeSecretValue": - if e.ComplexityRoot.Mutation.RemoveSecretValue == nil { + case "OpenSearch.environment": + if e.ComplexityRoot.OpenSearch.Environment == nil { break } - args, err := ec.field_Mutation_removeSecretValue_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearch.Environment(childComplexity), true + + case "OpenSearch.id": + if e.ComplexityRoot.OpenSearch.ID == nil { + break } - return e.ComplexityRoot.Mutation.RemoveSecretValue(childComplexity, args["input"].(secret.RemoveSecretValueInput)), true + return e.ComplexityRoot.OpenSearch.ID(childComplexity), true - case "Mutation.removeTeamMember": - if e.ComplexityRoot.Mutation.RemoveTeamMember == nil { + case "OpenSearch.issues": + if e.ComplexityRoot.OpenSearch.Issues == nil { break } - args, err := ec.field_Mutation_removeTeamMember_args(ctx, rawArgs) + args, err := ec.field_OpenSearch_issues_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.RemoveTeamMember(childComplexity, args["input"].(team.RemoveTeamMemberInput)), true + return e.ComplexityRoot.OpenSearch.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true - case "Mutation.requestTeamDeletion": - if e.ComplexityRoot.Mutation.RequestTeamDeletion == nil { + case "OpenSearch.maintenance": + if e.ComplexityRoot.OpenSearch.Maintenance == nil { break } - args, err := ec.field_Mutation_requestTeamDeletion_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearch.Maintenance(childComplexity), true + + case "OpenSearch.memory": + if e.ComplexityRoot.OpenSearch.Memory == nil { + break } - return e.ComplexityRoot.Mutation.RequestTeamDeletion(childComplexity, args["input"].(team.RequestTeamDeletionInput)), true + return e.ComplexityRoot.OpenSearch.Memory(childComplexity), true - case "Mutation.restartApplication": - if e.ComplexityRoot.Mutation.RestartApplication == nil { + case "OpenSearch.name": + if e.ComplexityRoot.OpenSearch.Name == nil { break } - args, err := ec.field_Mutation_restartApplication_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearch.Name(childComplexity), true + + case "OpenSearch.state": + if e.ComplexityRoot.OpenSearch.State == nil { + break } - return e.ComplexityRoot.Mutation.RestartApplication(childComplexity, args["input"].(application.RestartApplicationInput)), true + return e.ComplexityRoot.OpenSearch.State(childComplexity), true - case "Mutation.revokeRoleFromServiceAccount": - if e.ComplexityRoot.Mutation.RevokeRoleFromServiceAccount == nil { + case "OpenSearch.storageGB": + if e.ComplexityRoot.OpenSearch.StorageGB == nil { break } - args, err := ec.field_Mutation_revokeRoleFromServiceAccount_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearch.StorageGB(childComplexity), true + + case "OpenSearch.team": + if e.ComplexityRoot.OpenSearch.Team == nil { + break } - return e.ComplexityRoot.Mutation.RevokeRoleFromServiceAccount(childComplexity, args["input"].(serviceaccount.RevokeRoleFromServiceAccountInput)), true + return e.ComplexityRoot.OpenSearch.Team(childComplexity), true - case "Mutation.revokeTeamAccessToUnleash": - if e.ComplexityRoot.Mutation.RevokeTeamAccessToUnleash == nil { + case "OpenSearch.teamEnvironment": + if e.ComplexityRoot.OpenSearch.TeamEnvironment == nil { break } - args, err := ec.field_Mutation_revokeTeamAccessToUnleash_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearch.TeamEnvironment(childComplexity), true + + case "OpenSearch.terminationProtection": + if e.ComplexityRoot.OpenSearch.TerminationProtection == nil { + break } - return e.ComplexityRoot.Mutation.RevokeTeamAccessToUnleash(childComplexity, args["input"].(unleash.RevokeTeamAccessToUnleashInput)), true + return e.ComplexityRoot.OpenSearch.TerminationProtection(childComplexity), true - case "Mutation.setTeamMemberRole": - if e.ComplexityRoot.Mutation.SetTeamMemberRole == nil { + case "OpenSearch.tier": + if e.ComplexityRoot.OpenSearch.Tier == nil { break } - args, err := ec.field_Mutation_setTeamMemberRole_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearch.Tier(childComplexity), true + + case "OpenSearch.version": + if e.ComplexityRoot.OpenSearch.Version == nil { + break } - return e.ComplexityRoot.Mutation.SetTeamMemberRole(childComplexity, args["input"].(team.SetTeamMemberRoleInput)), true + return e.ComplexityRoot.OpenSearch.Version(childComplexity), true - case "Mutation.startOpenSearchMaintenance": - if e.ComplexityRoot.Mutation.StartOpenSearchMaintenance == nil { + case "OpenSearch.workload": + if e.ComplexityRoot.OpenSearch.Workload == nil { break } - args, err := ec.field_Mutation_startOpenSearchMaintenance_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearch.Workload(childComplexity), true + + case "OpenSearchAccess.access": + if e.ComplexityRoot.OpenSearchAccess.Access == nil { + break } - return e.ComplexityRoot.Mutation.StartOpenSearchMaintenance(childComplexity, args["input"].(servicemaintenance.StartOpenSearchMaintenanceInput)), true + return e.ComplexityRoot.OpenSearchAccess.Access(childComplexity), true - case "Mutation.startValkeyMaintenance": - if e.ComplexityRoot.Mutation.StartValkeyMaintenance == nil { + case "OpenSearchAccess.workload": + if e.ComplexityRoot.OpenSearchAccess.Workload == nil { break } - args, err := ec.field_Mutation_startValkeyMaintenance_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchAccess.Workload(childComplexity), true + + case "OpenSearchAccessConnection.edges": + if e.ComplexityRoot.OpenSearchAccessConnection.Edges == nil { + break } - return e.ComplexityRoot.Mutation.StartValkeyMaintenance(childComplexity, args["input"].(servicemaintenance.StartValkeyMaintenanceInput)), true + return e.ComplexityRoot.OpenSearchAccessConnection.Edges(childComplexity), true - case "Mutation.triggerJob": - if e.ComplexityRoot.Mutation.TriggerJob == nil { + case "OpenSearchAccessConnection.nodes": + if e.ComplexityRoot.OpenSearchAccessConnection.Nodes == nil { break } - args, err := ec.field_Mutation_triggerJob_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchAccessConnection.Nodes(childComplexity), true + + case "OpenSearchAccessConnection.pageInfo": + if e.ComplexityRoot.OpenSearchAccessConnection.PageInfo == nil { + break } - return e.ComplexityRoot.Mutation.TriggerJob(childComplexity, args["input"].(job.TriggerJobInput)), true + return e.ComplexityRoot.OpenSearchAccessConnection.PageInfo(childComplexity), true - case "Mutation.updateConfigValue": - if e.ComplexityRoot.Mutation.UpdateConfigValue == nil { + case "OpenSearchAccessEdge.cursor": + if e.ComplexityRoot.OpenSearchAccessEdge.Cursor == nil { break } - args, err := ec.field_Mutation_updateConfigValue_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchAccessEdge.Cursor(childComplexity), true + + case "OpenSearchAccessEdge.node": + if e.ComplexityRoot.OpenSearchAccessEdge.Node == nil { + break } - return e.ComplexityRoot.Mutation.UpdateConfigValue(childComplexity, args["input"].(configmap.UpdateConfigValueInput)), true + return e.ComplexityRoot.OpenSearchAccessEdge.Node(childComplexity), true - case "Mutation.updateImageVulnerability": - if e.ComplexityRoot.Mutation.UpdateImageVulnerability == nil { + case "OpenSearchConnection.edges": + if e.ComplexityRoot.OpenSearchConnection.Edges == nil { break } - args, err := ec.field_Mutation_updateImageVulnerability_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchConnection.Edges(childComplexity), true + + case "OpenSearchConnection.nodes": + if e.ComplexityRoot.OpenSearchConnection.Nodes == nil { + break } - return e.ComplexityRoot.Mutation.UpdateImageVulnerability(childComplexity, args["input"].(vulnerability.UpdateImageVulnerabilityInput)), true + return e.ComplexityRoot.OpenSearchConnection.Nodes(childComplexity), true - case "Mutation.updateOpenSearch": - if e.ComplexityRoot.Mutation.UpdateOpenSearch == nil { + case "OpenSearchConnection.pageInfo": + if e.ComplexityRoot.OpenSearchConnection.PageInfo == nil { break } - args, err := ec.field_Mutation_updateOpenSearch_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchConnection.PageInfo(childComplexity), true + + case "OpenSearchCost.sum": + if e.ComplexityRoot.OpenSearchCost.Sum == nil { + break } - return e.ComplexityRoot.Mutation.UpdateOpenSearch(childComplexity, args["input"].(opensearch.UpdateOpenSearchInput)), true + return e.ComplexityRoot.OpenSearchCost.Sum(childComplexity), true - case "Mutation.updateSecretValue": - if e.ComplexityRoot.Mutation.UpdateSecretValue == nil { + case "OpenSearchCreatedActivityLogEntry.actor": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Actor == nil { break } - args, err := ec.field_Mutation_updateSecretValue_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Actor(childComplexity), true + + case "OpenSearchCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.CreatedAt == nil { + break } - return e.ComplexityRoot.Mutation.UpdateSecretValue(childComplexity, args["input"].(secret.UpdateSecretValueInput)), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "Mutation.updateServiceAccount": - if e.ComplexityRoot.Mutation.UpdateServiceAccount == nil { + case "OpenSearchCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.EnvironmentName == nil { break } - args, err := ec.field_Mutation_updateServiceAccount_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.EnvironmentName(childComplexity), true + + case "OpenSearchCreatedActivityLogEntry.id": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ID == nil { + break } - return e.ComplexityRoot.Mutation.UpdateServiceAccount(childComplexity, args["input"].(serviceaccount.UpdateServiceAccountInput)), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ID(childComplexity), true - case "Mutation.updateServiceAccountToken": - if e.ComplexityRoot.Mutation.UpdateServiceAccountToken == nil { + case "OpenSearchCreatedActivityLogEntry.message": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Message == nil { break } - args, err := ec.field_Mutation_updateServiceAccountToken_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Message(childComplexity), true + + case "OpenSearchCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceName == nil { + break } - return e.ComplexityRoot.Mutation.UpdateServiceAccountToken(childComplexity, args["input"].(serviceaccount.UpdateServiceAccountTokenInput)), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceName(childComplexity), true - case "Mutation.updateTeam": - if e.ComplexityRoot.Mutation.UpdateTeam == nil { + case "OpenSearchCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceType == nil { break } - args, err := ec.field_Mutation_updateTeam_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceType(childComplexity), true + + case "OpenSearchCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.TeamSlug == nil { + break } - return e.ComplexityRoot.Mutation.UpdateTeam(childComplexity, args["input"].(team.UpdateTeamInput)), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "Mutation.updateTeamEnvironment": - if e.ComplexityRoot.Mutation.UpdateTeamEnvironment == nil { + case "OpenSearchCredentials.host": + if e.ComplexityRoot.OpenSearchCredentials.Host == nil { break } - args, err := ec.field_Mutation_updateTeamEnvironment_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchCredentials.Host(childComplexity), true + + case "OpenSearchCredentials.password": + if e.ComplexityRoot.OpenSearchCredentials.Password == nil { + break } - return e.ComplexityRoot.Mutation.UpdateTeamEnvironment(childComplexity, args["input"].(team.UpdateTeamEnvironmentInput)), true + return e.ComplexityRoot.OpenSearchCredentials.Password(childComplexity), true - case "Mutation.updateUnleashInstance": - if e.ComplexityRoot.Mutation.UpdateUnleashInstance == nil { + case "OpenSearchCredentials.port": + if e.ComplexityRoot.OpenSearchCredentials.Port == nil { break } - args, err := ec.field_Mutation_updateUnleashInstance_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Mutation.UpdateUnleashInstance(childComplexity, args["input"].(unleash.UpdateUnleashInstanceInput)), true + return e.ComplexityRoot.OpenSearchCredentials.Port(childComplexity), true - case "Mutation.updateValkey": - if e.ComplexityRoot.Mutation.UpdateValkey == nil { + case "OpenSearchCredentials.uri": + if e.ComplexityRoot.OpenSearchCredentials.URI == nil { break } - args, err := ec.field_Mutation_updateValkey_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchCredentials.URI(childComplexity), true + + case "OpenSearchCredentials.username": + if e.ComplexityRoot.OpenSearchCredentials.Username == nil { + break } - return e.ComplexityRoot.Mutation.UpdateValkey(childComplexity, args["input"].(valkey.UpdateValkeyInput)), true + return e.ComplexityRoot.OpenSearchCredentials.Username(childComplexity), true - case "Mutation.viewSecretValues": - if e.ComplexityRoot.Mutation.ViewSecretValues == nil { + case "OpenSearchDeletedActivityLogEntry.actor": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Actor == nil { break } - args, err := ec.field_Mutation_viewSecretValues_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Actor(childComplexity), true + + case "OpenSearchDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.CreatedAt == nil { + break } - return e.ComplexityRoot.Mutation.ViewSecretValues(childComplexity, args["input"].(secret.ViewSecretValuesInput)), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "NetworkPolicy.inbound": - if e.ComplexityRoot.NetworkPolicy.Inbound == nil { + case "OpenSearchDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.NetworkPolicy.Inbound(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "NetworkPolicy.outbound": - if e.ComplexityRoot.NetworkPolicy.Outbound == nil { + case "OpenSearchDeletedActivityLogEntry.id": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.NetworkPolicy.Outbound(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ID(childComplexity), true - case "NetworkPolicyRule.mutual": - if e.ComplexityRoot.NetworkPolicyRule.Mutual == nil { + case "OpenSearchDeletedActivityLogEntry.message": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.NetworkPolicyRule.Mutual(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Message(childComplexity), true - case "NetworkPolicyRule.targetTeam": - if e.ComplexityRoot.NetworkPolicyRule.TargetTeam == nil { + case "OpenSearchDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.NetworkPolicyRule.TargetTeam(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceName(childComplexity), true - case "NetworkPolicyRule.targetTeamSlug": - if e.ComplexityRoot.NetworkPolicyRule.TargetTeamSlug == nil { + case "OpenSearchDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.NetworkPolicyRule.TargetTeamSlug(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceType(childComplexity), true - case "NetworkPolicyRule.targetWorkload": - if e.ComplexityRoot.NetworkPolicyRule.TargetWorkload == nil { + case "OpenSearchDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.NetworkPolicyRule.TargetWorkload(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "NetworkPolicyRule.targetWorkloadName": - if e.ComplexityRoot.NetworkPolicyRule.TargetWorkloadName == nil { + case "OpenSearchEdge.cursor": + if e.ComplexityRoot.OpenSearchEdge.Cursor == nil { break } - return e.ComplexityRoot.NetworkPolicyRule.TargetWorkloadName(childComplexity), true + return e.ComplexityRoot.OpenSearchEdge.Cursor(childComplexity), true - case "NoRunningInstancesIssue.id": - if e.ComplexityRoot.NoRunningInstancesIssue.ID == nil { + case "OpenSearchEdge.node": + if e.ComplexityRoot.OpenSearchEdge.Node == nil { break } - return e.ComplexityRoot.NoRunningInstancesIssue.ID(childComplexity), true + return e.ComplexityRoot.OpenSearchEdge.Node(childComplexity), true - case "NoRunningInstancesIssue.message": - if e.ComplexityRoot.NoRunningInstancesIssue.Message == nil { + case "OpenSearchIssue.event": + if e.ComplexityRoot.OpenSearchIssue.Event == nil { break } - return e.ComplexityRoot.NoRunningInstancesIssue.Message(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.Event(childComplexity), true - case "NoRunningInstancesIssue.severity": - if e.ComplexityRoot.NoRunningInstancesIssue.Severity == nil { + case "OpenSearchIssue.id": + if e.ComplexityRoot.OpenSearchIssue.ID == nil { break } - return e.ComplexityRoot.NoRunningInstancesIssue.Severity(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.ID(childComplexity), true - case "NoRunningInstancesIssue.teamEnvironment": - if e.ComplexityRoot.NoRunningInstancesIssue.TeamEnvironment == nil { + case "OpenSearchIssue.message": + if e.ComplexityRoot.OpenSearchIssue.Message == nil { break } - return e.ComplexityRoot.NoRunningInstancesIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.Message(childComplexity), true - case "NoRunningInstancesIssue.workload": - if e.ComplexityRoot.NoRunningInstancesIssue.Workload == nil { + case "OpenSearchIssue.openSearch": + if e.ComplexityRoot.OpenSearchIssue.OpenSearch == nil { break } - return e.ComplexityRoot.NoRunningInstancesIssue.Workload(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.OpenSearch(childComplexity), true - case "OpenSearch.access": - if e.ComplexityRoot.OpenSearch.Access == nil { + case "OpenSearchIssue.severity": + if e.ComplexityRoot.OpenSearchIssue.Severity == nil { break } - args, err := ec.field_OpenSearch_access_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchIssue.Severity(childComplexity), true + + case "OpenSearchIssue.teamEnvironment": + if e.ComplexityRoot.OpenSearchIssue.TeamEnvironment == nil { + break } - return e.ComplexityRoot.OpenSearch.Access(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*opensearch.OpenSearchAccessOrder)), true + return e.ComplexityRoot.OpenSearchIssue.TeamEnvironment(childComplexity), true - case "OpenSearch.activityLog": - if e.ComplexityRoot.OpenSearch.ActivityLog == nil { + case "OpenSearchMaintenance.updates": + if e.ComplexityRoot.OpenSearchMaintenance.Updates == nil { break } - args, err := ec.field_OpenSearch_activityLog_args(ctx, rawArgs) + args, err := ec.field_OpenSearchMaintenance_updates_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.OpenSearch.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.OpenSearchMaintenance.Updates(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "OpenSearch.cost": - if e.ComplexityRoot.OpenSearch.Cost == nil { + case "OpenSearchMaintenance.window": + if e.ComplexityRoot.OpenSearchMaintenance.Window == nil { break } - return e.ComplexityRoot.OpenSearch.Cost(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenance.Window(childComplexity), true - case "OpenSearch.environment": - if e.ComplexityRoot.OpenSearch.Environment == nil { + case "OpenSearchMaintenanceUpdate.deadline": + if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Deadline == nil { break } - return e.ComplexityRoot.OpenSearch.Environment(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Deadline(childComplexity), true - case "OpenSearch.id": - if e.ComplexityRoot.OpenSearch.ID == nil { + case "OpenSearchMaintenanceUpdate.description": + if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Description == nil { break } - return e.ComplexityRoot.OpenSearch.ID(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Description(childComplexity), true - case "OpenSearch.issues": - if e.ComplexityRoot.OpenSearch.Issues == nil { + case "OpenSearchMaintenanceUpdate.startAt": + if e.ComplexityRoot.OpenSearchMaintenanceUpdate.StartAt == nil { break } - args, err := ec.field_OpenSearch_issues_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchMaintenanceUpdate.StartAt(childComplexity), true + + case "OpenSearchMaintenanceUpdate.title": + if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Title == nil { + break } - return e.ComplexityRoot.OpenSearch.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Title(childComplexity), true - case "OpenSearch.maintenance": - if e.ComplexityRoot.OpenSearch.Maintenance == nil { + case "OpenSearchMaintenanceUpdateConnection.edges": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Edges == nil { break } - return e.ComplexityRoot.OpenSearch.Maintenance(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Edges(childComplexity), true - case "OpenSearch.memory": - if e.ComplexityRoot.OpenSearch.Memory == nil { + case "OpenSearchMaintenanceUpdateConnection.nodes": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Nodes == nil { break } - return e.ComplexityRoot.OpenSearch.Memory(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Nodes(childComplexity), true - case "OpenSearch.name": - if e.ComplexityRoot.OpenSearch.Name == nil { + case "OpenSearchMaintenanceUpdateConnection.pageInfo": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.PageInfo == nil { break } - return e.ComplexityRoot.OpenSearch.Name(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.PageInfo(childComplexity), true - case "OpenSearch.state": - if e.ComplexityRoot.OpenSearch.State == nil { + case "OpenSearchMaintenanceUpdateEdge.cursor": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Cursor == nil { break } - return e.ComplexityRoot.OpenSearch.State(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Cursor(childComplexity), true - case "OpenSearch.storageGB": - if e.ComplexityRoot.OpenSearch.StorageGB == nil { + case "OpenSearchMaintenanceUpdateEdge.node": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Node == nil { break } - return e.ComplexityRoot.OpenSearch.StorageGB(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Node(childComplexity), true - case "OpenSearch.team": - if e.ComplexityRoot.OpenSearch.Team == nil { + case "OpenSearchUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.OpenSearch.Team(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Actor(childComplexity), true - case "OpenSearch.teamEnvironment": - if e.ComplexityRoot.OpenSearch.TeamEnvironment == nil { + case "OpenSearchUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.OpenSearch.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "OpenSearch.terminationProtection": - if e.ComplexityRoot.OpenSearch.TerminationProtection == nil { + case "OpenSearchUpdatedActivityLogEntry.data": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.OpenSearch.TerminationProtection(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Data(childComplexity), true - case "OpenSearch.tier": - if e.ComplexityRoot.OpenSearch.Tier == nil { + case "OpenSearchUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.OpenSearch.Tier(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "OpenSearch.version": - if e.ComplexityRoot.OpenSearch.Version == nil { + case "OpenSearchUpdatedActivityLogEntry.id": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.OpenSearch.Version(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ID(childComplexity), true - case "OpenSearch.workload": - if e.ComplexityRoot.OpenSearch.Workload == nil { + case "OpenSearchUpdatedActivityLogEntry.message": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.OpenSearch.Workload(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Message(childComplexity), true - case "OpenSearchAccess.access": - if e.ComplexityRoot.OpenSearchAccess.Access == nil { + case "OpenSearchUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.OpenSearchAccess.Access(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "OpenSearchAccess.workload": - if e.ComplexityRoot.OpenSearchAccess.Workload == nil { + case "OpenSearchUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.OpenSearchAccess.Workload(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "OpenSearchAccessConnection.edges": - if e.ComplexityRoot.OpenSearchAccessConnection.Edges == nil { + case "OpenSearchUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.OpenSearchAccessConnection.Edges(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "OpenSearchAccessConnection.nodes": - if e.ComplexityRoot.OpenSearchAccessConnection.Nodes == nil { + case "OpenSearchUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.OpenSearchAccessConnection.Nodes(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "OpenSearchAccessConnection.pageInfo": - if e.ComplexityRoot.OpenSearchAccessConnection.PageInfo == nil { + case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.OpenSearchAccessConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "OpenSearchAccessEdge.cursor": - if e.ComplexityRoot.OpenSearchAccessEdge.Cursor == nil { + case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.OpenSearchAccessEdge.Cursor(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "OpenSearchAccessEdge.node": - if e.ComplexityRoot.OpenSearchAccessEdge.Node == nil { + case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.OpenSearchAccessEdge.Node(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "OpenSearchConnection.edges": - if e.ComplexityRoot.OpenSearchConnection.Edges == nil { + case "OpenSearchVersion.actual": + if e.ComplexityRoot.OpenSearchVersion.Actual == nil { break } - return e.ComplexityRoot.OpenSearchConnection.Edges(childComplexity), true + return e.ComplexityRoot.OpenSearchVersion.Actual(childComplexity), true - case "OpenSearchConnection.nodes": - if e.ComplexityRoot.OpenSearchConnection.Nodes == nil { + case "OpenSearchVersion.desiredMajor": + if e.ComplexityRoot.OpenSearchVersion.DesiredMajor == nil { break } - return e.ComplexityRoot.OpenSearchConnection.Nodes(childComplexity), true + return e.ComplexityRoot.OpenSearchVersion.DesiredMajor(childComplexity), true - case "OpenSearchConnection.pageInfo": - if e.ComplexityRoot.OpenSearchConnection.PageInfo == nil { + case "OutboundNetworkPolicy.external": + if e.ComplexityRoot.OutboundNetworkPolicy.External == nil { break } - return e.ComplexityRoot.OpenSearchConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.OutboundNetworkPolicy.External(childComplexity), true - case "OpenSearchCost.sum": - if e.ComplexityRoot.OpenSearchCost.Sum == nil { + case "OutboundNetworkPolicy.rules": + if e.ComplexityRoot.OutboundNetworkPolicy.Rules == nil { break } - return e.ComplexityRoot.OpenSearchCost.Sum(childComplexity), true + return e.ComplexityRoot.OutboundNetworkPolicy.Rules(childComplexity), true - case "OpenSearchCreatedActivityLogEntry.actor": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Actor == nil { + case "PageInfo.endCursor": + if e.ComplexityRoot.PageInfo.EndCursor == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.PageInfo.EndCursor(childComplexity), true - case "OpenSearchCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.CreatedAt == nil { + case "PageInfo.hasNextPage": + if e.ComplexityRoot.PageInfo.HasNextPage == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.PageInfo.HasNextPage(childComplexity), true - case "OpenSearchCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.EnvironmentName == nil { + case "PageInfo.hasPreviousPage": + if e.ComplexityRoot.PageInfo.HasPreviousPage == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.PageInfo.HasPreviousPage(childComplexity), true - case "OpenSearchCreatedActivityLogEntry.id": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ID == nil { + case "PageInfo.pageEnd": + if e.ComplexityRoot.PageInfo.PageEnd == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.PageInfo.PageEnd(childComplexity), true - case "OpenSearchCreatedActivityLogEntry.message": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Message == nil { + case "PageInfo.pageStart": + if e.ComplexityRoot.PageInfo.PageStart == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.PageInfo.PageStart(childComplexity), true - case "OpenSearchCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceName == nil { + case "PageInfo.startCursor": + if e.ComplexityRoot.PageInfo.StartCursor == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.PageInfo.StartCursor(childComplexity), true - case "OpenSearchCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceType == nil { + case "PageInfo.totalCount": + if e.ComplexityRoot.PageInfo.TotalCount == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.PageInfo.TotalCount(childComplexity), true - case "OpenSearchCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.TeamSlug == nil { + case "PostgresGrantAccessActivityLogEntry.actor": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Actor(childComplexity), true - case "OpenSearchCredentials.host": - if e.ComplexityRoot.OpenSearchCredentials.Host == nil { + case "PostgresGrantAccessActivityLogEntry.createdAt": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.OpenSearchCredentials.Host(childComplexity), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.CreatedAt(childComplexity), true - case "OpenSearchCredentials.password": - if e.ComplexityRoot.OpenSearchCredentials.Password == nil { + case "PostgresGrantAccessActivityLogEntry.data": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.OpenSearchCredentials.Password(childComplexity), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Data(childComplexity), true - case "OpenSearchCredentials.port": - if e.ComplexityRoot.OpenSearchCredentials.Port == nil { + case "PostgresGrantAccessActivityLogEntry.environmentName": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.OpenSearchCredentials.Port(childComplexity), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.EnvironmentName(childComplexity), true - case "OpenSearchCredentials.uri": - if e.ComplexityRoot.OpenSearchCredentials.URI == nil { + case "PostgresGrantAccessActivityLogEntry.id": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.OpenSearchCredentials.URI(childComplexity), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ID(childComplexity), true - case "OpenSearchCredentials.username": - if e.ComplexityRoot.OpenSearchCredentials.Username == nil { + case "PostgresGrantAccessActivityLogEntry.message": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.OpenSearchCredentials.Username(childComplexity), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Message(childComplexity), true - case "OpenSearchDeletedActivityLogEntry.actor": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Actor == nil { + case "PostgresGrantAccessActivityLogEntry.resourceName": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceName(childComplexity), true - case "OpenSearchDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.CreatedAt == nil { + case "PostgresGrantAccessActivityLogEntry.resourceType": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceType(childComplexity), true - case "OpenSearchDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.EnvironmentName == nil { + case "PostgresGrantAccessActivityLogEntry.teamSlug": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.TeamSlug(childComplexity), true - case "OpenSearchDeletedActivityLogEntry.id": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ID == nil { + case "PostgresGrantAccessActivityLogEntryData.grantee": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Grantee == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Grantee(childComplexity), true - case "OpenSearchDeletedActivityLogEntry.message": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Message == nil { + case "PostgresGrantAccessActivityLogEntryData.until": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Until == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Until(childComplexity), true - case "OpenSearchDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceName == nil { + case "PostgresInstance.audit": + if e.ComplexityRoot.PostgresInstance.Audit == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.PostgresInstance.Audit(childComplexity), true - case "OpenSearchDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceType == nil { + case "PostgresInstance.environment": + if e.ComplexityRoot.PostgresInstance.Environment == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.PostgresInstance.Environment(childComplexity), true - case "OpenSearchDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.TeamSlug == nil { + case "PostgresInstance.highAvailability": + if e.ComplexityRoot.PostgresInstance.HighAvailability == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.PostgresInstance.HighAvailability(childComplexity), true - case "OpenSearchEdge.cursor": - if e.ComplexityRoot.OpenSearchEdge.Cursor == nil { + case "PostgresInstance.id": + if e.ComplexityRoot.PostgresInstance.ID == nil { break } - return e.ComplexityRoot.OpenSearchEdge.Cursor(childComplexity), true + return e.ComplexityRoot.PostgresInstance.ID(childComplexity), true - case "OpenSearchEdge.node": - if e.ComplexityRoot.OpenSearchEdge.Node == nil { + case "PostgresInstance.maintenanceWindow": + if e.ComplexityRoot.PostgresInstance.MaintenanceWindow == nil { break } - return e.ComplexityRoot.OpenSearchEdge.Node(childComplexity), true + return e.ComplexityRoot.PostgresInstance.MaintenanceWindow(childComplexity), true - case "OpenSearchIssue.event": - if e.ComplexityRoot.OpenSearchIssue.Event == nil { + case "PostgresInstance.majorVersion": + if e.ComplexityRoot.PostgresInstance.MajorVersion == nil { break } - return e.ComplexityRoot.OpenSearchIssue.Event(childComplexity), true + return e.ComplexityRoot.PostgresInstance.MajorVersion(childComplexity), true - case "OpenSearchIssue.id": - if e.ComplexityRoot.OpenSearchIssue.ID == nil { + case "PostgresInstance.name": + if e.ComplexityRoot.PostgresInstance.Name == nil { break } - return e.ComplexityRoot.OpenSearchIssue.ID(childComplexity), true + return e.ComplexityRoot.PostgresInstance.Name(childComplexity), true - case "OpenSearchIssue.message": - if e.ComplexityRoot.OpenSearchIssue.Message == nil { + case "PostgresInstance.resources": + if e.ComplexityRoot.PostgresInstance.Resources == nil { break } - return e.ComplexityRoot.OpenSearchIssue.Message(childComplexity), true + return e.ComplexityRoot.PostgresInstance.Resources(childComplexity), true - case "OpenSearchIssue.openSearch": - if e.ComplexityRoot.OpenSearchIssue.OpenSearch == nil { + case "PostgresInstance.state": + if e.ComplexityRoot.PostgresInstance.State == nil { break } - return e.ComplexityRoot.OpenSearchIssue.OpenSearch(childComplexity), true + return e.ComplexityRoot.PostgresInstance.State(childComplexity), true - case "OpenSearchIssue.severity": - if e.ComplexityRoot.OpenSearchIssue.Severity == nil { + case "PostgresInstance.team": + if e.ComplexityRoot.PostgresInstance.Team == nil { break } - return e.ComplexityRoot.OpenSearchIssue.Severity(childComplexity), true + return e.ComplexityRoot.PostgresInstance.Team(childComplexity), true - case "OpenSearchIssue.teamEnvironment": - if e.ComplexityRoot.OpenSearchIssue.TeamEnvironment == nil { + case "PostgresInstance.teamEnvironment": + if e.ComplexityRoot.PostgresInstance.TeamEnvironment == nil { break } - return e.ComplexityRoot.OpenSearchIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.PostgresInstance.TeamEnvironment(childComplexity), true - case "OpenSearchMaintenance.updates": - if e.ComplexityRoot.OpenSearchMaintenance.Updates == nil { + case "PostgresInstance.workloads": + if e.ComplexityRoot.PostgresInstance.Workloads == nil { break } - args, err := ec.field_OpenSearchMaintenance_updates_args(ctx, rawArgs) + args, err := ec.field_PostgresInstance_workloads_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.OpenSearchMaintenance.Updates(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.PostgresInstance.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "OpenSearchMaintenance.window": - if e.ComplexityRoot.OpenSearchMaintenance.Window == nil { + case "PostgresInstanceAudit.enabled": + if e.ComplexityRoot.PostgresInstanceAudit.Enabled == nil { break } - return e.ComplexityRoot.OpenSearchMaintenance.Window(childComplexity), true + return e.ComplexityRoot.PostgresInstanceAudit.Enabled(childComplexity), true - case "OpenSearchMaintenanceUpdate.deadline": - if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Deadline == nil { + case "PostgresInstanceAudit.statementClasses": + if e.ComplexityRoot.PostgresInstanceAudit.StatementClasses == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Deadline(childComplexity), true + return e.ComplexityRoot.PostgresInstanceAudit.StatementClasses(childComplexity), true - case "OpenSearchMaintenanceUpdate.description": - if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Description == nil { + case "PostgresInstanceAudit.url": + if e.ComplexityRoot.PostgresInstanceAudit.URL == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Description(childComplexity), true + return e.ComplexityRoot.PostgresInstanceAudit.URL(childComplexity), true - case "OpenSearchMaintenanceUpdate.startAt": - if e.ComplexityRoot.OpenSearchMaintenanceUpdate.StartAt == nil { + case "PostgresInstanceConnection.edges": + if e.ComplexityRoot.PostgresInstanceConnection.Edges == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdate.StartAt(childComplexity), true + return e.ComplexityRoot.PostgresInstanceConnection.Edges(childComplexity), true - case "OpenSearchMaintenanceUpdate.title": - if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Title == nil { + case "PostgresInstanceConnection.nodes": + if e.ComplexityRoot.PostgresInstanceConnection.Nodes == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Title(childComplexity), true + return e.ComplexityRoot.PostgresInstanceConnection.Nodes(childComplexity), true - case "OpenSearchMaintenanceUpdateConnection.edges": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Edges == nil { + case "PostgresInstanceConnection.pageInfo": + if e.ComplexityRoot.PostgresInstanceConnection.PageInfo == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Edges(childComplexity), true + return e.ComplexityRoot.PostgresInstanceConnection.PageInfo(childComplexity), true - case "OpenSearchMaintenanceUpdateConnection.nodes": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Nodes == nil { + case "PostgresInstanceEdge.cursor": + if e.ComplexityRoot.PostgresInstanceEdge.Cursor == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Nodes(childComplexity), true + return e.ComplexityRoot.PostgresInstanceEdge.Cursor(childComplexity), true - case "OpenSearchMaintenanceUpdateConnection.pageInfo": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.PageInfo == nil { + case "PostgresInstanceEdge.node": + if e.ComplexityRoot.PostgresInstanceEdge.Node == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.PostgresInstanceEdge.Node(childComplexity), true - case "OpenSearchMaintenanceUpdateEdge.cursor": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Cursor == nil { + case "PostgresInstanceMaintenanceWindow.day": + if e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Day == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Cursor(childComplexity), true + return e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Day(childComplexity), true - case "OpenSearchMaintenanceUpdateEdge.node": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Node == nil { + case "PostgresInstanceMaintenanceWindow.hour": + if e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Hour == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Node(childComplexity), true + return e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Hour(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Actor == nil { + case "PostgresInstanceResources.cpu": + if e.ComplexityRoot.PostgresInstanceResources.CPU == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.PostgresInstanceResources.CPU(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.CreatedAt == nil { + case "PostgresInstanceResources.diskSize": + if e.ComplexityRoot.PostgresInstanceResources.DiskSize == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.PostgresInstanceResources.DiskSize(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.data": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Data == nil { + case "PostgresInstanceResources.memory": + if e.ComplexityRoot.PostgresInstanceResources.Memory == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.PostgresInstanceResources.Memory(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.EnvironmentName == nil { + case "Price.value": + if e.ComplexityRoot.Price.Value == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Price.Value(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.id": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ID == nil { + case "PrometheusAlarm.action": + if e.ComplexityRoot.PrometheusAlarm.Action == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Action(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.message": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Message == nil { + case "PrometheusAlarm.consequence": + if e.ComplexityRoot.PrometheusAlarm.Consequence == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Consequence(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceName == nil { + case "PrometheusAlarm.since": + if e.ComplexityRoot.PrometheusAlarm.Since == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Since(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceType == nil { + case "PrometheusAlarm.state": + if e.ComplexityRoot.PrometheusAlarm.State == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.State(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.TeamSlug == nil { + case "PrometheusAlarm.summary": + if e.ComplexityRoot.PrometheusAlarm.Summary == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Summary(childComplexity), true - case "OpenSearchUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryData.UpdatedFields == nil { + case "PrometheusAlarm.value": + if e.ComplexityRoot.PrometheusAlarm.Value == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Value(childComplexity), true - case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "PrometheusAlert.alarms": + if e.ComplexityRoot.PrometheusAlert.Alarms == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Alarms(childComplexity), true - case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "PrometheusAlert.duration": + if e.ComplexityRoot.PrometheusAlert.Duration == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Duration(childComplexity), true - case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "PrometheusAlert.id": + if e.ComplexityRoot.PrometheusAlert.ID == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.ID(childComplexity), true - case "OpenSearchVersion.actual": - if e.ComplexityRoot.OpenSearchVersion.Actual == nil { + case "PrometheusAlert.name": + if e.ComplexityRoot.PrometheusAlert.Name == nil { break } - return e.ComplexityRoot.OpenSearchVersion.Actual(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Name(childComplexity), true - case "OpenSearchVersion.desiredMajor": - if e.ComplexityRoot.OpenSearchVersion.DesiredMajor == nil { + case "PrometheusAlert.query": + if e.ComplexityRoot.PrometheusAlert.Query == nil { break } - return e.ComplexityRoot.OpenSearchVersion.DesiredMajor(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Query(childComplexity), true - case "OutboundNetworkPolicy.external": - if e.ComplexityRoot.OutboundNetworkPolicy.External == nil { + case "PrometheusAlert.ruleGroup": + if e.ComplexityRoot.PrometheusAlert.RuleGroup == nil { break } - return e.ComplexityRoot.OutboundNetworkPolicy.External(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.RuleGroup(childComplexity), true - case "OutboundNetworkPolicy.rules": - if e.ComplexityRoot.OutboundNetworkPolicy.Rules == nil { + case "PrometheusAlert.state": + if e.ComplexityRoot.PrometheusAlert.State == nil { break } - return e.ComplexityRoot.OutboundNetworkPolicy.Rules(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.State(childComplexity), true - case "PageInfo.endCursor": - if e.ComplexityRoot.PageInfo.EndCursor == nil { + case "PrometheusAlert.team": + if e.ComplexityRoot.PrometheusAlert.Team == nil { break } - return e.ComplexityRoot.PageInfo.EndCursor(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Team(childComplexity), true - case "PageInfo.hasNextPage": - if e.ComplexityRoot.PageInfo.HasNextPage == nil { + case "PrometheusAlert.teamEnvironment": + if e.ComplexityRoot.PrometheusAlert.TeamEnvironment == nil { break } - return e.ComplexityRoot.PageInfo.HasNextPage(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.TeamEnvironment(childComplexity), true - case "PageInfo.hasPreviousPage": - if e.ComplexityRoot.PageInfo.HasPreviousPage == nil { + case "Query.cve": + if e.ComplexityRoot.Query.CVE == nil { break } - return e.ComplexityRoot.PageInfo.HasPreviousPage(childComplexity), true - - case "PageInfo.pageEnd": - if e.ComplexityRoot.PageInfo.PageEnd == nil { - break + args, err := ec.field_Query_cve_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PageInfo.PageEnd(childComplexity), true + return e.ComplexityRoot.Query.CVE(childComplexity, args["identifier"].(string)), true - case "PageInfo.pageStart": - if e.ComplexityRoot.PageInfo.PageStart == nil { + case "Query.costMonthlySummary": + if e.ComplexityRoot.Query.CostMonthlySummary == nil { break } - return e.ComplexityRoot.PageInfo.PageStart(childComplexity), true - - case "PageInfo.startCursor": - if e.ComplexityRoot.PageInfo.StartCursor == nil { - break + args, err := ec.field_Query_costMonthlySummary_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PageInfo.StartCursor(childComplexity), true + return e.ComplexityRoot.Query.CostMonthlySummary(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true - case "PageInfo.totalCount": - if e.ComplexityRoot.PageInfo.TotalCount == nil { + case "Query.currentUnitPrices": + if e.ComplexityRoot.Query.CurrentUnitPrices == nil { break } - return e.ComplexityRoot.PageInfo.TotalCount(childComplexity), true + return e.ComplexityRoot.Query.CurrentUnitPrices(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.actor": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Actor == nil { + case "Query.cves": + if e.ComplexityRoot.Query.Cves == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Actor(childComplexity), true - - case "PostgresGrantAccessActivityLogEntry.createdAt": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_Query_cves_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Query.Cves(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*vulnerability.CVEOrder)), true - case "PostgresGrantAccessActivityLogEntry.data": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Data == nil { + case "Query.deployments": + if e.ComplexityRoot.Query.Deployments == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Data(childComplexity), true - - case "PostgresGrantAccessActivityLogEntry.environmentName": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_Query_deployments_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Query.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*deployment.DeploymentOrder), args["filter"].(*deployment.DeploymentFilter)), true - case "PostgresGrantAccessActivityLogEntry.id": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ID == nil { + case "Query.environment": + if e.ComplexityRoot.Query.Environment == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ID(childComplexity), true - - case "PostgresGrantAccessActivityLogEntry.message": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Message == nil { - break + args, err := ec.field_Query_environment_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Query.Environment(childComplexity, args["name"].(string)), true - case "PostgresGrantAccessActivityLogEntry.resourceName": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceName == nil { + case "Query.environments": + if e.ComplexityRoot.Query.Environments == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceName(childComplexity), true - - case "PostgresGrantAccessActivityLogEntry.resourceType": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceType == nil { - break + args, err := ec.field_Query_environments_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Query.Environments(childComplexity, args["orderBy"].(*environment.EnvironmentOrder)), true - case "PostgresGrantAccessActivityLogEntry.teamSlug": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.TeamSlug == nil { + case "Query.features": + if e.ComplexityRoot.Query.Features == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Query.Features(childComplexity), true - case "PostgresGrantAccessActivityLogEntryData.grantee": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Grantee == nil { + case "Query.imageVulnerabilityHistory": + if e.ComplexityRoot.Query.ImageVulnerabilityHistory == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Grantee(childComplexity), true + args, err := ec.field_Query_imageVulnerabilityHistory_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "PostgresGrantAccessActivityLogEntryData.until": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Until == nil { + return e.ComplexityRoot.Query.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true + + case "Query.me": + if e.ComplexityRoot.Query.Me == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Until(childComplexity), true + return e.ComplexityRoot.Query.Me(childComplexity), true - case "PostgresInstance.audit": - if e.ComplexityRoot.PostgresInstance.Audit == nil { + case "Query.node": + if e.ComplexityRoot.Query.Node == nil { break } - return e.ComplexityRoot.PostgresInstance.Audit(childComplexity), true - - case "PostgresInstance.environment": - if e.ComplexityRoot.PostgresInstance.Environment == nil { - break + args, err := ec.field_Query_node_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresInstance.Environment(childComplexity), true + return e.ComplexityRoot.Query.Node(childComplexity, args["id"].(ident.Ident)), true - case "PostgresInstance.highAvailability": - if e.ComplexityRoot.PostgresInstance.HighAvailability == nil { + case "Query.reconcilers": + if e.ComplexityRoot.Query.Reconcilers == nil { break } - return e.ComplexityRoot.PostgresInstance.HighAvailability(childComplexity), true - - case "PostgresInstance.id": - if e.ComplexityRoot.PostgresInstance.ID == nil { - break + args, err := ec.field_Query_reconcilers_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresInstance.ID(childComplexity), true + return e.ComplexityRoot.Query.Reconcilers(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "PostgresInstance.maintenanceWindow": - if e.ComplexityRoot.PostgresInstance.MaintenanceWindow == nil { + case "Query.roles": + if e.ComplexityRoot.Query.Roles == nil { break } - return e.ComplexityRoot.PostgresInstance.MaintenanceWindow(childComplexity), true - - case "PostgresInstance.majorVersion": - if e.ComplexityRoot.PostgresInstance.MajorVersion == nil { - break + args, err := ec.field_Query_roles_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresInstance.MajorVersion(childComplexity), true + return e.ComplexityRoot.Query.Roles(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "PostgresInstance.name": - if e.ComplexityRoot.PostgresInstance.Name == nil { + case "Query.search": + if e.ComplexityRoot.Query.Search == nil { break } - return e.ComplexityRoot.PostgresInstance.Name(childComplexity), true - - case "PostgresInstance.resources": - if e.ComplexityRoot.PostgresInstance.Resources == nil { - break + args, err := ec.field_Query_search_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresInstance.Resources(childComplexity), true + return e.ComplexityRoot.Query.Search(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(search.SearchFilter)), true - case "PostgresInstance.state": - if e.ComplexityRoot.PostgresInstance.State == nil { + case "Query.serviceAccount": + if e.ComplexityRoot.Query.ServiceAccount == nil { break } - return e.ComplexityRoot.PostgresInstance.State(childComplexity), true - - case "PostgresInstance.team": - if e.ComplexityRoot.PostgresInstance.Team == nil { - break + args, err := ec.field_Query_serviceAccount_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresInstance.Team(childComplexity), true + return e.ComplexityRoot.Query.ServiceAccount(childComplexity, args["id"].(ident.Ident)), true - case "PostgresInstance.teamEnvironment": - if e.ComplexityRoot.PostgresInstance.TeamEnvironment == nil { + case "Query.serviceAccounts": + if e.ComplexityRoot.Query.ServiceAccounts == nil { break } - return e.ComplexityRoot.PostgresInstance.TeamEnvironment(childComplexity), true + args, err := ec.field_Query_serviceAccounts_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "PostgresInstance.workloads": - if e.ComplexityRoot.PostgresInstance.Workloads == nil { + return e.ComplexityRoot.Query.ServiceAccounts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "Query.team": + if e.ComplexityRoot.Query.Team == nil { break } - args, err := ec.field_PostgresInstance_workloads_args(ctx, rawArgs) + args, err := ec.field_Query_team_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.PostgresInstance.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Query.Team(childComplexity, args["slug"].(slug.Slug)), true - case "PostgresInstanceAudit.enabled": - if e.ComplexityRoot.PostgresInstanceAudit.Enabled == nil { + case "Query.teams": + if e.ComplexityRoot.Query.Teams == nil { break } - return e.ComplexityRoot.PostgresInstanceAudit.Enabled(childComplexity), true - - case "PostgresInstanceAudit.statementClasses": - if e.ComplexityRoot.PostgresInstanceAudit.StatementClasses == nil { - break + args, err := ec.field_Query_teams_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresInstanceAudit.StatementClasses(childComplexity), true + return e.ComplexityRoot.Query.Teams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.TeamOrder), args["filter"].(*team.TeamFilter)), true - case "PostgresInstanceAudit.url": - if e.ComplexityRoot.PostgresInstanceAudit.URL == nil { + case "Query.teamsUtilization": + if e.ComplexityRoot.Query.TeamsUtilization == nil { break } - return e.ComplexityRoot.PostgresInstanceAudit.URL(childComplexity), true - - case "PostgresInstanceConnection.edges": - if e.ComplexityRoot.PostgresInstanceConnection.Edges == nil { - break + args, err := ec.field_Query_teamsUtilization_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresInstanceConnection.Edges(childComplexity), true + return e.ComplexityRoot.Query.TeamsUtilization(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true - case "PostgresInstanceConnection.nodes": - if e.ComplexityRoot.PostgresInstanceConnection.Nodes == nil { + case "Query.unleashReleaseChannels": + if e.ComplexityRoot.Query.UnleashReleaseChannels == nil { break } - return e.ComplexityRoot.PostgresInstanceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Query.UnleashReleaseChannels(childComplexity), true - case "PostgresInstanceConnection.pageInfo": - if e.ComplexityRoot.PostgresInstanceConnection.PageInfo == nil { + case "Query.user": + if e.ComplexityRoot.Query.User == nil { break } - return e.ComplexityRoot.PostgresInstanceConnection.PageInfo(childComplexity), true - - case "PostgresInstanceEdge.cursor": - if e.ComplexityRoot.PostgresInstanceEdge.Cursor == nil { - break + args, err := ec.field_Query_user_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresInstanceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Query.User(childComplexity, args["email"].(*string)), true - case "PostgresInstanceEdge.node": - if e.ComplexityRoot.PostgresInstanceEdge.Node == nil { + case "Query.userSyncLog": + if e.ComplexityRoot.Query.UserSyncLog == nil { break } - return e.ComplexityRoot.PostgresInstanceEdge.Node(childComplexity), true - - case "PostgresInstanceMaintenanceWindow.day": - if e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Day == nil { - break + args, err := ec.field_Query_userSyncLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Day(childComplexity), true + return e.ComplexityRoot.Query.UserSyncLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "PostgresInstanceMaintenanceWindow.hour": - if e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Hour == nil { + case "Query.users": + if e.ComplexityRoot.Query.Users == nil { break } - return e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Hour(childComplexity), true - - case "PostgresInstanceResources.cpu": - if e.ComplexityRoot.PostgresInstanceResources.CPU == nil { - break + args, err := ec.field_Query_users_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresInstanceResources.CPU(childComplexity), true + return e.ComplexityRoot.Query.Users(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*user.UserOrder)), true - case "PostgresInstanceResources.diskSize": - if e.ComplexityRoot.PostgresInstanceResources.DiskSize == nil { + case "Query.vulnerabilityFixHistory": + if e.ComplexityRoot.Query.VulnerabilityFixHistory == nil { break } - return e.ComplexityRoot.PostgresInstanceResources.DiskSize(childComplexity), true - - case "PostgresInstanceResources.memory": - if e.ComplexityRoot.PostgresInstanceResources.Memory == nil { - break + args, err := ec.field_Query_vulnerabilityFixHistory_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PostgresInstanceResources.Memory(childComplexity), true + return e.ComplexityRoot.Query.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true - case "Price.value": - if e.ComplexityRoot.Price.Value == nil { + case "Query.vulnerabilitySummary": + if e.ComplexityRoot.Query.VulnerabilitySummary == nil { break } - return e.ComplexityRoot.Price.Value(childComplexity), true + return e.ComplexityRoot.Query.VulnerabilitySummary(childComplexity), true - case "PrometheusAlarm.action": - if e.ComplexityRoot.PrometheusAlarm.Action == nil { + case "Reconciler.activityLog": + if e.ComplexityRoot.Reconciler.ActivityLog == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Action(childComplexity), true - - case "PrometheusAlarm.consequence": - if e.ComplexityRoot.PrometheusAlarm.Consequence == nil { - break + args, err := ec.field_Reconciler_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.PrometheusAlarm.Consequence(childComplexity), true + return e.ComplexityRoot.Reconciler.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "PrometheusAlarm.since": - if e.ComplexityRoot.PrometheusAlarm.Since == nil { + case "Reconciler.config": + if e.ComplexityRoot.Reconciler.Config == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Since(childComplexity), true + return e.ComplexityRoot.Reconciler.Config(childComplexity), true - case "PrometheusAlarm.state": - if e.ComplexityRoot.PrometheusAlarm.State == nil { + case "Reconciler.configured": + if e.ComplexityRoot.Reconciler.Configured == nil { break } - return e.ComplexityRoot.PrometheusAlarm.State(childComplexity), true + return e.ComplexityRoot.Reconciler.Configured(childComplexity), true - case "PrometheusAlarm.summary": - if e.ComplexityRoot.PrometheusAlarm.Summary == nil { + case "Reconciler.description": + if e.ComplexityRoot.Reconciler.Description == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Summary(childComplexity), true + return e.ComplexityRoot.Reconciler.Description(childComplexity), true - case "PrometheusAlarm.value": - if e.ComplexityRoot.PrometheusAlarm.Value == nil { + case "Reconciler.displayName": + if e.ComplexityRoot.Reconciler.DisplayName == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Value(childComplexity), true + return e.ComplexityRoot.Reconciler.DisplayName(childComplexity), true - case "PrometheusAlert.alarms": - if e.ComplexityRoot.PrometheusAlert.Alarms == nil { + case "Reconciler.enabled": + if e.ComplexityRoot.Reconciler.Enabled == nil { break } - return e.ComplexityRoot.PrometheusAlert.Alarms(childComplexity), true + return e.ComplexityRoot.Reconciler.Enabled(childComplexity), true - case "PrometheusAlert.duration": - if e.ComplexityRoot.PrometheusAlert.Duration == nil { + case "Reconciler.errors": + if e.ComplexityRoot.Reconciler.Errors == nil { break } - return e.ComplexityRoot.PrometheusAlert.Duration(childComplexity), true + args, err := ec.field_Reconciler_errors_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "PrometheusAlert.id": - if e.ComplexityRoot.PrometheusAlert.ID == nil { + return e.ComplexityRoot.Reconciler.Errors(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "Reconciler.id": + if e.ComplexityRoot.Reconciler.ID == nil { break } - return e.ComplexityRoot.PrometheusAlert.ID(childComplexity), true + return e.ComplexityRoot.Reconciler.ID(childComplexity), true - case "PrometheusAlert.name": - if e.ComplexityRoot.PrometheusAlert.Name == nil { + case "Reconciler.name": + if e.ComplexityRoot.Reconciler.Name == nil { break } - return e.ComplexityRoot.PrometheusAlert.Name(childComplexity), true + return e.ComplexityRoot.Reconciler.Name(childComplexity), true - case "PrometheusAlert.query": - if e.ComplexityRoot.PrometheusAlert.Query == nil { + case "ReconcilerConfig.configured": + if e.ComplexityRoot.ReconcilerConfig.Configured == nil { break } - return e.ComplexityRoot.PrometheusAlert.Query(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Configured(childComplexity), true - case "PrometheusAlert.ruleGroup": - if e.ComplexityRoot.PrometheusAlert.RuleGroup == nil { + case "ReconcilerConfig.description": + if e.ComplexityRoot.ReconcilerConfig.Description == nil { break } - return e.ComplexityRoot.PrometheusAlert.RuleGroup(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Description(childComplexity), true - case "PrometheusAlert.state": - if e.ComplexityRoot.PrometheusAlert.State == nil { + case "ReconcilerConfig.displayName": + if e.ComplexityRoot.ReconcilerConfig.DisplayName == nil { break } - return e.ComplexityRoot.PrometheusAlert.State(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.DisplayName(childComplexity), true - case "PrometheusAlert.team": - if e.ComplexityRoot.PrometheusAlert.Team == nil { + case "ReconcilerConfig.key": + if e.ComplexityRoot.ReconcilerConfig.Key == nil { break } - return e.ComplexityRoot.PrometheusAlert.Team(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Key(childComplexity), true - case "PrometheusAlert.teamEnvironment": - if e.ComplexityRoot.PrometheusAlert.TeamEnvironment == nil { + case "ReconcilerConfig.secret": + if e.ComplexityRoot.ReconcilerConfig.Secret == nil { break } - return e.ComplexityRoot.PrometheusAlert.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Secret(childComplexity), true - case "Query.cve": - if e.ComplexityRoot.Query.CVE == nil { + case "ReconcilerConfig.value": + if e.ComplexityRoot.ReconcilerConfig.Value == nil { break } - args, err := ec.field_Query_cve_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerConfig.Value(childComplexity), true + + case "ReconcilerConfiguredActivityLogEntry.actor": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Actor == nil { + break } - return e.ComplexityRoot.Query.CVE(childComplexity, args["identifier"].(string)), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Actor(childComplexity), true - case "Query.costMonthlySummary": - if e.ComplexityRoot.Query.CostMonthlySummary == nil { + case "ReconcilerConfiguredActivityLogEntry.createdAt": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.CreatedAt == nil { break } - args, err := ec.field_Query_costMonthlySummary_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.CreatedAt(childComplexity), true + + case "ReconcilerConfiguredActivityLogEntry.data": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Data == nil { + break } - return e.ComplexityRoot.Query.CostMonthlySummary(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Data(childComplexity), true - case "Query.currentUnitPrices": - if e.ComplexityRoot.Query.CurrentUnitPrices == nil { + case "ReconcilerConfiguredActivityLogEntry.environmentName": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.Query.CurrentUnitPrices(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.EnvironmentName(childComplexity), true - case "Query.cves": - if e.ComplexityRoot.Query.Cves == nil { + case "ReconcilerConfiguredActivityLogEntry.id": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ID == nil { break } - args, err := ec.field_Query_cves_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ID(childComplexity), true + + case "ReconcilerConfiguredActivityLogEntry.message": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Message == nil { + break } - return e.ComplexityRoot.Query.Cves(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*vulnerability.CVEOrder)), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Message(childComplexity), true - case "Query.deployments": - if e.ComplexityRoot.Query.Deployments == nil { + case "ReconcilerConfiguredActivityLogEntry.resourceName": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceName == nil { break } - args, err := ec.field_Query_deployments_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceName(childComplexity), true + + case "ReconcilerConfiguredActivityLogEntry.resourceType": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceType == nil { + break } - return e.ComplexityRoot.Query.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*deployment.DeploymentOrder), args["filter"].(*deployment.DeploymentFilter)), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceType(childComplexity), true - case "Query.environment": - if e.ComplexityRoot.Query.Environment == nil { + case "ReconcilerConfiguredActivityLogEntry.teamSlug": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.TeamSlug == nil { break } - args, err := ec.field_Query_environment_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.TeamSlug(childComplexity), true + + case "ReconcilerConfiguredActivityLogEntryData.updatedKeys": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntryData.UpdatedKeys == nil { + break } - return e.ComplexityRoot.Query.Environment(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntryData.UpdatedKeys(childComplexity), true - case "Query.environments": - if e.ComplexityRoot.Query.Environments == nil { + case "ReconcilerConnection.edges": + if e.ComplexityRoot.ReconcilerConnection.Edges == nil { break } - args, err := ec.field_Query_environments_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerConnection.Edges(childComplexity), true + + case "ReconcilerConnection.nodes": + if e.ComplexityRoot.ReconcilerConnection.Nodes == nil { + break } - return e.ComplexityRoot.Query.Environments(childComplexity, args["orderBy"].(*environment.EnvironmentOrder)), true + return e.ComplexityRoot.ReconcilerConnection.Nodes(childComplexity), true - case "Query.features": - if e.ComplexityRoot.Query.Features == nil { + case "ReconcilerConnection.pageInfo": + if e.ComplexityRoot.ReconcilerConnection.PageInfo == nil { break } - return e.ComplexityRoot.Query.Features(childComplexity), true + return e.ComplexityRoot.ReconcilerConnection.PageInfo(childComplexity), true - case "Query.imageVulnerabilityHistory": - if e.ComplexityRoot.Query.ImageVulnerabilityHistory == nil { + case "ReconcilerDisabledActivityLogEntry.actor": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Actor == nil { break } - args, err := ec.field_Query_imageVulnerabilityHistory_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Actor(childComplexity), true + + case "ReconcilerDisabledActivityLogEntry.createdAt": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.CreatedAt == nil { + break } - return e.ComplexityRoot.Query.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.CreatedAt(childComplexity), true - case "Query.me": - if e.ComplexityRoot.Query.Me == nil { + case "ReconcilerDisabledActivityLogEntry.environmentName": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.Query.Me(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.EnvironmentName(childComplexity), true - case "Query.node": - if e.ComplexityRoot.Query.Node == nil { + case "ReconcilerDisabledActivityLogEntry.id": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ID == nil { break } - args, err := ec.field_Query_node_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ID(childComplexity), true + + case "ReconcilerDisabledActivityLogEntry.message": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Message == nil { + break } - return e.ComplexityRoot.Query.Node(childComplexity, args["id"].(ident.Ident)), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Message(childComplexity), true - case "Query.reconcilers": - if e.ComplexityRoot.Query.Reconcilers == nil { + case "ReconcilerDisabledActivityLogEntry.resourceName": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceName == nil { break } - args, err := ec.field_Query_reconcilers_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceName(childComplexity), true + + case "ReconcilerDisabledActivityLogEntry.resourceType": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceType == nil { + break } - return e.ComplexityRoot.Query.Reconcilers(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceType(childComplexity), true - case "Query.roles": - if e.ComplexityRoot.Query.Roles == nil { + case "ReconcilerDisabledActivityLogEntry.teamSlug": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.TeamSlug == nil { break } - args, err := ec.field_Query_roles_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.TeamSlug(childComplexity), true + + case "ReconcilerEdge.cursor": + if e.ComplexityRoot.ReconcilerEdge.Cursor == nil { + break } - return e.ComplexityRoot.Query.Roles(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ReconcilerEdge.Cursor(childComplexity), true - case "Query.search": - if e.ComplexityRoot.Query.Search == nil { + case "ReconcilerEdge.node": + if e.ComplexityRoot.ReconcilerEdge.Node == nil { break } - args, err := ec.field_Query_search_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerEdge.Node(childComplexity), true + + case "ReconcilerEnabledActivityLogEntry.actor": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Actor == nil { + break } - return e.ComplexityRoot.Query.Search(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(search.SearchFilter)), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Actor(childComplexity), true - case "Query.serviceAccount": - if e.ComplexityRoot.Query.ServiceAccount == nil { + case "ReconcilerEnabledActivityLogEntry.createdAt": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.CreatedAt == nil { break } - args, err := ec.field_Query_serviceAccount_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.CreatedAt(childComplexity), true + + case "ReconcilerEnabledActivityLogEntry.environmentName": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.EnvironmentName == nil { + break } - return e.ComplexityRoot.Query.ServiceAccount(childComplexity, args["id"].(ident.Ident)), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.EnvironmentName(childComplexity), true - case "Query.serviceAccounts": - if e.ComplexityRoot.Query.ServiceAccounts == nil { + case "ReconcilerEnabledActivityLogEntry.id": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ID == nil { break } - args, err := ec.field_Query_serviceAccounts_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ID(childComplexity), true + + case "ReconcilerEnabledActivityLogEntry.message": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Message == nil { + break } - return e.ComplexityRoot.Query.ServiceAccounts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Message(childComplexity), true - case "Query.team": - if e.ComplexityRoot.Query.Team == nil { + case "ReconcilerEnabledActivityLogEntry.resourceName": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceName == nil { break } - args, err := ec.field_Query_team_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceName(childComplexity), true + + case "ReconcilerEnabledActivityLogEntry.resourceType": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceType == nil { + break } - return e.ComplexityRoot.Query.Team(childComplexity, args["slug"].(slug.Slug)), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceType(childComplexity), true - case "Query.teams": - if e.ComplexityRoot.Query.Teams == nil { + case "ReconcilerEnabledActivityLogEntry.teamSlug": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.TeamSlug == nil { break } - args, err := ec.field_Query_teams_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.TeamSlug(childComplexity), true + + case "ReconcilerError.correlationID": + if e.ComplexityRoot.ReconcilerError.CorrelationID == nil { + break } - return e.ComplexityRoot.Query.Teams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.TeamOrder), args["filter"].(*team.TeamFilter)), true + return e.ComplexityRoot.ReconcilerError.CorrelationID(childComplexity), true - case "Query.teamsUtilization": - if e.ComplexityRoot.Query.TeamsUtilization == nil { + case "ReconcilerError.createdAt": + if e.ComplexityRoot.ReconcilerError.CreatedAt == nil { break } - args, err := ec.field_Query_teamsUtilization_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Query.TeamsUtilization(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + return e.ComplexityRoot.ReconcilerError.CreatedAt(childComplexity), true - case "Query.unleashReleaseChannels": - if e.ComplexityRoot.Query.UnleashReleaseChannels == nil { + case "ReconcilerError.id": + if e.ComplexityRoot.ReconcilerError.ID == nil { break } - return e.ComplexityRoot.Query.UnleashReleaseChannels(childComplexity), true + return e.ComplexityRoot.ReconcilerError.ID(childComplexity), true - case "Query.user": - if e.ComplexityRoot.Query.User == nil { + case "ReconcilerError.message": + if e.ComplexityRoot.ReconcilerError.Message == nil { break } - args, err := ec.field_Query_user_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerError.Message(childComplexity), true + + case "ReconcilerError.team": + if e.ComplexityRoot.ReconcilerError.Team == nil { + break } - return e.ComplexityRoot.Query.User(childComplexity, args["email"].(*string)), true + return e.ComplexityRoot.ReconcilerError.Team(childComplexity), true - case "Query.userSyncLog": - if e.ComplexityRoot.Query.UserSyncLog == nil { + case "ReconcilerErrorConnection.edges": + if e.ComplexityRoot.ReconcilerErrorConnection.Edges == nil { break } - args, err := ec.field_Query_userSyncLog_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerErrorConnection.Edges(childComplexity), true + + case "ReconcilerErrorConnection.nodes": + if e.ComplexityRoot.ReconcilerErrorConnection.Nodes == nil { + break } - return e.ComplexityRoot.Query.UserSyncLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ReconcilerErrorConnection.Nodes(childComplexity), true - case "Query.users": - if e.ComplexityRoot.Query.Users == nil { + case "ReconcilerErrorConnection.pageInfo": + if e.ComplexityRoot.ReconcilerErrorConnection.PageInfo == nil { break } - args, err := ec.field_Query_users_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerErrorConnection.PageInfo(childComplexity), true + + case "ReconcilerErrorEdge.cursor": + if e.ComplexityRoot.ReconcilerErrorEdge.Cursor == nil { + break } - return e.ComplexityRoot.Query.Users(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*user.UserOrder)), true + return e.ComplexityRoot.ReconcilerErrorEdge.Cursor(childComplexity), true - case "Query.vulnerabilityFixHistory": - if e.ComplexityRoot.Query.VulnerabilityFixHistory == nil { + case "ReconcilerErrorEdge.node": + if e.ComplexityRoot.ReconcilerErrorEdge.Node == nil { break } - args, err := ec.field_Query_vulnerabilityFixHistory_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ReconcilerErrorEdge.Node(childComplexity), true + + case "RemoveRepositoryFromTeamPayload.success": + if e.ComplexityRoot.RemoveRepositoryFromTeamPayload.Success == nil { + break } - return e.ComplexityRoot.Query.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.RemoveRepositoryFromTeamPayload.Success(childComplexity), true - case "Query.vulnerabilitySummary": - if e.ComplexityRoot.Query.VulnerabilitySummary == nil { + case "RemoveSecretValuePayload.secret": + if e.ComplexityRoot.RemoveSecretValuePayload.Secret == nil { break } - return e.ComplexityRoot.Query.VulnerabilitySummary(childComplexity), true + return e.ComplexityRoot.RemoveSecretValuePayload.Secret(childComplexity), true - case "Reconciler.activityLog": - if e.ComplexityRoot.Reconciler.ActivityLog == nil { + case "RemoveTeamMemberPayload.team": + if e.ComplexityRoot.RemoveTeamMemberPayload.Team == nil { break } - args, err := ec.field_Reconciler_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.RemoveTeamMemberPayload.Team(childComplexity), true + + case "RemoveTeamMemberPayload.user": + if e.ComplexityRoot.RemoveTeamMemberPayload.User == nil { + break } - return e.ComplexityRoot.Reconciler.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.RemoveTeamMemberPayload.User(childComplexity), true - case "Reconciler.config": - if e.ComplexityRoot.Reconciler.Config == nil { + case "Repository.id": + if e.ComplexityRoot.Repository.ID == nil { break } - return e.ComplexityRoot.Reconciler.Config(childComplexity), true + return e.ComplexityRoot.Repository.ID(childComplexity), true - case "Reconciler.configured": - if e.ComplexityRoot.Reconciler.Configured == nil { + case "Repository.name": + if e.ComplexityRoot.Repository.Name == nil { break } - return e.ComplexityRoot.Reconciler.Configured(childComplexity), true + return e.ComplexityRoot.Repository.Name(childComplexity), true - case "Reconciler.description": - if e.ComplexityRoot.Reconciler.Description == nil { + case "Repository.team": + if e.ComplexityRoot.Repository.Team == nil { break } - return e.ComplexityRoot.Reconciler.Description(childComplexity), true + return e.ComplexityRoot.Repository.Team(childComplexity), true - case "Reconciler.displayName": - if e.ComplexityRoot.Reconciler.DisplayName == nil { + case "RepositoryAddedActivityLogEntry.actor": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.Reconciler.DisplayName(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.Actor(childComplexity), true - case "Reconciler.enabled": - if e.ComplexityRoot.Reconciler.Enabled == nil { + case "RepositoryAddedActivityLogEntry.createdAt": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.Reconciler.Enabled(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.CreatedAt(childComplexity), true - case "Reconciler.errors": - if e.ComplexityRoot.Reconciler.Errors == nil { + case "RepositoryAddedActivityLogEntry.environmentName": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.EnvironmentName == nil { break } - args, err := ec.field_Reconciler_errors_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.EnvironmentName(childComplexity), true + + case "RepositoryAddedActivityLogEntry.id": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ID == nil { + break } - return e.ComplexityRoot.Reconciler.Errors(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ID(childComplexity), true - case "Reconciler.id": - if e.ComplexityRoot.Reconciler.ID == nil { + case "RepositoryAddedActivityLogEntry.message": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.Reconciler.ID(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.Message(childComplexity), true - case "Reconciler.name": - if e.ComplexityRoot.Reconciler.Name == nil { + case "RepositoryAddedActivityLogEntry.resourceName": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.Reconciler.Name(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceName(childComplexity), true - case "ReconcilerConfig.configured": - if e.ComplexityRoot.ReconcilerConfig.Configured == nil { + case "RepositoryAddedActivityLogEntry.resourceType": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Configured(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceType(childComplexity), true - case "ReconcilerConfig.description": - if e.ComplexityRoot.ReconcilerConfig.Description == nil { + case "RepositoryAddedActivityLogEntry.teamSlug": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Description(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.TeamSlug(childComplexity), true - case "ReconcilerConfig.displayName": - if e.ComplexityRoot.ReconcilerConfig.DisplayName == nil { + case "RepositoryConnection.edges": + if e.ComplexityRoot.RepositoryConnection.Edges == nil { break } - return e.ComplexityRoot.ReconcilerConfig.DisplayName(childComplexity), true + return e.ComplexityRoot.RepositoryConnection.Edges(childComplexity), true - case "ReconcilerConfig.key": - if e.ComplexityRoot.ReconcilerConfig.Key == nil { + case "RepositoryConnection.nodes": + if e.ComplexityRoot.RepositoryConnection.Nodes == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Key(childComplexity), true + return e.ComplexityRoot.RepositoryConnection.Nodes(childComplexity), true - case "ReconcilerConfig.secret": - if e.ComplexityRoot.ReconcilerConfig.Secret == nil { + case "RepositoryConnection.pageInfo": + if e.ComplexityRoot.RepositoryConnection.PageInfo == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Secret(childComplexity), true + return e.ComplexityRoot.RepositoryConnection.PageInfo(childComplexity), true - case "ReconcilerConfig.value": - if e.ComplexityRoot.ReconcilerConfig.Value == nil { + case "RepositoryEdge.cursor": + if e.ComplexityRoot.RepositoryEdge.Cursor == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Value(childComplexity), true + return e.ComplexityRoot.RepositoryEdge.Cursor(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.actor": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Actor == nil { + case "RepositoryEdge.node": + if e.ComplexityRoot.RepositoryEdge.Node == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RepositoryEdge.Node(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.createdAt": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.CreatedAt == nil { + case "RepositoryRemovedActivityLogEntry.actor": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Actor(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.data": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Data == nil { + case "RepositoryRemovedActivityLogEntry.createdAt": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.CreatedAt(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.environmentName": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.EnvironmentName == nil { + case "RepositoryRemovedActivityLogEntry.environmentName": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.EnvironmentName(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.id": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ID == nil { + case "RepositoryRemovedActivityLogEntry.id": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ID(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.message": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Message == nil { + case "RepositoryRemovedActivityLogEntry.message": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Message(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.resourceName": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceName == nil { + case "RepositoryRemovedActivityLogEntry.resourceName": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceName(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.resourceType": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceType == nil { + case "RepositoryRemovedActivityLogEntry.resourceType": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceType(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.teamSlug": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.TeamSlug == nil { + case "RepositoryRemovedActivityLogEntry.teamSlug": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.TeamSlug(childComplexity), true - case "ReconcilerConfiguredActivityLogEntryData.updatedKeys": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntryData.UpdatedKeys == nil { + case "RequestTeamDeletionPayload.key": + if e.ComplexityRoot.RequestTeamDeletionPayload.Key == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntryData.UpdatedKeys(childComplexity), true + return e.ComplexityRoot.RequestTeamDeletionPayload.Key(childComplexity), true - case "ReconcilerConnection.edges": - if e.ComplexityRoot.ReconcilerConnection.Edges == nil { + case "ResourceActivityLogEntryData.apiVersion": + if e.ComplexityRoot.ResourceActivityLogEntryData.APIVersion == nil { break } - return e.ComplexityRoot.ReconcilerConnection.Edges(childComplexity), true + return e.ComplexityRoot.ResourceActivityLogEntryData.APIVersion(childComplexity), true - case "ReconcilerConnection.nodes": - if e.ComplexityRoot.ReconcilerConnection.Nodes == nil { + case "ResourceActivityLogEntryData.changedFields": + if e.ComplexityRoot.ResourceActivityLogEntryData.ChangedFields == nil { break } - return e.ComplexityRoot.ReconcilerConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ResourceActivityLogEntryData.ChangedFields(childComplexity), true - case "ReconcilerConnection.pageInfo": - if e.ComplexityRoot.ReconcilerConnection.PageInfo == nil { + case "ResourceActivityLogEntryData.kind": + if e.ComplexityRoot.ResourceActivityLogEntryData.Kind == nil { break } - return e.ComplexityRoot.ReconcilerConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ResourceActivityLogEntryData.Kind(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.actor": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Actor == nil { + case "ResourceChangedField.field": + if e.ComplexityRoot.ResourceChangedField.Field == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ResourceChangedField.Field(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.createdAt": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.CreatedAt == nil { + case "ResourceChangedField.newValue": + if e.ComplexityRoot.ResourceChangedField.NewValue == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ResourceChangedField.NewValue(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.environmentName": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.EnvironmentName == nil { + case "ResourceChangedField.oldValue": + if e.ComplexityRoot.ResourceChangedField.OldValue == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ResourceChangedField.OldValue(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.id": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ID == nil { + case "RestartApplicationPayload.application": + if e.ComplexityRoot.RestartApplicationPayload.Application == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RestartApplicationPayload.Application(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.message": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Message == nil { + case "RevokeRoleFromServiceAccountPayload.serviceAccount": + if e.ComplexityRoot.RevokeRoleFromServiceAccountPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RevokeRoleFromServiceAccountPayload.ServiceAccount(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.resourceName": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceName == nil { + case "RevokeTeamAccessToUnleashPayload.unleash": + if e.ComplexityRoot.RevokeTeamAccessToUnleashPayload.Unleash == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RevokeTeamAccessToUnleashPayload.Unleash(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.resourceType": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceType == nil { + case "Role.description": + if e.ComplexityRoot.Role.Description == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Role.Description(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.teamSlug": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.TeamSlug == nil { + case "Role.id": + if e.ComplexityRoot.Role.ID == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Role.ID(childComplexity), true - case "ReconcilerEdge.cursor": - if e.ComplexityRoot.ReconcilerEdge.Cursor == nil { + case "Role.name": + if e.ComplexityRoot.Role.Name == nil { break } - return e.ComplexityRoot.ReconcilerEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Role.Name(childComplexity), true - case "ReconcilerEdge.node": - if e.ComplexityRoot.ReconcilerEdge.Node == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.actor": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ReconcilerEdge.Node(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Actor(childComplexity), true - case "ReconcilerEnabledActivityLogEntry.actor": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Actor == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.createdAt": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.CreatedAt(childComplexity), true - case "ReconcilerEnabledActivityLogEntry.createdAt": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.CreatedAt == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.data": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Data(childComplexity), true - case "ReconcilerEnabledActivityLogEntry.environmentName": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.EnvironmentName == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.environmentName": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.EnvironmentName(childComplexity), true - case "ReconcilerEnabledActivityLogEntry.id": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ID == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.id": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ID(childComplexity), true - case "ReconcilerEnabledActivityLogEntry.message": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Message == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.message": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Message(childComplexity), true - case "ReconcilerEnabledActivityLogEntry.resourceName": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceName == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.resourceName": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceName(childComplexity), true - case "ReconcilerEnabledActivityLogEntry.resourceType": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceType == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.resourceType": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceType(childComplexity), true - case "ReconcilerEnabledActivityLogEntry.teamSlug": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.TeamSlug == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.teamSlug": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.TeamSlug(childComplexity), true - case "ReconcilerError.correlationID": - if e.ComplexityRoot.ReconcilerError.CorrelationID == nil { + case "RoleAssignedToServiceAccountActivityLogEntryData.roleName": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntryData.RoleName == nil { break } - return e.ComplexityRoot.ReconcilerError.CorrelationID(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntryData.RoleName(childComplexity), true - case "ReconcilerError.createdAt": - if e.ComplexityRoot.ReconcilerError.CreatedAt == nil { + case "RoleAssignedUserSyncLogEntry.createdAt": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ReconcilerError.CreatedAt(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.CreatedAt(childComplexity), true - case "ReconcilerError.id": - if e.ComplexityRoot.ReconcilerError.ID == nil { + case "RoleAssignedUserSyncLogEntry.id": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.ID == nil { break } - return e.ComplexityRoot.ReconcilerError.ID(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.ID(childComplexity), true - case "ReconcilerError.message": - if e.ComplexityRoot.ReconcilerError.Message == nil { + case "RoleAssignedUserSyncLogEntry.message": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.Message == nil { break } - return e.ComplexityRoot.ReconcilerError.Message(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.Message(childComplexity), true - case "ReconcilerError.team": - if e.ComplexityRoot.ReconcilerError.Team == nil { + case "RoleAssignedUserSyncLogEntry.roleName": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.RoleName == nil { break } - return e.ComplexityRoot.ReconcilerError.Team(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.RoleName(childComplexity), true - case "ReconcilerErrorConnection.edges": - if e.ComplexityRoot.ReconcilerErrorConnection.Edges == nil { + case "RoleAssignedUserSyncLogEntry.userEmail": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserEmail == nil { break } - return e.ComplexityRoot.ReconcilerErrorConnection.Edges(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserEmail(childComplexity), true - case "ReconcilerErrorConnection.nodes": - if e.ComplexityRoot.ReconcilerErrorConnection.Nodes == nil { + case "RoleAssignedUserSyncLogEntry.userID": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserID == nil { break } - return e.ComplexityRoot.ReconcilerErrorConnection.Nodes(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserID(childComplexity), true - case "ReconcilerErrorConnection.pageInfo": - if e.ComplexityRoot.ReconcilerErrorConnection.PageInfo == nil { + case "RoleAssignedUserSyncLogEntry.userName": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserName == nil { break } - return e.ComplexityRoot.ReconcilerErrorConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserName(childComplexity), true - case "ReconcilerErrorEdge.cursor": - if e.ComplexityRoot.ReconcilerErrorEdge.Cursor == nil { + case "RoleConnection.edges": + if e.ComplexityRoot.RoleConnection.Edges == nil { break } - return e.ComplexityRoot.ReconcilerErrorEdge.Cursor(childComplexity), true + return e.ComplexityRoot.RoleConnection.Edges(childComplexity), true - case "ReconcilerErrorEdge.node": - if e.ComplexityRoot.ReconcilerErrorEdge.Node == nil { + case "RoleConnection.nodes": + if e.ComplexityRoot.RoleConnection.Nodes == nil { break } - return e.ComplexityRoot.ReconcilerErrorEdge.Node(childComplexity), true + return e.ComplexityRoot.RoleConnection.Nodes(childComplexity), true - case "RemoveConfigValuePayload.config": - if e.ComplexityRoot.RemoveConfigValuePayload.Config == nil { + case "RoleConnection.pageInfo": + if e.ComplexityRoot.RoleConnection.PageInfo == nil { break } - return e.ComplexityRoot.RemoveConfigValuePayload.Config(childComplexity), true + return e.ComplexityRoot.RoleConnection.PageInfo(childComplexity), true - case "RemoveRepositoryFromTeamPayload.success": - if e.ComplexityRoot.RemoveRepositoryFromTeamPayload.Success == nil { + case "RoleEdge.cursor": + if e.ComplexityRoot.RoleEdge.Cursor == nil { break } - return e.ComplexityRoot.RemoveRepositoryFromTeamPayload.Success(childComplexity), true + return e.ComplexityRoot.RoleEdge.Cursor(childComplexity), true - case "RemoveSecretValuePayload.secret": - if e.ComplexityRoot.RemoveSecretValuePayload.Secret == nil { + case "RoleEdge.node": + if e.ComplexityRoot.RoleEdge.Node == nil { break } - return e.ComplexityRoot.RemoveSecretValuePayload.Secret(childComplexity), true + return e.ComplexityRoot.RoleEdge.Node(childComplexity), true - case "RemoveTeamMemberPayload.team": - if e.ComplexityRoot.RemoveTeamMemberPayload.Team == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.actor": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.RemoveTeamMemberPayload.Team(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Actor(childComplexity), true - case "RemoveTeamMemberPayload.user": - if e.ComplexityRoot.RemoveTeamMemberPayload.User == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.createdAt": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.RemoveTeamMemberPayload.User(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.CreatedAt(childComplexity), true - case "Repository.id": - if e.ComplexityRoot.Repository.ID == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.data": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.Repository.ID(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Data(childComplexity), true - case "Repository.name": - if e.ComplexityRoot.Repository.Name == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.environmentName": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.Repository.Name(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.EnvironmentName(childComplexity), true - case "Repository.team": - if e.ComplexityRoot.Repository.Team == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.id": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.Repository.Team(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ID(childComplexity), true - case "RepositoryAddedActivityLogEntry.actor": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.Actor == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.message": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Message(childComplexity), true - case "RepositoryAddedActivityLogEntry.createdAt": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.CreatedAt == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.resourceName": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceName(childComplexity), true - case "RepositoryAddedActivityLogEntry.environmentName": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.EnvironmentName == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.resourceType": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceType(childComplexity), true - case "RepositoryAddedActivityLogEntry.id": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ID == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.teamSlug": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.TeamSlug(childComplexity), true - case "RepositoryAddedActivityLogEntry.message": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.Message == nil { + case "RoleRevokedFromServiceAccountActivityLogEntryData.roleName": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntryData.RoleName == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntryData.RoleName(childComplexity), true - case "RepositoryAddedActivityLogEntry.resourceName": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceName == nil { + case "RoleRevokedUserSyncLogEntry.createdAt": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.CreatedAt(childComplexity), true - case "RepositoryAddedActivityLogEntry.resourceType": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceType == nil { + case "RoleRevokedUserSyncLogEntry.id": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.ID == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.ID(childComplexity), true - case "RepositoryAddedActivityLogEntry.teamSlug": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.TeamSlug == nil { + case "RoleRevokedUserSyncLogEntry.message": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.Message == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.Message(childComplexity), true - case "RepositoryConnection.edges": - if e.ComplexityRoot.RepositoryConnection.Edges == nil { + case "RoleRevokedUserSyncLogEntry.roleName": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.RoleName == nil { break } - return e.ComplexityRoot.RepositoryConnection.Edges(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.RoleName(childComplexity), true - case "RepositoryConnection.nodes": - if e.ComplexityRoot.RepositoryConnection.Nodes == nil { + case "RoleRevokedUserSyncLogEntry.userEmail": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserEmail == nil { break } - return e.ComplexityRoot.RepositoryConnection.Nodes(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserEmail(childComplexity), true - case "RepositoryConnection.pageInfo": - if e.ComplexityRoot.RepositoryConnection.PageInfo == nil { + case "RoleRevokedUserSyncLogEntry.userID": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserID == nil { break } - return e.ComplexityRoot.RepositoryConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserID(childComplexity), true - case "RepositoryEdge.cursor": - if e.ComplexityRoot.RepositoryEdge.Cursor == nil { + case "RoleRevokedUserSyncLogEntry.userName": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserName == nil { break } - return e.ComplexityRoot.RepositoryEdge.Cursor(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserName(childComplexity), true - case "RepositoryEdge.node": - if e.ComplexityRoot.RepositoryEdge.Node == nil { + case "SearchNodeConnection.edges": + if e.ComplexityRoot.SearchNodeConnection.Edges == nil { break } - return e.ComplexityRoot.RepositoryEdge.Node(childComplexity), true + return e.ComplexityRoot.SearchNodeConnection.Edges(childComplexity), true - case "RepositoryRemovedActivityLogEntry.actor": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Actor == nil { + case "SearchNodeConnection.nodes": + if e.ComplexityRoot.SearchNodeConnection.Nodes == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SearchNodeConnection.Nodes(childComplexity), true - case "RepositoryRemovedActivityLogEntry.createdAt": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.CreatedAt == nil { + case "SearchNodeConnection.pageInfo": + if e.ComplexityRoot.SearchNodeConnection.PageInfo == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SearchNodeConnection.PageInfo(childComplexity), true - case "RepositoryRemovedActivityLogEntry.environmentName": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.EnvironmentName == nil { + case "SearchNodeEdge.cursor": + if e.ComplexityRoot.SearchNodeEdge.Cursor == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SearchNodeEdge.Cursor(childComplexity), true - case "RepositoryRemovedActivityLogEntry.id": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ID == nil { + case "SearchNodeEdge.node": + if e.ComplexityRoot.SearchNodeEdge.Node == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SearchNodeEdge.Node(childComplexity), true - case "RepositoryRemovedActivityLogEntry.message": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Message == nil { + case "Secret.activityLog": + if e.ComplexityRoot.Secret.ActivityLog == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Message(childComplexity), true - - case "RepositoryRemovedActivityLogEntry.resourceName": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceName == nil { - break + args, err := ec.field_Secret_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.Secret.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "RepositoryRemovedActivityLogEntry.resourceType": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceType == nil { + case "Secret.applications": + if e.ComplexityRoot.Secret.Applications == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceType(childComplexity), true - - case "RepositoryRemovedActivityLogEntry.teamSlug": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.TeamSlug == nil { - break + args, err := ec.field_Secret_applications_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Secret.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "RequestTeamDeletionPayload.key": - if e.ComplexityRoot.RequestTeamDeletionPayload.Key == nil { + case "Secret.environment": + if e.ComplexityRoot.Secret.Environment == nil { break } - return e.ComplexityRoot.RequestTeamDeletionPayload.Key(childComplexity), true + return e.ComplexityRoot.Secret.Environment(childComplexity), true - case "RestartApplicationPayload.application": - if e.ComplexityRoot.RestartApplicationPayload.Application == nil { + case "Secret.id": + if e.ComplexityRoot.Secret.ID == nil { break } - return e.ComplexityRoot.RestartApplicationPayload.Application(childComplexity), true + return e.ComplexityRoot.Secret.ID(childComplexity), true - case "RevokeRoleFromServiceAccountPayload.serviceAccount": - if e.ComplexityRoot.RevokeRoleFromServiceAccountPayload.ServiceAccount == nil { + case "Secret.jobs": + if e.ComplexityRoot.Secret.Jobs == nil { break } - return e.ComplexityRoot.RevokeRoleFromServiceAccountPayload.ServiceAccount(childComplexity), true - - case "RevokeTeamAccessToUnleashPayload.unleash": - if e.ComplexityRoot.RevokeTeamAccessToUnleashPayload.Unleash == nil { - break + args, err := ec.field_Secret_jobs_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RevokeTeamAccessToUnleashPayload.Unleash(childComplexity), true + return e.ComplexityRoot.Secret.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "Role.description": - if e.ComplexityRoot.Role.Description == nil { + case "Secret.keys": + if e.ComplexityRoot.Secret.Keys == nil { break } - return e.ComplexityRoot.Role.Description(childComplexity), true + return e.ComplexityRoot.Secret.Keys(childComplexity), true - case "Role.id": - if e.ComplexityRoot.Role.ID == nil { + case "Secret.lastModifiedAt": + if e.ComplexityRoot.Secret.LastModifiedAt == nil { break } - return e.ComplexityRoot.Role.ID(childComplexity), true + return e.ComplexityRoot.Secret.LastModifiedAt(childComplexity), true - case "Role.name": - if e.ComplexityRoot.Role.Name == nil { + case "Secret.lastModifiedBy": + if e.ComplexityRoot.Secret.LastModifiedBy == nil { break } - return e.ComplexityRoot.Role.Name(childComplexity), true + return e.ComplexityRoot.Secret.LastModifiedBy(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.actor": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Actor == nil { + case "Secret.name": + if e.ComplexityRoot.Secret.Name == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Secret.Name(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.createdAt": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.CreatedAt == nil { + case "Secret.team": + if e.ComplexityRoot.Secret.Team == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Secret.Team(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.data": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Data == nil { + case "Secret.teamEnvironment": + if e.ComplexityRoot.Secret.TeamEnvironment == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.Secret.TeamEnvironment(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.environmentName": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.EnvironmentName == nil { + case "Secret.workloads": + if e.ComplexityRoot.Secret.Workloads == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.EnvironmentName(childComplexity), true - - case "RoleAssignedToServiceAccountActivityLogEntry.id": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ID == nil { - break + args, err := ec.field_Secret_workloads_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Secret.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "RoleAssignedToServiceAccountActivityLogEntry.message": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Message == nil { + case "SecretConnection.edges": + if e.ComplexityRoot.SecretConnection.Edges == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretConnection.Edges(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.resourceName": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceName == nil { + case "SecretConnection.nodes": + if e.ComplexityRoot.SecretConnection.Nodes == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretConnection.Nodes(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.resourceType": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceType == nil { + case "SecretConnection.pageInfo": + if e.ComplexityRoot.SecretConnection.PageInfo == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretConnection.PageInfo(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.teamSlug": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.TeamSlug == nil { + case "SecretCreatedActivityLogEntry.actor": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.Actor(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntryData.roleName": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntryData.RoleName == nil { + case "SecretCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntryData.RoleName(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "RoleAssignedUserSyncLogEntry.createdAt": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.CreatedAt == nil { + case "SecretCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "RoleAssignedUserSyncLogEntry.id": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.ID == nil { + case "SecretCreatedActivityLogEntry.id": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.ID(childComplexity), true - case "RoleAssignedUserSyncLogEntry.message": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.Message == nil { + case "SecretCreatedActivityLogEntry.message": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.Message(childComplexity), true - case "RoleAssignedUserSyncLogEntry.roleName": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.RoleName == nil { + case "SecretCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.RoleName(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceName(childComplexity), true - case "RoleAssignedUserSyncLogEntry.userEmail": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserEmail == nil { + case "SecretCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserEmail(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceType(childComplexity), true - case "RoleAssignedUserSyncLogEntry.userID": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserID == nil { + case "SecretCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserID(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "RoleAssignedUserSyncLogEntry.userName": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserName == nil { + case "SecretDeletedActivityLogEntry.actor": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserName(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.Actor(childComplexity), true - case "RoleConnection.edges": - if e.ComplexityRoot.RoleConnection.Edges == nil { + case "SecretDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.RoleConnection.Edges(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "RoleConnection.nodes": - if e.ComplexityRoot.RoleConnection.Nodes == nil { + case "SecretDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.RoleConnection.Nodes(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "RoleConnection.pageInfo": - if e.ComplexityRoot.RoleConnection.PageInfo == nil { + case "SecretDeletedActivityLogEntry.id": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.RoleConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.ID(childComplexity), true - case "RoleEdge.cursor": - if e.ComplexityRoot.RoleEdge.Cursor == nil { + case "SecretDeletedActivityLogEntry.message": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.RoleEdge.Cursor(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.Message(childComplexity), true - case "RoleEdge.node": - if e.ComplexityRoot.RoleEdge.Node == nil { + case "SecretDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.RoleEdge.Node(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceName(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.actor": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Actor == nil { + case "SecretDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceType(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.createdAt": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.CreatedAt == nil { + case "SecretDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.data": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Data == nil { + case "SecretEdge.cursor": + if e.ComplexityRoot.SecretEdge.Cursor == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.SecretEdge.Cursor(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.environmentName": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.EnvironmentName == nil { + case "SecretEdge.node": + if e.ComplexityRoot.SecretEdge.Node == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SecretEdge.Node(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.id": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ID == nil { + case "SecretValue.encoding": + if e.ComplexityRoot.SecretValue.Encoding == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretValue.Encoding(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.message": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Message == nil { + case "SecretValue.name": + if e.ComplexityRoot.SecretValue.Name == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretValue.Name(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.resourceName": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceName == nil { + case "SecretValue.value": + if e.ComplexityRoot.SecretValue.Value == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretValue.Value(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.resourceType": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceType == nil { + case "SecretValueAddedActivityLogEntry.actor": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Actor(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.teamSlug": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.TeamSlug == nil { + case "SecretValueAddedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.CreatedAt(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntryData.roleName": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntryData.RoleName == nil { + case "SecretValueAddedActivityLogEntry.data": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntryData.RoleName(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Data(childComplexity), true - case "RoleRevokedUserSyncLogEntry.createdAt": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.CreatedAt == nil { + case "SecretValueAddedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.EnvironmentName(childComplexity), true - case "RoleRevokedUserSyncLogEntry.id": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.ID == nil { + case "SecretValueAddedActivityLogEntry.id": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ID(childComplexity), true - case "RoleRevokedUserSyncLogEntry.message": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.Message == nil { + case "SecretValueAddedActivityLogEntry.message": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Message(childComplexity), true - case "RoleRevokedUserSyncLogEntry.roleName": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.RoleName == nil { + case "SecretValueAddedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.RoleName(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceName(childComplexity), true - case "RoleRevokedUserSyncLogEntry.userEmail": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserEmail == nil { + case "SecretValueAddedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserEmail(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceType(childComplexity), true - case "RoleRevokedUserSyncLogEntry.userID": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserID == nil { + case "SecretValueAddedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserID(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.TeamSlug(childComplexity), true - case "RoleRevokedUserSyncLogEntry.userName": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserName == nil { + case "SecretValueAddedActivityLogEntryData.valueName": + if e.ComplexityRoot.SecretValueAddedActivityLogEntryData.ValueName == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserName(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntryData.ValueName(childComplexity), true - case "SearchNodeConnection.edges": - if e.ComplexityRoot.SearchNodeConnection.Edges == nil { + case "SecretValueRemovedActivityLogEntry.actor": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SearchNodeConnection.Edges(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Actor(childComplexity), true - case "SearchNodeConnection.nodes": - if e.ComplexityRoot.SearchNodeConnection.Nodes == nil { + case "SecretValueRemovedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SearchNodeConnection.Nodes(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.CreatedAt(childComplexity), true - case "SearchNodeConnection.pageInfo": - if e.ComplexityRoot.SearchNodeConnection.PageInfo == nil { + case "SecretValueRemovedActivityLogEntry.data": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SearchNodeConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Data(childComplexity), true - case "SearchNodeEdge.cursor": - if e.ComplexityRoot.SearchNodeEdge.Cursor == nil { + case "SecretValueRemovedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SearchNodeEdge.Cursor(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.EnvironmentName(childComplexity), true - case "SearchNodeEdge.node": - if e.ComplexityRoot.SearchNodeEdge.Node == nil { + case "SecretValueRemovedActivityLogEntry.id": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SearchNodeEdge.Node(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ID(childComplexity), true - case "Secret.activityLog": - if e.ComplexityRoot.Secret.ActivityLog == nil { + case "SecretValueRemovedActivityLogEntry.message": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Message == nil { break } - args, err := ec.field_Secret_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Secret.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Message(childComplexity), true - case "Secret.applications": - if e.ComplexityRoot.Secret.Applications == nil { + case "SecretValueRemovedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceName == nil { break } - args, err := ec.field_Secret_applications_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Secret.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceName(childComplexity), true - case "Secret.environment": - if e.ComplexityRoot.Secret.Environment == nil { + case "SecretValueRemovedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.Secret.Environment(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceType(childComplexity), true - case "Secret.id": - if e.ComplexityRoot.Secret.ID == nil { + case "SecretValueRemovedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.Secret.ID(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.TeamSlug(childComplexity), true - case "Secret.jobs": - if e.ComplexityRoot.Secret.Jobs == nil { + case "SecretValueRemovedActivityLogEntryData.valueName": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntryData.ValueName == nil { break } - args, err := ec.field_Secret_jobs_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Secret.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntryData.ValueName(childComplexity), true - case "Secret.keys": - if e.ComplexityRoot.Secret.Keys == nil { + case "SecretValueUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.Secret.Keys(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Actor(childComplexity), true - case "Secret.lastModifiedAt": - if e.ComplexityRoot.Secret.LastModifiedAt == nil { + case "SecretValueUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.Secret.LastModifiedAt(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "Secret.lastModifiedBy": - if e.ComplexityRoot.Secret.LastModifiedBy == nil { + case "SecretValueUpdatedActivityLogEntry.data": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.Secret.LastModifiedBy(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Data(childComplexity), true - case "Secret.name": - if e.ComplexityRoot.Secret.Name == nil { + case "SecretValueUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.Secret.Name(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "Secret.team": - if e.ComplexityRoot.Secret.Team == nil { + case "SecretValueUpdatedActivityLogEntry.id": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.Secret.Team(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ID(childComplexity), true - case "Secret.teamEnvironment": - if e.ComplexityRoot.Secret.TeamEnvironment == nil { + case "SecretValueUpdatedActivityLogEntry.message": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.Secret.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Message(childComplexity), true - case "Secret.workloads": - if e.ComplexityRoot.Secret.Workloads == nil { + case "SecretValueUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceName == nil { break } - args, err := ec.field_Secret_workloads_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Secret.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "SecretConnection.edges": - if e.ComplexityRoot.SecretConnection.Edges == nil { + case "SecretValueUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SecretConnection.Edges(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "SecretConnection.nodes": - if e.ComplexityRoot.SecretConnection.Nodes == nil { + case "SecretValueUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SecretConnection.Nodes(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "SecretConnection.pageInfo": - if e.ComplexityRoot.SecretConnection.PageInfo == nil { + case "SecretValueUpdatedActivityLogEntryData.valueName": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntryData.ValueName == nil { break } - return e.ComplexityRoot.SecretConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntryData.ValueName(childComplexity), true - case "SecretCreatedActivityLogEntry.actor": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.Actor == nil { + case "SecretValuesViewedActivityLogEntry.actor": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Actor(childComplexity), true - case "SecretCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.CreatedAt == nil { + case "SecretValuesViewedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.CreatedAt(childComplexity), true - case "SecretCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.EnvironmentName == nil { + case "SecretValuesViewedActivityLogEntry.data": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Data(childComplexity), true - case "SecretCreatedActivityLogEntry.id": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.ID == nil { + case "SecretValuesViewedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.EnvironmentName(childComplexity), true - case "SecretCreatedActivityLogEntry.message": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.Message == nil { + case "SecretValuesViewedActivityLogEntry.id": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ID(childComplexity), true - case "SecretCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceName == nil { + case "SecretValuesViewedActivityLogEntry.message": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Message(childComplexity), true - case "SecretCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceType == nil { + case "SecretValuesViewedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceName(childComplexity), true - case "SecretCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.TeamSlug == nil { + case "SecretValuesViewedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceType(childComplexity), true - case "SecretDeletedActivityLogEntry.actor": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.Actor == nil { + case "SecretValuesViewedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.TeamSlug(childComplexity), true - case "SecretDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.CreatedAt == nil { + case "SecretValuesViewedActivityLogEntryData.reason": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntryData.Reason == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntryData.Reason(childComplexity), true - case "SecretDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.EnvironmentName == nil { + case "ServiceAccount.createdAt": + if e.ComplexityRoot.ServiceAccount.CreatedAt == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ServiceAccount.CreatedAt(childComplexity), true - case "SecretDeletedActivityLogEntry.id": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.ID == nil { + case "ServiceAccount.description": + if e.ComplexityRoot.ServiceAccount.Description == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Description(childComplexity), true - case "SecretDeletedActivityLogEntry.message": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.Message == nil { + case "ServiceAccount.id": + if e.ComplexityRoot.ServiceAccount.ID == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ServiceAccount.ID(childComplexity), true - case "SecretDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceName == nil { + case "ServiceAccount.lastUsedAt": + if e.ComplexityRoot.ServiceAccount.LastUsedAt == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ServiceAccount.LastUsedAt(childComplexity), true - case "SecretDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceType == nil { + case "ServiceAccount.name": + if e.ComplexityRoot.ServiceAccount.Name == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Name(childComplexity), true - case "SecretDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.TeamSlug == nil { + case "ServiceAccount.roles": + if e.ComplexityRoot.ServiceAccount.Roles == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.TeamSlug(childComplexity), true - - case "SecretEdge.cursor": - if e.ComplexityRoot.SecretEdge.Cursor == nil { - break + args, err := ec.field_ServiceAccount_roles_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SecretEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Roles(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "SecretEdge.node": - if e.ComplexityRoot.SecretEdge.Node == nil { + case "ServiceAccount.team": + if e.ComplexityRoot.ServiceAccount.Team == nil { break } - return e.ComplexityRoot.SecretEdge.Node(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Team(childComplexity), true - case "SecretValue.encoding": - if e.ComplexityRoot.SecretValue.Encoding == nil { + case "ServiceAccount.tokens": + if e.ComplexityRoot.ServiceAccount.Tokens == nil { break } - return e.ComplexityRoot.SecretValue.Encoding(childComplexity), true - - case "SecretValue.name": - if e.ComplexityRoot.SecretValue.Name == nil { - break + args, err := ec.field_ServiceAccount_tokens_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SecretValue.Name(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Tokens(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "SecretValue.value": - if e.ComplexityRoot.SecretValue.Value == nil { + case "ServiceAccount.updatedAt": + if e.ComplexityRoot.ServiceAccount.UpdatedAt == nil { break } - return e.ComplexityRoot.SecretValue.Value(childComplexity), true + return e.ComplexityRoot.ServiceAccount.UpdatedAt(childComplexity), true - case "SecretValueAddedActivityLogEntry.actor": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Actor == nil { + case "ServiceAccountConnection.edges": + if e.ComplexityRoot.ServiceAccountConnection.Edges == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ServiceAccountConnection.Edges(childComplexity), true - case "SecretValueAddedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.CreatedAt == nil { + case "ServiceAccountConnection.nodes": + if e.ComplexityRoot.ServiceAccountConnection.Nodes == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountConnection.Nodes(childComplexity), true - case "SecretValueAddedActivityLogEntry.data": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Data == nil { + case "ServiceAccountConnection.pageInfo": + if e.ComplexityRoot.ServiceAccountConnection.PageInfo == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ServiceAccountConnection.PageInfo(childComplexity), true - case "SecretValueAddedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.EnvironmentName == nil { + case "ServiceAccountCreatedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Actor(childComplexity), true - case "SecretValueAddedActivityLogEntry.id": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ID == nil { + case "ServiceAccountCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "SecretValueAddedActivityLogEntry.message": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Message == nil { + case "ServiceAccountCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "SecretValueAddedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceName == nil { + case "ServiceAccountCreatedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ID(childComplexity), true - case "SecretValueAddedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceType == nil { + case "ServiceAccountCreatedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Message(childComplexity), true - case "SecretValueAddedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.TeamSlug == nil { + case "ServiceAccountCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceName(childComplexity), true - case "SecretValueAddedActivityLogEntryData.valueName": - if e.ComplexityRoot.SecretValueAddedActivityLogEntryData.ValueName == nil { + case "ServiceAccountCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntryData.ValueName(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceType(childComplexity), true - case "SecretValueRemovedActivityLogEntry.actor": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Actor == nil { + case "ServiceAccountCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "SecretValueRemovedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.CreatedAt == nil { + case "ServiceAccountDeletedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Actor(childComplexity), true - case "SecretValueRemovedActivityLogEntry.data": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Data == nil { + case "ServiceAccountDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "SecretValueRemovedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.EnvironmentName == nil { + case "ServiceAccountDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "SecretValueRemovedActivityLogEntry.id": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ID == nil { + case "ServiceAccountDeletedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ID(childComplexity), true - case "SecretValueRemovedActivityLogEntry.message": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Message == nil { + case "ServiceAccountDeletedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Message(childComplexity), true - case "SecretValueRemovedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceName == nil { + case "ServiceAccountDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceName(childComplexity), true - case "SecretValueRemovedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceType == nil { + case "ServiceAccountDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceType(childComplexity), true - case "SecretValueRemovedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.TeamSlug == nil { + case "ServiceAccountDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "SecretValueRemovedActivityLogEntryData.valueName": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntryData.ValueName == nil { + case "ServiceAccountEdge.cursor": + if e.ComplexityRoot.ServiceAccountEdge.Cursor == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntryData.ValueName(childComplexity), true + return e.ComplexityRoot.ServiceAccountEdge.Cursor(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Actor == nil { + case "ServiceAccountEdge.node": + if e.ComplexityRoot.ServiceAccountEdge.Node == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ServiceAccountEdge.Node(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.CreatedAt == nil { + case "ServiceAccountToken.createdAt": + if e.ComplexityRoot.ServiceAccountToken.CreatedAt == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.CreatedAt(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.data": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Data == nil { + case "ServiceAccountToken.description": + if e.ComplexityRoot.ServiceAccountToken.Description == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.Description(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.EnvironmentName == nil { + case "ServiceAccountToken.expiresAt": + if e.ComplexityRoot.ServiceAccountToken.ExpiresAt == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.ExpiresAt(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.id": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ID == nil { + case "ServiceAccountToken.id": + if e.ComplexityRoot.ServiceAccountToken.ID == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.ID(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.message": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Message == nil { + case "ServiceAccountToken.lastUsedAt": + if e.ComplexityRoot.ServiceAccountToken.LastUsedAt == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.LastUsedAt(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceName == nil { + case "ServiceAccountToken.name": + if e.ComplexityRoot.ServiceAccountToken.Name == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.Name(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceType == nil { + case "ServiceAccountToken.updatedAt": + if e.ComplexityRoot.ServiceAccountToken.UpdatedAt == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.UpdatedAt(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.TeamSlug == nil { + case "ServiceAccountTokenConnection.edges": + if e.ComplexityRoot.ServiceAccountTokenConnection.Edges == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenConnection.Edges(childComplexity), true - case "SecretValueUpdatedActivityLogEntryData.valueName": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntryData.ValueName == nil { + case "ServiceAccountTokenConnection.nodes": + if e.ComplexityRoot.ServiceAccountTokenConnection.Nodes == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntryData.ValueName(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenConnection.Nodes(childComplexity), true - case "SecretValuesViewedActivityLogEntry.actor": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Actor == nil { + case "ServiceAccountTokenConnection.pageInfo": + if e.ComplexityRoot.ServiceAccountTokenConnection.PageInfo == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenConnection.PageInfo(childComplexity), true - case "SecretValuesViewedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.CreatedAt == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Actor(childComplexity), true - case "SecretValuesViewedActivityLogEntry.data": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Data == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "SecretValuesViewedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.EnvironmentName == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.data": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Data(childComplexity), true - case "SecretValuesViewedActivityLogEntry.id": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ID == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "SecretValuesViewedActivityLogEntry.message": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Message == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ID(childComplexity), true - case "SecretValuesViewedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceName == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Message(childComplexity), true - case "SecretValuesViewedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceType == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceName(childComplexity), true - case "SecretValuesViewedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.TeamSlug == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceType(childComplexity), true - case "SecretValuesViewedActivityLogEntryData.reason": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntryData.Reason == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntryData.Reason(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccount.createdAt": - if e.ComplexityRoot.ServiceAccount.CreatedAt == nil { + case "ServiceAccountTokenCreatedActivityLogEntryData.tokenName": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntryData.TokenName == nil { break } - return e.ComplexityRoot.ServiceAccount.CreatedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntryData.TokenName(childComplexity), true - case "ServiceAccount.description": - if e.ComplexityRoot.ServiceAccount.Description == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccount.Description(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccount.id": - if e.ComplexityRoot.ServiceAccount.ID == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccount.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccount.lastUsedAt": - if e.ComplexityRoot.ServiceAccount.LastUsedAt == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.data": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ServiceAccount.LastUsedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Data(childComplexity), true - case "ServiceAccount.name": - if e.ComplexityRoot.ServiceAccount.Name == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccount.Name(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccount.roles": - if e.ComplexityRoot.ServiceAccount.Roles == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ID == nil { break } - args, err := ec.field_ServiceAccount_roles_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.ServiceAccount.Roles(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ID(childComplexity), true - case "ServiceAccount.team": - if e.ComplexityRoot.ServiceAccount.Team == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccount.Team(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Message(childComplexity), true - case "ServiceAccount.tokens": - if e.ComplexityRoot.ServiceAccount.Tokens == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceName == nil { break } - args, err := ec.field_ServiceAccount_tokens_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.ServiceAccount.Tokens(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccount.updatedAt": - if e.ComplexityRoot.ServiceAccount.UpdatedAt == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccount.UpdatedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountConnection.edges": - if e.ComplexityRoot.ServiceAccountConnection.Edges == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountConnection.Edges(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountConnection.nodes": - if e.ComplexityRoot.ServiceAccountConnection.Nodes == nil { + case "ServiceAccountTokenDeletedActivityLogEntryData.tokenName": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntryData.TokenName == nil { break } - return e.ComplexityRoot.ServiceAccountConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntryData.TokenName(childComplexity), true - case "ServiceAccountConnection.pageInfo": - if e.ComplexityRoot.ServiceAccountConnection.PageInfo == nil { + case "ServiceAccountTokenEdge.cursor": + if e.ComplexityRoot.ServiceAccountTokenEdge.Cursor == nil { break } - return e.ComplexityRoot.ServiceAccountConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenEdge.Cursor(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Actor == nil { + case "ServiceAccountTokenEdge.node": + if e.ComplexityRoot.ServiceAccountTokenEdge.Node == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenEdge.Node(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.CreatedAt == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.EnvironmentName == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ID == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.data": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Data(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Message == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceName == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceType == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.TeamSlug == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Actor == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.CreatedAt == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.EnvironmentName == nil { + case "ServiceAccountTokenUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ID == nil { + case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Message == nil { + case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceName == nil { + case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceType == nil { + case "ServiceAccountUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.TeamSlug == nil { + case "ServiceAccountUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountEdge.cursor": - if e.ComplexityRoot.ServiceAccountEdge.Cursor == nil { + case "ServiceAccountUpdatedActivityLogEntry.data": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ServiceAccountEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Data(childComplexity), true - case "ServiceAccountEdge.node": - if e.ComplexityRoot.ServiceAccountEdge.Node == nil { + case "ServiceAccountUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountEdge.Node(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountToken.createdAt": - if e.ComplexityRoot.ServiceAccountToken.CreatedAt == nil { + case "ServiceAccountUpdatedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountToken.CreatedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountToken.description": - if e.ComplexityRoot.ServiceAccountToken.Description == nil { + case "ServiceAccountUpdatedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountToken.Description(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountToken.expiresAt": - if e.ComplexityRoot.ServiceAccountToken.ExpiresAt == nil { + case "ServiceAccountUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountToken.ExpiresAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountToken.id": - if e.ComplexityRoot.ServiceAccountToken.ID == nil { + case "ServiceAccountUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountToken.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountToken.lastUsedAt": - if e.ComplexityRoot.ServiceAccountToken.LastUsedAt == nil { + case "ServiceAccountUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountToken.LastUsedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountToken.name": - if e.ComplexityRoot.ServiceAccountToken.Name == nil { + case "ServiceAccountUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.ServiceAccountToken.Name(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "ServiceAccountToken.updatedAt": - if e.ComplexityRoot.ServiceAccountToken.UpdatedAt == nil { + case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.ServiceAccountToken.UpdatedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "ServiceAccountTokenConnection.edges": - if e.ComplexityRoot.ServiceAccountTokenConnection.Edges == nil { + case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.ServiceAccountTokenConnection.Edges(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "ServiceAccountTokenConnection.nodes": - if e.ComplexityRoot.ServiceAccountTokenConnection.Nodes == nil { + case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.ServiceAccountTokenConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "ServiceAccountTokenConnection.pageInfo": - if e.ComplexityRoot.ServiceAccountTokenConnection.PageInfo == nil { + case "ServiceCostSample.cost": + if e.ComplexityRoot.ServiceCostSample.Cost == nil { break } - return e.ComplexityRoot.ServiceAccountTokenConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ServiceCostSample.Cost(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Actor == nil { + case "ServiceCostSample.service": + if e.ComplexityRoot.ServiceCostSample.Service == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ServiceCostSample.Service(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.CreatedAt == nil { + case "ServiceCostSeries.date": + if e.ComplexityRoot.ServiceCostSeries.Date == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ServiceCostSeries.Date(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.data": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Data == nil { + case "ServiceCostSeries.services": + if e.ComplexityRoot.ServiceCostSeries.Services == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ServiceCostSeries.Services(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.EnvironmentName == nil { + case "ServiceCostSeries.sum": + if e.ComplexityRoot.ServiceCostSeries.Sum == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ServiceCostSeries.Sum(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ID == nil { + case "ServiceMaintenanceActivityLogEntry.actor": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Message == nil { + case "ServiceMaintenanceActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceName == nil { + case "ServiceMaintenanceActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceType == nil { + case "ServiceMaintenanceActivityLogEntry.id": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ID(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.TeamSlug == nil { + case "ServiceMaintenanceActivityLogEntry.message": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Message(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntryData.tokenName": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntryData.TokenName == nil { + case "ServiceMaintenanceActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntryData.TokenName(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Actor == nil { + case "ServiceMaintenanceActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.CreatedAt == nil { + case "ServiceMaintenanceActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.data": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Data == nil { + case "SetTeamMemberRolePayload.member": + if e.ComplexityRoot.SetTeamMemberRolePayload.Member == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.SetTeamMemberRolePayload.Member(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.EnvironmentName == nil { + case "SqlDatabase.charset": + if e.ComplexityRoot.SqlDatabase.Charset == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Charset(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ID == nil { + case "SqlDatabase.collation": + if e.ComplexityRoot.SqlDatabase.Collation == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Collation(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Message == nil { + case "SqlDatabase.deletionPolicy": + if e.ComplexityRoot.SqlDatabase.DeletionPolicy == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SqlDatabase.DeletionPolicy(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceName == nil { + case "SqlDatabase.environment": + if e.ComplexityRoot.SqlDatabase.Environment == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Environment(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceType == nil { + case "SqlDatabase.healthy": + if e.ComplexityRoot.SqlDatabase.Healthy == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Healthy(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.TeamSlug == nil { + case "SqlDatabase.id": + if e.ComplexityRoot.SqlDatabase.ID == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SqlDatabase.ID(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntryData.tokenName": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntryData.TokenName == nil { + case "SqlDatabase.name": + if e.ComplexityRoot.SqlDatabase.Name == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntryData.TokenName(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Name(childComplexity), true - case "ServiceAccountTokenEdge.cursor": - if e.ComplexityRoot.ServiceAccountTokenEdge.Cursor == nil { + case "SqlDatabase.team": + if e.ComplexityRoot.SqlDatabase.Team == nil { break } - return e.ComplexityRoot.ServiceAccountTokenEdge.Cursor(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Team(childComplexity), true - case "ServiceAccountTokenEdge.node": - if e.ComplexityRoot.ServiceAccountTokenEdge.Node == nil { + case "SqlDatabase.teamEnvironment": + if e.ComplexityRoot.SqlDatabase.TeamEnvironment == nil { break } - return e.ComplexityRoot.ServiceAccountTokenEdge.Node(childComplexity), true + return e.ComplexityRoot.SqlDatabase.TeamEnvironment(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Actor == nil { + case "SqlInstance.auditLog": + if e.ComplexityRoot.SqlInstance.AuditLog == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SqlInstance.AuditLog(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.CreatedAt == nil { + case "SqlInstance.backupConfiguration": + if e.ComplexityRoot.SqlInstance.BackupConfiguration == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SqlInstance.BackupConfiguration(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.data": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Data == nil { + case "SqlInstance.cascadingDelete": + if e.ComplexityRoot.SqlInstance.CascadingDelete == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.SqlInstance.CascadingDelete(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.EnvironmentName == nil { + case "SqlInstance.connectionName": + if e.ComplexityRoot.SqlInstance.ConnectionName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SqlInstance.ConnectionName(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ID == nil { + case "SqlInstance.cost": + if e.ComplexityRoot.SqlInstance.Cost == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SqlInstance.Cost(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Message == nil { + case "SqlInstance.database": + if e.ComplexityRoot.SqlInstance.Database == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SqlInstance.Database(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceName == nil { + case "SqlInstance.diskAutoresize": + if e.ComplexityRoot.SqlInstance.DiskAutoresize == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SqlInstance.DiskAutoresize(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceType == nil { + case "SqlInstance.diskAutoresizeLimit": + if e.ComplexityRoot.SqlInstance.DiskAutoresizeLimit == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SqlInstance.DiskAutoresizeLimit(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.TeamSlug == nil { + case "SqlInstance.environment": + if e.ComplexityRoot.SqlInstance.Environment == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SqlInstance.Environment(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryData.UpdatedFields == nil { + case "SqlInstance.flags": + if e.ComplexityRoot.SqlInstance.Flags == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - - case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.Field == nil { - break + args, err := ec.field_SqlInstance_flags_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.SqlInstance.Flags(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "SqlInstance.healthy": + if e.ComplexityRoot.SqlInstance.Healthy == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.SqlInstance.Healthy(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "SqlInstance.highAvailability": + if e.ComplexityRoot.SqlInstance.HighAvailability == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.SqlInstance.HighAvailability(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Actor == nil { + case "SqlInstance.id": + if e.ComplexityRoot.SqlInstance.ID == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SqlInstance.ID(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.CreatedAt == nil { + case "SqlInstance.issues": + if e.ComplexityRoot.SqlInstance.Issues == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.CreatedAt(childComplexity), true - - case "ServiceAccountUpdatedActivityLogEntry.data": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Data == nil { - break + args, err := ec.field_SqlInstance_issues_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.SqlInstance.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true - case "ServiceAccountUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.EnvironmentName == nil { + case "SqlInstance.maintenanceVersion": + if e.ComplexityRoot.SqlInstance.MaintenanceVersion == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SqlInstance.MaintenanceVersion(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ID == nil { + case "SqlInstance.maintenanceWindow": + if e.ComplexityRoot.SqlInstance.MaintenanceWindow == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SqlInstance.MaintenanceWindow(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Message == nil { + case "SqlInstance.metrics": + if e.ComplexityRoot.SqlInstance.Metrics == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SqlInstance.Metrics(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceName == nil { + case "SqlInstance.name": + if e.ComplexityRoot.SqlInstance.Name == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SqlInstance.Name(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceType == nil { + case "SqlInstance.projectID": + if e.ComplexityRoot.SqlInstance.ProjectID == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SqlInstance.ProjectID(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.TeamSlug == nil { + case "SqlInstance.state": + if e.ComplexityRoot.SqlInstance.State == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SqlInstance.State(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryData.UpdatedFields == nil { + case "SqlInstance.status": + if e.ComplexityRoot.SqlInstance.Status == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.SqlInstance.Status(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "SqlInstance.team": + if e.ComplexityRoot.SqlInstance.Team == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.SqlInstance.Team(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "SqlInstance.teamEnvironment": + if e.ComplexityRoot.SqlInstance.TeamEnvironment == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.SqlInstance.TeamEnvironment(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "SqlInstance.tier": + if e.ComplexityRoot.SqlInstance.Tier == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.SqlInstance.Tier(childComplexity), true - case "ServiceCostSample.cost": - if e.ComplexityRoot.ServiceCostSample.Cost == nil { + case "SqlInstance.users": + if e.ComplexityRoot.SqlInstance.Users == nil { break } - return e.ComplexityRoot.ServiceCostSample.Cost(childComplexity), true + args, err := ec.field_SqlInstance_users_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "ServiceCostSample.service": - if e.ComplexityRoot.ServiceCostSample.Service == nil { + return e.ComplexityRoot.SqlInstance.Users(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*sqlinstance.SQLInstanceUserOrder)), true + + case "SqlInstance.version": + if e.ComplexityRoot.SqlInstance.Version == nil { break } - return e.ComplexityRoot.ServiceCostSample.Service(childComplexity), true + return e.ComplexityRoot.SqlInstance.Version(childComplexity), true - case "ServiceCostSeries.date": - if e.ComplexityRoot.ServiceCostSeries.Date == nil { + case "SqlInstance.workload": + if e.ComplexityRoot.SqlInstance.Workload == nil { break } - return e.ComplexityRoot.ServiceCostSeries.Date(childComplexity), true + return e.ComplexityRoot.SqlInstance.Workload(childComplexity), true - case "ServiceCostSeries.services": - if e.ComplexityRoot.ServiceCostSeries.Services == nil { + case "SqlInstanceBackupConfiguration.enabled": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.Enabled == nil { break } - return e.ComplexityRoot.ServiceCostSeries.Services(childComplexity), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.Enabled(childComplexity), true - case "ServiceCostSeries.sum": - if e.ComplexityRoot.ServiceCostSeries.Sum == nil { + case "SqlInstanceBackupConfiguration.pointInTimeRecovery": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.PointInTimeRecovery == nil { break } - return e.ComplexityRoot.ServiceCostSeries.Sum(childComplexity), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.PointInTimeRecovery(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.actor": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Actor == nil { + case "SqlInstanceBackupConfiguration.retainedBackups": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.RetainedBackups == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.RetainedBackups(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.CreatedAt == nil { + case "SqlInstanceBackupConfiguration.startTime": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.StartTime == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.StartTime(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.EnvironmentName == nil { + case "SqlInstanceBackupConfiguration.transactionLogRetentionDays": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.TransactionLogRetentionDays == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.TransactionLogRetentionDays(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.id": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ID == nil { + case "SqlInstanceConnection.edges": + if e.ComplexityRoot.SqlInstanceConnection.Edges == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SqlInstanceConnection.Edges(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.message": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Message == nil { + case "SqlInstanceConnection.nodes": + if e.ComplexityRoot.SqlInstanceConnection.Nodes == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SqlInstanceConnection.Nodes(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceName == nil { + case "SqlInstanceConnection.pageInfo": + if e.ComplexityRoot.SqlInstanceConnection.PageInfo == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SqlInstanceConnection.PageInfo(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceType == nil { + case "SqlInstanceCost.sum": + if e.ComplexityRoot.SqlInstanceCost.Sum == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SqlInstanceCost.Sum(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.TeamSlug == nil { + case "SqlInstanceCpu.cores": + if e.ComplexityRoot.SqlInstanceCpu.Cores == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SqlInstanceCpu.Cores(childComplexity), true - case "SetTeamMemberRolePayload.member": - if e.ComplexityRoot.SetTeamMemberRolePayload.Member == nil { + case "SqlInstanceCpu.utilization": + if e.ComplexityRoot.SqlInstanceCpu.Utilization == nil { break } - return e.ComplexityRoot.SetTeamMemberRolePayload.Member(childComplexity), true + return e.ComplexityRoot.SqlInstanceCpu.Utilization(childComplexity), true - case "SqlDatabase.charset": - if e.ComplexityRoot.SqlDatabase.Charset == nil { + case "SqlInstanceDisk.quotaBytes": + if e.ComplexityRoot.SqlInstanceDisk.QuotaBytes == nil { break } - return e.ComplexityRoot.SqlDatabase.Charset(childComplexity), true + return e.ComplexityRoot.SqlInstanceDisk.QuotaBytes(childComplexity), true - case "SqlDatabase.collation": - if e.ComplexityRoot.SqlDatabase.Collation == nil { + case "SqlInstanceDisk.utilization": + if e.ComplexityRoot.SqlInstanceDisk.Utilization == nil { break } - return e.ComplexityRoot.SqlDatabase.Collation(childComplexity), true + return e.ComplexityRoot.SqlInstanceDisk.Utilization(childComplexity), true - case "SqlDatabase.deletionPolicy": - if e.ComplexityRoot.SqlDatabase.DeletionPolicy == nil { + case "SqlInstanceEdge.cursor": + if e.ComplexityRoot.SqlInstanceEdge.Cursor == nil { break } - return e.ComplexityRoot.SqlDatabase.DeletionPolicy(childComplexity), true + return e.ComplexityRoot.SqlInstanceEdge.Cursor(childComplexity), true - case "SqlDatabase.environment": - if e.ComplexityRoot.SqlDatabase.Environment == nil { + case "SqlInstanceEdge.node": + if e.ComplexityRoot.SqlInstanceEdge.Node == nil { break } - return e.ComplexityRoot.SqlDatabase.Environment(childComplexity), true + return e.ComplexityRoot.SqlInstanceEdge.Node(childComplexity), true - case "SqlDatabase.healthy": - if e.ComplexityRoot.SqlDatabase.Healthy == nil { + case "SqlInstanceFlag.name": + if e.ComplexityRoot.SqlInstanceFlag.Name == nil { break } - return e.ComplexityRoot.SqlDatabase.Healthy(childComplexity), true + return e.ComplexityRoot.SqlInstanceFlag.Name(childComplexity), true - case "SqlDatabase.id": - if e.ComplexityRoot.SqlDatabase.ID == nil { + case "SqlInstanceFlag.value": + if e.ComplexityRoot.SqlInstanceFlag.Value == nil { break } - return e.ComplexityRoot.SqlDatabase.ID(childComplexity), true + return e.ComplexityRoot.SqlInstanceFlag.Value(childComplexity), true - case "SqlDatabase.name": - if e.ComplexityRoot.SqlDatabase.Name == nil { + case "SqlInstanceFlagConnection.edges": + if e.ComplexityRoot.SqlInstanceFlagConnection.Edges == nil { break } - return e.ComplexityRoot.SqlDatabase.Name(childComplexity), true + return e.ComplexityRoot.SqlInstanceFlagConnection.Edges(childComplexity), true - case "SqlDatabase.team": - if e.ComplexityRoot.SqlDatabase.Team == nil { + case "SqlInstanceFlagConnection.nodes": + if e.ComplexityRoot.SqlInstanceFlagConnection.Nodes == nil { break } - return e.ComplexityRoot.SqlDatabase.Team(childComplexity), true + return e.ComplexityRoot.SqlInstanceFlagConnection.Nodes(childComplexity), true - case "SqlDatabase.teamEnvironment": - if e.ComplexityRoot.SqlDatabase.TeamEnvironment == nil { + case "SqlInstanceFlagConnection.pageInfo": + if e.ComplexityRoot.SqlInstanceFlagConnection.PageInfo == nil { break } - return e.ComplexityRoot.SqlDatabase.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.SqlInstanceFlagConnection.PageInfo(childComplexity), true - case "SqlInstance.auditLog": - if e.ComplexityRoot.SqlInstance.AuditLog == nil { + case "SqlInstanceFlagEdge.cursor": + if e.ComplexityRoot.SqlInstanceFlagEdge.Cursor == nil { break } - return e.ComplexityRoot.SqlInstance.AuditLog(childComplexity), true + return e.ComplexityRoot.SqlInstanceFlagEdge.Cursor(childComplexity), true - case "SqlInstance.backupConfiguration": - if e.ComplexityRoot.SqlInstance.BackupConfiguration == nil { + case "SqlInstanceFlagEdge.node": + if e.ComplexityRoot.SqlInstanceFlagEdge.Node == nil { break } - return e.ComplexityRoot.SqlInstance.BackupConfiguration(childComplexity), true + return e.ComplexityRoot.SqlInstanceFlagEdge.Node(childComplexity), true - case "SqlInstance.cascadingDelete": - if e.ComplexityRoot.SqlInstance.CascadingDelete == nil { + case "SqlInstanceMaintenanceWindow.day": + if e.ComplexityRoot.SqlInstanceMaintenanceWindow.Day == nil { break } - return e.ComplexityRoot.SqlInstance.CascadingDelete(childComplexity), true + return e.ComplexityRoot.SqlInstanceMaintenanceWindow.Day(childComplexity), true - case "SqlInstance.connectionName": - if e.ComplexityRoot.SqlInstance.ConnectionName == nil { + case "SqlInstanceMaintenanceWindow.hour": + if e.ComplexityRoot.SqlInstanceMaintenanceWindow.Hour == nil { break } - return e.ComplexityRoot.SqlInstance.ConnectionName(childComplexity), true + return e.ComplexityRoot.SqlInstanceMaintenanceWindow.Hour(childComplexity), true - case "SqlInstance.cost": - if e.ComplexityRoot.SqlInstance.Cost == nil { + case "SqlInstanceMemory.quotaBytes": + if e.ComplexityRoot.SqlInstanceMemory.QuotaBytes == nil { break } - return e.ComplexityRoot.SqlInstance.Cost(childComplexity), true + return e.ComplexityRoot.SqlInstanceMemory.QuotaBytes(childComplexity), true - case "SqlInstance.database": - if e.ComplexityRoot.SqlInstance.Database == nil { + case "SqlInstanceMemory.utilization": + if e.ComplexityRoot.SqlInstanceMemory.Utilization == nil { break } - return e.ComplexityRoot.SqlInstance.Database(childComplexity), true + return e.ComplexityRoot.SqlInstanceMemory.Utilization(childComplexity), true - case "SqlInstance.diskAutoresize": - if e.ComplexityRoot.SqlInstance.DiskAutoresize == nil { + case "SqlInstanceMetrics.cpu": + if e.ComplexityRoot.SqlInstanceMetrics.CPU == nil { break } - return e.ComplexityRoot.SqlInstance.DiskAutoresize(childComplexity), true + return e.ComplexityRoot.SqlInstanceMetrics.CPU(childComplexity), true - case "SqlInstance.diskAutoresizeLimit": - if e.ComplexityRoot.SqlInstance.DiskAutoresizeLimit == nil { + case "SqlInstanceMetrics.disk": + if e.ComplexityRoot.SqlInstanceMetrics.Disk == nil { break } - return e.ComplexityRoot.SqlInstance.DiskAutoresizeLimit(childComplexity), true + return e.ComplexityRoot.SqlInstanceMetrics.Disk(childComplexity), true - case "SqlInstance.environment": - if e.ComplexityRoot.SqlInstance.Environment == nil { + case "SqlInstanceMetrics.memory": + if e.ComplexityRoot.SqlInstanceMetrics.Memory == nil { break } - return e.ComplexityRoot.SqlInstance.Environment(childComplexity), true + return e.ComplexityRoot.SqlInstanceMetrics.Memory(childComplexity), true - case "SqlInstance.flags": - if e.ComplexityRoot.SqlInstance.Flags == nil { + case "SqlInstanceStateIssue.id": + if e.ComplexityRoot.SqlInstanceStateIssue.ID == nil { break } - args, err := ec.field_SqlInstance_flags_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.SqlInstance.Flags(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.SqlInstanceStateIssue.ID(childComplexity), true - case "SqlInstance.healthy": - if e.ComplexityRoot.SqlInstance.Healthy == nil { + case "SqlInstanceStateIssue.message": + if e.ComplexityRoot.SqlInstanceStateIssue.Message == nil { break } - return e.ComplexityRoot.SqlInstance.Healthy(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.Message(childComplexity), true - case "SqlInstance.highAvailability": - if e.ComplexityRoot.SqlInstance.HighAvailability == nil { + case "SqlInstanceStateIssue.sqlInstance": + if e.ComplexityRoot.SqlInstanceStateIssue.SQLInstance == nil { break } - return e.ComplexityRoot.SqlInstance.HighAvailability(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.SQLInstance(childComplexity), true - case "SqlInstance.id": - if e.ComplexityRoot.SqlInstance.ID == nil { + case "SqlInstanceStateIssue.severity": + if e.ComplexityRoot.SqlInstanceStateIssue.Severity == nil { break } - return e.ComplexityRoot.SqlInstance.ID(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.Severity(childComplexity), true - case "SqlInstance.issues": - if e.ComplexityRoot.SqlInstance.Issues == nil { + case "SqlInstanceStateIssue.state": + if e.ComplexityRoot.SqlInstanceStateIssue.State == nil { break } - args, err := ec.field_SqlInstance_issues_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.SqlInstance.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + return e.ComplexityRoot.SqlInstanceStateIssue.State(childComplexity), true - case "SqlInstance.maintenanceVersion": - if e.ComplexityRoot.SqlInstance.MaintenanceVersion == nil { + case "SqlInstanceStateIssue.teamEnvironment": + if e.ComplexityRoot.SqlInstanceStateIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.SqlInstance.MaintenanceVersion(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.TeamEnvironment(childComplexity), true - case "SqlInstance.maintenanceWindow": - if e.ComplexityRoot.SqlInstance.MaintenanceWindow == nil { + case "SqlInstanceStatus.privateIpAddress": + if e.ComplexityRoot.SqlInstanceStatus.PrivateIPAddress == nil { break } - return e.ComplexityRoot.SqlInstance.MaintenanceWindow(childComplexity), true + return e.ComplexityRoot.SqlInstanceStatus.PrivateIPAddress(childComplexity), true - case "SqlInstance.metrics": - if e.ComplexityRoot.SqlInstance.Metrics == nil { + case "SqlInstanceStatus.publicIpAddress": + if e.ComplexityRoot.SqlInstanceStatus.PublicIPAddress == nil { break } - return e.ComplexityRoot.SqlInstance.Metrics(childComplexity), true + return e.ComplexityRoot.SqlInstanceStatus.PublicIPAddress(childComplexity), true - case "SqlInstance.name": - if e.ComplexityRoot.SqlInstance.Name == nil { + case "SqlInstanceUser.authentication": + if e.ComplexityRoot.SqlInstanceUser.Authentication == nil { break } - return e.ComplexityRoot.SqlInstance.Name(childComplexity), true + return e.ComplexityRoot.SqlInstanceUser.Authentication(childComplexity), true - case "SqlInstance.projectID": - if e.ComplexityRoot.SqlInstance.ProjectID == nil { + case "SqlInstanceUser.name": + if e.ComplexityRoot.SqlInstanceUser.Name == nil { break } - return e.ComplexityRoot.SqlInstance.ProjectID(childComplexity), true + return e.ComplexityRoot.SqlInstanceUser.Name(childComplexity), true - case "SqlInstance.state": - if e.ComplexityRoot.SqlInstance.State == nil { + case "SqlInstanceUserConnection.edges": + if e.ComplexityRoot.SqlInstanceUserConnection.Edges == nil { break } - return e.ComplexityRoot.SqlInstance.State(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserConnection.Edges(childComplexity), true - case "SqlInstance.status": - if e.ComplexityRoot.SqlInstance.Status == nil { + case "SqlInstanceUserConnection.nodes": + if e.ComplexityRoot.SqlInstanceUserConnection.Nodes == nil { break } - return e.ComplexityRoot.SqlInstance.Status(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserConnection.Nodes(childComplexity), true - case "SqlInstance.team": - if e.ComplexityRoot.SqlInstance.Team == nil { + case "SqlInstanceUserConnection.pageInfo": + if e.ComplexityRoot.SqlInstanceUserConnection.PageInfo == nil { break } - return e.ComplexityRoot.SqlInstance.Team(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserConnection.PageInfo(childComplexity), true - case "SqlInstance.teamEnvironment": - if e.ComplexityRoot.SqlInstance.TeamEnvironment == nil { + case "SqlInstanceUserEdge.cursor": + if e.ComplexityRoot.SqlInstanceUserEdge.Cursor == nil { break } - return e.ComplexityRoot.SqlInstance.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserEdge.Cursor(childComplexity), true - case "SqlInstance.tier": - if e.ComplexityRoot.SqlInstance.Tier == nil { + case "SqlInstanceUserEdge.node": + if e.ComplexityRoot.SqlInstanceUserEdge.Node == nil { break } - return e.ComplexityRoot.SqlInstance.Tier(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserEdge.Node(childComplexity), true - case "SqlInstance.users": - if e.ComplexityRoot.SqlInstance.Users == nil { + case "SqlInstanceVersionIssue.id": + if e.ComplexityRoot.SqlInstanceVersionIssue.ID == nil { break } - args, err := ec.field_SqlInstance_users_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.SqlInstance.Users(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*sqlinstance.SQLInstanceUserOrder)), true + return e.ComplexityRoot.SqlInstanceVersionIssue.ID(childComplexity), true - case "SqlInstance.version": - if e.ComplexityRoot.SqlInstance.Version == nil { + case "SqlInstanceVersionIssue.message": + if e.ComplexityRoot.SqlInstanceVersionIssue.Message == nil { break } - return e.ComplexityRoot.SqlInstance.Version(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.Message(childComplexity), true - case "SqlInstance.workload": - if e.ComplexityRoot.SqlInstance.Workload == nil { + case "SqlInstanceVersionIssue.sqlInstance": + if e.ComplexityRoot.SqlInstanceVersionIssue.SQLInstance == nil { break } - return e.ComplexityRoot.SqlInstance.Workload(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.SQLInstance(childComplexity), true - case "SqlInstanceBackupConfiguration.enabled": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.Enabled == nil { + case "SqlInstanceVersionIssue.severity": + if e.ComplexityRoot.SqlInstanceVersionIssue.Severity == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.Enabled(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.Severity(childComplexity), true - case "SqlInstanceBackupConfiguration.pointInTimeRecovery": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.PointInTimeRecovery == nil { + case "SqlInstanceVersionIssue.teamEnvironment": + if e.ComplexityRoot.SqlInstanceVersionIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.PointInTimeRecovery(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.TeamEnvironment(childComplexity), true - case "SqlInstanceBackupConfiguration.retainedBackups": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.RetainedBackups == nil { + case "StartOpenSearchMaintenancePayload.error": + if e.ComplexityRoot.StartOpenSearchMaintenancePayload.Error == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.RetainedBackups(childComplexity), true + return e.ComplexityRoot.StartOpenSearchMaintenancePayload.Error(childComplexity), true - case "SqlInstanceBackupConfiguration.startTime": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.StartTime == nil { + case "StartValkeyMaintenancePayload.error": + if e.ComplexityRoot.StartValkeyMaintenancePayload.Error == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.StartTime(childComplexity), true + return e.ComplexityRoot.StartValkeyMaintenancePayload.Error(childComplexity), true - case "SqlInstanceBackupConfiguration.transactionLogRetentionDays": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.TransactionLogRetentionDays == nil { + case "Subscription.log": + if e.ComplexityRoot.Subscription.Log == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.TransactionLogRetentionDays(childComplexity), true - - case "SqlInstanceConnection.edges": - if e.ComplexityRoot.SqlInstanceConnection.Edges == nil { - break + args, err := ec.field_Subscription_log_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceConnection.Edges(childComplexity), true + return e.ComplexityRoot.Subscription.Log(childComplexity, args["filter"].(loki.LogSubscriptionFilter)), true - case "SqlInstanceConnection.nodes": - if e.ComplexityRoot.SqlInstanceConnection.Nodes == nil { + case "Subscription.workloadLog": + if e.ComplexityRoot.Subscription.WorkloadLog == nil { break } - return e.ComplexityRoot.SqlInstanceConnection.Nodes(childComplexity), true - - case "SqlInstanceConnection.pageInfo": - if e.ComplexityRoot.SqlInstanceConnection.PageInfo == nil { - break + args, err := ec.field_Subscription_workloadLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Subscription.WorkloadLog(childComplexity, args["filter"].(podlog.WorkloadLogSubscriptionFilter)), true - case "SqlInstanceCost.sum": - if e.ComplexityRoot.SqlInstanceCost.Sum == nil { + case "Team.activityLog": + if e.ComplexityRoot.Team.ActivityLog == nil { break } - return e.ComplexityRoot.SqlInstanceCost.Sum(childComplexity), true - - case "SqlInstanceCpu.cores": - if e.ComplexityRoot.SqlInstanceCpu.Cores == nil { - break + args, err := ec.field_Team_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceCpu.Cores(childComplexity), true + return e.ComplexityRoot.Team.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "SqlInstanceCpu.utilization": - if e.ComplexityRoot.SqlInstanceCpu.Utilization == nil { + case "Team.alerts": + if e.ComplexityRoot.Team.Alerts == nil { break } - return e.ComplexityRoot.SqlInstanceCpu.Utilization(childComplexity), true - - case "SqlInstanceDisk.quotaBytes": - if e.ComplexityRoot.SqlInstanceDisk.QuotaBytes == nil { - break + args, err := ec.field_Team_alerts_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceDisk.QuotaBytes(childComplexity), true + return e.ComplexityRoot.Team.Alerts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*alerts.AlertOrder), args["filter"].(*alerts.TeamAlertsFilter)), true - case "SqlInstanceDisk.utilization": - if e.ComplexityRoot.SqlInstanceDisk.Utilization == nil { + case "Team.applications": + if e.ComplexityRoot.Team.Applications == nil { break } - return e.ComplexityRoot.SqlInstanceDisk.Utilization(childComplexity), true - - case "SqlInstanceEdge.cursor": - if e.ComplexityRoot.SqlInstanceEdge.Cursor == nil { - break + args, err := ec.field_Team_applications_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Team.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*application.ApplicationOrder), args["filter"].(*application.TeamApplicationsFilter)), true - case "SqlInstanceEdge.node": - if e.ComplexityRoot.SqlInstanceEdge.Node == nil { + case "Team.bigQueryDatasets": + if e.ComplexityRoot.Team.BigQueryDatasets == nil { break } - return e.ComplexityRoot.SqlInstanceEdge.Node(childComplexity), true - - case "SqlInstanceFlag.name": - if e.ComplexityRoot.SqlInstanceFlag.Name == nil { - break + args, err := ec.field_Team_bigQueryDatasets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceFlag.Name(childComplexity), true + return e.ComplexityRoot.Team.BigQueryDatasets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*bigquery.BigQueryDatasetOrder)), true - case "SqlInstanceFlag.value": - if e.ComplexityRoot.SqlInstanceFlag.Value == nil { + case "Team.buckets": + if e.ComplexityRoot.Team.Buckets == nil { break } - return e.ComplexityRoot.SqlInstanceFlag.Value(childComplexity), true - - case "SqlInstanceFlagConnection.edges": - if e.ComplexityRoot.SqlInstanceFlagConnection.Edges == nil { - break + args, err := ec.field_Team_buckets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceFlagConnection.Edges(childComplexity), true + return e.ComplexityRoot.Team.Buckets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*bucket.BucketOrder)), true - case "SqlInstanceFlagConnection.nodes": - if e.ComplexityRoot.SqlInstanceFlagConnection.Nodes == nil { + case "Team.cost": + if e.ComplexityRoot.Team.Cost == nil { break } - return e.ComplexityRoot.SqlInstanceFlagConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Team.Cost(childComplexity), true - case "SqlInstanceFlagConnection.pageInfo": - if e.ComplexityRoot.SqlInstanceFlagConnection.PageInfo == nil { + case "Team.deleteKey": + if e.ComplexityRoot.Team.DeleteKey == nil { break } - return e.ComplexityRoot.SqlInstanceFlagConnection.PageInfo(childComplexity), true - - case "SqlInstanceFlagEdge.cursor": - if e.ComplexityRoot.SqlInstanceFlagEdge.Cursor == nil { - break + args, err := ec.field_Team_deleteKey_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceFlagEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Team.DeleteKey(childComplexity, args["key"].(string)), true - case "SqlInstanceFlagEdge.node": - if e.ComplexityRoot.SqlInstanceFlagEdge.Node == nil { + case "Team.deletionInProgress": + if e.ComplexityRoot.Team.DeletionInProgress == nil { break } - return e.ComplexityRoot.SqlInstanceFlagEdge.Node(childComplexity), true + return e.ComplexityRoot.Team.DeletionInProgress(childComplexity), true - case "SqlInstanceMaintenanceWindow.day": - if e.ComplexityRoot.SqlInstanceMaintenanceWindow.Day == nil { + case "Team.deploymentKey": + if e.ComplexityRoot.Team.DeploymentKey == nil { break } - return e.ComplexityRoot.SqlInstanceMaintenanceWindow.Day(childComplexity), true + return e.ComplexityRoot.Team.DeploymentKey(childComplexity), true - case "SqlInstanceMaintenanceWindow.hour": - if e.ComplexityRoot.SqlInstanceMaintenanceWindow.Hour == nil { + case "Team.deployments": + if e.ComplexityRoot.Team.Deployments == nil { break } - return e.ComplexityRoot.SqlInstanceMaintenanceWindow.Hour(childComplexity), true - - case "SqlInstanceMemory.quotaBytes": - if e.ComplexityRoot.SqlInstanceMemory.QuotaBytes == nil { - break + args, err := ec.field_Team_deployments_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceMemory.QuotaBytes(childComplexity), true + return e.ComplexityRoot.Team.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "SqlInstanceMemory.utilization": - if e.ComplexityRoot.SqlInstanceMemory.Utilization == nil { + case "Team.environment": + if e.ComplexityRoot.Team.Environment == nil { break } - return e.ComplexityRoot.SqlInstanceMemory.Utilization(childComplexity), true - - case "SqlInstanceMetrics.cpu": - if e.ComplexityRoot.SqlInstanceMetrics.CPU == nil { - break + args, err := ec.field_Team_environment_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceMetrics.CPU(childComplexity), true + return e.ComplexityRoot.Team.Environment(childComplexity, args["name"].(string)), true - case "SqlInstanceMetrics.disk": - if e.ComplexityRoot.SqlInstanceMetrics.Disk == nil { + case "Team.environments": + if e.ComplexityRoot.Team.Environments == nil { break } - return e.ComplexityRoot.SqlInstanceMetrics.Disk(childComplexity), true + return e.ComplexityRoot.Team.Environments(childComplexity), true - case "SqlInstanceMetrics.memory": - if e.ComplexityRoot.SqlInstanceMetrics.Memory == nil { + case "Team.externalResources": + if e.ComplexityRoot.Team.ExternalResources == nil { break } - return e.ComplexityRoot.SqlInstanceMetrics.Memory(childComplexity), true + return e.ComplexityRoot.Team.ExternalResources(childComplexity), true - case "SqlInstanceStateIssue.id": - if e.ComplexityRoot.SqlInstanceStateIssue.ID == nil { + case "Team.id": + if e.ComplexityRoot.Team.ID == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.ID(childComplexity), true + return e.ComplexityRoot.Team.ID(childComplexity), true - case "SqlInstanceStateIssue.message": - if e.ComplexityRoot.SqlInstanceStateIssue.Message == nil { + case "Team.imageVulnerabilityHistory": + if e.ComplexityRoot.Team.ImageVulnerabilityHistory == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.Message(childComplexity), true - - case "SqlInstanceStateIssue.sqlInstance": - if e.ComplexityRoot.SqlInstanceStateIssue.SQLInstance == nil { - break + args, err := ec.field_Team_imageVulnerabilityHistory_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceStateIssue.SQLInstance(childComplexity), true + return e.ComplexityRoot.Team.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true - case "SqlInstanceStateIssue.severity": - if e.ComplexityRoot.SqlInstanceStateIssue.Severity == nil { + case "Team.inventoryCounts": + if e.ComplexityRoot.Team.InventoryCounts == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.Severity(childComplexity), true + return e.ComplexityRoot.Team.InventoryCounts(childComplexity), true - case "SqlInstanceStateIssue.state": - if e.ComplexityRoot.SqlInstanceStateIssue.State == nil { + case "Team.issues": + if e.ComplexityRoot.Team.Issues == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.State(childComplexity), true - - case "SqlInstanceStateIssue.teamEnvironment": - if e.ComplexityRoot.SqlInstanceStateIssue.TeamEnvironment == nil { - break + args, err := ec.field_Team_issues_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceStateIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.Team.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.IssueFilter)), true - case "SqlInstanceStatus.privateIpAddress": - if e.ComplexityRoot.SqlInstanceStatus.PrivateIPAddress == nil { + case "Team.jobs": + if e.ComplexityRoot.Team.Jobs == nil { break } - return e.ComplexityRoot.SqlInstanceStatus.PrivateIPAddress(childComplexity), true - - case "SqlInstanceStatus.publicIpAddress": - if e.ComplexityRoot.SqlInstanceStatus.PublicIPAddress == nil { - break + args, err := ec.field_Team_jobs_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceStatus.PublicIPAddress(childComplexity), true + return e.ComplexityRoot.Team.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*job.JobOrder), args["filter"].(*job.TeamJobsFilter)), true - case "SqlInstanceUser.authentication": - if e.ComplexityRoot.SqlInstanceUser.Authentication == nil { + case "Team.kafkaTopics": + if e.ComplexityRoot.Team.KafkaTopics == nil { break } - return e.ComplexityRoot.SqlInstanceUser.Authentication(childComplexity), true - - case "SqlInstanceUser.name": - if e.ComplexityRoot.SqlInstanceUser.Name == nil { - break + args, err := ec.field_Team_kafkaTopics_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceUser.Name(childComplexity), true + return e.ComplexityRoot.Team.KafkaTopics(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*kafkatopic.KafkaTopicOrder)), true - case "SqlInstanceUserConnection.edges": - if e.ComplexityRoot.SqlInstanceUserConnection.Edges == nil { + case "Team.lastSuccessfulSync": + if e.ComplexityRoot.Team.LastSuccessfulSync == nil { break } - return e.ComplexityRoot.SqlInstanceUserConnection.Edges(childComplexity), true + return e.ComplexityRoot.Team.LastSuccessfulSync(childComplexity), true - case "SqlInstanceUserConnection.nodes": - if e.ComplexityRoot.SqlInstanceUserConnection.Nodes == nil { + case "Team.member": + if e.ComplexityRoot.Team.Member == nil { break } - return e.ComplexityRoot.SqlInstanceUserConnection.Nodes(childComplexity), true - - case "SqlInstanceUserConnection.pageInfo": - if e.ComplexityRoot.SqlInstanceUserConnection.PageInfo == nil { - break + args, err := ec.field_Team_member_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceUserConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Team.Member(childComplexity, args["email"].(string)), true - case "SqlInstanceUserEdge.cursor": - if e.ComplexityRoot.SqlInstanceUserEdge.Cursor == nil { + case "Team.members": + if e.ComplexityRoot.Team.Members == nil { break } - return e.ComplexityRoot.SqlInstanceUserEdge.Cursor(childComplexity), true - - case "SqlInstanceUserEdge.node": - if e.ComplexityRoot.SqlInstanceUserEdge.Node == nil { - break + args, err := ec.field_Team_members_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceUserEdge.Node(childComplexity), true + return e.ComplexityRoot.Team.Members(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.TeamMemberOrder)), true - case "SqlInstanceVersionIssue.id": - if e.ComplexityRoot.SqlInstanceVersionIssue.ID == nil { + case "Team.openSearches": + if e.ComplexityRoot.Team.OpenSearches == nil { break } - return e.ComplexityRoot.SqlInstanceVersionIssue.ID(childComplexity), true - - case "SqlInstanceVersionIssue.message": - if e.ComplexityRoot.SqlInstanceVersionIssue.Message == nil { - break + args, err := ec.field_Team_openSearches_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceVersionIssue.Message(childComplexity), true + return e.ComplexityRoot.Team.OpenSearches(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*opensearch.OpenSearchOrder)), true - case "SqlInstanceVersionIssue.sqlInstance": - if e.ComplexityRoot.SqlInstanceVersionIssue.SQLInstance == nil { + case "Team.postgresInstances": + if e.ComplexityRoot.Team.PostgresInstances == nil { break } - return e.ComplexityRoot.SqlInstanceVersionIssue.SQLInstance(childComplexity), true - - case "SqlInstanceVersionIssue.severity": - if e.ComplexityRoot.SqlInstanceVersionIssue.Severity == nil { - break + args, err := ec.field_Team_postgresInstances_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.SqlInstanceVersionIssue.Severity(childComplexity), true + return e.ComplexityRoot.Team.PostgresInstances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*postgres.PostgresInstanceOrder)), true - case "SqlInstanceVersionIssue.teamEnvironment": - if e.ComplexityRoot.SqlInstanceVersionIssue.TeamEnvironment == nil { + case "Team.purpose": + if e.ComplexityRoot.Team.Purpose == nil { break } - return e.ComplexityRoot.SqlInstanceVersionIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.Team.Purpose(childComplexity), true - case "StartOpenSearchMaintenancePayload.error": - if e.ComplexityRoot.StartOpenSearchMaintenancePayload.Error == nil { + case "Team.repositories": + if e.ComplexityRoot.Team.Repositories == nil { break } - return e.ComplexityRoot.StartOpenSearchMaintenancePayload.Error(childComplexity), true - - case "StartValkeyMaintenancePayload.error": - if e.ComplexityRoot.StartValkeyMaintenancePayload.Error == nil { - break + args, err := ec.field_Team_repositories_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.StartValkeyMaintenancePayload.Error(childComplexity), true + return e.ComplexityRoot.Team.Repositories(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*repository.RepositoryOrder), args["filter"].(*repository.TeamRepositoryFilter)), true - case "Subscription.log": - if e.ComplexityRoot.Subscription.Log == nil { + case "Team.sqlInstances": + if e.ComplexityRoot.Team.SQLInstances == nil { break } - args, err := ec.field_Subscription_log_args(ctx, rawArgs) + args, err := ec.field_Team_sqlInstances_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Subscription.Log(childComplexity, args["filter"].(loki.LogSubscriptionFilter)), true + return e.ComplexityRoot.Team.SQLInstances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*sqlinstance.SQLInstanceOrder)), true - case "Subscription.workloadLog": - if e.ComplexityRoot.Subscription.WorkloadLog == nil { + case "Team.secrets": + if e.ComplexityRoot.Team.Secrets == nil { break } - args, err := ec.field_Subscription_workloadLog_args(ctx, rawArgs) + args, err := ec.field_Team_secrets_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Subscription.WorkloadLog(childComplexity, args["filter"].(podlog.WorkloadLogSubscriptionFilter)), true + return e.ComplexityRoot.Team.Secrets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*secret.SecretOrder), args["filter"].(*secret.SecretFilter)), true - case "Team.activityLog": - if e.ComplexityRoot.Team.ActivityLog == nil { + case "Team.serviceUtilization": + if e.ComplexityRoot.Team.ServiceUtilization == nil { break } - args, err := ec.field_Team_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.Team.ServiceUtilization(childComplexity), true + + case "Team.slackChannel": + if e.ComplexityRoot.Team.SlackChannel == nil { + break } - return e.ComplexityRoot.Team.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.Team.SlackChannel(childComplexity), true - case "Team.alerts": - if e.ComplexityRoot.Team.Alerts == nil { + case "Team.slug": + if e.ComplexityRoot.Team.Slug == nil { break } - args, err := ec.field_Team_alerts_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.Team.Slug(childComplexity), true + + case "Team.unleash": + if e.ComplexityRoot.Team.Unleash == nil { + break } - return e.ComplexityRoot.Team.Alerts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*alerts.AlertOrder), args["filter"].(*alerts.TeamAlertsFilter)), true + return e.ComplexityRoot.Team.Unleash(childComplexity), true - case "Team.applications": - if e.ComplexityRoot.Team.Applications == nil { + case "Team.valkeys": + if e.ComplexityRoot.Team.Valkeys == nil { break } - args, err := ec.field_Team_applications_args(ctx, rawArgs) + args, err := ec.field_Team_valkeys_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Team.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*application.ApplicationOrder), args["filter"].(*application.TeamApplicationsFilter)), true + return e.ComplexityRoot.Team.Valkeys(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*valkey.ValkeyOrder)), true - case "Team.bigQueryDatasets": - if e.ComplexityRoot.Team.BigQueryDatasets == nil { + case "Team.viewerIsMember": + if e.ComplexityRoot.Team.ViewerIsMember == nil { break } - args, err := ec.field_Team_bigQueryDatasets_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.Team.ViewerIsMember(childComplexity), true + + case "Team.viewerIsOwner": + if e.ComplexityRoot.Team.ViewerIsOwner == nil { + break } - return e.ComplexityRoot.Team.BigQueryDatasets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*bigquery.BigQueryDatasetOrder)), true + return e.ComplexityRoot.Team.ViewerIsOwner(childComplexity), true - case "Team.buckets": - if e.ComplexityRoot.Team.Buckets == nil { + case "Team.vulnerabilityFixHistory": + if e.ComplexityRoot.Team.VulnerabilityFixHistory == nil { break } - args, err := ec.field_Team_buckets_args(ctx, rawArgs) + args, err := ec.field_Team_vulnerabilityFixHistory_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Team.Buckets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*bucket.BucketOrder)), true + return e.ComplexityRoot.Team.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true - case "Team.configs": - if e.ComplexityRoot.Team.Configs == nil { + case "Team.vulnerabilitySummaries": + if e.ComplexityRoot.Team.VulnerabilitySummaries == nil { break } - args, err := ec.field_Team_configs_args(ctx, rawArgs) + args, err := ec.field_Team_vulnerabilitySummaries_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Team.Configs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*configmap.ConfigOrder), args["filter"].(*configmap.ConfigFilter)), true - - case "Team.cost": - if e.ComplexityRoot.Team.Cost == nil { - break - } - - return e.ComplexityRoot.Team.Cost(childComplexity), true + return e.ComplexityRoot.Team.VulnerabilitySummaries(childComplexity, args["filter"].(*vulnerability.TeamVulnerabilitySummaryFilter), args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*vulnerability.VulnerabilitySummaryOrder)), true - case "Team.deleteKey": - if e.ComplexityRoot.Team.DeleteKey == nil { + case "Team.vulnerabilitySummary": + if e.ComplexityRoot.Team.VulnerabilitySummary == nil { break } - args, err := ec.field_Team_deleteKey_args(ctx, rawArgs) + args, err := ec.field_Team_vulnerabilitySummary_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Team.DeleteKey(childComplexity, args["key"].(string)), true + return e.ComplexityRoot.Team.VulnerabilitySummary(childComplexity, args["filter"].(*vulnerability.TeamVulnerabilitySummaryFilter)), true - case "Team.deletionInProgress": - if e.ComplexityRoot.Team.DeletionInProgress == nil { + case "Team.workloadUtilization": + if e.ComplexityRoot.Team.WorkloadUtilization == nil { break } - return e.ComplexityRoot.Team.DeletionInProgress(childComplexity), true - - case "Team.deploymentKey": - if e.ComplexityRoot.Team.DeploymentKey == nil { - break + args, err := ec.field_Team_workloadUtilization_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Team.DeploymentKey(childComplexity), true + return e.ComplexityRoot.Team.WorkloadUtilization(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true - case "Team.deployments": - if e.ComplexityRoot.Team.Deployments == nil { + case "Team.workloads": + if e.ComplexityRoot.Team.Workloads == nil { break } - args, err := ec.field_Team_deployments_args(ctx, rawArgs) + args, err := ec.field_Team_workloads_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Team.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Team.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*workload.WorkloadOrder), args["filter"].(*workload.TeamWorkloadsFilter)), true - case "Team.environment": - if e.ComplexityRoot.Team.Environment == nil { + case "TeamCDN.bucket": + if e.ComplexityRoot.TeamCDN.Bucket == nil { break } - args, err := ec.field_Team_environment_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TeamCDN.Bucket(childComplexity), true + + case "TeamConfirmDeleteKeyActivityLogEntry.actor": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Actor == nil { + break } - return e.ComplexityRoot.Team.Environment(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Actor(childComplexity), true - case "Team.environments": - if e.ComplexityRoot.Team.Environments == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.Team.Environments(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.CreatedAt(childComplexity), true - case "Team.externalResources": - if e.ComplexityRoot.Team.ExternalResources == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.Team.ExternalResources(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.EnvironmentName(childComplexity), true - case "Team.id": - if e.ComplexityRoot.Team.ID == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.id": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.Team.ID(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ID(childComplexity), true - case "Team.imageVulnerabilityHistory": - if e.ComplexityRoot.Team.ImageVulnerabilityHistory == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.message": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Message == nil { break } - args, err := ec.field_Team_imageVulnerabilityHistory_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Message(childComplexity), true + + case "TeamConfirmDeleteKeyActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceName == nil { + break } - return e.ComplexityRoot.Team.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceName(childComplexity), true - case "Team.inventoryCounts": - if e.ComplexityRoot.Team.InventoryCounts == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.Team.InventoryCounts(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceType(childComplexity), true - case "Team.issues": - if e.ComplexityRoot.Team.Issues == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.TeamSlug == nil { break } - args, err := ec.field_Team_issues_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.TeamSlug(childComplexity), true + + case "TeamConnection.edges": + if e.ComplexityRoot.TeamConnection.Edges == nil { + break } - return e.ComplexityRoot.Team.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.IssueFilter)), true + return e.ComplexityRoot.TeamConnection.Edges(childComplexity), true - case "Team.jobs": - if e.ComplexityRoot.Team.Jobs == nil { + case "TeamConnection.nodes": + if e.ComplexityRoot.TeamConnection.Nodes == nil { break } - args, err := ec.field_Team_jobs_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TeamConnection.Nodes(childComplexity), true + + case "TeamConnection.pageInfo": + if e.ComplexityRoot.TeamConnection.PageInfo == nil { + break } - return e.ComplexityRoot.Team.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*job.JobOrder), args["filter"].(*job.TeamJobsFilter)), true + return e.ComplexityRoot.TeamConnection.PageInfo(childComplexity), true - case "Team.kafkaTopics": - if e.ComplexityRoot.Team.KafkaTopics == nil { + case "TeamCost.daily": + if e.ComplexityRoot.TeamCost.Daily == nil { break } - args, err := ec.field_Team_kafkaTopics_args(ctx, rawArgs) + args, err := ec.field_TeamCost_daily_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Team.KafkaTopics(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*kafkatopic.KafkaTopicOrder)), true + return e.ComplexityRoot.TeamCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date), args["filter"].(*cost.TeamCostDailyFilter)), true - case "Team.lastSuccessfulSync": - if e.ComplexityRoot.Team.LastSuccessfulSync == nil { + case "TeamCost.monthlySummary": + if e.ComplexityRoot.TeamCost.MonthlySummary == nil { break } - return e.ComplexityRoot.Team.LastSuccessfulSync(childComplexity), true + return e.ComplexityRoot.TeamCost.MonthlySummary(childComplexity), true - case "Team.member": - if e.ComplexityRoot.Team.Member == nil { + case "TeamCostMonthlySample.cost": + if e.ComplexityRoot.TeamCostMonthlySample.Cost == nil { break } - args, err := ec.field_Team_member_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Member(childComplexity, args["email"].(string)), true + return e.ComplexityRoot.TeamCostMonthlySample.Cost(childComplexity), true - case "Team.members": - if e.ComplexityRoot.Team.Members == nil { + case "TeamCostMonthlySample.date": + if e.ComplexityRoot.TeamCostMonthlySample.Date == nil { break } - args, err := ec.field_Team_members_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TeamCostMonthlySample.Date(childComplexity), true + + case "TeamCostMonthlySummary.series": + if e.ComplexityRoot.TeamCostMonthlySummary.Series == nil { + break } - return e.ComplexityRoot.Team.Members(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.TeamMemberOrder)), true + return e.ComplexityRoot.TeamCostMonthlySummary.Series(childComplexity), true - case "Team.openSearches": - if e.ComplexityRoot.Team.OpenSearches == nil { + case "TeamCostMonthlySummary.sum": + if e.ComplexityRoot.TeamCostMonthlySummary.Sum == nil { break } - args, err := ec.field_Team_openSearches_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.OpenSearches(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*opensearch.OpenSearchOrder)), true + return e.ComplexityRoot.TeamCostMonthlySummary.Sum(childComplexity), true - case "Team.postgresInstances": - if e.ComplexityRoot.Team.PostgresInstances == nil { + case "TeamCostPeriod.series": + if e.ComplexityRoot.TeamCostPeriod.Series == nil { break } - args, err := ec.field_Team_postgresInstances_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.PostgresInstances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*postgres.PostgresInstanceOrder)), true + return e.ComplexityRoot.TeamCostPeriod.Series(childComplexity), true - case "Team.purpose": - if e.ComplexityRoot.Team.Purpose == nil { + case "TeamCostPeriod.sum": + if e.ComplexityRoot.TeamCostPeriod.Sum == nil { break } - return e.ComplexityRoot.Team.Purpose(childComplexity), true + return e.ComplexityRoot.TeamCostPeriod.Sum(childComplexity), true - case "Team.repositories": - if e.ComplexityRoot.Team.Repositories == nil { + case "TeamCreateDeleteKeyActivityLogEntry.actor": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Actor == nil { break } - args, err := ec.field_Team_repositories_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Repositories(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*repository.RepositoryOrder), args["filter"].(*repository.TeamRepositoryFilter)), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Actor(childComplexity), true - case "Team.sqlInstances": - if e.ComplexityRoot.Team.SQLInstances == nil { + case "TeamCreateDeleteKeyActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.CreatedAt == nil { break } - args, err := ec.field_Team_sqlInstances_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.SQLInstances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*sqlinstance.SQLInstanceOrder)), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.CreatedAt(childComplexity), true - case "Team.secrets": - if e.ComplexityRoot.Team.Secrets == nil { + case "TeamCreateDeleteKeyActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.EnvironmentName == nil { break } - args, err := ec.field_Team_secrets_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Secrets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*secret.SecretOrder), args["filter"].(*secret.SecretFilter)), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.EnvironmentName(childComplexity), true - case "Team.serviceUtilization": - if e.ComplexityRoot.Team.ServiceUtilization == nil { + case "TeamCreateDeleteKeyActivityLogEntry.id": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.Team.ServiceUtilization(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ID(childComplexity), true - case "Team.slackChannel": - if e.ComplexityRoot.Team.SlackChannel == nil { + case "TeamCreateDeleteKeyActivityLogEntry.message": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.Team.SlackChannel(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Message(childComplexity), true - case "Team.slug": - if e.ComplexityRoot.Team.Slug == nil { + case "TeamCreateDeleteKeyActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.Team.Slug(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceName(childComplexity), true - case "Team.unleash": - if e.ComplexityRoot.Team.Unleash == nil { + case "TeamCreateDeleteKeyActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.Team.Unleash(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceType(childComplexity), true - case "Team.valkeys": - if e.ComplexityRoot.Team.Valkeys == nil { + case "TeamCreateDeleteKeyActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.TeamSlug == nil { break } - args, err := ec.field_Team_valkeys_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Valkeys(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*valkey.ValkeyOrder)), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.TeamSlug(childComplexity), true - case "Team.viewerIsMember": - if e.ComplexityRoot.Team.ViewerIsMember == nil { + case "TeamCreatedActivityLogEntry.actor": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.Team.ViewerIsMember(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.Actor(childComplexity), true - case "Team.viewerIsOwner": - if e.ComplexityRoot.Team.ViewerIsOwner == nil { + case "TeamCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.Team.ViewerIsOwner(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "Team.vulnerabilityFixHistory": - if e.ComplexityRoot.Team.VulnerabilityFixHistory == nil { + case "TeamCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.EnvironmentName == nil { break } - args, err := ec.field_Team_vulnerabilityFixHistory_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TeamCreatedActivityLogEntry.EnvironmentName(childComplexity), true + + case "TeamCreatedActivityLogEntry.id": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.ID == nil { + break } - return e.ComplexityRoot.Team.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.ID(childComplexity), true - case "Team.vulnerabilitySummaries": - if e.ComplexityRoot.Team.VulnerabilitySummaries == nil { + case "TeamCreatedActivityLogEntry.message": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.Message == nil { break } - args, err := ec.field_Team_vulnerabilitySummaries_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TeamCreatedActivityLogEntry.Message(childComplexity), true + + case "TeamCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceName == nil { + break } - return e.ComplexityRoot.Team.VulnerabilitySummaries(childComplexity, args["filter"].(*vulnerability.TeamVulnerabilitySummaryFilter), args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*vulnerability.VulnerabilitySummaryOrder)), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceName(childComplexity), true - case "Team.vulnerabilitySummary": - if e.ComplexityRoot.Team.VulnerabilitySummary == nil { + case "TeamCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceType == nil { break } - args, err := ec.field_Team_vulnerabilitySummary_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceType(childComplexity), true + + case "TeamCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.TeamSlug == nil { + break } - return e.ComplexityRoot.Team.VulnerabilitySummary(childComplexity, args["filter"].(*vulnerability.TeamVulnerabilitySummaryFilter)), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "Team.workloadUtilization": - if e.ComplexityRoot.Team.WorkloadUtilization == nil { + case "TeamDeleteKey.createdAt": + if e.ComplexityRoot.TeamDeleteKey.CreatedAt == nil { break } - args, err := ec.field_Team_workloadUtilization_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TeamDeleteKey.CreatedAt(childComplexity), true + + case "TeamDeleteKey.createdBy": + if e.ComplexityRoot.TeamDeleteKey.CreatedBy == nil { + break } - return e.ComplexityRoot.Team.WorkloadUtilization(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + return e.ComplexityRoot.TeamDeleteKey.CreatedBy(childComplexity), true - case "Team.workloads": - if e.ComplexityRoot.Team.Workloads == nil { + case "TeamDeleteKey.expires": + if e.ComplexityRoot.TeamDeleteKey.Expires == nil { break } - args, err := ec.field_Team_workloads_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TeamDeleteKey.Expires(childComplexity), true + + case "TeamDeleteKey.key": + if e.ComplexityRoot.TeamDeleteKey.Key == nil { + break } - return e.ComplexityRoot.Team.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*workload.WorkloadOrder), args["filter"].(*workload.TeamWorkloadsFilter)), true + return e.ComplexityRoot.TeamDeleteKey.Key(childComplexity), true - case "TeamCDN.bucket": - if e.ComplexityRoot.TeamCDN.Bucket == nil { + case "TeamDeleteKey.team": + if e.ComplexityRoot.TeamDeleteKey.Team == nil { break } - return e.ComplexityRoot.TeamCDN.Bucket(childComplexity), true + return e.ComplexityRoot.TeamDeleteKey.Team(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.actor": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Actor == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Actor(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.CreatedAt == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.EnvironmentName == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.id": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ID == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.id": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ID(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.message": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Message == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.message": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Message(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceName == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceType == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.TeamSlug == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "TeamConnection.edges": - if e.ComplexityRoot.TeamConnection.Edges == nil { + case "TeamEdge.cursor": + if e.ComplexityRoot.TeamEdge.Cursor == nil { break } - return e.ComplexityRoot.TeamConnection.Edges(childComplexity), true + return e.ComplexityRoot.TeamEdge.Cursor(childComplexity), true - case "TeamConnection.nodes": - if e.ComplexityRoot.TeamConnection.Nodes == nil { + case "TeamEdge.node": + if e.ComplexityRoot.TeamEdge.Node == nil { break } - return e.ComplexityRoot.TeamConnection.Nodes(childComplexity), true + return e.ComplexityRoot.TeamEdge.Node(childComplexity), true - case "TeamConnection.pageInfo": - if e.ComplexityRoot.TeamConnection.PageInfo == nil { + case "TeamEntraIDGroup.groupID": + if e.ComplexityRoot.TeamEntraIDGroup.GroupID == nil { break } - return e.ComplexityRoot.TeamConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.TeamEntraIDGroup.GroupID(childComplexity), true - case "TeamCost.daily": - if e.ComplexityRoot.TeamCost.Daily == nil { + case "TeamEnvironment.alerts": + if e.ComplexityRoot.TeamEnvironment.Alerts == nil { break } - args, err := ec.field_TeamCost_daily_args(ctx, rawArgs) + args, err := ec.field_TeamEnvironment_alerts_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date), args["filter"].(*cost.TeamCostDailyFilter)), true + return e.ComplexityRoot.TeamEnvironment.Alerts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*alerts.AlertOrder), args["filter"].(*alerts.TeamAlertsFilter)), true - case "TeamCost.monthlySummary": - if e.ComplexityRoot.TeamCost.MonthlySummary == nil { + case "TeamEnvironment.application": + if e.ComplexityRoot.TeamEnvironment.Application == nil { break } - return e.ComplexityRoot.TeamCost.MonthlySummary(childComplexity), true - - case "TeamCostMonthlySample.cost": - if e.ComplexityRoot.TeamCostMonthlySample.Cost == nil { - break + args, err := ec.field_TeamEnvironment_application_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCostMonthlySample.Cost(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Application(childComplexity, args["name"].(string)), true - case "TeamCostMonthlySample.date": - if e.ComplexityRoot.TeamCostMonthlySample.Date == nil { + case "TeamEnvironment.bigQueryDataset": + if e.ComplexityRoot.TeamEnvironment.BigQueryDataset == nil { break } - return e.ComplexityRoot.TeamCostMonthlySample.Date(childComplexity), true - - case "TeamCostMonthlySummary.series": - if e.ComplexityRoot.TeamCostMonthlySummary.Series == nil { - break + args, err := ec.field_TeamEnvironment_bigQueryDataset_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCostMonthlySummary.Series(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.BigQueryDataset(childComplexity, args["name"].(string)), true - case "TeamCostMonthlySummary.sum": - if e.ComplexityRoot.TeamCostMonthlySummary.Sum == nil { + case "TeamEnvironment.bucket": + if e.ComplexityRoot.TeamEnvironment.Bucket == nil { break } - return e.ComplexityRoot.TeamCostMonthlySummary.Sum(childComplexity), true - - case "TeamCostPeriod.series": - if e.ComplexityRoot.TeamCostPeriod.Series == nil { - break + args, err := ec.field_TeamEnvironment_bucket_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCostPeriod.Series(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Bucket(childComplexity, args["name"].(string)), true - case "TeamCostPeriod.sum": - if e.ComplexityRoot.TeamCostPeriod.Sum == nil { + case "TeamEnvironment.cost": + if e.ComplexityRoot.TeamEnvironment.Cost == nil { break } - return e.ComplexityRoot.TeamCostPeriod.Sum(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Cost(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.actor": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Actor == nil { + case "TeamEnvironment.environment": + if e.ComplexityRoot.TeamEnvironment.Environment == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Environment(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.CreatedAt == nil { + case "TeamEnvironment.gcpProjectID": + if e.ComplexityRoot.TeamEnvironment.GCPProjectID == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.GCPProjectID(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.EnvironmentName == nil { + case "TeamEnvironment.id": + if e.ComplexityRoot.TeamEnvironment.ID == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.ID(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.id": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ID == nil { + case "TeamEnvironment.job": + if e.ComplexityRoot.TeamEnvironment.Job == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ID(childComplexity), true - - case "TeamCreateDeleteKeyActivityLogEntry.message": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Message == nil { - break + args, err := ec.field_TeamEnvironment_job_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Job(childComplexity, args["name"].(string)), true - case "TeamCreateDeleteKeyActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceName == nil { + case "TeamEnvironment.kafkaTopic": + if e.ComplexityRoot.TeamEnvironment.KafkaTopic == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceName(childComplexity), true - - case "TeamCreateDeleteKeyActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceType == nil { - break + args, err := ec.field_TeamEnvironment_kafkaTopic_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.KafkaTopic(childComplexity, args["name"].(string)), true - case "TeamCreateDeleteKeyActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.TeamSlug == nil { + case "TeamEnvironment.name": + if e.ComplexityRoot.TeamEnvironment.Name == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Name(childComplexity), true - case "TeamCreatedActivityLogEntry.actor": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.Actor == nil { + case "TeamEnvironment.openSearch": + if e.ComplexityRoot.TeamEnvironment.OpenSearch == nil { break } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.Actor(childComplexity), true - - case "TeamCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_TeamEnvironment_openSearch_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.OpenSearch(childComplexity, args["name"].(string)), true - case "TeamCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.EnvironmentName == nil { + case "TeamEnvironment.postgresInstance": + if e.ComplexityRoot.TeamEnvironment.PostgresInstance == nil { break } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.EnvironmentName(childComplexity), true - - case "TeamCreatedActivityLogEntry.id": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.ID == nil { - break + args, err := ec.field_TeamEnvironment_postgresInstance_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.PostgresInstance(childComplexity, args["name"].(string)), true - case "TeamCreatedActivityLogEntry.message": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.Message == nil { + case "TeamEnvironment.sqlInstance": + if e.ComplexityRoot.TeamEnvironment.SQLInstance == nil { break } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.Message(childComplexity), true - - case "TeamCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceName == nil { - break + args, err := ec.field_TeamEnvironment_sqlInstance_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.SQLInstance(childComplexity, args["name"].(string)), true - case "TeamCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceType == nil { + case "TeamEnvironment.secret": + if e.ComplexityRoot.TeamEnvironment.Secret == nil { break } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceType(childComplexity), true - - case "TeamCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.TeamSlug == nil { - break + args, err := ec.field_TeamEnvironment_secret_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Secret(childComplexity, args["name"].(string)), true - case "TeamDeleteKey.createdAt": - if e.ComplexityRoot.TeamDeleteKey.CreatedAt == nil { + case "TeamEnvironment.slackAlertsChannel": + if e.ComplexityRoot.TeamEnvironment.SlackAlertsChannel == nil { break } - return e.ComplexityRoot.TeamDeleteKey.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.SlackAlertsChannel(childComplexity), true - case "TeamDeleteKey.createdBy": - if e.ComplexityRoot.TeamDeleteKey.CreatedBy == nil { + case "TeamEnvironment.team": + if e.ComplexityRoot.TeamEnvironment.Team == nil { break } - return e.ComplexityRoot.TeamDeleteKey.CreatedBy(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Team(childComplexity), true - case "TeamDeleteKey.expires": - if e.ComplexityRoot.TeamDeleteKey.Expires == nil { + case "TeamEnvironment.valkey": + if e.ComplexityRoot.TeamEnvironment.Valkey == nil { break } - return e.ComplexityRoot.TeamDeleteKey.Expires(childComplexity), true - - case "TeamDeleteKey.key": - if e.ComplexityRoot.TeamDeleteKey.Key == nil { - break + args, err := ec.field_TeamEnvironment_valkey_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamDeleteKey.Key(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Valkey(childComplexity, args["name"].(string)), true - case "TeamDeleteKey.team": - if e.ComplexityRoot.TeamDeleteKey.Team == nil { + case "TeamEnvironment.workload": + if e.ComplexityRoot.TeamEnvironment.Workload == nil { break } - return e.ComplexityRoot.TeamDeleteKey.Team(childComplexity), true - - case "TeamDeployKeyUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Actor == nil { - break + args, err := ec.field_TeamEnvironment_workload_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Workload(childComplexity, args["name"].(string)), true - case "TeamDeployKeyUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.CreatedAt == nil { + case "TeamEnvironmentCost.daily": + if e.ComplexityRoot.TeamEnvironmentCost.Daily == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.CreatedAt(childComplexity), true + args, err := ec.field_TeamEnvironmentCost_daily_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "TeamDeployKeyUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.EnvironmentName == nil { + return e.ComplexityRoot.TeamEnvironmentCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + + case "TeamEnvironmentCostPeriod.series": + if e.ComplexityRoot.TeamEnvironmentCostPeriod.Series == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentCostPeriod.Series(childComplexity), true - case "TeamDeployKeyUpdatedActivityLogEntry.id": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ID == nil { + case "TeamEnvironmentCostPeriod.sum": + if e.ComplexityRoot.TeamEnvironmentCostPeriod.Sum == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentCostPeriod.Sum(childComplexity), true - case "TeamDeployKeyUpdatedActivityLogEntry.message": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Message == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Actor(childComplexity), true - case "TeamDeployKeyUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceName == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "TeamDeployKeyUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceType == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.data": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Data(childComplexity), true - case "TeamDeployKeyUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.TeamSlug == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "TeamEdge.cursor": - if e.ComplexityRoot.TeamEdge.Cursor == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.id": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.TeamEdge.Cursor(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ID(childComplexity), true - case "TeamEdge.node": - if e.ComplexityRoot.TeamEdge.Node == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.message": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.TeamEdge.Node(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Message(childComplexity), true - case "TeamEntraIDGroup.groupID": - if e.ComplexityRoot.TeamEntraIDGroup.GroupID == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.TeamEntraIDGroup.GroupID(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "TeamEnvironment.alerts": - if e.ComplexityRoot.TeamEnvironment.Alerts == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceType == nil { break } - args, err := ec.field_TeamEnvironment_alerts_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.Alerts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*alerts.AlertOrder), args["filter"].(*alerts.TeamAlertsFilter)), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "TeamEnvironment.application": - if e.ComplexityRoot.TeamEnvironment.Application == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.TeamSlug == nil { break } - args, err := ec.field_TeamEnvironment_application_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.Application(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "TeamEnvironment.bigQueryDataset": - if e.ComplexityRoot.TeamEnvironment.BigQueryDataset == nil { + case "TeamEnvironmentUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryData.UpdatedFields == nil { break } - args, err := ec.field_TeamEnvironment_bigQueryDataset_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.BigQueryDataset(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "TeamEnvironment.bucket": - if e.ComplexityRoot.TeamEnvironment.Bucket == nil { + case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - args, err := ec.field_TeamEnvironment_bucket_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.Bucket(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "TeamEnvironment.config": - if e.ComplexityRoot.TeamEnvironment.Config == nil { + case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - args, err := ec.field_TeamEnvironment_config_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.Config(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "TeamEnvironment.cost": - if e.ComplexityRoot.TeamEnvironment.Cost == nil { + case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.TeamEnvironment.Cost(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "TeamEnvironment.environment": - if e.ComplexityRoot.TeamEnvironment.Environment == nil { + case "TeamExternalResources.cdn": + if e.ComplexityRoot.TeamExternalResources.CDN == nil { break } - return e.ComplexityRoot.TeamEnvironment.Environment(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.CDN(childComplexity), true - case "TeamEnvironment.gcpProjectID": - if e.ComplexityRoot.TeamEnvironment.GCPProjectID == nil { + case "TeamExternalResources.entraIDGroup": + if e.ComplexityRoot.TeamExternalResources.EntraIDGroup == nil { break } - return e.ComplexityRoot.TeamEnvironment.GCPProjectID(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.EntraIDGroup(childComplexity), true - case "TeamEnvironment.id": - if e.ComplexityRoot.TeamEnvironment.ID == nil { + case "TeamExternalResources.gitHubTeam": + if e.ComplexityRoot.TeamExternalResources.GitHubTeam == nil { break } - return e.ComplexityRoot.TeamEnvironment.ID(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.GitHubTeam(childComplexity), true - case "TeamEnvironment.job": - if e.ComplexityRoot.TeamEnvironment.Job == nil { + case "TeamExternalResources.googleArtifactRegistry": + if e.ComplexityRoot.TeamExternalResources.GoogleArtifactRegistry == nil { break } - args, err := ec.field_TeamEnvironment_job_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.Job(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamExternalResources.GoogleArtifactRegistry(childComplexity), true - case "TeamEnvironment.kafkaTopic": - if e.ComplexityRoot.TeamEnvironment.KafkaTopic == nil { + case "TeamExternalResources.googleGroup": + if e.ComplexityRoot.TeamExternalResources.GoogleGroup == nil { break } - args, err := ec.field_TeamEnvironment_kafkaTopic_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.KafkaTopic(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamExternalResources.GoogleGroup(childComplexity), true - case "TeamEnvironment.name": - if e.ComplexityRoot.TeamEnvironment.Name == nil { + case "TeamGitHubTeam.slug": + if e.ComplexityRoot.TeamGitHubTeam.Slug == nil { break } - return e.ComplexityRoot.TeamEnvironment.Name(childComplexity), true + return e.ComplexityRoot.TeamGitHubTeam.Slug(childComplexity), true - case "TeamEnvironment.openSearch": - if e.ComplexityRoot.TeamEnvironment.OpenSearch == nil { + case "TeamGoogleArtifactRegistry.repository": + if e.ComplexityRoot.TeamGoogleArtifactRegistry.Repository == nil { break } - args, err := ec.field_TeamEnvironment_openSearch_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.OpenSearch(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamGoogleArtifactRegistry.Repository(childComplexity), true - case "TeamEnvironment.postgresInstance": - if e.ComplexityRoot.TeamEnvironment.PostgresInstance == nil { + case "TeamGoogleGroup.email": + if e.ComplexityRoot.TeamGoogleGroup.Email == nil { break } - args, err := ec.field_TeamEnvironment_postgresInstance_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.PostgresInstance(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamGoogleGroup.Email(childComplexity), true - case "TeamEnvironment.sqlInstance": - if e.ComplexityRoot.TeamEnvironment.SQLInstance == nil { + case "TeamInventoryCountApplications.total": + if e.ComplexityRoot.TeamInventoryCountApplications.Total == nil { break } - args, err := ec.field_TeamEnvironment_sqlInstance_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.SQLInstance(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamInventoryCountApplications.Total(childComplexity), true - case "TeamEnvironment.secret": - if e.ComplexityRoot.TeamEnvironment.Secret == nil { + case "TeamInventoryCountBigQueryDatasets.total": + if e.ComplexityRoot.TeamInventoryCountBigQueryDatasets.Total == nil { break } - args, err := ec.field_TeamEnvironment_secret_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.Secret(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamInventoryCountBigQueryDatasets.Total(childComplexity), true - case "TeamEnvironment.slackAlertsChannel": - if e.ComplexityRoot.TeamEnvironment.SlackAlertsChannel == nil { + case "TeamInventoryCountBuckets.total": + if e.ComplexityRoot.TeamInventoryCountBuckets.Total == nil { break } - return e.ComplexityRoot.TeamEnvironment.SlackAlertsChannel(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountBuckets.Total(childComplexity), true - case "TeamEnvironment.team": - if e.ComplexityRoot.TeamEnvironment.Team == nil { + case "TeamInventoryCountJobs.total": + if e.ComplexityRoot.TeamInventoryCountJobs.Total == nil { break } - return e.ComplexityRoot.TeamEnvironment.Team(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountJobs.Total(childComplexity), true - case "TeamEnvironment.valkey": - if e.ComplexityRoot.TeamEnvironment.Valkey == nil { + case "TeamInventoryCountKafkaTopics.total": + if e.ComplexityRoot.TeamInventoryCountKafkaTopics.Total == nil { break } - args, err := ec.field_TeamEnvironment_valkey_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.Valkey(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamInventoryCountKafkaTopics.Total(childComplexity), true - case "TeamEnvironment.workload": - if e.ComplexityRoot.TeamEnvironment.Workload == nil { + case "TeamInventoryCountOpenSearches.total": + if e.ComplexityRoot.TeamInventoryCountOpenSearches.Total == nil { break } - args, err := ec.field_TeamEnvironment_workload_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.Workload(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.TeamInventoryCountOpenSearches.Total(childComplexity), true - case "TeamEnvironmentCost.daily": - if e.ComplexityRoot.TeamEnvironmentCost.Daily == nil { + case "TeamInventoryCountPostgresInstances.total": + if e.ComplexityRoot.TeamInventoryCountPostgresInstances.Total == nil { break } - args, err := ec.field_TeamEnvironmentCost_daily_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TeamInventoryCountPostgresInstances.Total(childComplexity), true + + case "TeamInventoryCountSecrets.total": + if e.ComplexityRoot.TeamInventoryCountSecrets.Total == nil { + break } - return e.ComplexityRoot.TeamEnvironmentCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + return e.ComplexityRoot.TeamInventoryCountSecrets.Total(childComplexity), true - case "TeamEnvironmentCostPeriod.series": - if e.ComplexityRoot.TeamEnvironmentCostPeriod.Series == nil { + case "TeamInventoryCountSqlInstances.total": + if e.ComplexityRoot.TeamInventoryCountSqlInstances.Total == nil { break } - return e.ComplexityRoot.TeamEnvironmentCostPeriod.Series(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountSqlInstances.Total(childComplexity), true - case "TeamEnvironmentCostPeriod.sum": - if e.ComplexityRoot.TeamEnvironmentCostPeriod.Sum == nil { + case "TeamInventoryCountValkeys.total": + if e.ComplexityRoot.TeamInventoryCountValkeys.Total == nil { break } - return e.ComplexityRoot.TeamEnvironmentCostPeriod.Sum(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountValkeys.Total(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Actor == nil { + case "TeamInventoryCounts.applications": + if e.ComplexityRoot.TeamInventoryCounts.Applications == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Applications(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.CreatedAt == nil { + case "TeamInventoryCounts.bigQueryDatasets": + if e.ComplexityRoot.TeamInventoryCounts.BigQueryDatasets == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.BigQueryDatasets(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.data": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Data == nil { + case "TeamInventoryCounts.buckets": + if e.ComplexityRoot.TeamInventoryCounts.Buckets == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Buckets(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.EnvironmentName == nil { + case "TeamInventoryCounts.jobs": + if e.ComplexityRoot.TeamInventoryCounts.Jobs == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Jobs(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.id": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ID == nil { + case "TeamInventoryCounts.kafkaTopics": + if e.ComplexityRoot.TeamInventoryCounts.KafkaTopics == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.KafkaTopics(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.message": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Message == nil { + case "TeamInventoryCounts.openSearches": + if e.ComplexityRoot.TeamInventoryCounts.OpenSearches == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.OpenSearches(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceName == nil { + case "TeamInventoryCounts.postgresInstances": + if e.ComplexityRoot.TeamInventoryCounts.PostgresInstances == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.PostgresInstances(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceType == nil { + case "TeamInventoryCounts.sqlInstances": + if e.ComplexityRoot.TeamInventoryCounts.SQLInstances == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceType(childComplexity), true - - case "TeamEnvironmentUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.TeamSlug == nil { - break - } - - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.TeamSlug(childComplexity), true - - case "TeamEnvironmentUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryData.UpdatedFields == nil { - break - } - - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - - case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.Field == nil { - break - } - - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - - case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { - break - } - - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - - case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { - break - } - - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - - case "TeamExternalResources.cdn": - if e.ComplexityRoot.TeamExternalResources.CDN == nil { - break - } - - return e.ComplexityRoot.TeamExternalResources.CDN(childComplexity), true - - case "TeamExternalResources.entraIDGroup": - if e.ComplexityRoot.TeamExternalResources.EntraIDGroup == nil { - break - } - - return e.ComplexityRoot.TeamExternalResources.EntraIDGroup(childComplexity), true - - case "TeamExternalResources.gitHubTeam": - if e.ComplexityRoot.TeamExternalResources.GitHubTeam == nil { - break - } - - return e.ComplexityRoot.TeamExternalResources.GitHubTeam(childComplexity), true - - case "TeamExternalResources.googleArtifactRegistry": - if e.ComplexityRoot.TeamExternalResources.GoogleArtifactRegistry == nil { - break - } - - return e.ComplexityRoot.TeamExternalResources.GoogleArtifactRegistry(childComplexity), true - - case "TeamExternalResources.googleGroup": - if e.ComplexityRoot.TeamExternalResources.GoogleGroup == nil { - break - } - - return e.ComplexityRoot.TeamExternalResources.GoogleGroup(childComplexity), true - - case "TeamGitHubTeam.slug": - if e.ComplexityRoot.TeamGitHubTeam.Slug == nil { - break - } - - return e.ComplexityRoot.TeamGitHubTeam.Slug(childComplexity), true - - case "TeamGoogleArtifactRegistry.repository": - if e.ComplexityRoot.TeamGoogleArtifactRegistry.Repository == nil { - break - } - - return e.ComplexityRoot.TeamGoogleArtifactRegistry.Repository(childComplexity), true - - case "TeamGoogleGroup.email": - if e.ComplexityRoot.TeamGoogleGroup.Email == nil { - break - } - - return e.ComplexityRoot.TeamGoogleGroup.Email(childComplexity), true - - case "TeamInventoryCountApplications.total": - if e.ComplexityRoot.TeamInventoryCountApplications.Total == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCountApplications.Total(childComplexity), true - - case "TeamInventoryCountBigQueryDatasets.total": - if e.ComplexityRoot.TeamInventoryCountBigQueryDatasets.Total == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCountBigQueryDatasets.Total(childComplexity), true - - case "TeamInventoryCountBuckets.total": - if e.ComplexityRoot.TeamInventoryCountBuckets.Total == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCountBuckets.Total(childComplexity), true - - case "TeamInventoryCountConfigs.total": - if e.ComplexityRoot.TeamInventoryCountConfigs.Total == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCountConfigs.Total(childComplexity), true - - case "TeamInventoryCountJobs.total": - if e.ComplexityRoot.TeamInventoryCountJobs.Total == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCountJobs.Total(childComplexity), true - - case "TeamInventoryCountKafkaTopics.total": - if e.ComplexityRoot.TeamInventoryCountKafkaTopics.Total == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCountKafkaTopics.Total(childComplexity), true - - case "TeamInventoryCountOpenSearches.total": - if e.ComplexityRoot.TeamInventoryCountOpenSearches.Total == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCountOpenSearches.Total(childComplexity), true - - case "TeamInventoryCountPostgresInstances.total": - if e.ComplexityRoot.TeamInventoryCountPostgresInstances.Total == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCountPostgresInstances.Total(childComplexity), true - - case "TeamInventoryCountSecrets.total": - if e.ComplexityRoot.TeamInventoryCountSecrets.Total == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCountSecrets.Total(childComplexity), true - - case "TeamInventoryCountSqlInstances.total": - if e.ComplexityRoot.TeamInventoryCountSqlInstances.Total == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCountSqlInstances.Total(childComplexity), true - - case "TeamInventoryCountValkeys.total": - if e.ComplexityRoot.TeamInventoryCountValkeys.Total == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCountValkeys.Total(childComplexity), true - - case "TeamInventoryCounts.applications": - if e.ComplexityRoot.TeamInventoryCounts.Applications == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCounts.Applications(childComplexity), true - - case "TeamInventoryCounts.bigQueryDatasets": - if e.ComplexityRoot.TeamInventoryCounts.BigQueryDatasets == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCounts.BigQueryDatasets(childComplexity), true - - case "TeamInventoryCounts.buckets": - if e.ComplexityRoot.TeamInventoryCounts.Buckets == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCounts.Buckets(childComplexity), true - - case "TeamInventoryCounts.configs": - if e.ComplexityRoot.TeamInventoryCounts.Configs == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCounts.Configs(childComplexity), true - - case "TeamInventoryCounts.jobs": - if e.ComplexityRoot.TeamInventoryCounts.Jobs == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCounts.Jobs(childComplexity), true - - case "TeamInventoryCounts.kafkaTopics": - if e.ComplexityRoot.TeamInventoryCounts.KafkaTopics == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCounts.KafkaTopics(childComplexity), true - - case "TeamInventoryCounts.openSearches": - if e.ComplexityRoot.TeamInventoryCounts.OpenSearches == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCounts.OpenSearches(childComplexity), true - - case "TeamInventoryCounts.postgresInstances": - if e.ComplexityRoot.TeamInventoryCounts.PostgresInstances == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCounts.PostgresInstances(childComplexity), true - - case "TeamInventoryCounts.sqlInstances": - if e.ComplexityRoot.TeamInventoryCounts.SQLInstances == nil { - break - } - - return e.ComplexityRoot.TeamInventoryCounts.SQLInstances(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.SQLInstances(childComplexity), true case "TeamInventoryCounts.secrets": if e.ComplexityRoot.TeamInventoryCounts.Secrets == nil { @@ -15144,77 +14436,133 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.UnleashReleaseChannelIssue.Unleash(childComplexity), true - case "UpdateConfigValuePayload.config": - if e.ComplexityRoot.UpdateConfigValuePayload.Config == nil { + case "UnsupportedResourceActivityLogEntry.actor": + if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.UpdateConfigValuePayload.Config(childComplexity), true + return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.Actor(childComplexity), true - case "UpdateImageVulnerabilityPayload.vulnerability": - if e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability == nil { + case "UnsupportedResourceActivityLogEntry.createdAt": + if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability(childComplexity), true + return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.CreatedAt(childComplexity), true - case "UpdateOpenSearchPayload.openSearch": - if e.ComplexityRoot.UpdateOpenSearchPayload.OpenSearch == nil { + case "UnsupportedResourceActivityLogEntry.data": + if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.UpdateOpenSearchPayload.OpenSearch(childComplexity), true + return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.Data(childComplexity), true - case "UpdateSecretValuePayload.secret": - if e.ComplexityRoot.UpdateSecretValuePayload.Secret == nil { + case "UnsupportedResourceActivityLogEntry.environmentName": + if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.UpdateSecretValuePayload.Secret(childComplexity), true + return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.EnvironmentName(childComplexity), true - case "UpdateServiceAccountPayload.serviceAccount": - if e.ComplexityRoot.UpdateServiceAccountPayload.ServiceAccount == nil { + case "UnsupportedResourceActivityLogEntry.id": + if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.UpdateServiceAccountPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.ID(childComplexity), true - case "UpdateServiceAccountTokenPayload.serviceAccount": - if e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccount == nil { + case "UnsupportedResourceActivityLogEntry.message": + if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.Message(childComplexity), true - case "UpdateServiceAccountTokenPayload.serviceAccountToken": - if e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccountToken == nil { + case "UnsupportedResourceActivityLogEntry.resourceName": + if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccountToken(childComplexity), true + return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.ResourceName(childComplexity), true - case "UpdateTeamEnvironmentPayload.environment": - if e.ComplexityRoot.UpdateTeamEnvironmentPayload.Environment == nil { + case "UnsupportedResourceActivityLogEntry.resourceType": + if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.UpdateTeamEnvironmentPayload.Environment(childComplexity), true + return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.ResourceType(childComplexity), true - case "UpdateTeamEnvironmentPayload.teamEnvironment": - if e.ComplexityRoot.UpdateTeamEnvironmentPayload.TeamEnvironment == nil { + case "UnsupportedResourceActivityLogEntry.teamSlug": + if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.UpdateTeamEnvironmentPayload.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.TeamSlug(childComplexity), true - case "UpdateTeamPayload.team": - if e.ComplexityRoot.UpdateTeamPayload.Team == nil { + case "UpdateImageVulnerabilityPayload.vulnerability": + if e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability == nil { break } - return e.ComplexityRoot.UpdateTeamPayload.Team(childComplexity), true + return e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability(childComplexity), true - case "UpdateUnleashInstancePayload.unleash": + case "UpdateOpenSearchPayload.openSearch": + if e.ComplexityRoot.UpdateOpenSearchPayload.OpenSearch == nil { + break + } + + return e.ComplexityRoot.UpdateOpenSearchPayload.OpenSearch(childComplexity), true + + case "UpdateSecretValuePayload.secret": + if e.ComplexityRoot.UpdateSecretValuePayload.Secret == nil { + break + } + + return e.ComplexityRoot.UpdateSecretValuePayload.Secret(childComplexity), true + + case "UpdateServiceAccountPayload.serviceAccount": + if e.ComplexityRoot.UpdateServiceAccountPayload.ServiceAccount == nil { + break + } + + return e.ComplexityRoot.UpdateServiceAccountPayload.ServiceAccount(childComplexity), true + + case "UpdateServiceAccountTokenPayload.serviceAccount": + if e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccount == nil { + break + } + + return e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccount(childComplexity), true + + case "UpdateServiceAccountTokenPayload.serviceAccountToken": + if e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccountToken == nil { + break + } + + return e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccountToken(childComplexity), true + + case "UpdateTeamEnvironmentPayload.environment": + if e.ComplexityRoot.UpdateTeamEnvironmentPayload.Environment == nil { + break + } + + return e.ComplexityRoot.UpdateTeamEnvironmentPayload.Environment(childComplexity), true + + case "UpdateTeamEnvironmentPayload.teamEnvironment": + if e.ComplexityRoot.UpdateTeamEnvironmentPayload.TeamEnvironment == nil { + break + } + + return e.ComplexityRoot.UpdateTeamEnvironmentPayload.TeamEnvironment(childComplexity), true + + case "UpdateTeamPayload.team": + if e.ComplexityRoot.UpdateTeamPayload.Team == nil { + break + } + + return e.ComplexityRoot.UpdateTeamPayload.Team(childComplexity), true + + case "UpdateUnleashInstancePayload.unleash": if e.ComplexityRoot.UpdateUnleashInstancePayload.Unleash == nil { break } @@ -16697,7 +16045,6 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { ec := newExecutionContext(opCtx, e, make(chan graphql.DeferredResult)) inputUnmarshalMap := graphql.BuildUnmarshalerMap( ec.unmarshalInputActivityLogFilter, - ec.unmarshalInputAddConfigValueInput, ec.unmarshalInputAddRepositoryToTeamInput, ec.unmarshalInputAddSecretValueInput, ec.unmarshalInputAddTeamMemberInput, @@ -16710,12 +16057,8 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { ec.unmarshalInputBucketOrder, ec.unmarshalInputCVEOrder, ec.unmarshalInputChangeDeploymentKeyInput, - ec.unmarshalInputConfigFilter, - ec.unmarshalInputConfigOrder, - ec.unmarshalInputConfigValueInput, ec.unmarshalInputConfigureReconcilerInput, ec.unmarshalInputConfirmTeamDeletionInput, - ec.unmarshalInputCreateConfigInput, ec.unmarshalInputCreateKafkaCredentialsInput, ec.unmarshalInputCreateOpenSearchCredentialsInput, ec.unmarshalInputCreateOpenSearchInput, @@ -16727,7 +16070,6 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { ec.unmarshalInputCreateValkeyCredentialsInput, ec.unmarshalInputCreateValkeyInput, ec.unmarshalInputDeleteApplicationInput, - ec.unmarshalInputDeleteConfigInput, ec.unmarshalInputDeleteJobInput, ec.unmarshalInputDeleteJobRunInput, ec.unmarshalInputDeleteOpenSearchInput, @@ -16760,7 +16102,6 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { ec.unmarshalInputOpenSearchOrder, ec.unmarshalInputPostgresInstanceOrder, ec.unmarshalInputReconcilerConfigInput, - ec.unmarshalInputRemoveConfigValueInput, ec.unmarshalInputRemoveRepositoryFromTeamInput, ec.unmarshalInputRemoveSecretValueInput, ec.unmarshalInputRemoveTeamMemberInput, @@ -16790,7 +16131,6 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { ec.unmarshalInputTeamVulnerabilitySummaryFilter, ec.unmarshalInputTeamWorkloadsFilter, ec.unmarshalInputTriggerJobInput, - ec.unmarshalInputUpdateConfigValueInput, ec.unmarshalInputUpdateImageVulnerabilityInput, ec.unmarshalInputUpdateOpenSearchInput, ec.unmarshalInputUpdateSecretValueInput, @@ -17158,7 +16498,7 @@ type ActivityLogEntryEdge { } `, BuiltIn: false}, {Name: "../schema/aiven_credentials.graphqls", Input: `"Permission level for OpenSearch and Valkey credentials." -enum CredentialPermission { +enum AivenPermission { READ WRITE READWRITE @@ -17173,7 +16513,7 @@ input CreateOpenSearchCredentialsInput { "Name of the OpenSearch instance." instanceName: String! "Permission level for the credentials." - permission: CredentialPermission! + permission: AivenPermission! "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." ttl: String! } @@ -17204,7 +16544,7 @@ input CreateValkeyCredentialsInput { "Name of the Valkey instance." instanceName: String! "Permission level for the credentials." - permission: CredentialPermission! + permission: AivenPermission! "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." ttl: String! } @@ -17256,56 +16596,6 @@ type CreateKafkaCredentialsPayload { credentials: KafkaCredentials! } -extend enum ActivityLogEntryResourceType { - "All activity log entries related to credential creation will use this resource type." - CREDENTIALS -} - -type CredentialsActivityLogEntry implements ActivityLogEntry & Node { - "ID of the entry." - id: ID! - - "The identity of the actor who performed the action." - actor: String! - - "Creation time of the entry." - createdAt: Time! - - "Message that summarizes the entry." - message: String! - - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! - - "Name of the resource that was affected by the action." - resourceName: String! - - "The team slug that the entry belongs to." - teamSlug: Slug! - - "The environment name that the entry belongs to." - environmentName: String - - "Data associated with the credential creation." - data: CredentialsActivityLogEntryData! -} - -type CredentialsActivityLogEntryData { - "The service type (OPENSEARCH, VALKEY, KAFKA)." - serviceType: String! - "The instance name, if applicable." - instanceName: String - "The permission level, if applicable." - permission: String - "The TTL that was requested for the credentials." - ttl: String! -} - -extend enum ActivityLogActivityType { - "Filter for credential creation events." - CREDENTIALS_CREATE -} - extend type Mutation { "Create temporary credentials for an OpenSearch instance." createOpenSearchCredentials( @@ -18346,7 +17636,7 @@ type ApplicationCreatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the creation." - data: ApplyActivityLogEntryData! + data: ResourceActivityLogEntryData! } type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { @@ -18375,7 +17665,7 @@ type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the update." - data: ApplyActivityLogEntryData! + data: ResourceActivityLogEntryData! } extend enum ActivityLogActivityType { @@ -18406,19 +17696,19 @@ extend enum ActivityLogActivityType { """ Additional data associated with a resource created or updated via apply. """ -type ApplyActivityLogEntryData { +type ResourceActivityLogEntryData { "The apiVersion of the applied resource." apiVersion: String! "The kind of the applied resource." kind: String! "The fields that changed during the apply. Only populated for updates." - changedFields: [ApplyChangedField!]! + changedFields: [ResourceChangedField!]! } """ A single field that changed during an apply operation. """ -type ApplyChangedField { +type ResourceChangedField { "The dot-separated path to the changed field, e.g. 'spec.replicas'." field: String! "The value before the apply. Null if the field was added." @@ -18426,6 +17716,39 @@ type ApplyChangedField { "The value after the apply. Null if the field was removed." newValue: String } + +""" +Activity log entry for a resource kind that is not modelled in the GraphQL API. +The resource type will be the uppercase Kubernetes kind, e.g. 'NAISJOB'. +""" +type UnsupportedResourceActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the apply operation." + data: ResourceActivityLogEntryData! +} `, BuiltIn: false}, {Name: "../schema/authz.graphqls", Input: `type Role implements Node { """ @@ -18766,475 +18089,6 @@ type ClusterAuditActivityLogEntryData { "The kind of resource that was affected by the action." resourceKind: String! } -`, BuiltIn: false}, - {Name: "../schema/configmap.graphqls", Input: `extend type Mutation { - "Create a new config." - createConfig(input: CreateConfigInput!): CreateConfigPayload! - - "Add a value to a config." - addConfigValue(input: AddConfigValueInput!): AddConfigValuePayload! - - "Update a value within a config." - updateConfigValue(input: UpdateConfigValueInput!): UpdateConfigValuePayload! - - "Remove a value from a config." - removeConfigValue(input: RemoveConfigValueInput!): RemoveConfigValuePayload! - - "Delete a config, and the values it contains." - deleteConfig(input: DeleteConfigInput!): DeleteConfigPayload! -} - -extend type Team { - "Configs owned by the team." - configs( - "Get the first n items in the connection. This can be used in combination with the after parameter." - first: Int - - "Get items after this cursor." - after: Cursor - - "Get the last n items in the connection. This can be used in combination with the before parameter." - last: Int - - "Get items before this cursor." - before: Cursor - - "Ordering options for items returned from the connection." - orderBy: ConfigOrder - - "Filtering options for items returned from the connection." - filter: ConfigFilter - ): ConfigConnection! -} - -""" -Input for filtering the configs of a team. -""" -input ConfigFilter { - """ - Filter by the name of the config. - """ - name: String - - """ - Filter by usage of the config. - """ - inUse: Boolean -} - -extend type TeamEnvironment { - "Get a config by name." - config(name: String!): Config! -} - -extend interface Workload { - "Configs used by the workload." - configs( - "Get the first n items in the connection. This can be used in combination with the after parameter." - first: Int - - "Get items after this cursor." - after: Cursor - - "Get the last n items in the connection. This can be used in combination with the before parameter." - last: Int - - "Get items before this cursor." - before: Cursor - ): ConfigConnection! -} - -extend type Application { - "Configs used by the application." - configs( - "Get the first n items in the connection. This can be used in combination with the after parameter." - first: Int - - "Get items after this cursor." - after: Cursor - - "Get the last n items in the connection. This can be used in combination with the before parameter." - last: Int - - "Get items before this cursor." - before: Cursor - ): ConfigConnection! -} - -extend type Job { - "Configs used by the job." - configs( - "Get the first n items in the connection. This can be used in combination with the after parameter." - first: Int - - "Get items after this cursor." - after: Cursor - - "Get the last n items in the connection. This can be used in combination with the before parameter." - last: Int - - "Get items before this cursor." - before: Cursor - ): ConfigConnection! -} - -"A config is a collection of key-value pairs." -type Config implements Node & ActivityLogger { - "The globally unique ID of the config." - id: ID! - - "The name of the config." - name: String! - - "The environment the config exists in." - teamEnvironment: TeamEnvironment! - - "The team that owns the config." - team: Team! - - "The values stored in the config." - values: [ConfigValue!]! - - "Applications that use the config." - applications( - "Get the first n items in the connection. This can be used in combination with the after parameter." - first: Int - - "Get items after this cursor." - after: Cursor - - "Get the last n items in the connection. This can be used in combination with the before parameter." - last: Int - - "Get items before this cursor." - before: Cursor - ): ApplicationConnection! - - "Jobs that use the config." - jobs( - "Get the first n items in the connection. This can be used in combination with the after parameter." - first: Int - - "Get items after this cursor." - after: Cursor - - "Get the last n items in the connection. This can be used in combination with the before parameter." - last: Int - - "Get items before this cursor." - before: Cursor - ): JobConnection! - - "Workloads that use the config." - workloads( - "Get the first n items in the connection. This can be used in combination with the after parameter." - first: Int - - "Get items after this cursor." - after: Cursor - - "Get the last n items in the connection. This can be used in combination with the before parameter." - last: Int - - "Get items before this cursor." - before: Cursor - ): WorkloadConnection! - - "Last time the config was modified." - lastModifiedAt: Time - - "User who last modified the config." - lastModifiedBy: User - - "Activity log associated with the config." - activityLog( - "Get the first n items in the connection. This can be used in combination with the after parameter." - first: Int - - "Get items after this cursor." - after: Cursor - - "Get the last n items in the connection. This can be used in combination with the before parameter." - last: Int - - "Get items before this cursor." - before: Cursor - - "Filter items." - filter: ActivityLogFilter - ): ActivityLogEntryConnection! -} - -extend type TeamInventoryCounts { - """ - Config inventory count for a team. - """ - configs: TeamInventoryCountConfigs! -} - -""" -Config inventory count for a team. -""" -type TeamInventoryCountConfigs { - """ - Total number of configs. - """ - total: Int! -} - -input ConfigValueInput { - "The name of the config value." - name: String! - - "The value to set." - value: String! -} - -input CreateConfigInput { - "The name of the config." - name: String! - - "The environment the config exists in." - environmentName: String! - - "The team that owns the config." - teamSlug: Slug! -} - -input AddConfigValueInput { - "The name of the config." - name: String! - - "The environment the config exists in." - environmentName: String! - - "The team that owns the config." - teamSlug: Slug! - - "The config value to add." - value: ConfigValueInput! -} - -input UpdateConfigValueInput { - "The name of the config." - name: String! - - "The environment the config exists in." - environmentName: String! - - "The team that owns the config." - teamSlug: Slug! - - "The config value to update." - value: ConfigValueInput! -} - -input RemoveConfigValueInput { - "The name of the config." - configName: String! - - "The environment the config exists in." - environmentName: String! - - "The team that owns the config." - teamSlug: Slug! - - "The config value to remove." - valueName: String! -} - -input DeleteConfigInput { - "The name of the config." - name: String! - - "The environment the config exists in." - environmentName: String! - - "The team that owns the config." - teamSlug: Slug! -} - -type CreateConfigPayload { - "The created config." - config: Config -} - -input ConfigOrder { - "The field to order items by." - field: ConfigOrderField! - - "The direction to order items by." - direction: OrderDirection! -} - -enum ConfigOrderField { - "Order configs by name." - NAME - - "Order configs by the name of the environment." - ENVIRONMENT - - "Order configs by the last time it was modified." - LAST_MODIFIED_AT -} - -type AddConfigValuePayload { - "The updated config." - config: Config -} - -type UpdateConfigValuePayload { - "The updated config." - config: Config -} - -type RemoveConfigValuePayload { - "The updated config." - config: Config -} - -type DeleteConfigPayload { - "The deleted config." - configDeleted: Boolean -} - -type ConfigConnection { - "Pagination information." - pageInfo: PageInfo! - - "List of nodes." - nodes: [Config!]! - - "List of edges." - edges: [ConfigEdge!]! -} - -type ConfigEdge { - "Cursor for this edge that can be used for pagination." - cursor: Cursor! - - "The Config." - node: Config! -} - -type ConfigValue { - "The name of the config value." - name: String! - - "The config value itself." - value: String! -} - -extend enum ActivityLogEntryResourceType { - "All activity log entries related to configs will use this resource type." - CONFIG -} - -type ConfigCreatedActivityLogEntry implements ActivityLogEntry & Node { - "ID of the entry." - id: ID! - - "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." - actor: String! - - "Creation time of the entry." - createdAt: Time! - - "Message that summarizes the entry." - message: String! - - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! - - "Name of the resource that was affected by the action." - resourceName: String! - - "The team slug that the entry belongs to." - teamSlug: Slug! - - "The environment name that the entry belongs to." - environmentName: String -} - -type ConfigUpdatedActivityLogEntry implements ActivityLogEntry & Node { - "ID of the entry." - id: ID! - - "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." - actor: String! - - "Creation time of the entry." - createdAt: Time! - - "Message that summarizes the entry." - message: String! - - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! - - "Name of the resource that was affected by the action." - resourceName: String! - - "The team slug that the entry belongs to." - teamSlug: Slug! - - "The environment name that the entry belongs to." - environmentName: String - - "Data associated with the entry." - data: ConfigUpdatedActivityLogEntryData! -} - -type ConfigUpdatedActivityLogEntryDataUpdatedField { - "The name of the field that was updated." - field: String! - - "The old value of the field." - oldValue: String - - "The new value of the field." - newValue: String -} - -type ConfigUpdatedActivityLogEntryData { - "The fields that were updated." - updatedFields: [ConfigUpdatedActivityLogEntryDataUpdatedField!]! -} - -type ConfigDeletedActivityLogEntry implements ActivityLogEntry & Node { - "ID of the entry." - id: ID! - - "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." - actor: String! - - "Creation time of the entry." - createdAt: Time! - - "Message that summarizes the entry." - message: String! - - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! - - "Name of the resource that was affected by the action." - resourceName: String! - - "The team slug that the entry belongs to." - teamSlug: Slug! - - "The environment name that the entry belongs to." - environmentName: String -} - -extend enum ActivityLogActivityType { - "Config was created." - CONFIG_CREATED - "Config was updated." - CONFIG_UPDATED - "Config was deleted." - CONFIG_DELETED -} `, BuiltIn: false}, {Name: "../schema/cost.graphqls", Input: `extend type Team { "The cost for the team." @@ -20940,7 +19794,7 @@ type JobCreatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the creation." - data: ApplyActivityLogEntryData! + data: ResourceActivityLogEntryData! } type JobUpdatedActivityLogEntry implements ActivityLogEntry & Node { @@ -20969,7 +19823,7 @@ type JobUpdatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the update." - data: ApplyActivityLogEntryData! + data: ResourceActivityLogEntryData! } extend enum ActivityLogActivityType { diff --git a/internal/graph/gengql/schema.generated.go b/internal/graph/gengql/schema.generated.go index 5ee061ef2..8c9badb85 100644 --- a/internal/graph/gengql/schema.generated.go +++ b/internal/graph/gengql/schema.generated.go @@ -10,7 +10,7 @@ import ( "sync/atomic" "github.com/99designs/gqlgen/graphql" - activitylog1 "github.com/nais/api/internal/activitylog" + "github.com/nais/api/internal/activitylog" "github.com/nais/api/internal/alerts" "github.com/nais/api/internal/auth/authz" "github.com/nais/api/internal/cost" @@ -40,7 +40,7 @@ import ( "github.com/nais/api/internal/search" "github.com/nais/api/internal/serviceaccount" "github.com/nais/api/internal/servicemaintenance" - "github.com/nais/api/internal/servicemaintenance/activitylog" + activitylog1 "github.com/nais/api/internal/servicemaintenance/activitylog" "github.com/nais/api/internal/slug" "github.com/nais/api/internal/team" "github.com/nais/api/internal/unleash" @@ -5574,6 +5574,13 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._UserCreatedUserSyncLogEntry(ctx, sel, obj) + case activitylog.UnsupportedResourceActivityLogEntry: + return ec._UnsupportedResourceActivityLogEntry(ctx, sel, &obj) + case *activitylog.UnsupportedResourceActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._UnsupportedResourceActivityLogEntry(ctx, sel, obj) case issue.UnleashReleaseChannelIssue: return ec._UnleashReleaseChannelIssue(ctx, sel, &obj) case *issue.UnleashReleaseChannelIssue: @@ -5700,9 +5707,9 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._SqlDatabase(ctx, sel, obj) - case activitylog.ServiceMaintenanceActivityLogEntry: + case activitylog1.ServiceMaintenanceActivityLogEntry: return ec._ServiceMaintenanceActivityLogEntry(ctx, sel, &obj) - case *activitylog.ServiceMaintenanceActivityLogEntry: + case *activitylog1.ServiceMaintenanceActivityLogEntry: if obj == nil { return graphql.Null } @@ -6332,7 +6339,7 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._Alert(ctx, sel, obj) - case activitylog1.ActivityLogEntry: + case activitylog.ActivityLogEntry: if obj == nil { return graphql.Null } diff --git a/internal/graph/schema/applications.graphqls b/internal/graph/schema/applications.graphqls index 099926d69..7338a0290 100644 --- a/internal/graph/schema/applications.graphqls +++ b/internal/graph/schema/applications.graphqls @@ -743,7 +743,7 @@ type ApplicationCreatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the creation." - data: ApplyActivityLogEntryData! + data: ResourceActivityLogEntryData! } type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { @@ -772,7 +772,7 @@ type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the update." - data: ApplyActivityLogEntryData! + data: ResourceActivityLogEntryData! } extend enum ActivityLogActivityType { diff --git a/internal/graph/schema/apply.graphqls b/internal/graph/schema/apply.graphqls index 6ac27a617..017c6007e 100644 --- a/internal/graph/schema/apply.graphqls +++ b/internal/graph/schema/apply.graphqls @@ -9,19 +9,19 @@ extend enum ActivityLogActivityType { """ Additional data associated with a resource created or updated via apply. """ -type ApplyActivityLogEntryData { +type ResourceActivityLogEntryData { "The apiVersion of the applied resource." apiVersion: String! "The kind of the applied resource." kind: String! "The fields that changed during the apply. Only populated for updates." - changedFields: [ApplyChangedField!]! + changedFields: [ResourceChangedField!]! } """ A single field that changed during an apply operation. """ -type ApplyChangedField { +type ResourceChangedField { "The dot-separated path to the changed field, e.g. 'spec.replicas'." field: String! "The value before the apply. Null if the field was added." @@ -29,3 +29,36 @@ type ApplyChangedField { "The value after the apply. Null if the field was removed." newValue: String } + +""" +Activity log entry for a resource kind that is not modelled in the GraphQL API. +The resource type will be the uppercase Kubernetes kind, e.g. 'NAISJOB'. +""" +type UnsupportedResourceActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the apply operation." + data: ResourceActivityLogEntryData! +} diff --git a/internal/graph/schema/jobs.graphqls b/internal/graph/schema/jobs.graphqls index 0244c6e85..e597ae4f2 100644 --- a/internal/graph/schema/jobs.graphqls +++ b/internal/graph/schema/jobs.graphqls @@ -538,7 +538,7 @@ type JobCreatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the creation." - data: ApplyActivityLogEntryData! + data: ResourceActivityLogEntryData! } type JobUpdatedActivityLogEntry implements ActivityLogEntry & Node { @@ -567,7 +567,7 @@ type JobUpdatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the update." - data: ApplyActivityLogEntryData! + data: ResourceActivityLogEntryData! } extend enum ActivityLogActivityType { diff --git a/internal/integration/manager.go b/internal/integration/manager.go index 35761c06c..b371f8da1 100644 --- a/internal/integration/manager.go +++ b/internal/integration/manager.go @@ -206,9 +206,12 @@ func newManager(_ context.Context, container *postgres.PostgresContainer, connSt } } +const testPreSharedKey = "test-pre-shared-key" + func newRestRunner(ctx context.Context, pool *pgxpool.Pool, clusterConfig kubernetes.ClusterConfigMap, k8sRunner *apiRunner.K8s, logger logrus.FieldLogger) (spec.Runner, error) { router := rest.MakeRouter(ctx, rest.Config{ Pool: pool, + PreSharedKey: testPreSharedKey, ClusterConfigs: clusterConfig, DynamicClientFactory: func(_ context.Context, cluster string) (dynamic.Interface, error) { return k8sRunner.DynamicClient(cluster) diff --git a/internal/rest/rest.go b/internal/rest/rest.go index 61edc3af6..77f07d973 100644 --- a/internal/rest/rest.go +++ b/internal/rest/rest.go @@ -84,11 +84,6 @@ func MakeRouter(ctx context.Context, cfg Config) *chi.Mux { r.Use(middleware.PreSharedKeyAuthentication(cfg.PreSharedKey)) r.Get("/teams/{teamSlug}", restteamsapi.TeamsApiHandler(ctx, cfg.Pool, cfg.Log)) }) - } else { - // In test mode there is no pre-shared key; mount without auth. - router.Group(func(r chi.Router) { - r.Get("/teams/{teamSlug}", restteamsapi.TeamsApiHandler(ctx, cfg.Pool, cfg.Log)) - }) } // Apply route with user authentication. @@ -123,7 +118,7 @@ func MakeRouter(ctx context.Context, cfg Config) *chi.Mux { clientFactory = apply.NewImpersonatingClientFactory(cfg.ClusterConfigs) } - r.Post("/api/v1/apply", apply.Handler(cfg.ClusterConfigs, clientFactory, cfg.Log)) + r.Post("/api/v1/teams/{teamSlug}/environments/{environment}/apply", apply.Handler(cfg.ClusterConfigs, clientFactory, cfg.Log)) }) } diff --git a/internal/workload/application/activitylog.go b/internal/workload/application/activitylog.go index aa04fee40..a2ce34096 100644 --- a/internal/workload/application/activitylog.go +++ b/internal/workload/application/activitylog.go @@ -4,7 +4,6 @@ import ( "fmt" "github.com/nais/api/internal/activitylog" - "github.com/nais/api/internal/apply" "github.com/nais/api/internal/deployment/deploymentactivity" ) @@ -16,6 +15,7 @@ const ( ) func init() { + activitylog.RegisterKindResourceType("Application", ActivityLogEntryResourceTypeApplication) activitylog.RegisterTransformer(ActivityLogEntryResourceTypeApplication, func(entry activitylog.GenericActivityLogEntry) (activitylog.ActivityLogEntry, error) { switch entry.Action { case activityLogEntryActionRestartApplication: @@ -57,7 +57,7 @@ func init() { Data: data, }, nil case activitylog.ActivityLogEntryActionCreated: - data, err := activitylog.UnmarshalData[apply.ApplyActivityLogEntryData](entry) + data, err := activitylog.UnmarshalData[activitylog.ResourceActivityLogEntryData](entry) if err != nil { return nil, fmt.Errorf("transforming application created activity log entry data: %w", err) } @@ -66,7 +66,7 @@ func init() { Data: data, }, nil case activitylog.ActivityLogEntryActionUpdated: - data, err := activitylog.UnmarshalData[apply.ApplyActivityLogEntryData](entry) + data, err := activitylog.UnmarshalData[activitylog.ResourceActivityLogEntryData](entry) if err != nil { return nil, fmt.Errorf("transforming application updated activity log entry data: %w", err) } @@ -109,11 +109,11 @@ type ApplicationScaledActivityLogEntryData struct { type ApplicationCreatedActivityLogEntry struct { activitylog.GenericActivityLogEntry - Data *apply.ApplyActivityLogEntryData `json:"data"` + Data *activitylog.ResourceActivityLogEntryData `json:"data"` } type ApplicationUpdatedActivityLogEntry struct { activitylog.GenericActivityLogEntry - Data *apply.ApplyActivityLogEntryData `json:"data"` + Data *activitylog.ResourceActivityLogEntryData `json:"data"` } diff --git a/internal/workload/job/activitylog.go b/internal/workload/job/activitylog.go index 4854bd60f..c18cc170f 100644 --- a/internal/workload/job/activitylog.go +++ b/internal/workload/job/activitylog.go @@ -4,7 +4,6 @@ import ( "fmt" "github.com/nais/api/internal/activitylog" - "github.com/nais/api/internal/apply" "github.com/nais/api/internal/deployment/deploymentactivity" ) @@ -15,6 +14,7 @@ const ( ) func init() { + activitylog.RegisterKindResourceType("Naisjob", ActivityLogEntryResourceTypeJob) activitylog.RegisterTransformer(ActivityLogEntryResourceTypeJob, func(entry activitylog.GenericActivityLogEntry) (activitylog.ActivityLogEntry, error) { switch entry.Action { case activityLogEntryActionTriggerJob: @@ -54,7 +54,7 @@ func init() { Data: data, }, nil case activitylog.ActivityLogEntryActionCreated: - data, err := activitylog.UnmarshalData[apply.ApplyActivityLogEntryData](entry) + data, err := activitylog.UnmarshalData[activitylog.ResourceActivityLogEntryData](entry) if err != nil { return nil, fmt.Errorf("transforming job created activity log entry data: %w", err) } @@ -63,7 +63,7 @@ func init() { Data: data, }, nil case activitylog.ActivityLogEntryActionUpdated: - data, err := activitylog.UnmarshalData[apply.ApplyActivityLogEntryData](entry) + data, err := activitylog.UnmarshalData[activitylog.ResourceActivityLogEntryData](entry) if err != nil { return nil, fmt.Errorf("transforming job updated activity log entry data: %w", err) } @@ -104,11 +104,11 @@ type JobRunDeletedActivityLogEntry struct { type JobCreatedActivityLogEntry struct { activitylog.GenericActivityLogEntry - Data *apply.ApplyActivityLogEntryData `json:"data"` + Data *activitylog.ResourceActivityLogEntryData `json:"data"` } type JobUpdatedActivityLogEntry struct { activitylog.GenericActivityLogEntry - Data *apply.ApplyActivityLogEntryData `json:"data"` + Data *activitylog.ResourceActivityLogEntryData `json:"data"` } From f5434ff6405cdd449e0cfae6d3230520a28c9585 Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Thu, 12 Mar 2026 13:17:49 +0100 Subject: [PATCH 06/25] Consolidate context setup --- internal/cmd/api/api.go | 61 +++++++++++++++++++-------------- internal/cmd/api/http.go | 49 ++------------------------ internal/integration/manager.go | 27 ++++++++------- internal/rest/rest.go | 40 +++++++-------------- 4 files changed, 64 insertions(+), 113 deletions(-) diff --git a/internal/cmd/api/api.go b/internal/cmd/api/api.go index 960ffe43a..025b450d7 100644 --- a/internal/cmd/api/api.go +++ b/internal/cmd/api/api.go @@ -285,34 +285,44 @@ func run(ctx context.Context, cfg *Config, log logrus.FieldLogger) error { return fmt.Errorf("create loki client: %w", err) } + contextDependencies, err := ConfigureGraph( + ctx, + cfg.Fakes, + watchers, + watcherMgr, + pool, + clusterConfig, + serviceMaintenanceManager, + aivenClient, + cfg.Aiven.Projects, + vulnMgr, + cfg.Tenant, + cfg.K8s.AllClusterNames(), + hookdClient, + cfg.Unleash.BifrostAPIURL, + cfg.K8s.AllClusterNames(), + cfg.Logging.DefaultLogDestinations(), + notifier, + lokiClient, + cfg.AuditLog.ProjectID, + cfg.AuditLog.Location, + log.WithField("subsystem", "http"), + ) + if err != nil { + return fmt.Errorf("configure graph: %w", err) + } + // HTTP server wg.Go(func() error { return runHTTPServer( ctx, cfg.Fakes, cfg.ListenAddress, - cfg.Tenant, - cfg.K8s.AllClusterNames(), - pool, - clusterConfig, - watchers, - watcherMgr, - mgmtWatcher, + jwtMiddleware, authHandler, graphHandler, - serviceMaintenanceManager, - aivenClient, - cfg.Aiven.Projects, - vulnMgr, - hookdClient, - cfg.Unleash.BifrostAPIURL, - cfg.K8s.AllClusterNames(), - cfg.Logging.DefaultLogDestinations(), - notifier, - lokiClient, - cfg.AuditLog.ProjectID, - cfg.AuditLog.Location, + contextDependencies, log.WithField("subsystem", "http"), ) }) @@ -328,12 +338,13 @@ func run(ctx context.Context, cfg *Config, log logrus.FieldLogger) error { wg.Go(func() error { return restserver.Run(ctx, restserver.Config{ - ListenAddress: cfg.RestListenAddress, - Pool: pool, - PreSharedKey: cfg.RestPreSharedKey, - ClusterConfigs: clusterConfig, - JWTMiddleware: jwtMiddleware, - AuthHandler: authHandler, + ListenAddress: cfg.RestListenAddress, + Pool: pool, + PreSharedKey: cfg.RestPreSharedKey, + ClusterConfigs: clusterConfig, + ContextMiddleware: contextDependencies, + JWTMiddleware: jwtMiddleware, + AuthHandler: authHandler, Fakes: restserver.Fakes{ WithInsecureUserHeader: cfg.Fakes.WithInsecureUserHeader, }, diff --git a/internal/cmd/api/http.go b/internal/cmd/api/http.go index 518ad48d9..3fa4e39d9 100644 --- a/internal/cmd/api/http.go +++ b/internal/cmd/api/http.go @@ -76,28 +76,11 @@ func runHTTPServer( ctx context.Context, fakes Fakes, listenAddress string, - tenantName string, - clusters []string, - pool *pgxpool.Pool, - k8sClients apik8s.ClusterConfigMap, - watchers *watchers.Watchers, - watcherMgr *watcher.Manager, - mgmtWatcherMgr *watcher.Manager, + jwtMiddleware func(http.Handler) http.Handler, authHandler authn.Handler, graphHandler *handler.Server, - serviceMaintenanceManager *servicemaintenance.Manager, - aivenClient aiven.AivenClient, - aivenProjects aiven.Projects, - vulnMgr *vulnerability.Manager, - hookdClient hookd.Client, - bifrostAPIURL string, - allowedClusters []string, - defaultLogDestinations []logging.SupportedLogDestination, - notifier *notify.Notifier, - lokiClient loki.Client, - auditLogProjectID string, - auditLogLocation string, + contextDependencies func(http.Handler) http.Handler, log logrus.FieldLogger, ) error { router := chi.NewRouter() @@ -105,34 +88,6 @@ func runHTTPServer( otelhttp.NewHandler(playground.Handler("GraphQL playground", "/graphql"), "playground"), ) - contextDependencies, err := ConfigureGraph( - ctx, - fakes, - watchers, - watcherMgr, - mgmtWatcherMgr, - pool, - k8sClients, - serviceMaintenanceManager, - aivenClient, - aivenProjects, - vulnMgr, - tenantName, - clusters, - hookdClient, - bifrostAPIURL, - allowedClusters, - defaultLogDestinations, - notifier, - lokiClient, - auditLogProjectID, - auditLogLocation, - log, - ) - if err != nil { - return err - } - router.Route("/graphql", func(r chi.Router) { middlewares := []func(http.Handler) http.Handler{ contextDependencies, diff --git a/internal/integration/manager.go b/internal/integration/manager.go index b371f8da1..d5514fada 100644 --- a/internal/integration/manager.go +++ b/internal/integration/manager.go @@ -150,13 +150,13 @@ func newManager(_ context.Context, container *postgres.PostgresContainer, connSt return ctx, nil, nil, err } - gqlRunner, gqlCleanup, err := newGQLRunner(ctx, config, pool, topic, watchers, watcherMgr, clusterConfig, fakeAivenClient, lokiClient) + gqlRunner, gqlCleanup, contextDependencies, err := newGQLRunner(ctx, config, pool, topic, watchers, watcherMgr, clusterConfig, fakeAivenClient, lokiClient) if err != nil { done() return ctx, nil, nil, err } - restRunner, err := newRestRunner(ctx, pool, clusterConfig, k8sRunner, log) + restRunner, err := newRestRunner(ctx, pool, clusterConfig, k8sRunner, contextDependencies, log) if err != nil { done() return ctx, nil, nil, err @@ -208,11 +208,12 @@ func newManager(_ context.Context, container *postgres.PostgresContainer, connSt const testPreSharedKey = "test-pre-shared-key" -func newRestRunner(ctx context.Context, pool *pgxpool.Pool, clusterConfig kubernetes.ClusterConfigMap, k8sRunner *apiRunner.K8s, logger logrus.FieldLogger) (spec.Runner, error) { +func newRestRunner(ctx context.Context, pool *pgxpool.Pool, clusterConfig kubernetes.ClusterConfigMap, k8sRunner *apiRunner.K8s, contextDependencies func(http.Handler) http.Handler, logger logrus.FieldLogger) (spec.Runner, error) { router := rest.MakeRouter(ctx, rest.Config{ - Pool: pool, - PreSharedKey: testPreSharedKey, - ClusterConfigs: clusterConfig, + Pool: pool, + PreSharedKey: testPreSharedKey, + ClusterConfigs: clusterConfig, + ContextMiddleware: contextDependencies, DynamicClientFactory: func(_ context.Context, cluster string) (dynamic.Interface, error) { return k8sRunner.DynamicClient(cluster) }, @@ -233,25 +234,25 @@ func newGQLRunner( clusterConfig kubernetes.ClusterConfigMap, fakeAivenClient *aiven.FakeAivenClient, lokiClient loki.Client, -) (spec.Runner, func(), error) { +) (spec.Runner, func(), func(http.Handler) http.Handler, error) { log := logrus.New() log.Out = io.Discard smMgr, err := servicemaintenance.NewManager(ctx, fakeAivenClient, log.WithField("subsystem", "service_maintenance")) if err != nil { - return nil, nil, err + return nil, nil, nil, err } vMgr, err := vulnerability.NewFakeManager(ctx, log.WithField("subsystem", "vulnerability")) if err != nil { - return nil, nil, err + return nil, nil, nil, err } notifierCtx, notifyCancel := context.WithCancel(ctx) notifier := notify.New(pool, log, notify.WithRetries(0)) go notifier.Run(notifierCtx) - graphMiddleware, err := api.ConfigureGraph( + contextDependencies, err := api.ConfigureGraph( ctx, api.Fakes{ WithFakeKubernetes: true, @@ -292,7 +293,7 @@ func newGQLRunner( ) if err != nil { notifyCancel() - return nil, nil, fmt.Errorf("failed to configure graph: %w", err) + return nil, nil, nil, fmt.Errorf("failed to configure graph: %w", err) } resolver := graph.NewResolver(topic) @@ -302,7 +303,7 @@ func newGQLRunner( Resolvers: resolver, }, hlog) if err != nil { - panic(fmt.Sprintf("failed to create graph handler: %s", err)) + return nil, nil, nil, fmt.Errorf("failed to create graph handler: %w", err) } authProxy := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { @@ -330,7 +331,7 @@ func newGQLRunner( middleware.ApiKeyAuthentication()(middleware.RequireAuthenticatedUser()(srv)).ServeHTTP(w, r) }) - return runner.NewGQLRunner(graphMiddleware(authProxy)), notifyCancel, nil + return runner.NewGQLRunner(contextDependencies(authProxy)), notifyCancel, contextDependencies, nil } func startPostgresql(ctx context.Context) (*postgres.PostgresContainer, string, error) { diff --git a/internal/rest/rest.go b/internal/rest/rest.go index 77f07d973..e2bf7d393 100644 --- a/internal/rest/rest.go +++ b/internal/rest/rest.go @@ -8,17 +8,11 @@ import ( "github.com/go-chi/chi/v5" "github.com/jackc/pgx/v5/pgxpool" - "github.com/nais/api/internal/activitylog" "github.com/nais/api/internal/apply" "github.com/nais/api/internal/auth/authn" - "github.com/nais/api/internal/auth/authz" "github.com/nais/api/internal/auth/middleware" - "github.com/nais/api/internal/database" - "github.com/nais/api/internal/graph/loader" "github.com/nais/api/internal/kubernetes" "github.com/nais/api/internal/rest/restteamsapi" - "github.com/nais/api/internal/serviceaccount" - "github.com/nais/api/internal/user" "github.com/sirupsen/logrus" "golang.org/x/sync/errgroup" ) @@ -35,10 +29,15 @@ type Config struct { PreSharedKey string ClusterConfigs kubernetes.ClusterConfigMap DynamicClientFactory apply.DynamicClientFactory - JWTMiddleware func(http.Handler) http.Handler - AuthHandler authn.Handler - Fakes Fakes - Log logrus.FieldLogger + // ContextMiddleware sets up the request context with all loaders and + // dependencies needed by the apply handler (authz, activitylog, etc.). + // In production this is the middleware returned by ConfigureGraph. + // In tests a minimal equivalent can be provided. + ContextMiddleware func(http.Handler) http.Handler + JWTMiddleware func(http.Handler) http.Handler + AuthHandler authn.Handler + Fakes Fakes + Log logrus.FieldLogger } func Run(ctx context.Context, cfg Config) error { @@ -89,8 +88,9 @@ func MakeRouter(ctx context.Context, cfg Config) *chi.Mux { // Apply route with user authentication. if cfg.ClusterConfigs != nil { router.Group(func(r chi.Router) { - // Context dependencies needed by authz and activitylog. - r.Use(applyContextDependencies(cfg.Pool)) + if cfg.ContextMiddleware != nil { + r.Use(cfg.ContextMiddleware) + } if cfg.Fakes.WithInsecureUserHeader { r.Use(middleware.InsecureUserHeader()) @@ -124,19 +124,3 @@ func MakeRouter(ctx context.Context, cfg Config) *chi.Mux { return router } - -// applyContextDependencies returns a middleware that sets up the context with -// DB-backed loaders needed by the apply handler: database, authz, and activitylog. -// This is a minimal subset of what ConfigureGraph sets up — only what the apply -// handler actually needs. -func applyContextDependencies(pool *pgxpool.Pool) func(http.Handler) http.Handler { - setupContext := func(ctx context.Context) context.Context { - ctx = database.NewLoaderContext(ctx, pool) - ctx = user.NewLoaderContext(ctx, pool) - ctx = serviceaccount.NewLoaderContext(ctx, pool) - ctx = authz.NewLoaderContext(ctx, pool) - ctx = activitylog.NewLoaderContext(ctx, pool) - return ctx - } - return loader.Middleware(setupContext) -} From 836f92e75aad7532e287b01e835fef4b803cf864 Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Fri, 13 Mar 2026 11:01:41 +0100 Subject: [PATCH 07/25] Rename activitylog for k8s types Fix environment name field --- integration_tests/apply.lua | 8 +- internal/activitylog/resource.go | 6 +- internal/apply/apply.go | 56 +-- internal/apply/model.go | 4 +- .../graph/gengql/activitylog.generated.go | 14 +- internal/graph/gengql/apply.generated.go | 358 +++++++++--------- internal/graph/gengql/root_.generated.go | 152 ++++---- internal/graph/gengql/schema.generated.go | 24 +- internal/graph/schema/apply.graphqls | 2 +- 9 files changed, 312 insertions(+), 312 deletions(-) diff --git a/integration_tests/apply.lua b/integration_tests/apply.lua index 70ea15a1a..673712676 100644 --- a/integration_tests/apply.lua +++ b/integration_tests/apply.lua @@ -33,7 +33,7 @@ Test.rest("create application via apply", function(t) results = { { resource = "Application/my-app", - environment = "dev", + environmentName = "dev", status = "created", }, }, @@ -87,7 +87,7 @@ Test.rest("update application via apply", function(t) results = { { resource = "Application/my-app", - environment = "dev", + environmentName = "dev", status = "applied", changedFields = { { @@ -178,7 +178,7 @@ Test.rest("non-member gets authorization error", function(t) results = { { resource = "Application/sneaky-app", - environment = "dev", + environmentName = "dev", status = "error", error = Contains("authorization failed"), }, @@ -226,7 +226,7 @@ Test.rest("create naisjob via apply", function(t) results = { { resource = "Naisjob/my-job", - environment = "dev", + environmentName = "dev", status = "created", }, }, diff --git a/internal/activitylog/resource.go b/internal/activitylog/resource.go index 88f6f2d13..f7fd624a0 100644 --- a/internal/activitylog/resource.go +++ b/internal/activitylog/resource.go @@ -68,10 +68,10 @@ type ResourceActivityLogEntryData struct { ChangedFields []ResourceChangedField `json:"changedFields"` } -// UnsupportedResourceActivityLogEntry is used for resource types that do not have +// GenericKubernetesActivityLogEntry is used for resource types that do not have // a dedicated transformer registered — i.e. kinds that are not modelled in the // GraphQL API. The uppercase Kind string is used directly as the resource type. -type UnsupportedResourceActivityLogEntry struct { +type GenericKubernetesResourceActivityLogEntry struct { GenericActivityLogEntry Data *ResourceActivityLogEntryData `json:"data"` @@ -95,7 +95,7 @@ func init() { if err != nil { return nil, fmt.Errorf("transforming unsupported resource activity log entry data: %w", err) } - return UnsupportedResourceActivityLogEntry{ + return GenericKubernetesResourceActivityLogEntry{ GenericActivityLogEntry: entry.WithMessage( fmt.Sprintf("%s %s %s", entry.ResourceName, entry.Action, entry.ResourceType), ), diff --git a/internal/apply/apply.go b/internal/apply/apply.go index 79de49654..1deb345f0 100644 --- a/internal/apply/apply.go +++ b/internal/apply/apply.go @@ -123,30 +123,30 @@ func applyOne( // Validate environment exists. if _, ok := clusterConfigs[environment]; !ok { return ResourceResult{ - Resource: resourceID, - Environment: environment, - Status: StatusError, - Error: fmt.Sprintf("unknown environment: %q", environment), + Resource: resourceID, + EnvironmentName: environment, + Status: StatusError, + Error: fmt.Sprintf("unknown environment: %q", environment), } } // Validate resource has a name. if name == "" { return ResourceResult{ - Resource: resourceID, - Environment: environment, - Status: StatusError, - Error: "resource must have metadata.name", + Resource: resourceID, + EnvironmentName: environment, + Status: StatusError, + Error: "resource must have metadata.name", } } // Authorize the actor for this team and kind. if err := authorizeResource(ctx, kind, teamSlug); err != nil { return ResourceResult{ - Resource: resourceID, - Environment: environment, - Status: StatusError, - Error: fmt.Sprintf("authorization failed: %s", err), + Resource: resourceID, + EnvironmentName: environment, + Status: StatusError, + Error: fmt.Sprintf("authorization failed: %s", err), } } @@ -154,10 +154,10 @@ func applyOne( gvr, ok := GVRFor(apiVersion, kind) if !ok { return ResourceResult{ - Resource: resourceID, - Environment: environment, - Status: StatusError, - Error: fmt.Sprintf("no GVR mapping for %s/%s", apiVersion, kind), + Resource: resourceID, + EnvironmentName: environment, + Status: StatusError, + Error: fmt.Sprintf("no GVR mapping for %s/%s", apiVersion, kind), } } @@ -169,10 +169,10 @@ func applyOne( if err != nil { log.WithError(err).Error("creating dynamic client") return ResourceResult{ - Resource: resourceID, - Environment: environment, - Status: StatusError, - Error: fmt.Sprintf("failed to create client for environment %q: %s", environment, err), + Resource: resourceID, + EnvironmentName: environment, + Status: StatusError, + Error: fmt.Sprintf("failed to create client for environment %q: %s", environment, err), } } @@ -181,10 +181,10 @@ func applyOne( if err != nil { log.WithError(err).Error("applying resource") return ResourceResult{ - Resource: resourceID, - Environment: environment, - Status: StatusError, - Error: fmt.Sprintf("apply failed: %s", err), + Resource: resourceID, + EnvironmentName: environment, + Status: StatusError, + Error: fmt.Sprintf("apply failed: %s", err), } } @@ -221,10 +221,10 @@ func applyOne( } return ResourceResult{ - Resource: resourceID, - Environment: environment, - Status: status, - ChangedFields: changes, + Resource: resourceID, + EnvironmentName: environment, + Status: status, + ChangedFields: changes, } } diff --git a/internal/apply/model.go b/internal/apply/model.go index 8047fbe63..be98704be 100644 --- a/internal/apply/model.go +++ b/internal/apply/model.go @@ -12,8 +12,8 @@ type ResourceResult struct { // Resource is a human-readable identifier for the resource, e.g. "Application/my-app". Resource string `json:"resource"` - // Environment is the target environment the resource was applied to. - Environment string `json:"environment"` + // EnvironmentName is the target environment the resource was applied to. + EnvironmentName string `json:"environmentName"` // Status is one of "created", "applied", or "error". Status string `json:"status"` diff --git a/internal/graph/gengql/activitylog.generated.go b/internal/graph/gengql/activitylog.generated.go index d8adbed27..1ea424fc5 100644 --- a/internal/graph/gengql/activitylog.generated.go +++ b/internal/graph/gengql/activitylog.generated.go @@ -280,13 +280,6 @@ func (ec *executionContext) _ActivityLogEntry(ctx context.Context, sel ast.Selec return graphql.Null } return ec._ValkeyCreatedActivityLogEntry(ctx, sel, obj) - case activitylog.UnsupportedResourceActivityLogEntry: - return ec._UnsupportedResourceActivityLogEntry(ctx, sel, &obj) - case *activitylog.UnsupportedResourceActivityLogEntry: - if obj == nil { - return graphql.Null - } - return ec._UnsupportedResourceActivityLogEntry(ctx, sel, obj) case unleash.UnleashInstanceUpdatedActivityLogEntry: return ec._UnleashInstanceUpdatedActivityLogEntry(ctx, sel, &obj) case *unleash.UnleashInstanceUpdatedActivityLogEntry: @@ -574,6 +567,13 @@ func (ec *executionContext) _ActivityLogEntry(ctx context.Context, sel ast.Selec return graphql.Null } return ec._JobCreatedActivityLogEntry(ctx, sel, obj) + case activitylog.GenericKubernetesResourceActivityLogEntry: + return ec._GenericKubernetesResourceActivityLogEntry(ctx, sel, &obj) + case *activitylog.GenericKubernetesResourceActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._GenericKubernetesResourceActivityLogEntry(ctx, sel, obj) case deploymentactivity.DeploymentActivityLogEntry: return ec._DeploymentActivityLogEntry(ctx, sel, &obj) case *deploymentactivity.DeploymentActivityLogEntry: diff --git a/internal/graph/gengql/apply.generated.go b/internal/graph/gengql/apply.generated.go index 216ae75a9..7c2c695a3 100644 --- a/internal/graph/gengql/apply.generated.go +++ b/internal/graph/gengql/apply.generated.go @@ -28,43 +28,43 @@ import ( // region **************************** field.gotpl ***************************** -func (ec *executionContext) _ResourceActivityLogEntryData_apiVersion(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceActivityLogEntryData) (ret graphql.Marshaler) { +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ResourceActivityLogEntryData_apiVersion, + ec.fieldContext_GenericKubernetesResourceActivityLogEntry_id, func(ctx context.Context) (any, error) { - return obj.APIVersion, nil + return obj.ID(), nil }, nil, - ec.marshalNString2string, + ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, true, true, ) } -func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_apiVersion(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ResourceActivityLogEntryData", + Object: "GenericKubernetesResourceActivityLogEntry", Field: field, - IsMethod: false, + IsMethod: true, 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 nil, errors.New("field of type ID does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ResourceActivityLogEntryData_kind(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceActivityLogEntryData) (ret graphql.Marshaler) { +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ResourceActivityLogEntryData_kind, + ec.fieldContext_GenericKubernetesResourceActivityLogEntry_actor, func(ctx context.Context) (any, error) { - return obj.Kind, nil + return obj.Actor, nil }, nil, ec.marshalNString2string, @@ -73,9 +73,9 @@ func (ec *executionContext) _ResourceActivityLogEntryData_kind(ctx context.Conte ) } -func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ResourceActivityLogEntryData", + Object: "GenericKubernetesResourceActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -86,51 +86,43 @@ func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_kind(_ con return fc, nil } -func (ec *executionContext) _ResourceActivityLogEntryData_changedFields(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceActivityLogEntryData) (ret graphql.Marshaler) { +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ResourceActivityLogEntryData_changedFields, + ec.fieldContext_GenericKubernetesResourceActivityLogEntry_createdAt, func(ctx context.Context) (any, error) { - return obj.ChangedFields, nil + return obj.CreatedAt, nil }, nil, - ec.marshalNResourceChangedField2ᚕgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceChangedFieldᚄ, + ec.marshalNTime2timeᚐTime, true, true, ) } -func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_changedFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ResourceActivityLogEntryData", + Object: "GenericKubernetesResourceActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "field": - return ec.fieldContext_ResourceChangedField_field(ctx, field) - case "oldValue": - return ec.fieldContext_ResourceChangedField_oldValue(ctx, field) - case "newValue": - return ec.fieldContext_ResourceChangedField_newValue(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type ResourceChangedField", field.Name) + return nil, errors.New("field of type Time does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ResourceChangedField_field(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceChangedField) (ret graphql.Marshaler) { +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ResourceChangedField_field, + ec.fieldContext_GenericKubernetesResourceActivityLogEntry_message, func(ctx context.Context) (any, error) { - return obj.Field, nil + return obj.Message, nil }, nil, ec.marshalNString2string, @@ -139,9 +131,9 @@ func (ec *executionContext) _ResourceChangedField_field(ctx context.Context, fie ) } -func (ec *executionContext) fieldContext_ResourceChangedField_field(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ResourceChangedField", + Object: "GenericKubernetesResourceActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -152,54 +144,54 @@ func (ec *executionContext) fieldContext_ResourceChangedField_field(_ context.Co return fc, nil } -func (ec *executionContext) _ResourceChangedField_oldValue(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceChangedField) (ret graphql.Marshaler) { +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ResourceChangedField_oldValue, + ec.fieldContext_GenericKubernetesResourceActivityLogEntry_resourceType, func(ctx context.Context) (any, error) { - return obj.OldValue, nil + return obj.ResourceType, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, + true, true, - false, ) } -func (ec *executionContext) fieldContext_ResourceChangedField_oldValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ResourceChangedField", + Object: "GenericKubernetesResourceActivityLogEntry", 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 nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") }, } return fc, nil } -func (ec *executionContext) _ResourceChangedField_newValue(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceChangedField) (ret graphql.Marshaler) { +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ResourceChangedField_newValue, + ec.fieldContext_GenericKubernetesResourceActivityLogEntry_resourceName, func(ctx context.Context) (any, error) { - return obj.NewValue, nil + return obj.ResourceName, nil }, nil, - ec.marshalOString2ᚖstring, + ec.marshalNString2string, + true, true, - false, ) } -func (ec *executionContext) fieldContext_ResourceChangedField_newValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ResourceChangedField", + Object: "GenericKubernetesResourceActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -210,54 +202,54 @@ func (ec *executionContext) fieldContext_ResourceChangedField_newValue(_ context return fc, nil } -func (ec *executionContext) _UnsupportedResourceActivityLogEntry_id(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_UnsupportedResourceActivityLogEntry_id, + ec.fieldContext_GenericKubernetesResourceActivityLogEntry_teamSlug, func(ctx context.Context) (any, error) { - return obj.ID(), nil + return obj.TeamSlug, nil }, nil, - ec.marshalNID2githubᚗcomᚋnaisᚋapiᚋinternalᚋgraphᚋidentᚐIdent, - true, + ec.marshalOSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, true, + false, ) } -func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "UnsupportedResourceActivityLogEntry", + Object: "GenericKubernetesResourceActivityLogEntry", Field: field, - IsMethod: true, + IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type ID does not have child fields") + return nil, errors.New("field of type Slug does not have child fields") }, } return fc, nil } -func (ec *executionContext) _UnsupportedResourceActivityLogEntry_actor(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_UnsupportedResourceActivityLogEntry_actor, + ec.fieldContext_GenericKubernetesResourceActivityLogEntry_environmentName, func(ctx context.Context) (any, error) { - return obj.Actor, nil + return obj.EnvironmentName, nil }, nil, - ec.marshalNString2string, - true, + ec.marshalOString2ᚖstring, true, + false, ) } -func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "UnsupportedResourceActivityLogEntry", + Object: "GenericKubernetesResourceActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, @@ -268,43 +260,51 @@ func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_act return fc, nil } -func (ec *executionContext) _UnsupportedResourceActivityLogEntry_createdAt(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntry_data(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntry) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_UnsupportedResourceActivityLogEntry_createdAt, + ec.fieldContext_GenericKubernetesResourceActivityLogEntry_data, func(ctx context.Context) (any, error) { - return obj.CreatedAt, nil + return obj.Data, nil }, nil, - ec.marshalNTime2timeᚐTime, + ec.marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData, true, true, ) } -func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntry_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "UnsupportedResourceActivityLogEntry", + Object: "GenericKubernetesResourceActivityLogEntry", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + switch field.Name { + case "apiVersion": + return ec.fieldContext_ResourceActivityLogEntryData_apiVersion(ctx, field) + case "kind": + return ec.fieldContext_ResourceActivityLogEntryData_kind(ctx, field) + case "changedFields": + return ec.fieldContext_ResourceActivityLogEntryData_changedFields(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ResourceActivityLogEntryData", field.Name) }, } return fc, nil } -func (ec *executionContext) _UnsupportedResourceActivityLogEntry_message(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _ResourceActivityLogEntryData_apiVersion(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceActivityLogEntryData) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_UnsupportedResourceActivityLogEntry_message, + ec.fieldContext_ResourceActivityLogEntryData_apiVersion, func(ctx context.Context) (any, error) { - return obj.Message, nil + return obj.APIVersion, nil }, nil, ec.marshalNString2string, @@ -313,9 +313,9 @@ func (ec *executionContext) _UnsupportedResourceActivityLogEntry_message(ctx con ) } -func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_apiVersion(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "UnsupportedResourceActivityLogEntry", + Object: "ResourceActivityLogEntryData", Field: field, IsMethod: false, IsResolver: false, @@ -326,101 +326,109 @@ func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_mes return fc, nil } -func (ec *executionContext) _UnsupportedResourceActivityLogEntry_resourceType(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _ResourceActivityLogEntryData_kind(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceActivityLogEntryData) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_UnsupportedResourceActivityLogEntry_resourceType, + ec.fieldContext_ResourceActivityLogEntryData_kind, func(ctx context.Context) (any, error) { - return obj.ResourceType, nil + return obj.Kind, nil }, nil, - ec.marshalNActivityLogEntryResourceType2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐActivityLogEntryResourceType, + ec.marshalNString2string, true, true, ) } -func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_resourceType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "UnsupportedResourceActivityLogEntry", + Object: "ResourceActivityLogEntryData", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type ActivityLogEntryResourceType does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _UnsupportedResourceActivityLogEntry_resourceName(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _ResourceActivityLogEntryData_changedFields(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceActivityLogEntryData) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_UnsupportedResourceActivityLogEntry_resourceName, + ec.fieldContext_ResourceActivityLogEntryData_changedFields, func(ctx context.Context) (any, error) { - return obj.ResourceName, nil + return obj.ChangedFields, nil }, nil, - ec.marshalNString2string, + ec.marshalNResourceChangedField2ᚕgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceChangedFieldᚄ, true, true, ) } -func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_resourceName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_changedFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "UnsupportedResourceActivityLogEntry", + Object: "ResourceActivityLogEntryData", 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") + switch field.Name { + case "field": + return ec.fieldContext_ResourceChangedField_field(ctx, field) + case "oldValue": + return ec.fieldContext_ResourceChangedField_oldValue(ctx, field) + case "newValue": + return ec.fieldContext_ResourceChangedField_newValue(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ResourceChangedField", field.Name) }, } return fc, nil } -func (ec *executionContext) _UnsupportedResourceActivityLogEntry_teamSlug(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _ResourceChangedField_field(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceChangedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_UnsupportedResourceActivityLogEntry_teamSlug, + ec.fieldContext_ResourceChangedField_field, func(ctx context.Context) (any, error) { - return obj.TeamSlug, nil + return obj.Field, nil }, nil, - ec.marshalOSlug2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋslugᚐSlug, + ec.marshalNString2string, + true, true, - false, ) } -func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_teamSlug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ResourceChangedField_field(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "UnsupportedResourceActivityLogEntry", + Object: "ResourceChangedField", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Slug does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _UnsupportedResourceActivityLogEntry_environmentName(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _ResourceChangedField_oldValue(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceChangedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_UnsupportedResourceActivityLogEntry_environmentName, + ec.fieldContext_ResourceChangedField_oldValue, func(ctx context.Context) (any, error) { - return obj.EnvironmentName, nil + return obj.OldValue, nil }, nil, ec.marshalOString2ᚖstring, @@ -429,9 +437,9 @@ func (ec *executionContext) _UnsupportedResourceActivityLogEntry_environmentName ) } -func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_environmentName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ResourceChangedField_oldValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "UnsupportedResourceActivityLogEntry", + Object: "ResourceChangedField", Field: field, IsMethod: false, IsResolver: false, @@ -442,38 +450,30 @@ func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_env return fc, nil } -func (ec *executionContext) _UnsupportedResourceActivityLogEntry_data(ctx context.Context, field graphql.CollectedField, obj *activitylog.UnsupportedResourceActivityLogEntry) (ret graphql.Marshaler) { +func (ec *executionContext) _ResourceChangedField_newValue(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceChangedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_UnsupportedResourceActivityLogEntry_data, + ec.fieldContext_ResourceChangedField_newValue, func(ctx context.Context) (any, error) { - return obj.Data, nil + return obj.NewValue, nil }, nil, - ec.marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData, - true, + ec.marshalOString2ᚖstring, true, + false, ) } -func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_data(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_ResourceChangedField_newValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "UnsupportedResourceActivityLogEntry", + Object: "ResourceChangedField", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "apiVersion": - return ec.fieldContext_ResourceActivityLogEntryData_apiVersion(ctx, field) - case "kind": - return ec.fieldContext_ResourceActivityLogEntryData_kind(ctx, field) - case "changedFields": - return ec.fieldContext_ResourceActivityLogEntryData_changedFields(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type ResourceActivityLogEntryData", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil @@ -491,29 +491,53 @@ func (ec *executionContext) fieldContext_UnsupportedResourceActivityLogEntry_dat // region **************************** object.gotpl **************************** -var resourceActivityLogEntryDataImplementors = []string{"ResourceActivityLogEntryData"} +var genericKubernetesResourceActivityLogEntryImplementors = []string{"GenericKubernetesResourceActivityLogEntry", "ActivityLogEntry", "Node"} -func (ec *executionContext) _ResourceActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, obj *activitylog.ResourceActivityLogEntryData) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, resourceActivityLogEntryDataImplementors) +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *activitylog.GenericKubernetesResourceActivityLogEntry) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, genericKubernetesResourceActivityLogEntryImplementors) 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("ResourceActivityLogEntryData") - case "apiVersion": - out.Values[i] = ec._ResourceActivityLogEntryData_apiVersion(ctx, field, obj) + out.Values[i] = graphql.MarshalString("GenericKubernetesResourceActivityLogEntry") + case "id": + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntry_id(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "kind": - out.Values[i] = ec._ResourceActivityLogEntryData_kind(ctx, field, obj) + case "actor": + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntry_actor(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "changedFields": - out.Values[i] = ec._ResourceActivityLogEntryData_changedFields(ctx, field, obj) + case "createdAt": + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntry_createdAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "message": + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntry_message(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceType": + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntry_resourceType(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resourceName": + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntry_resourceName(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "teamSlug": + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntry_teamSlug(ctx, field, obj) + case "environmentName": + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntry_environmentName(ctx, field, obj) + case "data": + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntry_data(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -540,26 +564,32 @@ func (ec *executionContext) _ResourceActivityLogEntryData(ctx context.Context, s return out } -var resourceChangedFieldImplementors = []string{"ResourceChangedField"} +var resourceActivityLogEntryDataImplementors = []string{"ResourceActivityLogEntryData"} -func (ec *executionContext) _ResourceChangedField(ctx context.Context, sel ast.SelectionSet, obj *activitylog.ResourceChangedField) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, resourceChangedFieldImplementors) +func (ec *executionContext) _ResourceActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, obj *activitylog.ResourceActivityLogEntryData) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, resourceActivityLogEntryDataImplementors) 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("ResourceChangedField") - case "field": - out.Values[i] = ec._ResourceChangedField_field(ctx, field, obj) + out.Values[i] = graphql.MarshalString("ResourceActivityLogEntryData") + case "apiVersion": + out.Values[i] = ec._ResourceActivityLogEntryData_apiVersion(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "kind": + out.Values[i] = ec._ResourceActivityLogEntryData_kind(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "changedFields": + out.Values[i] = ec._ResourceActivityLogEntryData_changedFields(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "oldValue": - out.Values[i] = ec._ResourceChangedField_oldValue(ctx, field, obj) - case "newValue": - out.Values[i] = ec._ResourceChangedField_newValue(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -583,56 +613,26 @@ func (ec *executionContext) _ResourceChangedField(ctx context.Context, sel ast.S return out } -var unsupportedResourceActivityLogEntryImplementors = []string{"UnsupportedResourceActivityLogEntry", "ActivityLogEntry", "Node"} +var resourceChangedFieldImplementors = []string{"ResourceChangedField"} -func (ec *executionContext) _UnsupportedResourceActivityLogEntry(ctx context.Context, sel ast.SelectionSet, obj *activitylog.UnsupportedResourceActivityLogEntry) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, unsupportedResourceActivityLogEntryImplementors) +func (ec *executionContext) _ResourceChangedField(ctx context.Context, sel ast.SelectionSet, obj *activitylog.ResourceChangedField) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, resourceChangedFieldImplementors) 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("UnsupportedResourceActivityLogEntry") - case "id": - out.Values[i] = ec._UnsupportedResourceActivityLogEntry_id(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "actor": - out.Values[i] = ec._UnsupportedResourceActivityLogEntry_actor(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "createdAt": - out.Values[i] = ec._UnsupportedResourceActivityLogEntry_createdAt(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "message": - out.Values[i] = ec._UnsupportedResourceActivityLogEntry_message(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "resourceType": - out.Values[i] = ec._UnsupportedResourceActivityLogEntry_resourceType(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "resourceName": - out.Values[i] = ec._UnsupportedResourceActivityLogEntry_resourceName(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "teamSlug": - out.Values[i] = ec._UnsupportedResourceActivityLogEntry_teamSlug(ctx, field, obj) - case "environmentName": - out.Values[i] = ec._UnsupportedResourceActivityLogEntry_environmentName(ctx, field, obj) - case "data": - out.Values[i] = ec._UnsupportedResourceActivityLogEntry_data(ctx, field, obj) + out.Values[i] = graphql.MarshalString("ResourceChangedField") + case "field": + out.Values[i] = ec._ResourceChangedField_field(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } + case "oldValue": + out.Values[i] = ec._ResourceChangedField_oldValue(ctx, field, obj) + case "newValue": + out.Values[i] = ec._ResourceChangedField_newValue(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } diff --git a/internal/graph/gengql/root_.generated.go b/internal/graph/gengql/root_.generated.go index 64fcbfd2d..e449fcd04 100644 --- a/internal/graph/gengql/root_.generated.go +++ b/internal/graph/gengql/root_.generated.go @@ -755,6 +755,18 @@ type ComplexityRoot struct { Valkey func(childComplexity int) int } + GenericKubernetesResourceActivityLogEntry struct { + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + Data func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int + } + GrantPostgresAccessPayload struct { Error func(childComplexity int) int } @@ -2695,18 +2707,6 @@ type ComplexityRoot struct { Unleash func(childComplexity int) int } - UnsupportedResourceActivityLogEntry struct { - Actor func(childComplexity int) int - CreatedAt func(childComplexity int) int - Data func(childComplexity int) int - EnvironmentName func(childComplexity int) int - ID func(childComplexity int) int - Message func(childComplexity int) int - ResourceName func(childComplexity int) int - ResourceType func(childComplexity int) int - TeamSlug func(childComplexity int) int - } - UpdateImageVulnerabilityPayload struct { Vulnerability func(childComplexity int) int } @@ -5486,6 +5486,69 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.Features.Valkey(childComplexity), true + case "GenericKubernetesResourceActivityLogEntry.actor": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Actor == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Actor(childComplexity), true + + case "GenericKubernetesResourceActivityLogEntry.createdAt": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.CreatedAt == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.CreatedAt(childComplexity), true + + case "GenericKubernetesResourceActivityLogEntry.data": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Data == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Data(childComplexity), true + + case "GenericKubernetesResourceActivityLogEntry.environmentName": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.EnvironmentName == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.EnvironmentName(childComplexity), true + + case "GenericKubernetesResourceActivityLogEntry.id": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ID == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ID(childComplexity), true + + case "GenericKubernetesResourceActivityLogEntry.message": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Message == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Message(childComplexity), true + + case "GenericKubernetesResourceActivityLogEntry.resourceName": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ResourceName == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ResourceName(childComplexity), true + + case "GenericKubernetesResourceActivityLogEntry.resourceType": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ResourceType == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ResourceType(childComplexity), true + + case "GenericKubernetesResourceActivityLogEntry.teamSlug": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.TeamSlug == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.TeamSlug(childComplexity), true + case "GrantPostgresAccessPayload.error": if e.ComplexityRoot.GrantPostgresAccessPayload.Error == nil { break @@ -14436,69 +14499,6 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.UnleashReleaseChannelIssue.Unleash(childComplexity), true - case "UnsupportedResourceActivityLogEntry.actor": - if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.Actor == nil { - break - } - - return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.Actor(childComplexity), true - - case "UnsupportedResourceActivityLogEntry.createdAt": - if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.CreatedAt == nil { - break - } - - return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.CreatedAt(childComplexity), true - - case "UnsupportedResourceActivityLogEntry.data": - if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.Data == nil { - break - } - - return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.Data(childComplexity), true - - case "UnsupportedResourceActivityLogEntry.environmentName": - if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.EnvironmentName == nil { - break - } - - return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.EnvironmentName(childComplexity), true - - case "UnsupportedResourceActivityLogEntry.id": - if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.ID == nil { - break - } - - return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.ID(childComplexity), true - - case "UnsupportedResourceActivityLogEntry.message": - if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.Message == nil { - break - } - - return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.Message(childComplexity), true - - case "UnsupportedResourceActivityLogEntry.resourceName": - if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.ResourceName == nil { - break - } - - return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.ResourceName(childComplexity), true - - case "UnsupportedResourceActivityLogEntry.resourceType": - if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.ResourceType == nil { - break - } - - return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.ResourceType(childComplexity), true - - case "UnsupportedResourceActivityLogEntry.teamSlug": - if e.ComplexityRoot.UnsupportedResourceActivityLogEntry.TeamSlug == nil { - break - } - - return e.ComplexityRoot.UnsupportedResourceActivityLogEntry.TeamSlug(childComplexity), true - case "UpdateImageVulnerabilityPayload.vulnerability": if e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability == nil { break @@ -17721,7 +17721,7 @@ type ResourceChangedField { Activity log entry for a resource kind that is not modelled in the GraphQL API. The resource type will be the uppercase Kubernetes kind, e.g. 'NAISJOB'. """ -type UnsupportedResourceActivityLogEntry implements ActivityLogEntry & Node { +type GenericKubernetesResourceActivityLogEntry implements ActivityLogEntry & Node { "ID of the entry." id: ID! diff --git a/internal/graph/gengql/schema.generated.go b/internal/graph/gengql/schema.generated.go index 8c9badb85..8ffe48dbe 100644 --- a/internal/graph/gengql/schema.generated.go +++ b/internal/graph/gengql/schema.generated.go @@ -10,7 +10,7 @@ import ( "sync/atomic" "github.com/99designs/gqlgen/graphql" - "github.com/nais/api/internal/activitylog" + activitylog1 "github.com/nais/api/internal/activitylog" "github.com/nais/api/internal/alerts" "github.com/nais/api/internal/auth/authz" "github.com/nais/api/internal/cost" @@ -40,7 +40,7 @@ import ( "github.com/nais/api/internal/search" "github.com/nais/api/internal/serviceaccount" "github.com/nais/api/internal/servicemaintenance" - activitylog1 "github.com/nais/api/internal/servicemaintenance/activitylog" + "github.com/nais/api/internal/servicemaintenance/activitylog" "github.com/nais/api/internal/slug" "github.com/nais/api/internal/team" "github.com/nais/api/internal/unleash" @@ -5574,13 +5574,6 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._UserCreatedUserSyncLogEntry(ctx, sel, obj) - case activitylog.UnsupportedResourceActivityLogEntry: - return ec._UnsupportedResourceActivityLogEntry(ctx, sel, &obj) - case *activitylog.UnsupportedResourceActivityLogEntry: - if obj == nil { - return graphql.Null - } - return ec._UnsupportedResourceActivityLogEntry(ctx, sel, obj) case issue.UnleashReleaseChannelIssue: return ec._UnleashReleaseChannelIssue(ctx, sel, &obj) case *issue.UnleashReleaseChannelIssue: @@ -5707,9 +5700,9 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._SqlDatabase(ctx, sel, obj) - case activitylog1.ServiceMaintenanceActivityLogEntry: + case activitylog.ServiceMaintenanceActivityLogEntry: return ec._ServiceMaintenanceActivityLogEntry(ctx, sel, &obj) - case *activitylog1.ServiceMaintenanceActivityLogEntry: + case *activitylog.ServiceMaintenanceActivityLogEntry: if obj == nil { return graphql.Null } @@ -6015,6 +6008,13 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._InvalidSpecIssue(ctx, sel, obj) + case activitylog1.GenericKubernetesResourceActivityLogEntry: + return ec._GenericKubernetesResourceActivityLogEntry(ctx, sel, &obj) + case *activitylog1.GenericKubernetesResourceActivityLogEntry: + if obj == nil { + return graphql.Null + } + return ec._GenericKubernetesResourceActivityLogEntry(ctx, sel, obj) case issue.FailedSynchronizationIssue: return ec._FailedSynchronizationIssue(ctx, sel, &obj) case *issue.FailedSynchronizationIssue: @@ -6339,7 +6339,7 @@ func (ec *executionContext) _Node(ctx context.Context, sel ast.SelectionSet, obj return graphql.Null } return ec._Alert(ctx, sel, obj) - case activitylog.ActivityLogEntry: + case activitylog1.ActivityLogEntry: if obj == nil { return graphql.Null } diff --git a/internal/graph/schema/apply.graphqls b/internal/graph/schema/apply.graphqls index 017c6007e..b570a2738 100644 --- a/internal/graph/schema/apply.graphqls +++ b/internal/graph/schema/apply.graphqls @@ -34,7 +34,7 @@ type ResourceChangedField { Activity log entry for a resource kind that is not modelled in the GraphQL API. The resource type will be the uppercase Kubernetes kind, e.g. 'NAISJOB'. """ -type UnsupportedResourceActivityLogEntry implements ActivityLogEntry & Node { +type GenericKubernetesResourceActivityLogEntry implements ActivityLogEntry & Node { "ID of the entry." id: ID! From 35750c3cce30791e5b68db3cf67a4feb8ca2162b Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Fri, 13 Mar 2026 11:02:49 +0100 Subject: [PATCH 08/25] Use modern Go --- internal/apply/client.go | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/internal/apply/client.go b/internal/apply/client.go index 0fb582a62..aafd3b6d0 100644 --- a/internal/apply/client.go +++ b/internal/apply/client.go @@ -113,7 +113,7 @@ func ApplyResource( data, metav1.PatchOptions{ FieldManager: fieldManager, - Force: boolPtr(true), + Force: new(true), }, ) if err != nil { @@ -126,7 +126,3 @@ func ApplyResource( Created: before == nil, }, nil } - -func boolPtr(b bool) *bool { - return &b -} From 730c48ee39133ff645f61c2b2ea6c577afb066ad Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Fri, 13 Mar 2026 14:11:17 +0100 Subject: [PATCH 09/25] change activity log resource type name --- integration_tests/apply.lua | 10 +-- internal/activitylog/resource.go | 8 +- internal/apply/apply.go | 2 +- .../graph/gengql/applications.generated.go | 20 ++--- internal/graph/gengql/apply.generated.go | 52 ++++++------ internal/graph/gengql/jobs.generated.go | 20 ++--- internal/graph/gengql/root_.generated.go | 80 +++++++++---------- internal/graph/schema/applications.graphqls | 4 +- internal/graph/schema/apply.graphqls | 18 ++--- internal/graph/schema/jobs.graphqls | 4 +- internal/workload/application/activitylog.go | 12 +-- internal/workload/job/activitylog.go | 12 +-- 12 files changed, 121 insertions(+), 121 deletions(-) diff --git a/integration_tests/apply.lua b/integration_tests/apply.lua index 673712676..57c792c37 100644 --- a/integration_tests/apply.lua +++ b/integration_tests/apply.lua @@ -268,7 +268,7 @@ Test.gql("activity log contains ApplicationCreatedActivityLogEntry after apply", team(slug: "%s") { activityLog( first: 20 - filter: { activityTypes: [RESOURCE_CREATED] } + filter: { activityTypes: [GENERIC_KUBERNETES_RESOURCE_CREATED] } ) { nodes { __typename @@ -291,7 +291,7 @@ Test.gql("activity log contains ApplicationCreatedActivityLogEntry after apply", team:slug() )) - -- RESOURCE_CREATED is registered for both APP and JOB, so the job entry appears too. + -- GENERIC_KUBERNETES_RESOURCE_CREATED is registered for both APP and JOB, so the job entry appears too. t.check({ data = { team = { @@ -333,7 +333,7 @@ Test.gql("activity log contains ApplicationUpdatedActivityLogEntry with changedF team(slug: "%s") { activityLog( first: 20 - filter: { activityTypes: [RESOURCE_UPDATED] } + filter: { activityTypes: [GENERIC_KUBERNETES_RESOURCE_UPDATED] } ) { nodes { __typename @@ -411,7 +411,7 @@ Test.gql("activity log contains JobCreatedActivityLogEntry after apply", functio team(slug: "%s") { activityLog( first: 20 - filter: { activityTypes: [RESOURCE_CREATED] } + filter: { activityTypes: [GENERIC_KUBERNETES_RESOURCE_CREATED] } ) { nodes { __typename @@ -432,7 +432,7 @@ Test.gql("activity log contains JobCreatedActivityLogEntry after apply", functio team:slug() )) - -- RESOURCE_CREATED is registered for both JOB and APP, so application entries appear too. + -- GENERIC_KUBERNETES_RESOURCE_CREATED is registered for both JOB and APP, so application entries appear too. t.check({ data = { team = { diff --git a/internal/activitylog/resource.go b/internal/activitylog/resource.go index f7fd624a0..9a3752b07 100644 --- a/internal/activitylog/resource.go +++ b/internal/activitylog/resource.go @@ -54,9 +54,9 @@ type ResourceChangedField struct { NewValue *string `json:"newValue,omitempty"` } -// ResourceActivityLogEntryData contains the additional data stored with a resource +// GenericKubernetesResourceActivityLogEntryData contains the additional data stored with a resource // created or updated via apply. -type ResourceActivityLogEntryData struct { +type GenericKubernetesResourceActivityLogEntryData struct { // APIVersion is the apiVersion of the applied resource. APIVersion string `json:"apiVersion"` @@ -74,7 +74,7 @@ type ResourceActivityLogEntryData struct { type GenericKubernetesResourceActivityLogEntry struct { GenericActivityLogEntry - Data *ResourceActivityLogEntryData `json:"data"` + Data *GenericKubernetesResourceActivityLogEntryData `json:"data"` } var fallbackTransformer Transformer @@ -91,7 +91,7 @@ func RegisterFallbackTransformer(t Transformer) { func init() { RegisterFallbackTransformer(func(entry GenericActivityLogEntry) (ActivityLogEntry, error) { - data, err := UnmarshalData[ResourceActivityLogEntryData](entry) + data, err := UnmarshalData[GenericKubernetesResourceActivityLogEntryData](entry) if err != nil { return nil, fmt.Errorf("transforming unsupported resource activity log entry data: %w", err) } diff --git a/internal/apply/apply.go b/internal/apply/apply.go index 1deb345f0..a9586888c 100644 --- a/internal/apply/apply.go +++ b/internal/apply/apply.go @@ -210,7 +210,7 @@ func applyOne( ResourceName: name, TeamSlug: &teamSlug, EnvironmentName: &environment, - Data: activitylog.ResourceActivityLogEntryData{ + Data: activitylog.GenericKubernetesResourceActivityLogEntryData{ APIVersion: apiVersion, Kind: kind, ChangedFields: changes, diff --git a/internal/graph/gengql/applications.generated.go b/internal/graph/gengql/applications.generated.go index c070ed0c9..1d65e232a 100644 --- a/internal/graph/gengql/applications.generated.go +++ b/internal/graph/gengql/applications.generated.go @@ -2234,7 +2234,7 @@ func (ec *executionContext) _ApplicationCreatedActivityLogEntry_data(ctx context return obj.Data, nil }, nil, - ec.marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData, + ec.marshalNGenericKubernetesResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐGenericKubernetesResourceActivityLogEntryData, true, true, ) @@ -2249,13 +2249,13 @@ func (ec *executionContext) fieldContext_ApplicationCreatedActivityLogEntry_data Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "apiVersion": - return ec.fieldContext_ResourceActivityLogEntryData_apiVersion(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_apiVersion(ctx, field) case "kind": - return ec.fieldContext_ResourceActivityLogEntryData_kind(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_kind(ctx, field) case "changedFields": - return ec.fieldContext_ResourceActivityLogEntryData_changedFields(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_changedFields(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type ResourceActivityLogEntryData", field.Name) + return nil, fmt.Errorf("no field named %q was found under type GenericKubernetesResourceActivityLogEntryData", field.Name) }, } return fc, nil @@ -4137,7 +4137,7 @@ func (ec *executionContext) _ApplicationUpdatedActivityLogEntry_data(ctx context return obj.Data, nil }, nil, - ec.marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData, + ec.marshalNGenericKubernetesResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐGenericKubernetesResourceActivityLogEntryData, true, true, ) @@ -4152,13 +4152,13 @@ func (ec *executionContext) fieldContext_ApplicationUpdatedActivityLogEntry_data Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "apiVersion": - return ec.fieldContext_ResourceActivityLogEntryData_apiVersion(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_apiVersion(ctx, field) case "kind": - return ec.fieldContext_ResourceActivityLogEntryData_kind(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_kind(ctx, field) case "changedFields": - return ec.fieldContext_ResourceActivityLogEntryData_changedFields(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_changedFields(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type ResourceActivityLogEntryData", field.Name) + return nil, fmt.Errorf("no field named %q was found under type GenericKubernetesResourceActivityLogEntryData", field.Name) }, } return fc, nil diff --git a/internal/graph/gengql/apply.generated.go b/internal/graph/gengql/apply.generated.go index 7c2c695a3..35ff29dfb 100644 --- a/internal/graph/gengql/apply.generated.go +++ b/internal/graph/gengql/apply.generated.go @@ -270,7 +270,7 @@ func (ec *executionContext) _GenericKubernetesResourceActivityLogEntry_data(ctx return obj.Data, nil }, nil, - ec.marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData, + ec.marshalNGenericKubernetesResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐGenericKubernetesResourceActivityLogEntryData, true, true, ) @@ -285,24 +285,24 @@ func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEnt Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "apiVersion": - return ec.fieldContext_ResourceActivityLogEntryData_apiVersion(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_apiVersion(ctx, field) case "kind": - return ec.fieldContext_ResourceActivityLogEntryData_kind(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_kind(ctx, field) case "changedFields": - return ec.fieldContext_ResourceActivityLogEntryData_changedFields(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_changedFields(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type ResourceActivityLogEntryData", field.Name) + return nil, fmt.Errorf("no field named %q was found under type GenericKubernetesResourceActivityLogEntryData", field.Name) }, } return fc, nil } -func (ec *executionContext) _ResourceActivityLogEntryData_apiVersion(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceActivityLogEntryData) (ret graphql.Marshaler) { +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntryData_apiVersion(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntryData) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ResourceActivityLogEntryData_apiVersion, + ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_apiVersion, func(ctx context.Context) (any, error) { return obj.APIVersion, nil }, @@ -313,9 +313,9 @@ func (ec *executionContext) _ResourceActivityLogEntryData_apiVersion(ctx context ) } -func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_apiVersion(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntryData_apiVersion(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ResourceActivityLogEntryData", + Object: "GenericKubernetesResourceActivityLogEntryData", Field: field, IsMethod: false, IsResolver: false, @@ -326,12 +326,12 @@ func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_apiVersion return fc, nil } -func (ec *executionContext) _ResourceActivityLogEntryData_kind(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceActivityLogEntryData) (ret graphql.Marshaler) { +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntryData_kind(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntryData) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ResourceActivityLogEntryData_kind, + ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_kind, func(ctx context.Context) (any, error) { return obj.Kind, nil }, @@ -342,9 +342,9 @@ func (ec *executionContext) _ResourceActivityLogEntryData_kind(ctx context.Conte ) } -func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntryData_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ResourceActivityLogEntryData", + Object: "GenericKubernetesResourceActivityLogEntryData", Field: field, IsMethod: false, IsResolver: false, @@ -355,12 +355,12 @@ func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_kind(_ con return fc, nil } -func (ec *executionContext) _ResourceActivityLogEntryData_changedFields(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceActivityLogEntryData) (ret graphql.Marshaler) { +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntryData_changedFields(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntryData) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, ec.OperationContext, field, - ec.fieldContext_ResourceActivityLogEntryData_changedFields, + ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_changedFields, func(ctx context.Context) (any, error) { return obj.ChangedFields, nil }, @@ -371,9 +371,9 @@ func (ec *executionContext) _ResourceActivityLogEntryData_changedFields(ctx cont ) } -func (ec *executionContext) fieldContext_ResourceActivityLogEntryData_changedFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntryData_changedFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "ResourceActivityLogEntryData", + Object: "GenericKubernetesResourceActivityLogEntryData", Field: field, IsMethod: false, IsResolver: false, @@ -564,29 +564,29 @@ func (ec *executionContext) _GenericKubernetesResourceActivityLogEntry(ctx conte return out } -var resourceActivityLogEntryDataImplementors = []string{"ResourceActivityLogEntryData"} +var genericKubernetesResourceActivityLogEntryDataImplementors = []string{"GenericKubernetesResourceActivityLogEntryData"} -func (ec *executionContext) _ResourceActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, obj *activitylog.ResourceActivityLogEntryData) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, resourceActivityLogEntryDataImplementors) +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, obj *activitylog.GenericKubernetesResourceActivityLogEntryData) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, genericKubernetesResourceActivityLogEntryDataImplementors) 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("ResourceActivityLogEntryData") + out.Values[i] = graphql.MarshalString("GenericKubernetesResourceActivityLogEntryData") case "apiVersion": - out.Values[i] = ec._ResourceActivityLogEntryData_apiVersion(ctx, field, obj) + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntryData_apiVersion(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "kind": - out.Values[i] = ec._ResourceActivityLogEntryData_kind(ctx, field, obj) + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntryData_kind(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } case "changedFields": - out.Values[i] = ec._ResourceActivityLogEntryData_changedFields(ctx, field, obj) + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntryData_changedFields(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -660,14 +660,14 @@ func (ec *executionContext) _ResourceChangedField(ctx context.Context, sel ast.S // region ***************************** type.gotpl ***************************** -func (ec *executionContext) marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, v *activitylog.ResourceActivityLogEntryData) graphql.Marshaler { +func (ec *executionContext) marshalNGenericKubernetesResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐGenericKubernetesResourceActivityLogEntryData(ctx context.Context, sel ast.SelectionSet, v *activitylog.GenericKubernetesResourceActivityLogEntryData) graphql.Marshaler { if v == nil { if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow") } return graphql.Null } - return ec._ResourceActivityLogEntryData(ctx, sel, v) + return ec._GenericKubernetesResourceActivityLogEntryData(ctx, sel, v) } func (ec *executionContext) marshalNResourceChangedField2githubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceChangedField(ctx context.Context, sel ast.SelectionSet, v activitylog.ResourceChangedField) graphql.Marshaler { diff --git a/internal/graph/gengql/jobs.generated.go b/internal/graph/gengql/jobs.generated.go index 14d4ce374..d35ebc3ac 100644 --- a/internal/graph/gengql/jobs.generated.go +++ b/internal/graph/gengql/jobs.generated.go @@ -2443,7 +2443,7 @@ func (ec *executionContext) _JobCreatedActivityLogEntry_data(ctx context.Context return obj.Data, nil }, nil, - ec.marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData, + ec.marshalNGenericKubernetesResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐGenericKubernetesResourceActivityLogEntryData, true, true, ) @@ -2458,13 +2458,13 @@ func (ec *executionContext) fieldContext_JobCreatedActivityLogEntry_data(_ conte Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "apiVersion": - return ec.fieldContext_ResourceActivityLogEntryData_apiVersion(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_apiVersion(ctx, field) case "kind": - return ec.fieldContext_ResourceActivityLogEntryData_kind(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_kind(ctx, field) case "changedFields": - return ec.fieldContext_ResourceActivityLogEntryData_changedFields(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_changedFields(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type ResourceActivityLogEntryData", field.Name) + return nil, fmt.Errorf("no field named %q was found under type GenericKubernetesResourceActivityLogEntryData", field.Name) }, } return fc, nil @@ -4618,7 +4618,7 @@ func (ec *executionContext) _JobUpdatedActivityLogEntry_data(ctx context.Context return obj.Data, nil }, nil, - ec.marshalNResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐResourceActivityLogEntryData, + ec.marshalNGenericKubernetesResourceActivityLogEntryData2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐGenericKubernetesResourceActivityLogEntryData, true, true, ) @@ -4633,13 +4633,13 @@ func (ec *executionContext) fieldContext_JobUpdatedActivityLogEntry_data(_ conte Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "apiVersion": - return ec.fieldContext_ResourceActivityLogEntryData_apiVersion(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_apiVersion(ctx, field) case "kind": - return ec.fieldContext_ResourceActivityLogEntryData_kind(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_kind(ctx, field) case "changedFields": - return ec.fieldContext_ResourceActivityLogEntryData_changedFields(ctx, field) + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_changedFields(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type ResourceActivityLogEntryData", field.Name) + return nil, fmt.Errorf("no field named %q was found under type GenericKubernetesResourceActivityLogEntryData", field.Name) }, } return fc, nil diff --git a/internal/graph/gengql/root_.generated.go b/internal/graph/gengql/root_.generated.go index e449fcd04..6fa975161 100644 --- a/internal/graph/gengql/root_.generated.go +++ b/internal/graph/gengql/root_.generated.go @@ -767,6 +767,12 @@ type ComplexityRoot struct { TeamSlug func(childComplexity int) int } + GenericKubernetesResourceActivityLogEntryData struct { + APIVersion func(childComplexity int) int + ChangedFields func(childComplexity int) int + Kind func(childComplexity int) int + } + GrantPostgresAccessPayload struct { Error func(childComplexity int) int } @@ -1657,12 +1663,6 @@ type ComplexityRoot struct { Key func(childComplexity int) int } - ResourceActivityLogEntryData struct { - APIVersion func(childComplexity int) int - ChangedFields func(childComplexity int) int - Kind func(childComplexity int) int - } - ResourceChangedField struct { Field func(childComplexity int) int NewValue func(childComplexity int) int @@ -5549,6 +5549,27 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.TeamSlug(childComplexity), true + case "GenericKubernetesResourceActivityLogEntryData.apiVersion": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.APIVersion == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.APIVersion(childComplexity), true + + case "GenericKubernetesResourceActivityLogEntryData.changedFields": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.ChangedFields == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.ChangedFields(childComplexity), true + + case "GenericKubernetesResourceActivityLogEntryData.kind": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.Kind == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.Kind(childComplexity), true + case "GrantPostgresAccessPayload.error": if e.ComplexityRoot.GrantPostgresAccessPayload.Error == nil { break @@ -9834,27 +9855,6 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.RequestTeamDeletionPayload.Key(childComplexity), true - case "ResourceActivityLogEntryData.apiVersion": - if e.ComplexityRoot.ResourceActivityLogEntryData.APIVersion == nil { - break - } - - return e.ComplexityRoot.ResourceActivityLogEntryData.APIVersion(childComplexity), true - - case "ResourceActivityLogEntryData.changedFields": - if e.ComplexityRoot.ResourceActivityLogEntryData.ChangedFields == nil { - break - } - - return e.ComplexityRoot.ResourceActivityLogEntryData.ChangedFields(childComplexity), true - - case "ResourceActivityLogEntryData.kind": - if e.ComplexityRoot.ResourceActivityLogEntryData.Kind == nil { - break - } - - return e.ComplexityRoot.ResourceActivityLogEntryData.Kind(childComplexity), true - case "ResourceChangedField.field": if e.ComplexityRoot.ResourceChangedField.Field == nil { break @@ -17636,7 +17636,7 @@ type ApplicationCreatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the creation." - data: ResourceActivityLogEntryData! + data: GenericKubernetesResourceActivityLogEntryData! } type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { @@ -17665,7 +17665,7 @@ type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the update." - data: ResourceActivityLogEntryData! + data: GenericKubernetesResourceActivityLogEntryData! } extend enum ActivityLogActivityType { @@ -17686,17 +17686,17 @@ extend enum ActivityLogActivityType { } `, BuiltIn: false}, {Name: "../schema/apply.graphqls", Input: `extend enum ActivityLogActivityType { - "A resource was updated via apply." - RESOURCE_UPDATED + "A generic kubernetes resource was updated via apply." + GENERIC_KUBERNETES_RESOURCE_UPDATED - "A resource was created via apply." - RESOURCE_CREATED + "A generic kubernetes resource was created via apply." + GENERIC_KUBERNETES_RESOURCE_CREATED } """ Additional data associated with a resource created or updated via apply. """ -type ResourceActivityLogEntryData { +type GenericKubernetesResourceActivityLogEntryData { "The apiVersion of the applied resource." apiVersion: String! "The kind of the applied resource." @@ -17706,14 +17706,14 @@ type ResourceActivityLogEntryData { } """ -A single field that changed during an apply operation. +A single field that changed. """ type ResourceChangedField { "The dot-separated path to the changed field, e.g. 'spec.replicas'." field: String! - "The value before the apply. Null if the field was added." + "The value before the change. Null if the field was added." oldValue: String - "The value after the apply. Null if the field was removed." + "The value after the change. Null if the field was removed." newValue: String } @@ -17747,7 +17747,7 @@ type GenericKubernetesResourceActivityLogEntry implements ActivityLogEntry & Nod environmentName: String "Data associated with the apply operation." - data: ResourceActivityLogEntryData! + data: GenericKubernetesResourceActivityLogEntryData! } `, BuiltIn: false}, {Name: "../schema/authz.graphqls", Input: `type Role implements Node { @@ -19794,7 +19794,7 @@ type JobCreatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the creation." - data: ResourceActivityLogEntryData! + data: GenericKubernetesResourceActivityLogEntryData! } type JobUpdatedActivityLogEntry implements ActivityLogEntry & Node { @@ -19823,7 +19823,7 @@ type JobUpdatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the update." - data: ResourceActivityLogEntryData! + data: GenericKubernetesResourceActivityLogEntryData! } extend enum ActivityLogActivityType { diff --git a/internal/graph/schema/applications.graphqls b/internal/graph/schema/applications.graphqls index 7338a0290..7938830df 100644 --- a/internal/graph/schema/applications.graphqls +++ b/internal/graph/schema/applications.graphqls @@ -743,7 +743,7 @@ type ApplicationCreatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the creation." - data: ResourceActivityLogEntryData! + data: GenericKubernetesResourceActivityLogEntryData! } type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { @@ -772,7 +772,7 @@ type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the update." - data: ResourceActivityLogEntryData! + data: GenericKubernetesResourceActivityLogEntryData! } extend enum ActivityLogActivityType { diff --git a/internal/graph/schema/apply.graphqls b/internal/graph/schema/apply.graphqls index b570a2738..8d6dcb52b 100644 --- a/internal/graph/schema/apply.graphqls +++ b/internal/graph/schema/apply.graphqls @@ -1,15 +1,15 @@ extend enum ActivityLogActivityType { - "A resource was updated via apply." - RESOURCE_UPDATED + "A generic kubernetes resource was updated via apply." + GENERIC_KUBERNETES_RESOURCE_UPDATED - "A resource was created via apply." - RESOURCE_CREATED + "A generic kubernetes resource was created via apply." + GENERIC_KUBERNETES_RESOURCE_CREATED } """ Additional data associated with a resource created or updated via apply. """ -type ResourceActivityLogEntryData { +type GenericKubernetesResourceActivityLogEntryData { "The apiVersion of the applied resource." apiVersion: String! "The kind of the applied resource." @@ -19,14 +19,14 @@ type ResourceActivityLogEntryData { } """ -A single field that changed during an apply operation. +A single field that changed. """ type ResourceChangedField { "The dot-separated path to the changed field, e.g. 'spec.replicas'." field: String! - "The value before the apply. Null if the field was added." + "The value before the change. Null if the field was added." oldValue: String - "The value after the apply. Null if the field was removed." + "The value after the change. Null if the field was removed." newValue: String } @@ -60,5 +60,5 @@ type GenericKubernetesResourceActivityLogEntry implements ActivityLogEntry & Nod environmentName: String "Data associated with the apply operation." - data: ResourceActivityLogEntryData! + data: GenericKubernetesResourceActivityLogEntryData! } diff --git a/internal/graph/schema/jobs.graphqls b/internal/graph/schema/jobs.graphqls index e597ae4f2..b177ea53a 100644 --- a/internal/graph/schema/jobs.graphqls +++ b/internal/graph/schema/jobs.graphqls @@ -538,7 +538,7 @@ type JobCreatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the creation." - data: ResourceActivityLogEntryData! + data: GenericKubernetesResourceActivityLogEntryData! } type JobUpdatedActivityLogEntry implements ActivityLogEntry & Node { @@ -567,7 +567,7 @@ type JobUpdatedActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the update." - data: ResourceActivityLogEntryData! + data: GenericKubernetesResourceActivityLogEntryData! } extend enum ActivityLogActivityType { diff --git a/internal/workload/application/activitylog.go b/internal/workload/application/activitylog.go index a2ce34096..3e18da11f 100644 --- a/internal/workload/application/activitylog.go +++ b/internal/workload/application/activitylog.go @@ -57,7 +57,7 @@ func init() { Data: data, }, nil case activitylog.ActivityLogEntryActionCreated: - data, err := activitylog.UnmarshalData[activitylog.ResourceActivityLogEntryData](entry) + data, err := activitylog.UnmarshalData[activitylog.GenericKubernetesResourceActivityLogEntryData](entry) if err != nil { return nil, fmt.Errorf("transforming application created activity log entry data: %w", err) } @@ -66,7 +66,7 @@ func init() { Data: data, }, nil case activitylog.ActivityLogEntryActionUpdated: - data, err := activitylog.UnmarshalData[activitylog.ResourceActivityLogEntryData](entry) + data, err := activitylog.UnmarshalData[activitylog.GenericKubernetesResourceActivityLogEntryData](entry) if err != nil { return nil, fmt.Errorf("transforming application updated activity log entry data: %w", err) } @@ -83,8 +83,8 @@ func init() { activitylog.RegisterFilter("APPLICATION_RESTARTED", activityLogEntryActionRestartApplication, ActivityLogEntryResourceTypeApplication) activitylog.RegisterFilter("APPLICATION_SCALED", activityLogEntryActionAutoScaleApplication, ActivityLogEntryResourceTypeApplication) activitylog.RegisterFilter("DEPLOYMENT", deploymentactivity.ActivityLogEntryActionDeployment, ActivityLogEntryResourceTypeApplication) - activitylog.RegisterFilter("RESOURCE_CREATED", activitylog.ActivityLogEntryActionCreated, ActivityLogEntryResourceTypeApplication) - activitylog.RegisterFilter("RESOURCE_UPDATED", activitylog.ActivityLogEntryActionUpdated, ActivityLogEntryResourceTypeApplication) + activitylog.RegisterFilter("GENERIC_KUBERNETES_RESOURCE_CREATED", activitylog.ActivityLogEntryActionCreated, ActivityLogEntryResourceTypeApplication) + activitylog.RegisterFilter("GENERIC_KUBERNETES_RESOURCE_UPDATED", activitylog.ActivityLogEntryActionUpdated, ActivityLogEntryResourceTypeApplication) } type ApplicationRestartedActivityLogEntry struct { @@ -109,11 +109,11 @@ type ApplicationScaledActivityLogEntryData struct { type ApplicationCreatedActivityLogEntry struct { activitylog.GenericActivityLogEntry - Data *activitylog.ResourceActivityLogEntryData `json:"data"` + Data *activitylog.GenericKubernetesResourceActivityLogEntryData `json:"data"` } type ApplicationUpdatedActivityLogEntry struct { activitylog.GenericActivityLogEntry - Data *activitylog.ResourceActivityLogEntryData `json:"data"` + Data *activitylog.GenericKubernetesResourceActivityLogEntryData `json:"data"` } diff --git a/internal/workload/job/activitylog.go b/internal/workload/job/activitylog.go index c18cc170f..05f94ad9f 100644 --- a/internal/workload/job/activitylog.go +++ b/internal/workload/job/activitylog.go @@ -54,7 +54,7 @@ func init() { Data: data, }, nil case activitylog.ActivityLogEntryActionCreated: - data, err := activitylog.UnmarshalData[activitylog.ResourceActivityLogEntryData](entry) + data, err := activitylog.UnmarshalData[activitylog.GenericKubernetesResourceActivityLogEntryData](entry) if err != nil { return nil, fmt.Errorf("transforming job created activity log entry data: %w", err) } @@ -63,7 +63,7 @@ func init() { Data: data, }, nil case activitylog.ActivityLogEntryActionUpdated: - data, err := activitylog.UnmarshalData[activitylog.ResourceActivityLogEntryData](entry) + data, err := activitylog.UnmarshalData[activitylog.GenericKubernetesResourceActivityLogEntryData](entry) if err != nil { return nil, fmt.Errorf("transforming job updated activity log entry data: %w", err) } @@ -80,8 +80,8 @@ func init() { activitylog.RegisterFilter("JOB_RUN_DELETED", activityLogEntryActionDeleteJobRun, ActivityLogEntryResourceTypeJob) activitylog.RegisterFilter("JOB_TRIGGERED", activityLogEntryActionTriggerJob, ActivityLogEntryResourceTypeJob) activitylog.RegisterFilter("DEPLOYMENT", deploymentactivity.ActivityLogEntryActionDeployment, ActivityLogEntryResourceTypeJob) - activitylog.RegisterFilter("RESOURCE_CREATED", activitylog.ActivityLogEntryActionCreated, ActivityLogEntryResourceTypeJob) - activitylog.RegisterFilter("RESOURCE_UPDATED", activitylog.ActivityLogEntryActionUpdated, ActivityLogEntryResourceTypeJob) + activitylog.RegisterFilter("GENERIC_KUBERNETES_RESOURCE_CREATED", activitylog.ActivityLogEntryActionCreated, ActivityLogEntryResourceTypeJob) + activitylog.RegisterFilter("GENERIC_KUBERNETES_RESOURCE_UPDATED", activitylog.ActivityLogEntryActionUpdated, ActivityLogEntryResourceTypeJob) } type JobTriggeredActivityLogEntry struct { @@ -104,11 +104,11 @@ type JobRunDeletedActivityLogEntry struct { type JobCreatedActivityLogEntry struct { activitylog.GenericActivityLogEntry - Data *activitylog.ResourceActivityLogEntryData `json:"data"` + Data *activitylog.GenericKubernetesResourceActivityLogEntryData `json:"data"` } type JobUpdatedActivityLogEntry struct { activitylog.GenericActivityLogEntry - Data *activitylog.ResourceActivityLogEntryData `json:"data"` + Data *activitylog.GenericKubernetesResourceActivityLogEntryData `json:"data"` } From 5cbd4aaabc73d2594e3075ce9617ad9a8c68d29f Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Mon, 16 Mar 2026 10:37:06 +0100 Subject: [PATCH 10/25] Add more resources --- internal/apply/apply.go | 19 +-- internal/apply/whitelist.go | 138 ++++++++++++++++++ internal/auth/authz/queries.go | 4 + ..._add_k8s_resources_apply_authorization.sql | 28 ++++ 4 files changed, 176 insertions(+), 13 deletions(-) create mode 100644 internal/database/migrations/0059_add_k8s_resources_apply_authorization.sql diff --git a/internal/apply/apply.go b/internal/apply/apply.go index a9586888c..1522cf29f 100644 --- a/internal/apply/apply.go +++ b/internal/apply/apply.go @@ -140,8 +140,8 @@ func applyOne( } } - // Authorize the actor for this team and kind. - if err := authorizeResource(ctx, kind, teamSlug); err != nil { + // Authorize the actor for this team. + if err := authorizeResource(ctx, teamSlug); err != nil { return ResourceResult{ Resource: resourceID, EnvironmentName: environment, @@ -228,17 +228,10 @@ func applyOne( } } -// authorizeResource checks if the current actor is authorized to apply the given kind -// to the team from the URL. -func authorizeResource(ctx context.Context, kind string, teamSlug slug.Slug) error { - switch kind { - case "Application": - return authz.CanUpdateApplications(ctx, teamSlug) - case "Naisjob": - return authz.CanUpdateJobs(ctx, teamSlug) - default: - return fmt.Errorf("no authorization mapping for kind %q", kind) - } +// authorizeResource checks if the current actor is authorized to apply kubernetes +// resources to the given team. +func authorizeResource(ctx context.Context, teamSlug slug.Slug) error { + return authz.CanApplyKubernetesResource(ctx, teamSlug) } // request is the incoming JSON request body. diff --git a/internal/apply/whitelist.go b/internal/apply/whitelist.go index a6bcfce68..c6243990e 100644 --- a/internal/apply/whitelist.go +++ b/internal/apply/whitelist.go @@ -12,12 +12,150 @@ type AllowedResource struct { // through the API. Each entry maps an apiVersion+kind pair to its GroupVersionResource, // avoiding the need for a discovery client. var allowedResources = map[AllowedResource]schema.GroupVersionResource{ + // Core workloads {APIVersion: "nais.io/v1alpha1", Kind: "Application"}: { Group: "nais.io", Version: "v1alpha1", Resource: "applications", }, {APIVersion: "nais.io/v1", Kind: "Naisjob"}: { Group: "nais.io", Version: "v1", Resource: "naisjobs", }, + + // Aiven + {APIVersion: "aiven.io/v1alpha1", Kind: "OpenSearch"}: { + Group: "aiven.io", Version: "v1alpha1", Resource: "opensearches", + }, + {APIVersion: "aiven.io/v1alpha1", Kind: "ServiceIntegration"}: { + Group: "aiven.io", Version: "v1alpha1", Resource: "serviceintegrations", + }, + {APIVersion: "aiven.io/v1alpha1", Kind: "Valkey"}: { + Group: "aiven.io", Version: "v1alpha1", Resource: "valkeys", + }, + {APIVersion: "aiven.nais.io/v1", Kind: "AivenApplication"}: { + Group: "aiven.nais.io", Version: "v1", Resource: "aivenapplications", + }, + + // Autoscaling + {APIVersion: "autoscaling/v2", Kind: "HorizontalPodAutoscaler"}: { + Group: "autoscaling", Version: "v2", Resource: "horizontalpodautoscalers", + }, + + // Batch + {APIVersion: "batch/v1", Kind: "Job"}: { + Group: "batch", Version: "v1", Resource: "jobs", + }, + + // BigQuery (Config Connector) + {APIVersion: "bigquery.cnrm.cloud.google.com/v1beta1", Kind: "BigQueryTable"}: { + Group: "bigquery.cnrm.cloud.google.com", Version: "v1beta1", Resource: "bigquerytables", + }, + + // Postgres (NAIS) + {APIVersion: "data.nais.io/v1", Kind: "Postgres"}: { + Group: "data.nais.io", Version: "v1", Resource: "postgres", + }, + + // IAM (Config Connector) + {APIVersion: "iam.cnrm.cloud.google.com/v1beta1", Kind: "IAMPolicyMember"}: { + Group: "iam.cnrm.cloud.google.com", Version: "v1beta1", Resource: "iampolicymembers", + }, + + // Kafka + {APIVersion: "kafka.nais.io/v1", Kind: "Topic"}: { + Group: "kafka.nais.io", Version: "v1", Resource: "topics", + }, + + // Krakend + {APIVersion: "krakend.nais.io/v1", Kind: "ApiEndpoints"}: { + Group: "krakend.nais.io", Version: "v1", Resource: "apiendpoints", + }, + {APIVersion: "krakend.nais.io/v1", Kind: "Krakend"}: { + Group: "krakend.nais.io", Version: "v1", Resource: "krakends", + }, + + // Logging (Config Connector) + {APIVersion: "logging.cnrm.cloud.google.com/v1beta1", Kind: "LoggingLogSink"}: { + Group: "logging.cnrm.cloud.google.com", Version: "v1beta1", Resource: "logginglogsinks", + }, + + // Monitoring (Prometheus Operator) + {APIVersion: "monitoring.coreos.com/v1", Kind: "Probe"}: { + Group: "monitoring.coreos.com", Version: "v1", Resource: "probes", + }, + {APIVersion: "monitoring.coreos.com/v1", Kind: "PrometheusRule"}: { + Group: "monitoring.coreos.com", Version: "v1", Resource: "prometheusrules", + }, + {APIVersion: "monitoring.coreos.com/v1", Kind: "ServiceMonitor"}: { + Group: "monitoring.coreos.com", Version: "v1", Resource: "servicemonitors", + }, + {APIVersion: "monitoring.coreos.com/v1alpha1", Kind: "AlertmanagerConfig"}: { + Group: "monitoring.coreos.com", Version: "v1alpha1", Resource: "alertmanagerconfigs", + }, + + // NAIS + {APIVersion: "nais.io/v1", Kind: "AzureAdApplication"}: { + Group: "nais.io", Version: "v1", Resource: "azureadapplications", + }, + {APIVersion: "nais.io/v1", Kind: "Image"}: { + Group: "nais.io", Version: "v1", Resource: "images", + }, + {APIVersion: "nais.io/v1alpha1", Kind: "Alerts"}: { + Group: "nais.io", Version: "v1alpha1", Resource: "alerts", + }, + {APIVersion: "nais.io/v1alpha1", Kind: "Naisjob"}: { + Group: "nais.io", Version: "v1alpha1", Resource: "naisjobs", + }, + + // Networking + {APIVersion: "networking.k8s.io/v1", Kind: "Ingress"}: { + Group: "networking.k8s.io", Version: "v1", Resource: "ingresses", + }, + {APIVersion: "networking.k8s.io/v1", Kind: "NetworkPolicy"}: { + Group: "networking.k8s.io", Version: "v1", Resource: "networkpolicies", + }, + + // PubSub (Config Connector) + {APIVersion: "pubsub.cnrm.cloud.google.com/v1beta1", Kind: "PubSubTopic"}: { + Group: "pubsub.cnrm.cloud.google.com", Version: "v1beta1", Resource: "pubsubtopics", + }, + + // RBAC + {APIVersion: "rbac.authorization.k8s.io/v1", Kind: "ClusterRole"}: { + Group: "rbac.authorization.k8s.io", Version: "v1", Resource: "clusterroles", + }, + {APIVersion: "rbac.authorization.k8s.io/v1", Kind: "ClusterRoleBinding"}: { + Group: "rbac.authorization.k8s.io", Version: "v1", Resource: "clusterrolebindings", + }, + {APIVersion: "rbac.authorization.k8s.io/v1", Kind: "Role"}: { + Group: "rbac.authorization.k8s.io", Version: "v1", Resource: "roles", + }, + {APIVersion: "rbac.authorization.k8s.io/v1", Kind: "RoleBinding"}: { + Group: "rbac.authorization.k8s.io", Version: "v1", Resource: "rolebindings", + }, + + // Unleash + {APIVersion: "unleash.nais.io/v1", Kind: "ApiToken"}: { + Group: "unleash.nais.io", Version: "v1", Resource: "apitokens", + }, + + // Core v1 + {APIVersion: "v1", Kind: "ConfigMap"}: { + Group: "", Version: "v1", Resource: "configmaps", + }, + {APIVersion: "v1", Kind: "Endpoints"}: { + Group: "", Version: "v1", Resource: "endpoints", + }, + {APIVersion: "v1", Kind: "PersistentVolumeClaim"}: { + Group: "", Version: "v1", Resource: "persistentvolumeclaims", + }, + {APIVersion: "v1", Kind: "Secret"}: { + Group: "", Version: "v1", Resource: "secrets", + }, + {APIVersion: "v1", Kind: "Service"}: { + Group: "", Version: "v1", Resource: "services", + }, + {APIVersion: "v1", Kind: "ServiceAccount"}: { + Group: "", Version: "v1", Resource: "serviceaccounts", + }, } // IsAllowed returns true if the given apiVersion and kind are in the whitelist. diff --git a/internal/auth/authz/queries.go b/internal/auth/authz/queries.go index cdfec2cb7..0d1c529ac 100644 --- a/internal/auth/authz/queries.go +++ b/internal/auth/authz/queries.go @@ -200,6 +200,10 @@ func CanUpdateJobs(ctx context.Context, teamSlug slug.Slug) error { return requireTeamAuthorization(ctx, teamSlug, "jobs:update") } +func CanApplyKubernetesResource(ctx context.Context, teamSlug slug.Slug) error { + return requireTeamAuthorization(ctx, teamSlug, "k8s_resources:apply") +} + func CanCreateRepositories(ctx context.Context, teamSlug slug.Slug) error { return requireTeamAuthorization(ctx, teamSlug, "repositories:create") } diff --git a/internal/database/migrations/0059_add_k8s_resources_apply_authorization.sql b/internal/database/migrations/0059_add_k8s_resources_apply_authorization.sql new file mode 100644 index 000000000..b5f0e70dc --- /dev/null +++ b/internal/database/migrations/0059_add_k8s_resources_apply_authorization.sql @@ -0,0 +1,28 @@ +-- +goose Up +INSERT INTO + authorizations (name, description) +VALUES + ( + 'k8s_resources:apply', + 'Permission to apply generic Kubernetes resources on behalf of a team.' + ) +; + +INSERT INTO + role_authorizations (role_name, authorization_name) +VALUES + ('Team member', 'k8s_resources:apply'), + ('Team owner', 'k8s_resources:apply'), + ('GitHub repository', 'k8s_resources:apply') +; + +-- +goose Down +DELETE FROM role_authorizations +WHERE + authorization_name = 'k8s_resources:apply' +; + +DELETE FROM authorizations +WHERE + name = 'k8s_resources:apply' +; From 2c5caf0d17289d5bd1ca8c32e4a3ff974dba91ad Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Mon, 16 Mar 2026 11:12:47 +0100 Subject: [PATCH 11/25] Add Github claims when applied using gh workflow Co-authored-by: Vegar Sechmann Molvig --- internal/activitylog/resource.go | 20 + internal/apply/apply.go | 18 +- internal/auth/middleware/github_token.go | 57 ++- .../graph/gengql/applications.generated.go | 4 + internal/graph/gengql/apply.generated.go | 436 ++++++++++++++++++ internal/graph/gengql/jobs.generated.go | 4 + internal/graph/gengql/root_.generated.go | 119 +++++ internal/graph/schema/apply.graphqls | 28 ++ 8 files changed, 663 insertions(+), 23 deletions(-) diff --git a/internal/activitylog/resource.go b/internal/activitylog/resource.go index 9a3752b07..d50d785ca 100644 --- a/internal/activitylog/resource.go +++ b/internal/activitylog/resource.go @@ -66,6 +66,26 @@ type GenericKubernetesResourceActivityLogEntryData struct { // ChangedFields lists the fields that changed during the apply. // Only populated for updates. ChangedFields []ResourceChangedField `json:"changedFields"` + + // GitHubClaims holds the GitHub Actions OIDC token claims at the time of the + // apply. Only populated when the request was authenticated via a GitHub token. + GitHubClaims *GitHubActorClaims `json:"gitHubClaims,omitempty"` +} + +// GitHubActorClaims holds the GitHub Actions OIDC token claims captured at the +// time of an apply operation. Duplicated from the middleware package to avoid a +// circular import; JSON tags must stay in sync. +type GitHubActorClaims struct { + Ref string `json:"ref"` + Repository string `json:"repository"` + RepositoryID string `json:"repositoryId"` + RunID string `json:"runId"` + RunAttempt string `json:"runAttempt"` + Actor string `json:"actor"` + Workflow string `json:"workflow"` + EventName string `json:"eventName"` + Environment string `json:"environment"` + JobWorkflowRef string `json:"jobWorkflowRef"` } // GenericKubernetesActivityLogEntry is used for resource types that do not have diff --git a/internal/apply/apply.go b/internal/apply/apply.go index 1522cf29f..feb876a92 100644 --- a/internal/apply/apply.go +++ b/internal/apply/apply.go @@ -10,6 +10,7 @@ import ( "github.com/nais/api/internal/activitylog" "github.com/nais/api/internal/auth/authz" + "github.com/nais/api/internal/auth/middleware" "github.com/nais/api/internal/kubernetes" "github.com/nais/api/internal/slug" "github.com/sirupsen/logrus" @@ -203,6 +204,17 @@ func applyOne( } resourceType, _ := activitylog.ResourceTypeForKind(kind) + + logData := activitylog.GenericKubernetesResourceActivityLogEntryData{ + APIVersion: apiVersion, + Kind: kind, + ChangedFields: changes, + } + if ghActor, ok := actor.User.(*middleware.GitHubRepoActor); ok { + claims := activitylog.GitHubActorClaims(ghActor.Claims) + logData.GitHubClaims = &claims + } + if err := activitylog.Create(ctx, activitylog.CreateInput{ Action: action, Actor: actor.User, @@ -210,11 +222,7 @@ func applyOne( ResourceName: name, TeamSlug: &teamSlug, EnvironmentName: &environment, - Data: activitylog.GenericKubernetesResourceActivityLogEntryData{ - APIVersion: apiVersion, - Kind: kind, - ChangedFields: changes, - }, + Data: logData, }); err != nil { log.WithError(err).Error("creating activity log entry") // Don't fail the apply because of a logging error. diff --git a/internal/auth/middleware/github_token.go b/internal/auth/middleware/github_token.go index 5667ae84f..9b51b9afd 100644 --- a/internal/auth/middleware/github_token.go +++ b/internal/auth/middleware/github_token.go @@ -16,26 +16,34 @@ import ( "github.com/sirupsen/logrus" ) -// ghClaims represents the claims present in a GitHub OIDC token +// ghClaims represents the claims present in a GitHub OIDC token. // See https://docs.github.com/en/actions/reference/security/oidc#oidc-token-claims. type ghClaims struct { - // Ref string `json:"ref"` - Repository string `json:"repository"` - // RepositoryID string `json:"repository_id"` - // RepositoryOwner string `json:"repository_owner"` - // RepositoryOwnerID string `json:"repository_owner_id"` - // RunID string `json:"run_id"` - // RunNumber string `json:"run_number"` - // RunAttempt string `json:"run_attempt"` - // Actor string `json:"actor"` - // ActorID string `json:"actor_id"` - // Workflow string `json:"workflow"` - // HeadRef string `json:"head_ref"` - // BaseRef string `json:"base_ref"` - // EventName string `json:"event_name"` - // RefType string `json:"ref_type"` - // Environment string `json:"environment"` - // JobWorkflowRef string `json:"job_workflow_ref"` + Ref string `json:"ref"` + Repository string `json:"repository"` + RepositoryID string `json:"repository_id"` + RunID string `json:"run_id"` + RunAttempt string `json:"run_attempt"` + Actor string `json:"actor"` + Workflow string `json:"workflow"` + EventName string `json:"event_name"` + Environment string `json:"environment"` + JobWorkflowRef string `json:"job_workflow_ref"` +} + +// GitHubActorClaims holds the subset of GitHub OIDC claims that are stored +// alongside activity log entries for audit purposes. +type GitHubActorClaims struct { + Ref string `json:"ref"` + Repository string `json:"repository"` + RepositoryID string `json:"repositoryID"` + RunID string `json:"runID"` + RunAttempt string `json:"runAttempt"` + Actor string `json:"actor"` + Workflow string `json:"workflow"` + EventName string `json:"eventName"` + Environment string `json:"environment"` + JobWorkflowRef string `json:"jobWorkflowRef"` } func GitHubOIDC(ctx context.Context, log logrus.FieldLogger) func(next http.Handler) http.Handler { @@ -108,6 +116,18 @@ func GitHubOIDC(ctx context.Context, log logrus.FieldLogger) func(next http.Hand usr := &GitHubRepoActor{ RepositoryName: claims.Repository, TeamSlugs: slices.Collect(maps.Keys(slugs)), + Claims: GitHubActorClaims{ + Ref: claims.Ref, + Repository: claims.Repository, + RepositoryID: claims.RepositoryID, + RunID: claims.RunID, + RunAttempt: claims.RunAttempt, + Actor: claims.Actor, + Workflow: claims.Workflow, + EventName: claims.EventName, + Environment: claims.Environment, + JobWorkflowRef: claims.JobWorkflowRef, + }, } next.ServeHTTP(w, r.WithContext(authz.ContextWithActor(ctx, usr, roles))) @@ -119,6 +139,7 @@ func GitHubOIDC(ctx context.Context, log logrus.FieldLogger) func(next http.Hand type GitHubRepoActor struct { RepositoryName string TeamSlugs []slug.Slug + Claims GitHubActorClaims } func (g *GitHubRepoActor) GetID() uuid.UUID { return uuid.Nil } diff --git a/internal/graph/gengql/applications.generated.go b/internal/graph/gengql/applications.generated.go index 1d65e232a..8f9b12fe8 100644 --- a/internal/graph/gengql/applications.generated.go +++ b/internal/graph/gengql/applications.generated.go @@ -2254,6 +2254,8 @@ func (ec *executionContext) fieldContext_ApplicationCreatedActivityLogEntry_data return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_kind(ctx, field) case "changedFields": return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_changedFields(ctx, field) + case "gitHubClaims": + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_gitHubClaims(ctx, field) } return nil, fmt.Errorf("no field named %q was found under type GenericKubernetesResourceActivityLogEntryData", field.Name) }, @@ -4157,6 +4159,8 @@ func (ec *executionContext) fieldContext_ApplicationUpdatedActivityLogEntry_data return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_kind(ctx, field) case "changedFields": return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_changedFields(ctx, field) + case "gitHubClaims": + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_gitHubClaims(ctx, field) } return nil, fmt.Errorf("no field named %q was found under type GenericKubernetesResourceActivityLogEntryData", field.Name) }, diff --git a/internal/graph/gengql/apply.generated.go b/internal/graph/gengql/apply.generated.go index 35ff29dfb..f59c4dc99 100644 --- a/internal/graph/gengql/apply.generated.go +++ b/internal/graph/gengql/apply.generated.go @@ -290,6 +290,8 @@ func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEnt return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_kind(ctx, field) case "changedFields": return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_changedFields(ctx, field) + case "gitHubClaims": + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_gitHubClaims(ctx, field) } return nil, fmt.Errorf("no field named %q was found under type GenericKubernetesResourceActivityLogEntryData", field.Name) }, @@ -392,6 +394,347 @@ func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEnt return fc, nil } +func (ec *executionContext) _GenericKubernetesResourceActivityLogEntryData_gitHubClaims(ctx context.Context, field graphql.CollectedField, obj *activitylog.GenericKubernetesResourceActivityLogEntryData) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_gitHubClaims, + func(ctx context.Context) (any, error) { + return obj.GitHubClaims, nil + }, + nil, + ec.marshalOGitHubActorClaims2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐGitHubActorClaims, + true, + false, + ) +} + +func (ec *executionContext) fieldContext_GenericKubernetesResourceActivityLogEntryData_gitHubClaims(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "GenericKubernetesResourceActivityLogEntryData", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "ref": + return ec.fieldContext_GitHubActorClaims_ref(ctx, field) + case "repository": + return ec.fieldContext_GitHubActorClaims_repository(ctx, field) + case "repositoryID": + return ec.fieldContext_GitHubActorClaims_repositoryID(ctx, field) + case "runID": + return ec.fieldContext_GitHubActorClaims_runID(ctx, field) + case "runAttempt": + return ec.fieldContext_GitHubActorClaims_runAttempt(ctx, field) + case "actor": + return ec.fieldContext_GitHubActorClaims_actor(ctx, field) + case "workflow": + return ec.fieldContext_GitHubActorClaims_workflow(ctx, field) + case "eventName": + return ec.fieldContext_GitHubActorClaims_eventName(ctx, field) + case "environment": + return ec.fieldContext_GitHubActorClaims_environment(ctx, field) + case "jobWorkflowRef": + return ec.fieldContext_GitHubActorClaims_jobWorkflowRef(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type GitHubActorClaims", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _GitHubActorClaims_ref(ctx context.Context, field graphql.CollectedField, obj *activitylog.GitHubActorClaims) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_GitHubActorClaims_ref, + func(ctx context.Context) (any, error) { + return obj.Ref, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_GitHubActorClaims_ref(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "GitHubActorClaims", + 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) _GitHubActorClaims_repository(ctx context.Context, field graphql.CollectedField, obj *activitylog.GitHubActorClaims) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_GitHubActorClaims_repository, + func(ctx context.Context) (any, error) { + return obj.Repository, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_GitHubActorClaims_repository(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "GitHubActorClaims", + 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) _GitHubActorClaims_repositoryID(ctx context.Context, field graphql.CollectedField, obj *activitylog.GitHubActorClaims) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_GitHubActorClaims_repositoryID, + func(ctx context.Context) (any, error) { + return obj.RepositoryID, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_GitHubActorClaims_repositoryID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "GitHubActorClaims", + 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) _GitHubActorClaims_runID(ctx context.Context, field graphql.CollectedField, obj *activitylog.GitHubActorClaims) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_GitHubActorClaims_runID, + func(ctx context.Context) (any, error) { + return obj.RunID, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_GitHubActorClaims_runID(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "GitHubActorClaims", + 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) _GitHubActorClaims_runAttempt(ctx context.Context, field graphql.CollectedField, obj *activitylog.GitHubActorClaims) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_GitHubActorClaims_runAttempt, + func(ctx context.Context) (any, error) { + return obj.RunAttempt, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_GitHubActorClaims_runAttempt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "GitHubActorClaims", + 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) _GitHubActorClaims_actor(ctx context.Context, field graphql.CollectedField, obj *activitylog.GitHubActorClaims) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_GitHubActorClaims_actor, + func(ctx context.Context) (any, error) { + return obj.Actor, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_GitHubActorClaims_actor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "GitHubActorClaims", + 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) _GitHubActorClaims_workflow(ctx context.Context, field graphql.CollectedField, obj *activitylog.GitHubActorClaims) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_GitHubActorClaims_workflow, + func(ctx context.Context) (any, error) { + return obj.Workflow, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_GitHubActorClaims_workflow(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "GitHubActorClaims", + 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) _GitHubActorClaims_eventName(ctx context.Context, field graphql.CollectedField, obj *activitylog.GitHubActorClaims) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_GitHubActorClaims_eventName, + func(ctx context.Context) (any, error) { + return obj.EventName, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_GitHubActorClaims_eventName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "GitHubActorClaims", + 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) _GitHubActorClaims_environment(ctx context.Context, field graphql.CollectedField, obj *activitylog.GitHubActorClaims) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_GitHubActorClaims_environment, + func(ctx context.Context) (any, error) { + return obj.Environment, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_GitHubActorClaims_environment(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "GitHubActorClaims", + 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) _GitHubActorClaims_jobWorkflowRef(ctx context.Context, field graphql.CollectedField, obj *activitylog.GitHubActorClaims) (ret graphql.Marshaler) { + return graphql.ResolveField( + ctx, + ec.OperationContext, + field, + ec.fieldContext_GitHubActorClaims_jobWorkflowRef, + func(ctx context.Context) (any, error) { + return obj.JobWorkflowRef, nil + }, + nil, + ec.marshalNString2string, + true, + true, + ) +} + +func (ec *executionContext) fieldContext_GitHubActorClaims_jobWorkflowRef(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "GitHubActorClaims", + 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) _ResourceChangedField_field(ctx context.Context, field graphql.CollectedField, obj *activitylog.ResourceChangedField) (ret graphql.Marshaler) { return graphql.ResolveField( ctx, @@ -590,6 +933,92 @@ func (ec *executionContext) _GenericKubernetesResourceActivityLogEntryData(ctx c if out.Values[i] == graphql.Null { out.Invalids++ } + case "gitHubClaims": + out.Values[i] = ec._GenericKubernetesResourceActivityLogEntryData_gitHubClaims(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 gitHubActorClaimsImplementors = []string{"GitHubActorClaims"} + +func (ec *executionContext) _GitHubActorClaims(ctx context.Context, sel ast.SelectionSet, obj *activitylog.GitHubActorClaims) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, gitHubActorClaimsImplementors) + + 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("GitHubActorClaims") + case "ref": + out.Values[i] = ec._GitHubActorClaims_ref(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "repository": + out.Values[i] = ec._GitHubActorClaims_repository(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "repositoryID": + out.Values[i] = ec._GitHubActorClaims_repositoryID(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "runID": + out.Values[i] = ec._GitHubActorClaims_runID(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "runAttempt": + out.Values[i] = ec._GitHubActorClaims_runAttempt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "actor": + out.Values[i] = ec._GitHubActorClaims_actor(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "workflow": + out.Values[i] = ec._GitHubActorClaims_workflow(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "eventName": + out.Values[i] = ec._GitHubActorClaims_eventName(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "environment": + out.Values[i] = ec._GitHubActorClaims_environment(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "jobWorkflowRef": + out.Values[i] = ec._GitHubActorClaims_jobWorkflowRef(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -690,4 +1119,11 @@ func (ec *executionContext) marshalNResourceChangedField2ᚕgithubᚗcomᚋnais return ret } +func (ec *executionContext) marshalOGitHubActorClaims2ᚖgithubᚗcomᚋnaisᚋapiᚋinternalᚋactivitylogᚐGitHubActorClaims(ctx context.Context, sel ast.SelectionSet, v *activitylog.GitHubActorClaims) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._GitHubActorClaims(ctx, sel, v) +} + // endregion ***************************** type.gotpl ***************************** diff --git a/internal/graph/gengql/jobs.generated.go b/internal/graph/gengql/jobs.generated.go index d35ebc3ac..d6b42bf9e 100644 --- a/internal/graph/gengql/jobs.generated.go +++ b/internal/graph/gengql/jobs.generated.go @@ -2463,6 +2463,8 @@ func (ec *executionContext) fieldContext_JobCreatedActivityLogEntry_data(_ conte return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_kind(ctx, field) case "changedFields": return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_changedFields(ctx, field) + case "gitHubClaims": + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_gitHubClaims(ctx, field) } return nil, fmt.Errorf("no field named %q was found under type GenericKubernetesResourceActivityLogEntryData", field.Name) }, @@ -4638,6 +4640,8 @@ func (ec *executionContext) fieldContext_JobUpdatedActivityLogEntry_data(_ conte return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_kind(ctx, field) case "changedFields": return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_changedFields(ctx, field) + case "gitHubClaims": + return ec.fieldContext_GenericKubernetesResourceActivityLogEntryData_gitHubClaims(ctx, field) } return nil, fmt.Errorf("no field named %q was found under type GenericKubernetesResourceActivityLogEntryData", field.Name) }, diff --git a/internal/graph/gengql/root_.generated.go b/internal/graph/gengql/root_.generated.go index 6fa975161..fdd5d7d21 100644 --- a/internal/graph/gengql/root_.generated.go +++ b/internal/graph/gengql/root_.generated.go @@ -770,9 +770,23 @@ type ComplexityRoot struct { GenericKubernetesResourceActivityLogEntryData struct { APIVersion func(childComplexity int) int ChangedFields func(childComplexity int) int + GitHubClaims func(childComplexity int) int Kind func(childComplexity int) int } + GitHubActorClaims struct { + Actor func(childComplexity int) int + Environment func(childComplexity int) int + EventName func(childComplexity int) int + JobWorkflowRef func(childComplexity int) int + Ref func(childComplexity int) int + Repository func(childComplexity int) int + RepositoryID func(childComplexity int) int + RunAttempt func(childComplexity int) int + RunID func(childComplexity int) int + Workflow func(childComplexity int) int + } + GrantPostgresAccessPayload struct { Error func(childComplexity int) int } @@ -5563,6 +5577,13 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.ChangedFields(childComplexity), true + case "GenericKubernetesResourceActivityLogEntryData.gitHubClaims": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.GitHubClaims == nil { + break + } + + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.GitHubClaims(childComplexity), true + case "GenericKubernetesResourceActivityLogEntryData.kind": if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.Kind == nil { break @@ -5570,6 +5591,76 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.Kind(childComplexity), true + case "GitHubActorClaims.actor": + if e.ComplexityRoot.GitHubActorClaims.Actor == nil { + break + } + + return e.ComplexityRoot.GitHubActorClaims.Actor(childComplexity), true + + case "GitHubActorClaims.environment": + if e.ComplexityRoot.GitHubActorClaims.Environment == nil { + break + } + + return e.ComplexityRoot.GitHubActorClaims.Environment(childComplexity), true + + case "GitHubActorClaims.eventName": + if e.ComplexityRoot.GitHubActorClaims.EventName == nil { + break + } + + return e.ComplexityRoot.GitHubActorClaims.EventName(childComplexity), true + + case "GitHubActorClaims.jobWorkflowRef": + if e.ComplexityRoot.GitHubActorClaims.JobWorkflowRef == nil { + break + } + + return e.ComplexityRoot.GitHubActorClaims.JobWorkflowRef(childComplexity), true + + case "GitHubActorClaims.ref": + if e.ComplexityRoot.GitHubActorClaims.Ref == nil { + break + } + + return e.ComplexityRoot.GitHubActorClaims.Ref(childComplexity), true + + case "GitHubActorClaims.repository": + if e.ComplexityRoot.GitHubActorClaims.Repository == nil { + break + } + + return e.ComplexityRoot.GitHubActorClaims.Repository(childComplexity), true + + case "GitHubActorClaims.repositoryID": + if e.ComplexityRoot.GitHubActorClaims.RepositoryID == nil { + break + } + + return e.ComplexityRoot.GitHubActorClaims.RepositoryID(childComplexity), true + + case "GitHubActorClaims.runAttempt": + if e.ComplexityRoot.GitHubActorClaims.RunAttempt == nil { + break + } + + return e.ComplexityRoot.GitHubActorClaims.RunAttempt(childComplexity), true + + case "GitHubActorClaims.runID": + if e.ComplexityRoot.GitHubActorClaims.RunID == nil { + break + } + + return e.ComplexityRoot.GitHubActorClaims.RunID(childComplexity), true + + case "GitHubActorClaims.workflow": + if e.ComplexityRoot.GitHubActorClaims.Workflow == nil { + break + } + + return e.ComplexityRoot.GitHubActorClaims.Workflow(childComplexity), true + case "GrantPostgresAccessPayload.error": if e.ComplexityRoot.GrantPostgresAccessPayload.Error == nil { break @@ -17703,6 +17794,34 @@ type GenericKubernetesResourceActivityLogEntryData { kind: String! "The fields that changed during the apply. Only populated for updates." changedFields: [ResourceChangedField!]! + "GitHub Actions OIDC token claims at the time of the apply. Only present when the request was authenticated via a GitHub token." + gitHubClaims: GitHubActorClaims +} + +""" +GitHub Actions OIDC token claims captured at the time of an apply operation. +""" +type GitHubActorClaims { + "The git ref that triggered the workflow, e.g. 'refs/heads/main'." + ref: String! + "The repository name that triggered the workflow, e.g. 'org/repo'." + repository: String! + "The immutable numeric GitHub repository ID." + repositoryID: String! + "The unique identifier of the Actions workflow run. Links to https://github.com//actions/runs/." + runID: String! + "The attempt number of the workflow run (1-indexed)." + runAttempt: String! + "The GitHub username that triggered the workflow." + actor: String! + "The path to the workflow file, e.g. '.github/workflows/deploy.yaml'." + workflow: String! + "The event that triggered the workflow, e.g. 'push' or 'workflow_dispatch'." + eventName: String! + "The GitHub deployment environment name, if the job targets one." + environment: String! + "The ref of the reusable workflow called by this job, if any. E.g. 'org/repo/.github/workflows/deploy.yaml@refs/heads/main'." + jobWorkflowRef: String! } """ diff --git a/internal/graph/schema/apply.graphqls b/internal/graph/schema/apply.graphqls index 8d6dcb52b..44a38b20b 100644 --- a/internal/graph/schema/apply.graphqls +++ b/internal/graph/schema/apply.graphqls @@ -16,6 +16,34 @@ type GenericKubernetesResourceActivityLogEntryData { kind: String! "The fields that changed during the apply. Only populated for updates." changedFields: [ResourceChangedField!]! + "GitHub Actions OIDC token claims at the time of the apply. Only present when the request was authenticated via a GitHub token." + gitHubClaims: GitHubActorClaims +} + +""" +GitHub Actions OIDC token claims captured at the time of an apply operation. +""" +type GitHubActorClaims { + "The git ref that triggered the workflow, e.g. 'refs/heads/main'." + ref: String! + "The repository name that triggered the workflow, e.g. 'org/repo'." + repository: String! + "The immutable numeric GitHub repository ID." + repositoryID: String! + "The unique identifier of the Actions workflow run. Links to https://github.com//actions/runs/." + runID: String! + "The attempt number of the workflow run (1-indexed)." + runAttempt: String! + "The GitHub username that triggered the workflow." + actor: String! + "The path to the workflow file, e.g. '.github/workflows/deploy.yaml'." + workflow: String! + "The event that triggered the workflow, e.g. 'push' or 'workflow_dispatch'." + eventName: String! + "The GitHub deployment environment name, if the job targets one." + environment: String! + "The ref of the reusable workflow called by this job, if any. E.g. 'org/repo/.github/workflows/deploy.yaml@refs/heads/main'." + jobWorkflowRef: String! } """ From 63369f27bba550fc705acf2ff04dcde248232531 Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Mon, 16 Mar 2026 11:28:57 +0100 Subject: [PATCH 12/25] Move migration --- ...ization.sql => 0060_add_k8s_resources_apply_authorization.sql} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename internal/database/migrations/{0059_add_k8s_resources_apply_authorization.sql => 0060_add_k8s_resources_apply_authorization.sql} (100%) diff --git a/internal/database/migrations/0059_add_k8s_resources_apply_authorization.sql b/internal/database/migrations/0060_add_k8s_resources_apply_authorization.sql similarity index 100% rename from internal/database/migrations/0059_add_k8s_resources_apply_authorization.sql rename to internal/database/migrations/0060_add_k8s_resources_apply_authorization.sql From 299795eee0a31e0911fe56ea0290a11aa9351257 Mon Sep 17 00:00:00 2001 From: Vegar Sechmann Molvig Date: Tue, 17 Mar 2026 15:47:51 +0100 Subject: [PATCH 13/25] build(mise): use EmmyLuaCodeStyle from toolchain Use the mise-installed CodeFormat binary in the Lua fmt task instead of downloading a formatter at runtime. --- .mise-tasks/fmt/lua | 45 +-------------------------------------------- mise.toml | 1 + 2 files changed, 2 insertions(+), 44 deletions(-) diff --git a/.mise-tasks/fmt/lua b/.mise-tasks/fmt/lua index 3ff26b4a3..53668ed68 100755 --- a/.mise-tasks/fmt/lua +++ b/.mise-tasks/fmt/lua @@ -3,47 +3,4 @@ set -e -LUA_FORMATTER_VERSION=1.5.6 -BIN_DIR=./bin -LUAFMT="$BIN_DIR/luafmt-$LUA_FORMATTER_VERSION" -LUA_FORMATTER_URL="https://github.com/CppCXY/EmmyLuaCodeStyle/releases/download/$LUA_FORMATTER_VERSION" - -if [ ! -d "$LUAFMT" ]; then - OS=$(uname -s) - ARCH=$(uname -m) - if [ "$OS" = "Darwin" ]; then - if [ "$ARCH" = "x86_64" ]; then - LUA_FORMATTER_FILE=darwin-x64 - else - if [ "$ARCH" = "arm64" ]; then - LUA_FORMATTER_FILE=darwin-arm64 - else - echo "Unsupported architecture: $ARCH on macOS" - exit 1 - fi - fi - elif [ "$OS" = "Linux" ]; then - if [ "$ARCH" = "x86_64" ]; then - LUA_FORMATTER_FILE=linux-x64 - else - if [ "$ARCH" = "aarch64" ]; then - LUA_FORMATTER_FILE=linux-aarch64 - else - echo "Unsupported architecture: $ARCH on Linux" - exit 1 - fi - fi - else - echo "Unsupported OS: $OS" - exit 1 - fi - - mkdir -p "$LUAFMT" - curl -L "$LUA_FORMATTER_URL/$LUA_FORMATTER_FILE.tar.gz" -o /tmp/luafmt.tar.gz - tar -xzf /tmp/luafmt.tar.gz -C "$LUAFMT" - rm /tmp/luafmt.tar.gz - mv "$LUAFMT/$LUA_FORMATTER_FILE/"* "$LUAFMT/" - rmdir "$LUAFMT/$LUA_FORMATTER_FILE" -fi - -$LUAFMT/bin/CodeFormat format -w . --ignores-file ".gitignore" -c ./integration_tests/.editorconfig +CodeFormat format -w . --ignores-file ".gitignore" -c ./integration_tests/.editorconfig diff --git a/mise.toml b/mise.toml index 3eff67b32..965d4d408 100644 --- a/mise.toml +++ b/mise.toml @@ -8,3 +8,4 @@ node = "24" protoc = "29.3" protoc-gen-go = "1.36.4" protoc-gen-go-grpc = "1.5.1" +"github:CppCXY/EmmyLuaCodeStyle" = "1.5.6" From 422dbe96265c8ccd703b6ba56e9bfb15ea59ff83 Mon Sep 17 00:00:00 2001 From: Vegar Sechmann Molvig Date: Tue, 17 Mar 2026 15:47:58 +0100 Subject: [PATCH 14/25] refactor(apply): make endpoint handler stateful Convert apply to a struct-based HTTP handler, perform team authorization before request parsing, and restore environmentName in per-resource results. NOTE: tests are currently not passing in this branch. --- internal/apply/apply.go | 201 ++++++++++++-------------------- internal/apply/client.go | 36 ++---- internal/apply/whitelist.go | 19 +-- internal/graph/sse_transport.go | 2 +- internal/integration/manager.go | 8 +- internal/rest/rest.go | 17 +-- 6 files changed, 98 insertions(+), 185 deletions(-) diff --git a/internal/apply/apply.go b/internal/apply/apply.go index feb876a92..8f0f00c56 100644 --- a/internal/apply/apply.go +++ b/internal/apply/apply.go @@ -20,176 +20,134 @@ import ( const maxBodySize = 5 * 1024 * 1024 // 5 MB -// DynamicClientFactory creates a dynamic Kubernetes client for a given environment. -// In production this creates an impersonated client from environment configs. -// In tests this can return fake dynamic clients. -type DynamicClientFactory func(ctx context.Context, environment string) (dynamic.Interface, error) - -// NewImpersonatingClientFactory returns a DynamicClientFactory that creates -// impersonated dynamic clients from the provided environment config map. -func NewImpersonatingClientFactory(clusterConfigs kubernetes.ClusterConfigMap) DynamicClientFactory { - return func(ctx context.Context, environment string) (dynamic.Interface, error) { - return ImpersonatedClient(ctx, clusterConfigs, environment) +type Handler struct { + clusterConfigsMap kubernetes.ClusterConfigMap + log logrus.FieldLogger +} + +func NewHandler(clusterConfigsMap kubernetes.ClusterConfigMap, log logrus.FieldLogger) *Handler { + return &Handler{ + clusterConfigsMap: clusterConfigsMap, + log: log, } } -// Handler returns an http.HandlerFunc that handles apply requests. -// It validates the request body, checks authorization, applies resources -// to Kubernetes environments via server-side apply, diffs the results, and -// writes activity log entries. -// -// The team slug and environment are read from URL path parameters. -// The clusterConfigs map is used to validate that an environment name exists. -// The clientFactory is used to create dynamic Kubernetes clients per environment. -func Handler(clusterConfigs kubernetes.ClusterConfigMap, clientFactory DynamicClientFactory, log logrus.FieldLogger) http.HandlerFunc { - return func(w http.ResponseWriter, r *http.Request) { - ctx := r.Context() - - teamSlug := slug.Slug(r.PathValue("teamSlug")) - environment := r.PathValue("environment") - - actor := authz.ActorFromContext(ctx) - - // Read and parse request body. - body, err := io.ReadAll(io.LimitReader(r.Body, maxBodySize+1)) - if err != nil { - writeError(w, http.StatusBadRequest, "unable to read request body") - return - } - if len(body) > maxBodySize { - writeError(w, http.StatusBadRequest, fmt.Sprintf("request body too large (max %d bytes)", maxBodySize)) - return - } +func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() - var req request - if err := json.Unmarshal(body, &req); err != nil { - writeError(w, http.StatusBadRequest, "invalid JSON: "+err.Error()) - return - } + teamSlug := slug.Slug(r.PathValue("teamSlug")) + environmentName := r.PathValue("environment") - if len(req.Resources) == 0 { - writeError(w, http.StatusBadRequest, "no resources provided") - return - } + if err := authz.CanApplyKubernetesResource(ctx, teamSlug); err != nil { + writeError(w, http.StatusForbidden, fmt.Sprintf("authorization failed: %s", err)) + return + } - // Phase 1: Validate all resources before applying any. - var disallowed []string - for i, res := range req.Resources { - apiVersion := res.GetAPIVersion() - kind := res.GetKind() - if !IsAllowed(apiVersion, kind) { - disallowed = append(disallowed, fmt.Sprintf("resources[%d]: %s/%s is not an allowed resource type", i, apiVersion, kind)) - } - } - if len(disallowed) > 0 { - writeError(w, http.StatusBadRequest, fmt.Sprintf("disallowed resource types: %s", strings.Join(disallowed, "; "))) - return - } + body, err := io.ReadAll(io.LimitReader(r.Body, maxBodySize+1)) + if err != nil { + writeError(w, http.StatusBadRequest, "unable to read request body") + return + } + if len(body) > maxBodySize { + writeError(w, http.StatusBadRequest, fmt.Sprintf("request body too large (max %d bytes)", maxBodySize)) + return + } - // Phase 2: Apply each resource, collecting results. - results := make([]ResourceResult, 0, len(req.Resources)) + var req request + if err := json.Unmarshal(body, &req); err != nil { + writeError(w, http.StatusBadRequest, "invalid JSON: "+err.Error()) + return + } + + if len(req.Resources) == 0 { + writeError(w, http.StatusBadRequest, "no resources provided") + return + } - for _, res := range req.Resources { - result := applyOne(ctx, clusterConfigs, clientFactory, teamSlug, environment, &res, actor, log) - results = append(results, result) + var disallowed []string + for i, res := range req.Resources { + if !IsAllowed(res) { + disallowed = append(disallowed, fmt.Sprintf("resources[%d]: %s/%s is not an allowed resource type", i, res.GetAPIVersion(), res.GetKind())) } + } + if len(disallowed) > 0 { + writeError(w, http.StatusBadRequest, fmt.Sprintf("disallowed resource types: %s", strings.Join(disallowed, "; "))) + return + } + + results := make([]ResourceResult, 0, len(req.Resources)) + + cfg, ok := h.clusterConfigsMap[environmentName] + if !ok { + writeError(w, http.StatusBadRequest, fmt.Sprintf("unknown environment: %q", environmentName)) + return + } + + client, err := impersonatedClient(cfg, teamSlug) + if err != nil { + writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to create client for environment %q: %s", environmentName, err)) + return + } - writeJSON(w, http.StatusOK, Response{Results: results}) + for _, res := range req.Resources { + result := h.applyOne(ctx, client, teamSlug, environmentName, &res) + results = append(results, result) } + + writeJSON(w, http.StatusOK, Response{Results: results}) } -// applyOne processes a single resource: authorizes, applies, diffs, and logs. -func applyOne( +func (h *Handler) applyOne( ctx context.Context, - clusterConfigs kubernetes.ClusterConfigMap, - clientFactory DynamicClientFactory, + client dynamic.Interface, teamSlug slug.Slug, - environment string, + environmentName string, res *unstructured.Unstructured, - actor *authz.Actor, - log logrus.FieldLogger, ) ResourceResult { apiVersion := res.GetAPIVersion() kind := res.GetKind() name := res.GetName() resourceID := kind + "/" + name - log = log.WithFields(logrus.Fields{ - "environment": environment, + log := h.log.WithFields(logrus.Fields{ + "environment": environmentName, "team": teamSlug, "name": name, "kind": kind, }) - // Validate environment exists. - if _, ok := clusterConfigs[environment]; !ok { - return ResourceResult{ - Resource: resourceID, - EnvironmentName: environment, - Status: StatusError, - Error: fmt.Sprintf("unknown environment: %q", environment), - } - } - - // Validate resource has a name. if name == "" { return ResourceResult{ Resource: resourceID, - EnvironmentName: environment, + EnvironmentName: environmentName, Status: StatusError, Error: "resource must have metadata.name", } } - // Authorize the actor for this team. - if err := authorizeResource(ctx, teamSlug); err != nil { - return ResourceResult{ - Resource: resourceID, - EnvironmentName: environment, - Status: StatusError, - Error: fmt.Sprintf("authorization failed: %s", err), - } - } - - // Resolve GVR. gvr, ok := GVRFor(apiVersion, kind) if !ok { return ResourceResult{ Resource: resourceID, - EnvironmentName: environment, + EnvironmentName: environmentName, Status: StatusError, Error: fmt.Sprintf("no GVR mapping for %s/%s", apiVersion, kind), } } - // Force the namespace to match the team slug from the URL. res.SetNamespace(string(teamSlug)) - // Create dynamic client for environment. - client, err := clientFactory(ctx, environment) - if err != nil { - log.WithError(err).Error("creating dynamic client") - return ResourceResult{ - Resource: resourceID, - EnvironmentName: environment, - Status: StatusError, - Error: fmt.Sprintf("failed to create client for environment %q: %s", environment, err), - } - } - - // Apply the resource. applyResult, err := ApplyResource(ctx, client, gvr, res) if err != nil { log.WithError(err).Error("applying resource") return ResourceResult{ Resource: resourceID, - EnvironmentName: environment, + EnvironmentName: environmentName, Status: StatusError, Error: fmt.Sprintf("apply failed: %s", err), } } - // Diff before and after. var changes []activitylog.ResourceChangedField status := StatusCreated if !applyResult.Created { @@ -197,7 +155,6 @@ func applyOne( changes = Diff(applyResult.Before, applyResult.After) } - // Write activity log entry. action := activitylog.ActivityLogEntryActionCreated if !applyResult.Created { action = activitylog.ActivityLogEntryActionUpdated @@ -210,6 +167,8 @@ func applyOne( Kind: kind, ChangedFields: changes, } + + actor := authz.ActorFromContext(ctx) if ghActor, ok := actor.User.(*middleware.GitHubRepoActor); ok { claims := activitylog.GitHubActorClaims(ghActor.Claims) logData.GitHubClaims = &claims @@ -221,28 +180,20 @@ func applyOne( ResourceType: resourceType, ResourceName: name, TeamSlug: &teamSlug, - EnvironmentName: &environment, + EnvironmentName: &environmentName, Data: logData, }); err != nil { log.WithError(err).Error("creating activity log entry") - // Don't fail the apply because of a logging error. } return ResourceResult{ Resource: resourceID, - EnvironmentName: environment, + EnvironmentName: environmentName, Status: status, ChangedFields: changes, } } -// authorizeResource checks if the current actor is authorized to apply kubernetes -// resources to the given team. -func authorizeResource(ctx context.Context, teamSlug slug.Slug) error { - return authz.CanApplyKubernetesResource(ctx, teamSlug) -} - -// request is the incoming JSON request body. type request struct { Resources []unstructured.Unstructured `json:"resources"` } diff --git a/internal/apply/client.go b/internal/apply/client.go index aafd3b6d0..39a3de721 100644 --- a/internal/apply/client.go +++ b/internal/apply/client.go @@ -5,8 +5,7 @@ import ( "encoding/json" "fmt" - "github.com/nais/api/internal/auth/authz" - "github.com/nais/api/internal/kubernetes" + "github.com/nais/api/internal/slug" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" @@ -18,42 +17,21 @@ import ( const fieldManager = "nais-api" -// ImpersonatedClient creates a dynamic Kubernetes client for the given environment +// impersonatedClient creates a dynamic Kubernetes client for the given environment // that impersonates the authenticated user from the context. This creates a fresh // client per call — it does NOT reuse informers or watcher clients. -func ImpersonatedClient( - ctx context.Context, - clusterConfigs kubernetes.ClusterConfigMap, - environment string, +func impersonatedClient( + cfg *rest.Config, + teamSlug slug.Slug, ) (dynamic.Interface, error) { - cfg, ok := clusterConfigs[environment] - if !ok { - return nil, fmt.Errorf("unknown environment: %q", environment) - } - - if cfg == nil { - return nil, fmt.Errorf("no config available for environment: %q", environment) - } - - actor := authz.ActorFromContext(ctx) - if actor == nil { - return nil, fmt.Errorf("no authenticated user in context") - } - - groups, err := actor.User.GCPTeamGroups(ctx) - if err != nil { - return nil, fmt.Errorf("listing GCP groups for user: %w", err) - } - impersonatedCfg := rest.CopyConfig(cfg) impersonatedCfg.Impersonate = rest.ImpersonationConfig{ - UserName: actor.User.Identity(), - Groups: groups, + UserName: fmt.Sprintf("system:serviceaccount:%[1]v:serviceuser-%[1]v", teamSlug), } client, err := dynamic.NewForConfig(impersonatedCfg) if err != nil { - return nil, fmt.Errorf("creating dynamic client for environment %q: %w", environment, err) + return nil, fmt.Errorf("creating dynamic client for team %q: %w", teamSlug, err) } return client, nil diff --git a/internal/apply/whitelist.go b/internal/apply/whitelist.go index c6243990e..02044d493 100644 --- a/internal/apply/whitelist.go +++ b/internal/apply/whitelist.go @@ -1,6 +1,9 @@ package apply -import "k8s.io/apimachinery/pkg/runtime/schema" +import ( + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/apimachinery/pkg/runtime/schema" +) // AllowedResource identifies a Kubernetes resource by its apiVersion and kind. type AllowedResource struct { @@ -159,8 +162,8 @@ var allowedResources = map[AllowedResource]schema.GroupVersionResource{ } // IsAllowed returns true if the given apiVersion and kind are in the whitelist. -func IsAllowed(apiVersion, kind string) bool { - _, ok := allowedResources[AllowedResource{APIVersion: apiVersion, Kind: kind}] +func IsAllowed(res unstructured.Unstructured) bool { + _, ok := allowedResources[AllowedResource{APIVersion: res.GetAPIVersion(), Kind: res.GetKind()}] return ok } @@ -170,13 +173,3 @@ func GVRFor(apiVersion, kind string) (schema.GroupVersionResource, bool) { gvr, ok := allowedResources[AllowedResource{APIVersion: apiVersion, Kind: kind}] return gvr, ok } - -// AllowedKinds returns a list of all allowed apiVersion+kind combinations. -// Useful for error messages. -func AllowedKinds() []AllowedResource { - kinds := make([]AllowedResource, 0, len(allowedResources)) - for k := range allowedResources { - kinds = append(kinds, k) - } - return kinds -} diff --git a/internal/graph/sse_transport.go b/internal/graph/sse_transport.go index 5e75f9a75..689e34893 100644 --- a/internal/graph/sse_transport.go +++ b/internal/graph/sse_transport.go @@ -205,7 +205,7 @@ func writeJson(w io.Writer, response *graphql.Response) { if err != nil { panic(fmt.Errorf("unable to marshal %s: %w", string(response.Data), err)) } - w.Write(b) + _, _ = w.Write(b) } func jsonDecode(r io.Reader, val any) error { diff --git a/internal/integration/manager.go b/internal/integration/manager.go index d5514fada..b85dc980e 100644 --- a/internal/integration/manager.go +++ b/internal/integration/manager.go @@ -43,7 +43,6 @@ import ( "github.com/testcontainers/testcontainers-go/modules/postgres" "google.golang.org/protobuf/encoding/protojson" "google.golang.org/protobuf/reflect/protoreflect" - "k8s.io/client-go/dynamic" ) type ctxKey int @@ -214,11 +213,8 @@ func newRestRunner(ctx context.Context, pool *pgxpool.Pool, clusterConfig kubern PreSharedKey: testPreSharedKey, ClusterConfigs: clusterConfig, ContextMiddleware: contextDependencies, - DynamicClientFactory: func(_ context.Context, cluster string) (dynamic.Interface, error) { - return k8sRunner.DynamicClient(cluster) - }, - Fakes: rest.Fakes{WithInsecureUserHeader: true}, - Log: logger, + Fakes: rest.Fakes{WithInsecureUserHeader: true}, + Log: logger, }) return runner.NewRestRunner(router), nil diff --git a/internal/rest/rest.go b/internal/rest/rest.go index e2bf7d393..549fd7698 100644 --- a/internal/rest/rest.go +++ b/internal/rest/rest.go @@ -24,11 +24,10 @@ type Fakes struct { // Config holds all dependencies needed by the REST server. type Config struct { - ListenAddress string - Pool *pgxpool.Pool - PreSharedKey string - ClusterConfigs kubernetes.ClusterConfigMap - DynamicClientFactory apply.DynamicClientFactory + ListenAddress string + Pool *pgxpool.Pool + PreSharedKey string + ClusterConfigs kubernetes.ClusterConfigMap // ContextMiddleware sets up the request context with all loaders and // dependencies needed by the apply handler (authz, activitylog, etc.). // In production this is the middleware returned by ConfigureGraph. @@ -113,12 +112,8 @@ func MakeRouter(ctx context.Context, cfg Config) *chi.Mux { middleware.RequireAuthenticatedUser(), ) - clientFactory := cfg.DynamicClientFactory - if clientFactory == nil { - clientFactory = apply.NewImpersonatingClientFactory(cfg.ClusterConfigs) - } - - r.Post("/api/v1/teams/{teamSlug}/environments/{environment}/apply", apply.Handler(cfg.ClusterConfigs, clientFactory, cfg.Log)) + handler := apply.NewHandler(cfg.ClusterConfigs, cfg.Log) + r.Post("/api/v1/teams/{teamSlug}/environments/{environment}/apply", handler.ServeHTTP) }) } From f5d44b9376d98da43b9ba1c994fd5e680be5390c Mon Sep 17 00:00:00 2001 From: Vegar Sechmann Molvig Date: Wed, 18 Mar 2026 11:56:32 +0100 Subject: [PATCH 15/25] refactor(apply): inject dynamic client factory for environment clients Move team impersonation client creation into kubernetes config and allow rest/apply wiring to override the dynamic client in integration tests. This keeps production behavior while making authorization outcomes deterministic in tests. --- integration_tests/apply.lua | 11 ++-------- internal/apply/apply.go | 36 +++++++++++++++++++++------------ internal/apply/client.go | 22 -------------------- internal/integration/manager.go | 9 +++++++-- internal/kubernetes/config.go | 16 +++++++++++++++ internal/rest/rest.go | 8 +++++++- 6 files changed, 55 insertions(+), 47 deletions(-) diff --git a/integration_tests/apply.lua b/integration_tests/apply.lua index 57c792c37..fc4b0fcb2 100644 --- a/integration_tests/apply.lua +++ b/integration_tests/apply.lua @@ -174,15 +174,8 @@ Test.rest("non-member gets authorization error", function(t) } ]]) - t.check(200, { - results = { - { - resource = "Application/sneaky-app", - environmentName = "dev", - status = "error", - error = Contains("authorization failed"), - }, - }, + t.check(403, { + error = Contains("authorization failed"), }) end) diff --git a/internal/apply/apply.go b/internal/apply/apply.go index 8f0f00c56..1cb5601c1 100644 --- a/internal/apply/apply.go +++ b/internal/apply/apply.go @@ -21,14 +21,30 @@ import ( const maxBodySize = 5 * 1024 * 1024 // 5 MB type Handler struct { - clusterConfigsMap kubernetes.ClusterConfigMap - log logrus.FieldLogger + dynamicClientFn DynamicClientFactory + log logrus.FieldLogger } -func NewHandler(clusterConfigsMap kubernetes.ClusterConfigMap, log logrus.FieldLogger) *Handler { - return &Handler{ - clusterConfigsMap: clusterConfigsMap, - log: log, +type DynamicClientFactory func(environmentName string, teamSlug slug.Slug) (dynamic.Interface, error) + +type HandlerOpt func(*Handler) + +func NewHandler(clusterConfigsMap kubernetes.ClusterConfigMap, log logrus.FieldLogger, opts ...HandlerOpt) *Handler { + h := &Handler{ + log: log, + dynamicClientFn: clusterConfigsMap.TeamClient, + } + + for _, opt := range opts { + opt(h) + } + + return h +} + +func WithClientFactory(clientFactory DynamicClientFactory) HandlerOpt { + return func(h *Handler) { + h.dynamicClientFn = clientFactory } } @@ -77,13 +93,7 @@ func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { results := make([]ResourceResult, 0, len(req.Resources)) - cfg, ok := h.clusterConfigsMap[environmentName] - if !ok { - writeError(w, http.StatusBadRequest, fmt.Sprintf("unknown environment: %q", environmentName)) - return - } - - client, err := impersonatedClient(cfg, teamSlug) + client, err := h.dynamicClientFn(environmentName, teamSlug) if err != nil { writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to create client for environment %q: %s", environmentName, err)) return diff --git a/internal/apply/client.go b/internal/apply/client.go index 39a3de721..f34ec7e2f 100644 --- a/internal/apply/client.go +++ b/internal/apply/client.go @@ -5,38 +5,16 @@ import ( "encoding/json" "fmt" - "github.com/nais/api/internal/slug" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" "k8s.io/apimachinery/pkg/runtime/schema" "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/dynamic" - "k8s.io/client-go/rest" ) const fieldManager = "nais-api" -// impersonatedClient creates a dynamic Kubernetes client for the given environment -// that impersonates the authenticated user from the context. This creates a fresh -// client per call — it does NOT reuse informers or watcher clients. -func impersonatedClient( - cfg *rest.Config, - teamSlug slug.Slug, -) (dynamic.Interface, error) { - impersonatedCfg := rest.CopyConfig(cfg) - impersonatedCfg.Impersonate = rest.ImpersonationConfig{ - UserName: fmt.Sprintf("system:serviceaccount:%[1]v:serviceuser-%[1]v", teamSlug), - } - - client, err := dynamic.NewForConfig(impersonatedCfg) - if err != nil { - return nil, fmt.Errorf("creating dynamic client for team %q: %w", teamSlug, err) - } - - return client, nil -} - // ApplyResult holds the before and after states of a server-side apply operation. type ApplyResult struct { // Before is the state of the object before the apply. Nil if the object did not exist. diff --git a/internal/integration/manager.go b/internal/integration/manager.go index b85dc980e..be2439a95 100644 --- a/internal/integration/manager.go +++ b/internal/integration/manager.go @@ -30,6 +30,7 @@ import ( "github.com/nais/api/internal/persistence/sqlinstance" "github.com/nais/api/internal/rest" "github.com/nais/api/internal/servicemaintenance" + "github.com/nais/api/internal/slug" "github.com/nais/api/internal/thirdparty/aiven" fakeHookd "github.com/nais/api/internal/thirdparty/hookd/fake" "github.com/nais/api/internal/unleash" @@ -43,6 +44,7 @@ import ( "github.com/testcontainers/testcontainers-go/modules/postgres" "google.golang.org/protobuf/encoding/protojson" "google.golang.org/protobuf/reflect/protoreflect" + "k8s.io/client-go/dynamic" ) type ctxKey int @@ -213,8 +215,11 @@ func newRestRunner(ctx context.Context, pool *pgxpool.Pool, clusterConfig kubern PreSharedKey: testPreSharedKey, ClusterConfigs: clusterConfig, ContextMiddleware: contextDependencies, - Fakes: rest.Fakes{WithInsecureUserHeader: true}, - Log: logger, + DynamicClient: func(cluster string, _ slug.Slug) (dynamic.Interface, error) { + return k8sRunner.DynamicClient(cluster) + }, + Fakes: rest.Fakes{WithInsecureUserHeader: true}, + Log: logger, }) return runner.NewRestRunner(router), nil diff --git a/internal/kubernetes/config.go b/internal/kubernetes/config.go index 0a61633eb..0c34c0995 100644 --- a/internal/kubernetes/config.go +++ b/internal/kubernetes/config.go @@ -6,7 +6,9 @@ import ( "net/http" "strings" + "github.com/nais/api/internal/slug" "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp" + "k8s.io/client-go/dynamic" "k8s.io/client-go/rest" "k8s.io/client-go/tools/clientcmd/api" ) @@ -89,3 +91,17 @@ func (c *StaticCluster) EnvDecode(value string) error { } return nil } + +func (c ClusterConfigMap) TeamClient(environmentName string, teamSlug slug.Slug) (dynamic.Interface, error) { + cfg, ok := c[environmentName] + if !ok { + return nil, fmt.Errorf("unknown environment: %q", environmentName) + } + + impersonatedCfg := rest.CopyConfig(cfg) + impersonatedCfg.Impersonate = rest.ImpersonationConfig{ + UserName: fmt.Sprintf("system:serviceaccount:%[1]v:serviceuser-%[1]v", teamSlug), + } + + return dynamic.NewForConfig(impersonatedCfg) +} diff --git a/internal/rest/rest.go b/internal/rest/rest.go index 549fd7698..104fa00d6 100644 --- a/internal/rest/rest.go +++ b/internal/rest/rest.go @@ -28,6 +28,7 @@ type Config struct { Pool *pgxpool.Pool PreSharedKey string ClusterConfigs kubernetes.ClusterConfigMap + DynamicClient apply.DynamicClientFactory // ContextMiddleware sets up the request context with all loaders and // dependencies needed by the apply handler (authz, activitylog, etc.). // In production this is the middleware returned by ConfigureGraph. @@ -112,7 +113,12 @@ func MakeRouter(ctx context.Context, cfg Config) *chi.Mux { middleware.RequireAuthenticatedUser(), ) - handler := apply.NewHandler(cfg.ClusterConfigs, cfg.Log) + opts := []apply.HandlerOpt{} + if cfg.DynamicClient != nil { + opts = append(opts, apply.WithClientFactory(cfg.DynamicClient)) + } + + handler := apply.NewHandler(cfg.ClusterConfigs, cfg.Log, opts...) r.Post("/api/v1/teams/{teamSlug}/environments/{environment}/apply", handler.ServeHTTP) }) } From b2c7d73b912bc02a65ec9628d93ed28cd56a2bf7 Mon Sep 17 00:00:00 2001 From: Vegar Sechmann Molvig Date: Wed, 18 Mar 2026 12:18:20 +0100 Subject: [PATCH 16/25] fix: bump migration id --- ...ization.sql => 0061_add_k8s_resources_apply_authorization.sql} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename internal/database/migrations/{0060_add_k8s_resources_apply_authorization.sql => 0061_add_k8s_resources_apply_authorization.sql} (100%) diff --git a/internal/database/migrations/0060_add_k8s_resources_apply_authorization.sql b/internal/database/migrations/0061_add_k8s_resources_apply_authorization.sql similarity index 100% rename from internal/database/migrations/0060_add_k8s_resources_apply_authorization.sql rename to internal/database/migrations/0061_add_k8s_resources_apply_authorization.sql From b490fcb4eeffd2fa6f71d2558e0308bbf86068f3 Mon Sep 17 00:00:00 2001 From: Vegar Sechmann Molvig Date: Wed, 18 Mar 2026 12:35:33 +0100 Subject: [PATCH 17/25] fix: regenerate --- internal/graph/gengql/root_.generated.go | 14783 +++++++++++---------- 1 file changed, 8018 insertions(+), 6765 deletions(-) diff --git a/internal/graph/gengql/root_.generated.go b/internal/graph/gengql/root_.generated.go index fdd5d7d21..6b7cb5506 100644 --- a/internal/graph/gengql/root_.generated.go +++ b/internal/graph/gengql/root_.generated.go @@ -40,6 +40,7 @@ import ( "github.com/nais/api/internal/vulnerability" "github.com/nais/api/internal/workload" "github.com/nais/api/internal/workload/application" + "github.com/nais/api/internal/workload/configmap" "github.com/nais/api/internal/workload/job" "github.com/nais/api/internal/workload/podlog" "github.com/nais/api/internal/workload/secret" @@ -60,6 +61,7 @@ type ResolverRoot interface { BigQueryDataset() BigQueryDatasetResolver Bucket() BucketResolver CVE() CVEResolver + Config() ConfigResolver ContainerImage() ContainerImageResolver ContainerImageWorkloadReference() ContainerImageWorkloadReferenceResolver CurrentUnitPrices() CurrentUnitPricesResolver @@ -149,6 +151,10 @@ type ComplexityRoot struct { Node func(childComplexity int) int } + AddConfigValuePayload struct { + Config func(childComplexity int) int + } + AddRepositoryToTeamPayload struct { Repository func(childComplexity int) int } @@ -181,6 +187,7 @@ type ComplexityRoot struct { AuthIntegrations func(childComplexity int) int BigQueryDatasets func(childComplexity int, orderBy *bigquery.BigQueryDatasetOrder) int Buckets func(childComplexity int, orderBy *bucket.BucketOrder) int + Configs func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int Cost func(childComplexity int) int DeletionStartedAt func(childComplexity int) int Deployments func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int @@ -457,6 +464,80 @@ type ComplexityRoot struct { ResourceKind func(childComplexity int) int } + Config struct { + ActivityLog func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, filter *activitylog.ActivityLogFilter) int + Applications func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int + ID func(childComplexity int) int + Jobs func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int + LastModifiedAt func(childComplexity int) int + LastModifiedBy func(childComplexity int) int + Name func(childComplexity int) int + Team func(childComplexity int) int + TeamEnvironment func(childComplexity int) int + Values func(childComplexity int) int + Workloads func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int + } + + ConfigConnection struct { + Edges func(childComplexity int) int + Nodes func(childComplexity int) int + PageInfo func(childComplexity int) int + } + + ConfigCreatedActivityLogEntry struct { + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int + } + + ConfigDeletedActivityLogEntry struct { + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int + } + + ConfigEdge struct { + Cursor func(childComplexity int) int + Node func(childComplexity int) int + } + + ConfigUpdatedActivityLogEntry struct { + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + Data func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int + } + + ConfigUpdatedActivityLogEntryData struct { + UpdatedFields func(childComplexity int) int + } + + ConfigUpdatedActivityLogEntryDataUpdatedField struct { + Field func(childComplexity int) int + NewValue func(childComplexity int) int + OldValue func(childComplexity int) int + } + + ConfigValue struct { + Name func(childComplexity int) int + Value func(childComplexity int) int + } + ConfirmTeamDeletionPayload struct { DeletionStarted func(childComplexity int) int } @@ -491,6 +572,10 @@ type ComplexityRoot struct { Series func(childComplexity int) int } + CreateConfigPayload struct { + Config func(childComplexity int) int + } + CreateKafkaCredentialsPayload struct { Credentials func(childComplexity int) int } @@ -533,6 +618,25 @@ type ComplexityRoot struct { Valkey func(childComplexity int) int } + CredentialsActivityLogEntry struct { + Actor func(childComplexity int) int + CreatedAt func(childComplexity int) int + Data func(childComplexity int) int + EnvironmentName func(childComplexity int) int + ID func(childComplexity int) int + Message func(childComplexity int) int + ResourceName func(childComplexity int) int + ResourceType func(childComplexity int) int + TeamSlug func(childComplexity int) int + } + + CredentialsActivityLogEntryData struct { + InstanceName func(childComplexity int) int + Permission func(childComplexity int) int + ServiceType func(childComplexity int) int + TTL func(childComplexity int) int + } + CurrentUnitPrices struct { CPU func(childComplexity int) int Memory func(childComplexity int) int @@ -543,6 +647,10 @@ type ComplexityRoot struct { Team func(childComplexity int) int } + DeleteConfigPayload struct { + ConfigDeleted func(childComplexity int) int + } + DeleteJobPayload struct { Success func(childComplexity int) int Team func(childComplexity int) int @@ -888,6 +996,7 @@ type ComplexityRoot struct { AuthIntegrations func(childComplexity int) int BigQueryDatasets func(childComplexity int, orderBy *bigquery.BigQueryDatasetOrder) int Buckets func(childComplexity int, orderBy *bucket.BucketOrder) int + Configs func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int Cost func(childComplexity int) int DeletionStartedAt func(childComplexity int) int Deployments func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor) int @@ -1190,6 +1299,7 @@ type ComplexityRoot struct { } Mutation struct { + AddConfigValue func(childComplexity int, input configmap.AddConfigValueInput) int AddRepositoryToTeam func(childComplexity int, input repository.AddRepositoryToTeamInput) int AddSecretValue func(childComplexity int, input secret.AddSecretValueInput) int AddTeamMember func(childComplexity int, input team.AddTeamMemberInput) int @@ -1198,6 +1308,7 @@ type ComplexityRoot struct { ChangeDeploymentKey func(childComplexity int, input deployment.ChangeDeploymentKeyInput) int ConfigureReconciler func(childComplexity int, input reconciler.ConfigureReconcilerInput) int ConfirmTeamDeletion func(childComplexity int, input team.ConfirmTeamDeletionInput) int + CreateConfig func(childComplexity int, input configmap.CreateConfigInput) int CreateKafkaCredentials func(childComplexity int, input aivencredentials.CreateKafkaCredentialsInput) int CreateOpenSearch func(childComplexity int, input opensearch.CreateOpenSearchInput) int CreateOpenSearchCredentials func(childComplexity int, input aivencredentials.CreateOpenSearchCredentialsInput) int @@ -1209,6 +1320,7 @@ type ComplexityRoot struct { CreateValkey func(childComplexity int, input valkey.CreateValkeyInput) int CreateValkeyCredentials func(childComplexity int, input aivencredentials.CreateValkeyCredentialsInput) int DeleteApplication func(childComplexity int, input application.DeleteApplicationInput) int + DeleteConfig func(childComplexity int, input configmap.DeleteConfigInput) int DeleteJob func(childComplexity int, input job.DeleteJobInput) int DeleteJobRun func(childComplexity int, input job.DeleteJobRunInput) int DeleteOpenSearch func(childComplexity int, input opensearch.DeleteOpenSearchInput) int @@ -1220,6 +1332,7 @@ type ComplexityRoot struct { DisableReconciler func(childComplexity int, input reconciler.DisableReconcilerInput) int EnableReconciler func(childComplexity int, input reconciler.EnableReconcilerInput) int GrantPostgresAccess func(childComplexity int, input postgres.GrantPostgresAccessInput) int + RemoveConfigValue func(childComplexity int, input configmap.RemoveConfigValueInput) int RemoveRepositoryFromTeam func(childComplexity int, input repository.RemoveRepositoryFromTeamInput) int RemoveSecretValue func(childComplexity int, input secret.RemoveSecretValueInput) int RemoveTeamMember func(childComplexity int, input team.RemoveTeamMemberInput) int @@ -1231,6 +1344,7 @@ type ComplexityRoot struct { StartOpenSearchMaintenance func(childComplexity int, input servicemaintenance.StartOpenSearchMaintenanceInput) int StartValkeyMaintenance func(childComplexity int, input servicemaintenance.StartValkeyMaintenanceInput) int TriggerJob func(childComplexity int, input job.TriggerJobInput) int + UpdateConfigValue func(childComplexity int, input configmap.UpdateConfigValueInput) int UpdateImageVulnerability func(childComplexity int, input vulnerability.UpdateImageVulnerabilityInput) int UpdateOpenSearch func(childComplexity int, input opensearch.UpdateOpenSearchInput) int UpdateSecretValue func(childComplexity int, input secret.UpdateSecretValueInput) int @@ -1621,6 +1735,10 @@ type ComplexityRoot struct { Node func(childComplexity int) int } + RemoveConfigValuePayload struct { + Config func(childComplexity int) int + } + RemoveRepositoryFromTeamPayload struct { Success func(childComplexity int) int } @@ -2225,6 +2343,7 @@ type ComplexityRoot struct { Applications func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *application.ApplicationOrder, filter *application.TeamApplicationsFilter) int BigQueryDatasets func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *bigquery.BigQueryDatasetOrder) int Buckets func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *bucket.BucketOrder) int + Configs func(childComplexity int, first *int, after *pagination.Cursor, last *int, before *pagination.Cursor, orderBy *configmap.ConfigOrder, filter *configmap.ConfigFilter) int Cost func(childComplexity int) int DeleteKey func(childComplexity int, key string) int DeletionInProgress func(childComplexity int) int @@ -2358,6 +2477,7 @@ type ComplexityRoot struct { Application func(childComplexity int, name string) int BigQueryDataset func(childComplexity int, name string) int Bucket func(childComplexity int, name string) int + Config func(childComplexity int, name string) int Cost func(childComplexity int) int Environment func(childComplexity int) int GCPProjectID func(childComplexity int) int @@ -2438,6 +2558,10 @@ type ComplexityRoot struct { Total func(childComplexity int) int } + TeamInventoryCountConfigs struct { + Total func(childComplexity int) int + } + TeamInventoryCountJobs struct { Total func(childComplexity int) int } @@ -2470,6 +2594,7 @@ type ComplexityRoot struct { Applications func(childComplexity int) int BigQueryDatasets func(childComplexity int) int Buckets func(childComplexity int) int + Configs func(childComplexity int) int Jobs func(childComplexity int) int KafkaTopics func(childComplexity int) int OpenSearches func(childComplexity int) int @@ -2721,6 +2846,10 @@ type ComplexityRoot struct { Unleash func(childComplexity int) int } + UpdateConfigValuePayload struct { + Config func(childComplexity int) int + } + UpdateImageVulnerabilityPayload struct { Vulnerability func(childComplexity int) int } @@ -3159,6 +3288,13 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.ActivityLogEntryEdge.Node(childComplexity), true + case "AddConfigValuePayload.config": + if e.ComplexityRoot.AddConfigValuePayload.Config == nil { + break + } + + return e.ComplexityRoot.AddConfigValuePayload.Config(childComplexity), true + case "AddRepositoryToTeamPayload.repository": if e.ComplexityRoot.AddRepositoryToTeamPayload.Repository == nil { break @@ -3265,6 +3401,18 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.Application.Buckets(childComplexity, args["orderBy"].(*bucket.BucketOrder)), true + case "Application.configs": + if e.ComplexityRoot.Application.Configs == nil { + break + } + + args, err := ec.field_Application_configs_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.Application.Configs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + case "Application.cost": if e.ComplexityRoot.Application.Cost == nil { break @@ -4492,11736 +4640,12322 @@ func (e *executableSchema) Complexity(ctx context.Context, typeName, field strin return e.ComplexityRoot.ClusterAuditActivityLogEntryData.ResourceKind(childComplexity), true - case "ConfirmTeamDeletionPayload.deletionStarted": - if e.ComplexityRoot.ConfirmTeamDeletionPayload.DeletionStarted == nil { + case "Config.activityLog": + if e.ComplexityRoot.Config.ActivityLog == nil { break } - return e.ComplexityRoot.ConfirmTeamDeletionPayload.DeletionStarted(childComplexity), true + args, err := ec.field_Config_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "ContainerImage.activityLog": - if e.ComplexityRoot.ContainerImage.ActivityLog == nil { + return e.ComplexityRoot.Config.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + + case "Config.applications": + if e.ComplexityRoot.Config.Applications == nil { break } - args, err := ec.field_ContainerImage_activityLog_args(ctx, rawArgs) + args, err := ec.field_Config_applications_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.ContainerImage.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.Config.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ContainerImage.hasSBOM": - if e.ComplexityRoot.ContainerImage.HasSbom == nil { + case "Config.id": + if e.ComplexityRoot.Config.ID == nil { break } - return e.ComplexityRoot.ContainerImage.HasSbom(childComplexity), true + return e.ComplexityRoot.Config.ID(childComplexity), true - case "ContainerImage.id": - if e.ComplexityRoot.ContainerImage.ID == nil { + case "Config.jobs": + if e.ComplexityRoot.Config.Jobs == nil { break } - return e.ComplexityRoot.ContainerImage.ID(childComplexity), true + args, err := ec.field_Config_jobs_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "ContainerImage.name": - if e.ComplexityRoot.ContainerImage.Name == nil { + return e.ComplexityRoot.Config.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "Config.lastModifiedAt": + if e.ComplexityRoot.Config.LastModifiedAt == nil { break } - return e.ComplexityRoot.ContainerImage.Name(childComplexity), true + return e.ComplexityRoot.Config.LastModifiedAt(childComplexity), true - case "ContainerImage.tag": - if e.ComplexityRoot.ContainerImage.Tag == nil { + case "Config.lastModifiedBy": + if e.ComplexityRoot.Config.LastModifiedBy == nil { break } - return e.ComplexityRoot.ContainerImage.Tag(childComplexity), true + return e.ComplexityRoot.Config.LastModifiedBy(childComplexity), true - case "ContainerImage.vulnerabilities": - if e.ComplexityRoot.ContainerImage.Vulnerabilities == nil { + case "Config.name": + if e.ComplexityRoot.Config.Name == nil { break } - args, err := ec.field_ContainerImage_vulnerabilities_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.Config.Name(childComplexity), true + + case "Config.team": + if e.ComplexityRoot.Config.Team == nil { + break } - return e.ComplexityRoot.ContainerImage.Vulnerabilities(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*vulnerability.ImageVulnerabilityFilter), args["orderBy"].(*vulnerability.ImageVulnerabilityOrder)), true + return e.ComplexityRoot.Config.Team(childComplexity), true - case "ContainerImage.vulnerabilitySummary": - if e.ComplexityRoot.ContainerImage.VulnerabilitySummary == nil { + case "Config.teamEnvironment": + if e.ComplexityRoot.Config.TeamEnvironment == nil { break } - return e.ComplexityRoot.ContainerImage.VulnerabilitySummary(childComplexity), true + return e.ComplexityRoot.Config.TeamEnvironment(childComplexity), true - case "ContainerImage.workloadReferences": - if e.ComplexityRoot.ContainerImage.WorkloadReferences == nil { + case "Config.values": + if e.ComplexityRoot.Config.Values == nil { break } - args, err := ec.field_ContainerImage_workloadReferences_args(ctx, rawArgs) + return e.ComplexityRoot.Config.Values(childComplexity), true + + case "Config.workloads": + if e.ComplexityRoot.Config.Workloads == nil { + break + } + + args, err := ec.field_Config_workloads_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.ContainerImage.WorkloadReferences(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Config.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ContainerImageWorkloadReference.workload": - if e.ComplexityRoot.ContainerImageWorkloadReference.Workload == nil { + case "ConfigConnection.edges": + if e.ComplexityRoot.ConfigConnection.Edges == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReference.Workload(childComplexity), true + return e.ComplexityRoot.ConfigConnection.Edges(childComplexity), true - case "ContainerImageWorkloadReferenceConnection.edges": - if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Edges == nil { + case "ConfigConnection.nodes": + if e.ComplexityRoot.ConfigConnection.Nodes == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Edges(childComplexity), true + return e.ComplexityRoot.ConfigConnection.Nodes(childComplexity), true - case "ContainerImageWorkloadReferenceConnection.nodes": - if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Nodes == nil { + case "ConfigConnection.pageInfo": + if e.ComplexityRoot.ConfigConnection.PageInfo == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ConfigConnection.PageInfo(childComplexity), true - case "ContainerImageWorkloadReferenceConnection.pageInfo": - if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.PageInfo == nil { + case "ConfigCreatedActivityLogEntry.actor": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.Actor(childComplexity), true - case "ContainerImageWorkloadReferenceEdge.cursor": - if e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Cursor == nil { + case "ConfigCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "ContainerImageWorkloadReferenceEdge.node": - if e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Node == nil { + case "ConfigCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Node(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "CostMonthlySummary.series": - if e.ComplexityRoot.CostMonthlySummary.Series == nil { + case "ConfigCreatedActivityLogEntry.id": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.CostMonthlySummary.Series(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.ID(childComplexity), true - case "CreateKafkaCredentialsPayload.credentials": - if e.ComplexityRoot.CreateKafkaCredentialsPayload.Credentials == nil { + case "ConfigCreatedActivityLogEntry.message": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.CreateKafkaCredentialsPayload.Credentials(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.Message(childComplexity), true - case "CreateOpenSearchCredentialsPayload.credentials": - if e.ComplexityRoot.CreateOpenSearchCredentialsPayload.Credentials == nil { + case "ConfigCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.CreateOpenSearchCredentialsPayload.Credentials(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.ResourceName(childComplexity), true - case "CreateOpenSearchPayload.openSearch": - if e.ComplexityRoot.CreateOpenSearchPayload.OpenSearch == nil { + case "ConfigCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.CreateOpenSearchPayload.OpenSearch(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.ResourceType(childComplexity), true - case "CreateSecretPayload.secret": - if e.ComplexityRoot.CreateSecretPayload.Secret == nil { + case "ConfigCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ConfigCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.CreateSecretPayload.Secret(childComplexity), true + return e.ComplexityRoot.ConfigCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "CreateServiceAccountPayload.serviceAccount": - if e.ComplexityRoot.CreateServiceAccountPayload.ServiceAccount == nil { + case "ConfigDeletedActivityLogEntry.actor": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.CreateServiceAccountPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.Actor(childComplexity), true - case "CreateServiceAccountTokenPayload.secret": - if e.ComplexityRoot.CreateServiceAccountTokenPayload.Secret == nil { + case "ConfigDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.CreateServiceAccountTokenPayload.Secret(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "CreateServiceAccountTokenPayload.serviceAccount": - if e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccount == nil { + case "ConfigDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "CreateServiceAccountTokenPayload.serviceAccountToken": - if e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccountToken == nil { + case "ConfigDeletedActivityLogEntry.id": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccountToken(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.ID(childComplexity), true - case "CreateTeamPayload.team": - if e.ComplexityRoot.CreateTeamPayload.Team == nil { + case "ConfigDeletedActivityLogEntry.message": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.CreateTeamPayload.Team(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.Message(childComplexity), true - case "CreateUnleashForTeamPayload.unleash": - if e.ComplexityRoot.CreateUnleashForTeamPayload.Unleash == nil { + case "ConfigDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.CreateUnleashForTeamPayload.Unleash(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.ResourceName(childComplexity), true - case "CreateValkeyCredentialsPayload.credentials": - if e.ComplexityRoot.CreateValkeyCredentialsPayload.Credentials == nil { + case "ConfigDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.CreateValkeyCredentialsPayload.Credentials(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.ResourceType(childComplexity), true - case "CreateValkeyPayload.valkey": - if e.ComplexityRoot.CreateValkeyPayload.Valkey == nil { + case "ConfigDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ConfigDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.CreateValkeyPayload.Valkey(childComplexity), true + return e.ComplexityRoot.ConfigDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "CurrentUnitPrices.cpu": - if e.ComplexityRoot.CurrentUnitPrices.CPU == nil { + case "ConfigEdge.cursor": + if e.ComplexityRoot.ConfigEdge.Cursor == nil { break } - return e.ComplexityRoot.CurrentUnitPrices.CPU(childComplexity), true + return e.ComplexityRoot.ConfigEdge.Cursor(childComplexity), true - case "CurrentUnitPrices.memory": - if e.ComplexityRoot.CurrentUnitPrices.Memory == nil { + case "ConfigEdge.node": + if e.ComplexityRoot.ConfigEdge.Node == nil { break } - return e.ComplexityRoot.CurrentUnitPrices.Memory(childComplexity), true + return e.ComplexityRoot.ConfigEdge.Node(childComplexity), true - case "DeleteApplicationPayload.success": - if e.ComplexityRoot.DeleteApplicationPayload.Success == nil { + case "ConfigUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.DeleteApplicationPayload.Success(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Actor(childComplexity), true - case "DeleteApplicationPayload.team": - if e.ComplexityRoot.DeleteApplicationPayload.Team == nil { + case "ConfigUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.DeleteApplicationPayload.Team(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "DeleteJobPayload.success": - if e.ComplexityRoot.DeleteJobPayload.Success == nil { + case "ConfigUpdatedActivityLogEntry.data": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.DeleteJobPayload.Success(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Data(childComplexity), true - case "DeleteJobPayload.team": - if e.ComplexityRoot.DeleteJobPayload.Team == nil { + case "ConfigUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.DeleteJobPayload.Team(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "DeleteJobRunPayload.job": - if e.ComplexityRoot.DeleteJobRunPayload.Job == nil { + case "ConfigUpdatedActivityLogEntry.id": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.DeleteJobRunPayload.Job(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ID(childComplexity), true - case "DeleteJobRunPayload.success": - if e.ComplexityRoot.DeleteJobRunPayload.Success == nil { + case "ConfigUpdatedActivityLogEntry.message": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.DeleteJobRunPayload.Success(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.Message(childComplexity), true - case "DeleteOpenSearchPayload.openSearchDeleted": - if e.ComplexityRoot.DeleteOpenSearchPayload.OpenSearchDeleted == nil { + case "ConfigUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.DeleteOpenSearchPayload.OpenSearchDeleted(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "DeleteSecretPayload.secretDeleted": - if e.ComplexityRoot.DeleteSecretPayload.SecretDeleted == nil { + case "ConfigUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.DeleteSecretPayload.SecretDeleted(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "DeleteServiceAccountPayload.serviceAccountDeleted": - if e.ComplexityRoot.DeleteServiceAccountPayload.ServiceAccountDeleted == nil { + case "ConfigUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.DeleteServiceAccountPayload.ServiceAccountDeleted(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "DeleteServiceAccountTokenPayload.serviceAccount": - if e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccount == nil { + case "ConfigUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "DeleteServiceAccountTokenPayload.serviceAccountTokenDeleted": - if e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccountTokenDeleted == nil { + case "ConfigUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccountTokenDeleted(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "DeleteUnleashInstancePayload.unleashDeleted": - if e.ComplexityRoot.DeleteUnleashInstancePayload.UnleashDeleted == nil { + case "ConfigUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.DeleteUnleashInstancePayload.UnleashDeleted(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "DeleteValkeyPayload.valkeyDeleted": - if e.ComplexityRoot.DeleteValkeyPayload.ValkeyDeleted == nil { + case "ConfigUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.DeleteValkeyPayload.ValkeyDeleted(childComplexity), true + return e.ComplexityRoot.ConfigUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "Deployment.commitSha": - if e.ComplexityRoot.Deployment.CommitSha == nil { + case "ConfigValue.name": + if e.ComplexityRoot.ConfigValue.Name == nil { break } - return e.ComplexityRoot.Deployment.CommitSha(childComplexity), true + return e.ComplexityRoot.ConfigValue.Name(childComplexity), true - case "Deployment.createdAt": - if e.ComplexityRoot.Deployment.CreatedAt == nil { + case "ConfigValue.value": + if e.ComplexityRoot.ConfigValue.Value == nil { break } - return e.ComplexityRoot.Deployment.CreatedAt(childComplexity), true + return e.ComplexityRoot.ConfigValue.Value(childComplexity), true - case "Deployment.deployerUsername": - if e.ComplexityRoot.Deployment.DeployerUsername == nil { + case "ConfirmTeamDeletionPayload.deletionStarted": + if e.ComplexityRoot.ConfirmTeamDeletionPayload.DeletionStarted == nil { break } - return e.ComplexityRoot.Deployment.DeployerUsername(childComplexity), true + return e.ComplexityRoot.ConfirmTeamDeletionPayload.DeletionStarted(childComplexity), true - case "Deployment.environmentName": - if e.ComplexityRoot.Deployment.EnvironmentName == nil { + case "ContainerImage.activityLog": + if e.ComplexityRoot.ContainerImage.ActivityLog == nil { break } - return e.ComplexityRoot.Deployment.EnvironmentName(childComplexity), true + args, err := ec.field_ContainerImage_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "Deployment.id": - if e.ComplexityRoot.Deployment.ID == nil { + return e.ComplexityRoot.ContainerImage.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + + case "ContainerImage.hasSBOM": + if e.ComplexityRoot.ContainerImage.HasSbom == nil { break } - return e.ComplexityRoot.Deployment.ID(childComplexity), true + return e.ComplexityRoot.ContainerImage.HasSbom(childComplexity), true - case "Deployment.repository": - if e.ComplexityRoot.Deployment.Repository == nil { + case "ContainerImage.id": + if e.ComplexityRoot.ContainerImage.ID == nil { break } - return e.ComplexityRoot.Deployment.Repository(childComplexity), true + return e.ComplexityRoot.ContainerImage.ID(childComplexity), true - case "Deployment.resources": - if e.ComplexityRoot.Deployment.Resources == nil { + case "ContainerImage.name": + if e.ComplexityRoot.ContainerImage.Name == nil { break } - args, err := ec.field_Deployment_resources_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ContainerImage.Name(childComplexity), true + + case "ContainerImage.tag": + if e.ComplexityRoot.ContainerImage.Tag == nil { + break } - return e.ComplexityRoot.Deployment.Resources(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ContainerImage.Tag(childComplexity), true - case "Deployment.statuses": - if e.ComplexityRoot.Deployment.Statuses == nil { + case "ContainerImage.vulnerabilities": + if e.ComplexityRoot.ContainerImage.Vulnerabilities == nil { break } - args, err := ec.field_Deployment_statuses_args(ctx, rawArgs) + args, err := ec.field_ContainerImage_vulnerabilities_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Deployment.Statuses(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ContainerImage.Vulnerabilities(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*vulnerability.ImageVulnerabilityFilter), args["orderBy"].(*vulnerability.ImageVulnerabilityOrder)), true - case "Deployment.teamSlug": - if e.ComplexityRoot.Deployment.TeamSlug == nil { + case "ContainerImage.vulnerabilitySummary": + if e.ComplexityRoot.ContainerImage.VulnerabilitySummary == nil { break } - return e.ComplexityRoot.Deployment.TeamSlug(childComplexity), true + return e.ComplexityRoot.ContainerImage.VulnerabilitySummary(childComplexity), true - case "Deployment.triggerUrl": - if e.ComplexityRoot.Deployment.TriggerUrl == nil { + case "ContainerImage.workloadReferences": + if e.ComplexityRoot.ContainerImage.WorkloadReferences == nil { break } - return e.ComplexityRoot.Deployment.TriggerUrl(childComplexity), true + args, err := ec.field_ContainerImage_workloadReferences_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "DeploymentActivityLogEntry.actor": - if e.ComplexityRoot.DeploymentActivityLogEntry.Actor == nil { + return e.ComplexityRoot.ContainerImage.WorkloadReferences(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "ContainerImageWorkloadReference.workload": + if e.ComplexityRoot.ContainerImageWorkloadReference.Workload == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReference.Workload(childComplexity), true - case "DeploymentActivityLogEntry.createdAt": - if e.ComplexityRoot.DeploymentActivityLogEntry.CreatedAt == nil { + case "ContainerImageWorkloadReferenceConnection.edges": + if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Edges == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Edges(childComplexity), true - case "DeploymentActivityLogEntry.data": - if e.ComplexityRoot.DeploymentActivityLogEntry.Data == nil { + case "ContainerImageWorkloadReferenceConnection.nodes": + if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Nodes == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.Nodes(childComplexity), true - case "DeploymentActivityLogEntry.environmentName": - if e.ComplexityRoot.DeploymentActivityLogEntry.EnvironmentName == nil { + case "ContainerImageWorkloadReferenceConnection.pageInfo": + if e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.PageInfo == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceConnection.PageInfo(childComplexity), true - case "DeploymentActivityLogEntry.id": - if e.ComplexityRoot.DeploymentActivityLogEntry.ID == nil { + case "ContainerImageWorkloadReferenceEdge.cursor": + if e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Cursor == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Cursor(childComplexity), true - case "DeploymentActivityLogEntry.message": - if e.ComplexityRoot.DeploymentActivityLogEntry.Message == nil { + case "ContainerImageWorkloadReferenceEdge.node": + if e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Node == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ContainerImageWorkloadReferenceEdge.Node(childComplexity), true - case "DeploymentActivityLogEntry.resourceName": - if e.ComplexityRoot.DeploymentActivityLogEntry.ResourceName == nil { + case "CostMonthlySummary.series": + if e.ComplexityRoot.CostMonthlySummary.Series == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.CostMonthlySummary.Series(childComplexity), true - case "DeploymentActivityLogEntry.resourceType": - if e.ComplexityRoot.DeploymentActivityLogEntry.ResourceType == nil { + case "CreateConfigPayload.config": + if e.ComplexityRoot.CreateConfigPayload.Config == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.CreateConfigPayload.Config(childComplexity), true - case "DeploymentActivityLogEntry.teamSlug": - if e.ComplexityRoot.DeploymentActivityLogEntry.TeamSlug == nil { + case "CreateKafkaCredentialsPayload.credentials": + if e.ComplexityRoot.CreateKafkaCredentialsPayload.Credentials == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.CreateKafkaCredentialsPayload.Credentials(childComplexity), true - case "DeploymentActivityLogEntryData.triggerURL": - if e.ComplexityRoot.DeploymentActivityLogEntryData.TriggerURL == nil { + case "CreateOpenSearchCredentialsPayload.credentials": + if e.ComplexityRoot.CreateOpenSearchCredentialsPayload.Credentials == nil { break } - return e.ComplexityRoot.DeploymentActivityLogEntryData.TriggerURL(childComplexity), true + return e.ComplexityRoot.CreateOpenSearchCredentialsPayload.Credentials(childComplexity), true - case "DeploymentConnection.edges": - if e.ComplexityRoot.DeploymentConnection.Edges == nil { + case "CreateOpenSearchPayload.openSearch": + if e.ComplexityRoot.CreateOpenSearchPayload.OpenSearch == nil { break } - return e.ComplexityRoot.DeploymentConnection.Edges(childComplexity), true + return e.ComplexityRoot.CreateOpenSearchPayload.OpenSearch(childComplexity), true - case "DeploymentConnection.nodes": - if e.ComplexityRoot.DeploymentConnection.Nodes == nil { + case "CreateSecretPayload.secret": + if e.ComplexityRoot.CreateSecretPayload.Secret == nil { break } - return e.ComplexityRoot.DeploymentConnection.Nodes(childComplexity), true + return e.ComplexityRoot.CreateSecretPayload.Secret(childComplexity), true - case "DeploymentConnection.pageInfo": - if e.ComplexityRoot.DeploymentConnection.PageInfo == nil { + case "CreateServiceAccountPayload.serviceAccount": + if e.ComplexityRoot.CreateServiceAccountPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.DeploymentConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.CreateServiceAccountPayload.ServiceAccount(childComplexity), true - case "DeploymentEdge.cursor": - if e.ComplexityRoot.DeploymentEdge.Cursor == nil { + case "CreateServiceAccountTokenPayload.secret": + if e.ComplexityRoot.CreateServiceAccountTokenPayload.Secret == nil { break } - return e.ComplexityRoot.DeploymentEdge.Cursor(childComplexity), true + return e.ComplexityRoot.CreateServiceAccountTokenPayload.Secret(childComplexity), true - case "DeploymentEdge.node": - if e.ComplexityRoot.DeploymentEdge.Node == nil { + case "CreateServiceAccountTokenPayload.serviceAccount": + if e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.DeploymentEdge.Node(childComplexity), true + return e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccount(childComplexity), true - case "DeploymentKey.created": - if e.ComplexityRoot.DeploymentKey.Created == nil { + case "CreateServiceAccountTokenPayload.serviceAccountToken": + if e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccountToken == nil { break } - return e.ComplexityRoot.DeploymentKey.Created(childComplexity), true + return e.ComplexityRoot.CreateServiceAccountTokenPayload.ServiceAccountToken(childComplexity), true - case "DeploymentKey.expires": - if e.ComplexityRoot.DeploymentKey.Expires == nil { + case "CreateTeamPayload.team": + if e.ComplexityRoot.CreateTeamPayload.Team == nil { break } - return e.ComplexityRoot.DeploymentKey.Expires(childComplexity), true + return e.ComplexityRoot.CreateTeamPayload.Team(childComplexity), true - case "DeploymentKey.id": - if e.ComplexityRoot.DeploymentKey.ID == nil { + case "CreateUnleashForTeamPayload.unleash": + if e.ComplexityRoot.CreateUnleashForTeamPayload.Unleash == nil { break } - return e.ComplexityRoot.DeploymentKey.ID(childComplexity), true + return e.ComplexityRoot.CreateUnleashForTeamPayload.Unleash(childComplexity), true - case "DeploymentKey.key": - if e.ComplexityRoot.DeploymentKey.Key == nil { + case "CreateValkeyCredentialsPayload.credentials": + if e.ComplexityRoot.CreateValkeyCredentialsPayload.Credentials == nil { break } - return e.ComplexityRoot.DeploymentKey.Key(childComplexity), true + return e.ComplexityRoot.CreateValkeyCredentialsPayload.Credentials(childComplexity), true - case "DeploymentResource.id": - if e.ComplexityRoot.DeploymentResource.ID == nil { + case "CreateValkeyPayload.valkey": + if e.ComplexityRoot.CreateValkeyPayload.Valkey == nil { break } - return e.ComplexityRoot.DeploymentResource.ID(childComplexity), true + return e.ComplexityRoot.CreateValkeyPayload.Valkey(childComplexity), true - case "DeploymentResource.kind": - if e.ComplexityRoot.DeploymentResource.Kind == nil { + case "CredentialsActivityLogEntry.actor": + if e.ComplexityRoot.CredentialsActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.DeploymentResource.Kind(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.Actor(childComplexity), true - case "DeploymentResource.name": - if e.ComplexityRoot.DeploymentResource.Name == nil { + case "CredentialsActivityLogEntry.createdAt": + if e.ComplexityRoot.CredentialsActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.DeploymentResource.Name(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.CreatedAt(childComplexity), true - case "DeploymentResourceConnection.edges": - if e.ComplexityRoot.DeploymentResourceConnection.Edges == nil { + case "CredentialsActivityLogEntry.data": + if e.ComplexityRoot.CredentialsActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.DeploymentResourceConnection.Edges(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.Data(childComplexity), true - case "DeploymentResourceConnection.nodes": - if e.ComplexityRoot.DeploymentResourceConnection.Nodes == nil { + case "CredentialsActivityLogEntry.environmentName": + if e.ComplexityRoot.CredentialsActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.DeploymentResourceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.EnvironmentName(childComplexity), true - case "DeploymentResourceConnection.pageInfo": - if e.ComplexityRoot.DeploymentResourceConnection.PageInfo == nil { + case "CredentialsActivityLogEntry.id": + if e.ComplexityRoot.CredentialsActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.DeploymentResourceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.ID(childComplexity), true - case "DeploymentResourceEdge.cursor": - if e.ComplexityRoot.DeploymentResourceEdge.Cursor == nil { + case "CredentialsActivityLogEntry.message": + if e.ComplexityRoot.CredentialsActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.DeploymentResourceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.Message(childComplexity), true - case "DeploymentResourceEdge.node": - if e.ComplexityRoot.DeploymentResourceEdge.Node == nil { + case "CredentialsActivityLogEntry.resourceName": + if e.ComplexityRoot.CredentialsActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.DeploymentResourceEdge.Node(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.ResourceName(childComplexity), true - case "DeploymentStatus.createdAt": - if e.ComplexityRoot.DeploymentStatus.CreatedAt == nil { + case "CredentialsActivityLogEntry.resourceType": + if e.ComplexityRoot.CredentialsActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.DeploymentStatus.CreatedAt(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.ResourceType(childComplexity), true - case "DeploymentStatus.id": - if e.ComplexityRoot.DeploymentStatus.ID == nil { + case "CredentialsActivityLogEntry.teamSlug": + if e.ComplexityRoot.CredentialsActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.DeploymentStatus.ID(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntry.TeamSlug(childComplexity), true - case "DeploymentStatus.message": - if e.ComplexityRoot.DeploymentStatus.Message == nil { + case "CredentialsActivityLogEntryData.instanceName": + if e.ComplexityRoot.CredentialsActivityLogEntryData.InstanceName == nil { break } - return e.ComplexityRoot.DeploymentStatus.Message(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntryData.InstanceName(childComplexity), true - case "DeploymentStatus.state": - if e.ComplexityRoot.DeploymentStatus.State == nil { + case "CredentialsActivityLogEntryData.permission": + if e.ComplexityRoot.CredentialsActivityLogEntryData.Permission == nil { break } - return e.ComplexityRoot.DeploymentStatus.State(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntryData.Permission(childComplexity), true - case "DeploymentStatusConnection.edges": - if e.ComplexityRoot.DeploymentStatusConnection.Edges == nil { + case "CredentialsActivityLogEntryData.serviceType": + if e.ComplexityRoot.CredentialsActivityLogEntryData.ServiceType == nil { break } - return e.ComplexityRoot.DeploymentStatusConnection.Edges(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntryData.ServiceType(childComplexity), true - case "DeploymentStatusConnection.nodes": - if e.ComplexityRoot.DeploymentStatusConnection.Nodes == nil { + case "CredentialsActivityLogEntryData.ttl": + if e.ComplexityRoot.CredentialsActivityLogEntryData.TTL == nil { break } - return e.ComplexityRoot.DeploymentStatusConnection.Nodes(childComplexity), true + return e.ComplexityRoot.CredentialsActivityLogEntryData.TTL(childComplexity), true - case "DeploymentStatusConnection.pageInfo": - if e.ComplexityRoot.DeploymentStatusConnection.PageInfo == nil { + case "CurrentUnitPrices.cpu": + if e.ComplexityRoot.CurrentUnitPrices.CPU == nil { break } - return e.ComplexityRoot.DeploymentStatusConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.CurrentUnitPrices.CPU(childComplexity), true - case "DeploymentStatusEdge.cursor": - if e.ComplexityRoot.DeploymentStatusEdge.Cursor == nil { + case "CurrentUnitPrices.memory": + if e.ComplexityRoot.CurrentUnitPrices.Memory == nil { break } - return e.ComplexityRoot.DeploymentStatusEdge.Cursor(childComplexity), true + return e.ComplexityRoot.CurrentUnitPrices.Memory(childComplexity), true - case "DeploymentStatusEdge.node": - if e.ComplexityRoot.DeploymentStatusEdge.Node == nil { + case "DeleteApplicationPayload.success": + if e.ComplexityRoot.DeleteApplicationPayload.Success == nil { break } - return e.ComplexityRoot.DeploymentStatusEdge.Node(childComplexity), true + return e.ComplexityRoot.DeleteApplicationPayload.Success(childComplexity), true - case "DeprecatedIngressIssue.application": - if e.ComplexityRoot.DeprecatedIngressIssue.Application == nil { + case "DeleteApplicationPayload.team": + if e.ComplexityRoot.DeleteApplicationPayload.Team == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.Application(childComplexity), true + return e.ComplexityRoot.DeleteApplicationPayload.Team(childComplexity), true - case "DeprecatedIngressIssue.id": - if e.ComplexityRoot.DeprecatedIngressIssue.ID == nil { + case "DeleteConfigPayload.configDeleted": + if e.ComplexityRoot.DeleteConfigPayload.ConfigDeleted == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.ID(childComplexity), true + return e.ComplexityRoot.DeleteConfigPayload.ConfigDeleted(childComplexity), true - case "DeprecatedIngressIssue.ingresses": - if e.ComplexityRoot.DeprecatedIngressIssue.Ingresses == nil { + case "DeleteJobPayload.success": + if e.ComplexityRoot.DeleteJobPayload.Success == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.Ingresses(childComplexity), true + return e.ComplexityRoot.DeleteJobPayload.Success(childComplexity), true - case "DeprecatedIngressIssue.message": - if e.ComplexityRoot.DeprecatedIngressIssue.Message == nil { + case "DeleteJobPayload.team": + if e.ComplexityRoot.DeleteJobPayload.Team == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.Message(childComplexity), true + return e.ComplexityRoot.DeleteJobPayload.Team(childComplexity), true - case "DeprecatedIngressIssue.severity": - if e.ComplexityRoot.DeprecatedIngressIssue.Severity == nil { + case "DeleteJobRunPayload.job": + if e.ComplexityRoot.DeleteJobRunPayload.Job == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.Severity(childComplexity), true + return e.ComplexityRoot.DeleteJobRunPayload.Job(childComplexity), true - case "DeprecatedIngressIssue.teamEnvironment": - if e.ComplexityRoot.DeprecatedIngressIssue.TeamEnvironment == nil { + case "DeleteJobRunPayload.success": + if e.ComplexityRoot.DeleteJobRunPayload.Success == nil { break } - return e.ComplexityRoot.DeprecatedIngressIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.DeleteJobRunPayload.Success(childComplexity), true - case "DeprecatedRegistryIssue.id": - if e.ComplexityRoot.DeprecatedRegistryIssue.ID == nil { + case "DeleteOpenSearchPayload.openSearchDeleted": + if e.ComplexityRoot.DeleteOpenSearchPayload.OpenSearchDeleted == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.ID(childComplexity), true + return e.ComplexityRoot.DeleteOpenSearchPayload.OpenSearchDeleted(childComplexity), true - case "DeprecatedRegistryIssue.message": - if e.ComplexityRoot.DeprecatedRegistryIssue.Message == nil { + case "DeleteSecretPayload.secretDeleted": + if e.ComplexityRoot.DeleteSecretPayload.SecretDeleted == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.Message(childComplexity), true + return e.ComplexityRoot.DeleteSecretPayload.SecretDeleted(childComplexity), true - case "DeprecatedRegistryIssue.severity": - if e.ComplexityRoot.DeprecatedRegistryIssue.Severity == nil { + case "DeleteServiceAccountPayload.serviceAccountDeleted": + if e.ComplexityRoot.DeleteServiceAccountPayload.ServiceAccountDeleted == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.Severity(childComplexity), true + return e.ComplexityRoot.DeleteServiceAccountPayload.ServiceAccountDeleted(childComplexity), true - case "DeprecatedRegistryIssue.teamEnvironment": - if e.ComplexityRoot.DeprecatedRegistryIssue.TeamEnvironment == nil { + case "DeleteServiceAccountTokenPayload.serviceAccount": + if e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccount(childComplexity), true - case "DeprecatedRegistryIssue.workload": - if e.ComplexityRoot.DeprecatedRegistryIssue.Workload == nil { + case "DeleteServiceAccountTokenPayload.serviceAccountTokenDeleted": + if e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccountTokenDeleted == nil { break } - return e.ComplexityRoot.DeprecatedRegistryIssue.Workload(childComplexity), true + return e.ComplexityRoot.DeleteServiceAccountTokenPayload.ServiceAccountTokenDeleted(childComplexity), true - case "EntraIDAuthIntegration.name": - if e.ComplexityRoot.EntraIDAuthIntegration.Name == nil { + case "DeleteUnleashInstancePayload.unleashDeleted": + if e.ComplexityRoot.DeleteUnleashInstancePayload.UnleashDeleted == nil { break } - return e.ComplexityRoot.EntraIDAuthIntegration.Name(childComplexity), true + return e.ComplexityRoot.DeleteUnleashInstancePayload.UnleashDeleted(childComplexity), true - case "Environment.id": - if e.ComplexityRoot.Environment.ID == nil { + case "DeleteValkeyPayload.valkeyDeleted": + if e.ComplexityRoot.DeleteValkeyPayload.ValkeyDeleted == nil { break } - return e.ComplexityRoot.Environment.ID(childComplexity), true + return e.ComplexityRoot.DeleteValkeyPayload.ValkeyDeleted(childComplexity), true - case "Environment.metrics": - if e.ComplexityRoot.Environment.Metrics == nil { + case "Deployment.commitSha": + if e.ComplexityRoot.Deployment.CommitSha == nil { break } - args, err := ec.field_Environment_metrics_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Environment.Metrics(childComplexity, args["input"].(metrics.MetricsQueryInput)), true + return e.ComplexityRoot.Deployment.CommitSha(childComplexity), true - case "Environment.name": - if e.ComplexityRoot.Environment.Name == nil { + case "Deployment.createdAt": + if e.ComplexityRoot.Deployment.CreatedAt == nil { break } - return e.ComplexityRoot.Environment.Name(childComplexity), true + return e.ComplexityRoot.Deployment.CreatedAt(childComplexity), true - case "Environment.workloads": - if e.ComplexityRoot.Environment.Workloads == nil { + case "Deployment.deployerUsername": + if e.ComplexityRoot.Deployment.DeployerUsername == nil { break } - args, err := ec.field_Environment_workloads_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Environment.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*workload.EnvironmentWorkloadOrder)), true + return e.ComplexityRoot.Deployment.DeployerUsername(childComplexity), true - case "EnvironmentConnection.edges": - if e.ComplexityRoot.EnvironmentConnection.Edges == nil { + case "Deployment.environmentName": + if e.ComplexityRoot.Deployment.EnvironmentName == nil { break } - return e.ComplexityRoot.EnvironmentConnection.Edges(childComplexity), true + return e.ComplexityRoot.Deployment.EnvironmentName(childComplexity), true - case "EnvironmentConnection.nodes": - if e.ComplexityRoot.EnvironmentConnection.Nodes == nil { + case "Deployment.id": + if e.ComplexityRoot.Deployment.ID == nil { break } - return e.ComplexityRoot.EnvironmentConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Deployment.ID(childComplexity), true - case "EnvironmentConnection.pageInfo": - if e.ComplexityRoot.EnvironmentConnection.PageInfo == nil { + case "Deployment.repository": + if e.ComplexityRoot.Deployment.Repository == nil { break } - return e.ComplexityRoot.EnvironmentConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Deployment.Repository(childComplexity), true - case "EnvironmentEdge.cursor": - if e.ComplexityRoot.EnvironmentEdge.Cursor == nil { + case "Deployment.resources": + if e.ComplexityRoot.Deployment.Resources == nil { break } - return e.ComplexityRoot.EnvironmentEdge.Cursor(childComplexity), true - - case "EnvironmentEdge.node": - if e.ComplexityRoot.EnvironmentEdge.Node == nil { - break + args, err := ec.field_Deployment_resources_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.EnvironmentEdge.Node(childComplexity), true + return e.ComplexityRoot.Deployment.Resources(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ExternalIngressCriticalVulnerabilityIssue.cvssScore": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.CvssScore == nil { + case "Deployment.statuses": + if e.ComplexityRoot.Deployment.Statuses == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.CvssScore(childComplexity), true + args, err := ec.field_Deployment_statuses_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "ExternalIngressCriticalVulnerabilityIssue.id": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.ID == nil { + return e.ComplexityRoot.Deployment.Statuses(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "Deployment.teamSlug": + if e.ComplexityRoot.Deployment.TeamSlug == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.ID(childComplexity), true + return e.ComplexityRoot.Deployment.TeamSlug(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.ingresses": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Ingresses == nil { + case "Deployment.triggerUrl": + if e.ComplexityRoot.Deployment.TriggerUrl == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Ingresses(childComplexity), true + return e.ComplexityRoot.Deployment.TriggerUrl(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.message": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Message == nil { + case "DeploymentActivityLogEntry.actor": + if e.ComplexityRoot.DeploymentActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Message(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.Actor(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.severity": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Severity == nil { + case "DeploymentActivityLogEntry.createdAt": + if e.ComplexityRoot.DeploymentActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Severity(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.CreatedAt(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.teamEnvironment": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.TeamEnvironment == nil { + case "DeploymentActivityLogEntry.data": + if e.ComplexityRoot.DeploymentActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.Data(childComplexity), true - case "ExternalIngressCriticalVulnerabilityIssue.workload": - if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Workload == nil { + case "DeploymentActivityLogEntry.environmentName": + if e.ComplexityRoot.DeploymentActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Workload(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.EnvironmentName(childComplexity), true - case "ExternalNetworkPolicyHost.ports": - if e.ComplexityRoot.ExternalNetworkPolicyHost.Ports == nil { + case "DeploymentActivityLogEntry.id": + if e.ComplexityRoot.DeploymentActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ExternalNetworkPolicyHost.Ports(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.ID(childComplexity), true - case "ExternalNetworkPolicyHost.target": - if e.ComplexityRoot.ExternalNetworkPolicyHost.Target == nil { + case "DeploymentActivityLogEntry.message": + if e.ComplexityRoot.DeploymentActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ExternalNetworkPolicyHost.Target(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.Message(childComplexity), true - case "ExternalNetworkPolicyIpv4.ports": - if e.ComplexityRoot.ExternalNetworkPolicyIpv4.Ports == nil { + case "DeploymentActivityLogEntry.resourceName": + if e.ComplexityRoot.DeploymentActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ExternalNetworkPolicyIpv4.Ports(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.ResourceName(childComplexity), true - case "ExternalNetworkPolicyIpv4.target": - if e.ComplexityRoot.ExternalNetworkPolicyIpv4.Target == nil { + case "DeploymentActivityLogEntry.resourceType": + if e.ComplexityRoot.DeploymentActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ExternalNetworkPolicyIpv4.Target(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.ResourceType(childComplexity), true - case "FailedSynchronizationIssue.id": - if e.ComplexityRoot.FailedSynchronizationIssue.ID == nil { + case "DeploymentActivityLogEntry.teamSlug": + if e.ComplexityRoot.DeploymentActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.ID(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntry.TeamSlug(childComplexity), true - case "FailedSynchronizationIssue.message": - if e.ComplexityRoot.FailedSynchronizationIssue.Message == nil { + case "DeploymentActivityLogEntryData.triggerURL": + if e.ComplexityRoot.DeploymentActivityLogEntryData.TriggerURL == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.Message(childComplexity), true + return e.ComplexityRoot.DeploymentActivityLogEntryData.TriggerURL(childComplexity), true - case "FailedSynchronizationIssue.severity": - if e.ComplexityRoot.FailedSynchronizationIssue.Severity == nil { + case "DeploymentConnection.edges": + if e.ComplexityRoot.DeploymentConnection.Edges == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.Severity(childComplexity), true + return e.ComplexityRoot.DeploymentConnection.Edges(childComplexity), true - case "FailedSynchronizationIssue.teamEnvironment": - if e.ComplexityRoot.FailedSynchronizationIssue.TeamEnvironment == nil { + case "DeploymentConnection.nodes": + if e.ComplexityRoot.DeploymentConnection.Nodes == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.DeploymentConnection.Nodes(childComplexity), true - case "FailedSynchronizationIssue.workload": - if e.ComplexityRoot.FailedSynchronizationIssue.Workload == nil { + case "DeploymentConnection.pageInfo": + if e.ComplexityRoot.DeploymentConnection.PageInfo == nil { break } - return e.ComplexityRoot.FailedSynchronizationIssue.Workload(childComplexity), true + return e.ComplexityRoot.DeploymentConnection.PageInfo(childComplexity), true - case "FeatureKafka.enabled": - if e.ComplexityRoot.FeatureKafka.Enabled == nil { + case "DeploymentEdge.cursor": + if e.ComplexityRoot.DeploymentEdge.Cursor == nil { break } - return e.ComplexityRoot.FeatureKafka.Enabled(childComplexity), true + return e.ComplexityRoot.DeploymentEdge.Cursor(childComplexity), true - case "FeatureKafka.id": - if e.ComplexityRoot.FeatureKafka.ID == nil { + case "DeploymentEdge.node": + if e.ComplexityRoot.DeploymentEdge.Node == nil { break } - return e.ComplexityRoot.FeatureKafka.ID(childComplexity), true + return e.ComplexityRoot.DeploymentEdge.Node(childComplexity), true - case "FeatureOpenSearch.enabled": - if e.ComplexityRoot.FeatureOpenSearch.Enabled == nil { + case "DeploymentKey.created": + if e.ComplexityRoot.DeploymentKey.Created == nil { break } - return e.ComplexityRoot.FeatureOpenSearch.Enabled(childComplexity), true + return e.ComplexityRoot.DeploymentKey.Created(childComplexity), true - case "FeatureOpenSearch.id": - if e.ComplexityRoot.FeatureOpenSearch.ID == nil { + case "DeploymentKey.expires": + if e.ComplexityRoot.DeploymentKey.Expires == nil { break } - return e.ComplexityRoot.FeatureOpenSearch.ID(childComplexity), true + return e.ComplexityRoot.DeploymentKey.Expires(childComplexity), true - case "FeatureUnleash.enabled": - if e.ComplexityRoot.FeatureUnleash.Enabled == nil { + case "DeploymentKey.id": + if e.ComplexityRoot.DeploymentKey.ID == nil { break } - return e.ComplexityRoot.FeatureUnleash.Enabled(childComplexity), true + return e.ComplexityRoot.DeploymentKey.ID(childComplexity), true - case "FeatureUnleash.id": - if e.ComplexityRoot.FeatureUnleash.ID == nil { + case "DeploymentKey.key": + if e.ComplexityRoot.DeploymentKey.Key == nil { break } - return e.ComplexityRoot.FeatureUnleash.ID(childComplexity), true + return e.ComplexityRoot.DeploymentKey.Key(childComplexity), true - case "FeatureValkey.enabled": - if e.ComplexityRoot.FeatureValkey.Enabled == nil { + case "DeploymentResource.id": + if e.ComplexityRoot.DeploymentResource.ID == nil { break } - return e.ComplexityRoot.FeatureValkey.Enabled(childComplexity), true + return e.ComplexityRoot.DeploymentResource.ID(childComplexity), true - case "FeatureValkey.id": - if e.ComplexityRoot.FeatureValkey.ID == nil { + case "DeploymentResource.kind": + if e.ComplexityRoot.DeploymentResource.Kind == nil { break } - return e.ComplexityRoot.FeatureValkey.ID(childComplexity), true + return e.ComplexityRoot.DeploymentResource.Kind(childComplexity), true - case "Features.id": - if e.ComplexityRoot.Features.ID == nil { + case "DeploymentResource.name": + if e.ComplexityRoot.DeploymentResource.Name == nil { break } - return e.ComplexityRoot.Features.ID(childComplexity), true + return e.ComplexityRoot.DeploymentResource.Name(childComplexity), true - case "Features.kafka": - if e.ComplexityRoot.Features.Kafka == nil { + case "DeploymentResourceConnection.edges": + if e.ComplexityRoot.DeploymentResourceConnection.Edges == nil { break } - return e.ComplexityRoot.Features.Kafka(childComplexity), true + return e.ComplexityRoot.DeploymentResourceConnection.Edges(childComplexity), true - case "Features.openSearch": - if e.ComplexityRoot.Features.OpenSearch == nil { + case "DeploymentResourceConnection.nodes": + if e.ComplexityRoot.DeploymentResourceConnection.Nodes == nil { break } - return e.ComplexityRoot.Features.OpenSearch(childComplexity), true + return e.ComplexityRoot.DeploymentResourceConnection.Nodes(childComplexity), true - case "Features.unleash": - if e.ComplexityRoot.Features.Unleash == nil { + case "DeploymentResourceConnection.pageInfo": + if e.ComplexityRoot.DeploymentResourceConnection.PageInfo == nil { break } - return e.ComplexityRoot.Features.Unleash(childComplexity), true + return e.ComplexityRoot.DeploymentResourceConnection.PageInfo(childComplexity), true - case "Features.valkey": - if e.ComplexityRoot.Features.Valkey == nil { + case "DeploymentResourceEdge.cursor": + if e.ComplexityRoot.DeploymentResourceEdge.Cursor == nil { break } - return e.ComplexityRoot.Features.Valkey(childComplexity), true + return e.ComplexityRoot.DeploymentResourceEdge.Cursor(childComplexity), true - case "GenericKubernetesResourceActivityLogEntry.actor": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Actor == nil { + case "DeploymentResourceEdge.node": + if e.ComplexityRoot.DeploymentResourceEdge.Node == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.DeploymentResourceEdge.Node(childComplexity), true - case "GenericKubernetesResourceActivityLogEntry.createdAt": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.CreatedAt == nil { + case "DeploymentStatus.createdAt": + if e.ComplexityRoot.DeploymentStatus.CreatedAt == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.DeploymentStatus.CreatedAt(childComplexity), true - case "GenericKubernetesResourceActivityLogEntry.data": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Data == nil { + case "DeploymentStatus.id": + if e.ComplexityRoot.DeploymentStatus.ID == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.DeploymentStatus.ID(childComplexity), true - case "GenericKubernetesResourceActivityLogEntry.environmentName": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.EnvironmentName == nil { + case "DeploymentStatus.message": + if e.ComplexityRoot.DeploymentStatus.Message == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.DeploymentStatus.Message(childComplexity), true - case "GenericKubernetesResourceActivityLogEntry.id": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ID == nil { + case "DeploymentStatus.state": + if e.ComplexityRoot.DeploymentStatus.State == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.DeploymentStatus.State(childComplexity), true - case "GenericKubernetesResourceActivityLogEntry.message": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Message == nil { + case "DeploymentStatusConnection.edges": + if e.ComplexityRoot.DeploymentStatusConnection.Edges == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.DeploymentStatusConnection.Edges(childComplexity), true - case "GenericKubernetesResourceActivityLogEntry.resourceName": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ResourceName == nil { + case "DeploymentStatusConnection.nodes": + if e.ComplexityRoot.DeploymentStatusConnection.Nodes == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.DeploymentStatusConnection.Nodes(childComplexity), true - case "GenericKubernetesResourceActivityLogEntry.resourceType": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ResourceType == nil { + case "DeploymentStatusConnection.pageInfo": + if e.ComplexityRoot.DeploymentStatusConnection.PageInfo == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.DeploymentStatusConnection.PageInfo(childComplexity), true - case "GenericKubernetesResourceActivityLogEntry.teamSlug": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.TeamSlug == nil { + case "DeploymentStatusEdge.cursor": + if e.ComplexityRoot.DeploymentStatusEdge.Cursor == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.DeploymentStatusEdge.Cursor(childComplexity), true - case "GenericKubernetesResourceActivityLogEntryData.apiVersion": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.APIVersion == nil { + case "DeploymentStatusEdge.node": + if e.ComplexityRoot.DeploymentStatusEdge.Node == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.APIVersion(childComplexity), true + return e.ComplexityRoot.DeploymentStatusEdge.Node(childComplexity), true - case "GenericKubernetesResourceActivityLogEntryData.changedFields": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.ChangedFields == nil { + case "DeprecatedIngressIssue.application": + if e.ComplexityRoot.DeprecatedIngressIssue.Application == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.ChangedFields(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.Application(childComplexity), true - case "GenericKubernetesResourceActivityLogEntryData.gitHubClaims": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.GitHubClaims == nil { + case "DeprecatedIngressIssue.id": + if e.ComplexityRoot.DeprecatedIngressIssue.ID == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.GitHubClaims(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.ID(childComplexity), true - case "GenericKubernetesResourceActivityLogEntryData.kind": - if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.Kind == nil { + case "DeprecatedIngressIssue.ingresses": + if e.ComplexityRoot.DeprecatedIngressIssue.Ingresses == nil { break } - return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.Kind(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.Ingresses(childComplexity), true - case "GitHubActorClaims.actor": - if e.ComplexityRoot.GitHubActorClaims.Actor == nil { + case "DeprecatedIngressIssue.message": + if e.ComplexityRoot.DeprecatedIngressIssue.Message == nil { break } - return e.ComplexityRoot.GitHubActorClaims.Actor(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.Message(childComplexity), true - case "GitHubActorClaims.environment": - if e.ComplexityRoot.GitHubActorClaims.Environment == nil { + case "DeprecatedIngressIssue.severity": + if e.ComplexityRoot.DeprecatedIngressIssue.Severity == nil { break } - return e.ComplexityRoot.GitHubActorClaims.Environment(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.Severity(childComplexity), true - case "GitHubActorClaims.eventName": - if e.ComplexityRoot.GitHubActorClaims.EventName == nil { + case "DeprecatedIngressIssue.teamEnvironment": + if e.ComplexityRoot.DeprecatedIngressIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.GitHubActorClaims.EventName(childComplexity), true + return e.ComplexityRoot.DeprecatedIngressIssue.TeamEnvironment(childComplexity), true - case "GitHubActorClaims.jobWorkflowRef": - if e.ComplexityRoot.GitHubActorClaims.JobWorkflowRef == nil { + case "DeprecatedRegistryIssue.id": + if e.ComplexityRoot.DeprecatedRegistryIssue.ID == nil { break } - return e.ComplexityRoot.GitHubActorClaims.JobWorkflowRef(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.ID(childComplexity), true - case "GitHubActorClaims.ref": - if e.ComplexityRoot.GitHubActorClaims.Ref == nil { + case "DeprecatedRegistryIssue.message": + if e.ComplexityRoot.DeprecatedRegistryIssue.Message == nil { break } - return e.ComplexityRoot.GitHubActorClaims.Ref(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.Message(childComplexity), true - case "GitHubActorClaims.repository": - if e.ComplexityRoot.GitHubActorClaims.Repository == nil { + case "DeprecatedRegistryIssue.severity": + if e.ComplexityRoot.DeprecatedRegistryIssue.Severity == nil { break } - return e.ComplexityRoot.GitHubActorClaims.Repository(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.Severity(childComplexity), true - case "GitHubActorClaims.repositoryID": - if e.ComplexityRoot.GitHubActorClaims.RepositoryID == nil { + case "DeprecatedRegistryIssue.teamEnvironment": + if e.ComplexityRoot.DeprecatedRegistryIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.GitHubActorClaims.RepositoryID(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.TeamEnvironment(childComplexity), true - case "GitHubActorClaims.runAttempt": - if e.ComplexityRoot.GitHubActorClaims.RunAttempt == nil { + case "DeprecatedRegistryIssue.workload": + if e.ComplexityRoot.DeprecatedRegistryIssue.Workload == nil { break } - return e.ComplexityRoot.GitHubActorClaims.RunAttempt(childComplexity), true + return e.ComplexityRoot.DeprecatedRegistryIssue.Workload(childComplexity), true - case "GitHubActorClaims.runID": - if e.ComplexityRoot.GitHubActorClaims.RunID == nil { + case "EntraIDAuthIntegration.name": + if e.ComplexityRoot.EntraIDAuthIntegration.Name == nil { break } - return e.ComplexityRoot.GitHubActorClaims.RunID(childComplexity), true + return e.ComplexityRoot.EntraIDAuthIntegration.Name(childComplexity), true - case "GitHubActorClaims.workflow": - if e.ComplexityRoot.GitHubActorClaims.Workflow == nil { + case "Environment.id": + if e.ComplexityRoot.Environment.ID == nil { break } - return e.ComplexityRoot.GitHubActorClaims.Workflow(childComplexity), true + return e.ComplexityRoot.Environment.ID(childComplexity), true - case "GrantPostgresAccessPayload.error": - if e.ComplexityRoot.GrantPostgresAccessPayload.Error == nil { + case "Environment.metrics": + if e.ComplexityRoot.Environment.Metrics == nil { break } - return e.ComplexityRoot.GrantPostgresAccessPayload.Error(childComplexity), true - - case "IDPortenAuthIntegration.name": - if e.ComplexityRoot.IDPortenAuthIntegration.Name == nil { - break + args, err := ec.field_Environment_metrics_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.IDPortenAuthIntegration.Name(childComplexity), true + return e.ComplexityRoot.Environment.Metrics(childComplexity, args["input"].(metrics.MetricsQueryInput)), true - case "ImageVulnerability.cvssScore": - if e.ComplexityRoot.ImageVulnerability.CvssScore == nil { + case "Environment.name": + if e.ComplexityRoot.Environment.Name == nil { break } - return e.ComplexityRoot.ImageVulnerability.CvssScore(childComplexity), true + return e.ComplexityRoot.Environment.Name(childComplexity), true - case "ImageVulnerability.description": - if e.ComplexityRoot.ImageVulnerability.Description == nil { + case "Environment.workloads": + if e.ComplexityRoot.Environment.Workloads == nil { break } - return e.ComplexityRoot.ImageVulnerability.Description(childComplexity), true - - case "ImageVulnerability.id": - if e.ComplexityRoot.ImageVulnerability.ID == nil { - break + args, err := ec.field_Environment_workloads_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ImageVulnerability.ID(childComplexity), true + return e.ComplexityRoot.Environment.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*workload.EnvironmentWorkloadOrder)), true - case "ImageVulnerability.identifier": - if e.ComplexityRoot.ImageVulnerability.Identifier == nil { + case "EnvironmentConnection.edges": + if e.ComplexityRoot.EnvironmentConnection.Edges == nil { break } - return e.ComplexityRoot.ImageVulnerability.Identifier(childComplexity), true + return e.ComplexityRoot.EnvironmentConnection.Edges(childComplexity), true - case "ImageVulnerability.package": - if e.ComplexityRoot.ImageVulnerability.Package == nil { + case "EnvironmentConnection.nodes": + if e.ComplexityRoot.EnvironmentConnection.Nodes == nil { break } - return e.ComplexityRoot.ImageVulnerability.Package(childComplexity), true + return e.ComplexityRoot.EnvironmentConnection.Nodes(childComplexity), true - case "ImageVulnerability.severity": - if e.ComplexityRoot.ImageVulnerability.Severity == nil { + case "EnvironmentConnection.pageInfo": + if e.ComplexityRoot.EnvironmentConnection.PageInfo == nil { break } - return e.ComplexityRoot.ImageVulnerability.Severity(childComplexity), true + return e.ComplexityRoot.EnvironmentConnection.PageInfo(childComplexity), true - case "ImageVulnerability.severitySince": - if e.ComplexityRoot.ImageVulnerability.SeveritySince == nil { + case "EnvironmentEdge.cursor": + if e.ComplexityRoot.EnvironmentEdge.Cursor == nil { break } - return e.ComplexityRoot.ImageVulnerability.SeveritySince(childComplexity), true + return e.ComplexityRoot.EnvironmentEdge.Cursor(childComplexity), true - case "ImageVulnerability.suppression": - if e.ComplexityRoot.ImageVulnerability.Suppression == nil { + case "EnvironmentEdge.node": + if e.ComplexityRoot.EnvironmentEdge.Node == nil { break } - return e.ComplexityRoot.ImageVulnerability.Suppression(childComplexity), true + return e.ComplexityRoot.EnvironmentEdge.Node(childComplexity), true - case "ImageVulnerability.vulnerabilityDetailsLink": - if e.ComplexityRoot.ImageVulnerability.VulnerabilityDetailsLink == nil { + case "ExternalIngressCriticalVulnerabilityIssue.cvssScore": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.CvssScore == nil { break } - return e.ComplexityRoot.ImageVulnerability.VulnerabilityDetailsLink(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.CvssScore(childComplexity), true - case "ImageVulnerabilityConnection.edges": - if e.ComplexityRoot.ImageVulnerabilityConnection.Edges == nil { + case "ExternalIngressCriticalVulnerabilityIssue.id": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.ID == nil { break } - return e.ComplexityRoot.ImageVulnerabilityConnection.Edges(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.ID(childComplexity), true - case "ImageVulnerabilityConnection.nodes": - if e.ComplexityRoot.ImageVulnerabilityConnection.Nodes == nil { + case "ExternalIngressCriticalVulnerabilityIssue.ingresses": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Ingresses == nil { break } - return e.ComplexityRoot.ImageVulnerabilityConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Ingresses(childComplexity), true - case "ImageVulnerabilityConnection.pageInfo": - if e.ComplexityRoot.ImageVulnerabilityConnection.PageInfo == nil { + case "ExternalIngressCriticalVulnerabilityIssue.message": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Message == nil { break } - return e.ComplexityRoot.ImageVulnerabilityConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Message(childComplexity), true - case "ImageVulnerabilityEdge.cursor": - if e.ComplexityRoot.ImageVulnerabilityEdge.Cursor == nil { + case "ExternalIngressCriticalVulnerabilityIssue.severity": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Severity == nil { break } - return e.ComplexityRoot.ImageVulnerabilityEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Severity(childComplexity), true - case "ImageVulnerabilityEdge.node": - if e.ComplexityRoot.ImageVulnerabilityEdge.Node == nil { + case "ExternalIngressCriticalVulnerabilityIssue.teamEnvironment": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.ImageVulnerabilityEdge.Node(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.TeamEnvironment(childComplexity), true - case "ImageVulnerabilityHistory.samples": - if e.ComplexityRoot.ImageVulnerabilityHistory.Samples == nil { + case "ExternalIngressCriticalVulnerabilityIssue.workload": + if e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Workload == nil { break } - return e.ComplexityRoot.ImageVulnerabilityHistory.Samples(childComplexity), true + return e.ComplexityRoot.ExternalIngressCriticalVulnerabilityIssue.Workload(childComplexity), true - case "ImageVulnerabilitySample.date": - if e.ComplexityRoot.ImageVulnerabilitySample.Date == nil { + case "ExternalNetworkPolicyHost.ports": + if e.ComplexityRoot.ExternalNetworkPolicyHost.Ports == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySample.Date(childComplexity), true + return e.ComplexityRoot.ExternalNetworkPolicyHost.Ports(childComplexity), true - case "ImageVulnerabilitySample.summary": - if e.ComplexityRoot.ImageVulnerabilitySample.Summary == nil { + case "ExternalNetworkPolicyHost.target": + if e.ComplexityRoot.ExternalNetworkPolicyHost.Target == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySample.Summary(childComplexity), true + return e.ComplexityRoot.ExternalNetworkPolicyHost.Target(childComplexity), true - case "ImageVulnerabilitySummary.critical": - if e.ComplexityRoot.ImageVulnerabilitySummary.Critical == nil { + case "ExternalNetworkPolicyIpv4.ports": + if e.ComplexityRoot.ExternalNetworkPolicyIpv4.Ports == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Critical(childComplexity), true + return e.ComplexityRoot.ExternalNetworkPolicyIpv4.Ports(childComplexity), true - case "ImageVulnerabilitySummary.high": - if e.ComplexityRoot.ImageVulnerabilitySummary.High == nil { + case "ExternalNetworkPolicyIpv4.target": + if e.ComplexityRoot.ExternalNetworkPolicyIpv4.Target == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.High(childComplexity), true + return e.ComplexityRoot.ExternalNetworkPolicyIpv4.Target(childComplexity), true - case "ImageVulnerabilitySummary.lastUpdated": - if e.ComplexityRoot.ImageVulnerabilitySummary.LastUpdated == nil { + case "FailedSynchronizationIssue.id": + if e.ComplexityRoot.FailedSynchronizationIssue.ID == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.LastUpdated(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.ID(childComplexity), true - case "ImageVulnerabilitySummary.low": - if e.ComplexityRoot.ImageVulnerabilitySummary.Low == nil { + case "FailedSynchronizationIssue.message": + if e.ComplexityRoot.FailedSynchronizationIssue.Message == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Low(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.Message(childComplexity), true - case "ImageVulnerabilitySummary.medium": - if e.ComplexityRoot.ImageVulnerabilitySummary.Medium == nil { + case "FailedSynchronizationIssue.severity": + if e.ComplexityRoot.FailedSynchronizationIssue.Severity == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Medium(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.Severity(childComplexity), true - case "ImageVulnerabilitySummary.riskScore": - if e.ComplexityRoot.ImageVulnerabilitySummary.RiskScore == nil { + case "FailedSynchronizationIssue.teamEnvironment": + if e.ComplexityRoot.FailedSynchronizationIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.RiskScore(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.TeamEnvironment(childComplexity), true - case "ImageVulnerabilitySummary.total": - if e.ComplexityRoot.ImageVulnerabilitySummary.Total == nil { + case "FailedSynchronizationIssue.workload": + if e.ComplexityRoot.FailedSynchronizationIssue.Workload == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Total(childComplexity), true + return e.ComplexityRoot.FailedSynchronizationIssue.Workload(childComplexity), true - case "ImageVulnerabilitySummary.unassigned": - if e.ComplexityRoot.ImageVulnerabilitySummary.Unassigned == nil { + case "FeatureKafka.enabled": + if e.ComplexityRoot.FeatureKafka.Enabled == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySummary.Unassigned(childComplexity), true + return e.ComplexityRoot.FeatureKafka.Enabled(childComplexity), true - case "ImageVulnerabilitySuppression.reason": - if e.ComplexityRoot.ImageVulnerabilitySuppression.Reason == nil { + case "FeatureKafka.id": + if e.ComplexityRoot.FeatureKafka.ID == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySuppression.Reason(childComplexity), true + return e.ComplexityRoot.FeatureKafka.ID(childComplexity), true - case "ImageVulnerabilitySuppression.state": - if e.ComplexityRoot.ImageVulnerabilitySuppression.State == nil { + case "FeatureOpenSearch.enabled": + if e.ComplexityRoot.FeatureOpenSearch.Enabled == nil { break } - return e.ComplexityRoot.ImageVulnerabilitySuppression.State(childComplexity), true + return e.ComplexityRoot.FeatureOpenSearch.Enabled(childComplexity), true - case "InboundNetworkPolicy.rules": - if e.ComplexityRoot.InboundNetworkPolicy.Rules == nil { + case "FeatureOpenSearch.id": + if e.ComplexityRoot.FeatureOpenSearch.ID == nil { break } - return e.ComplexityRoot.InboundNetworkPolicy.Rules(childComplexity), true + return e.ComplexityRoot.FeatureOpenSearch.ID(childComplexity), true - case "Ingress.metrics": - if e.ComplexityRoot.Ingress.Metrics == nil { + case "FeatureUnleash.enabled": + if e.ComplexityRoot.FeatureUnleash.Enabled == nil { break } - return e.ComplexityRoot.Ingress.Metrics(childComplexity), true + return e.ComplexityRoot.FeatureUnleash.Enabled(childComplexity), true - case "Ingress.type": - if e.ComplexityRoot.Ingress.Type == nil { + case "FeatureUnleash.id": + if e.ComplexityRoot.FeatureUnleash.ID == nil { break } - return e.ComplexityRoot.Ingress.Type(childComplexity), true + return e.ComplexityRoot.FeatureUnleash.ID(childComplexity), true - case "Ingress.url": - if e.ComplexityRoot.Ingress.URL == nil { + case "FeatureValkey.enabled": + if e.ComplexityRoot.FeatureValkey.Enabled == nil { break } - return e.ComplexityRoot.Ingress.URL(childComplexity), true + return e.ComplexityRoot.FeatureValkey.Enabled(childComplexity), true - case "IngressMetricSample.timestamp": - if e.ComplexityRoot.IngressMetricSample.Timestamp == nil { + case "FeatureValkey.id": + if e.ComplexityRoot.FeatureValkey.ID == nil { break } - return e.ComplexityRoot.IngressMetricSample.Timestamp(childComplexity), true + return e.ComplexityRoot.FeatureValkey.ID(childComplexity), true - case "IngressMetricSample.value": - if e.ComplexityRoot.IngressMetricSample.Value == nil { + case "Features.id": + if e.ComplexityRoot.Features.ID == nil { break } - return e.ComplexityRoot.IngressMetricSample.Value(childComplexity), true + return e.ComplexityRoot.Features.ID(childComplexity), true - case "IngressMetrics.errorsPerSecond": - if e.ComplexityRoot.IngressMetrics.ErrorsPerSecond == nil { + case "Features.kafka": + if e.ComplexityRoot.Features.Kafka == nil { break } - return e.ComplexityRoot.IngressMetrics.ErrorsPerSecond(childComplexity), true + return e.ComplexityRoot.Features.Kafka(childComplexity), true - case "IngressMetrics.requestsPerSecond": - if e.ComplexityRoot.IngressMetrics.RequestsPerSecond == nil { + case "Features.openSearch": + if e.ComplexityRoot.Features.OpenSearch == nil { break } - return e.ComplexityRoot.IngressMetrics.RequestsPerSecond(childComplexity), true + return e.ComplexityRoot.Features.OpenSearch(childComplexity), true - case "IngressMetrics.series": - if e.ComplexityRoot.IngressMetrics.Series == nil { + case "Features.unleash": + if e.ComplexityRoot.Features.Unleash == nil { break } - args, err := ec.field_IngressMetrics_series_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.Features.Unleash(childComplexity), true + + case "Features.valkey": + if e.ComplexityRoot.Features.Valkey == nil { + break } - return e.ComplexityRoot.IngressMetrics.Series(childComplexity, args["input"].(application.IngressMetricsInput)), true + return e.ComplexityRoot.Features.Valkey(childComplexity), true - case "InvalidSpecIssue.id": - if e.ComplexityRoot.InvalidSpecIssue.ID == nil { + case "GenericKubernetesResourceActivityLogEntry.actor": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.ID(childComplexity), true + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Actor(childComplexity), true - case "InvalidSpecIssue.message": - if e.ComplexityRoot.InvalidSpecIssue.Message == nil { + case "GenericKubernetesResourceActivityLogEntry.createdAt": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.Message(childComplexity), true + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.CreatedAt(childComplexity), true - case "InvalidSpecIssue.severity": - if e.ComplexityRoot.InvalidSpecIssue.Severity == nil { + case "GenericKubernetesResourceActivityLogEntry.data": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.Severity(childComplexity), true + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Data(childComplexity), true - case "InvalidSpecIssue.teamEnvironment": - if e.ComplexityRoot.InvalidSpecIssue.TeamEnvironment == nil { + case "GenericKubernetesResourceActivityLogEntry.environmentName": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.EnvironmentName(childComplexity), true - case "InvalidSpecIssue.workload": - if e.ComplexityRoot.InvalidSpecIssue.Workload == nil { + case "GenericKubernetesResourceActivityLogEntry.id": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.InvalidSpecIssue.Workload(childComplexity), true + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ID(childComplexity), true - case "IssueConnection.edges": - if e.ComplexityRoot.IssueConnection.Edges == nil { + case "GenericKubernetesResourceActivityLogEntry.message": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.IssueConnection.Edges(childComplexity), true + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.Message(childComplexity), true - case "IssueConnection.nodes": - if e.ComplexityRoot.IssueConnection.Nodes == nil { + case "GenericKubernetesResourceActivityLogEntry.resourceName": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.IssueConnection.Nodes(childComplexity), true + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ResourceName(childComplexity), true - case "IssueConnection.pageInfo": - if e.ComplexityRoot.IssueConnection.PageInfo == nil { + case "GenericKubernetesResourceActivityLogEntry.resourceType": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.IssueConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.ResourceType(childComplexity), true - case "IssueEdge.cursor": - if e.ComplexityRoot.IssueEdge.Cursor == nil { + case "GenericKubernetesResourceActivityLogEntry.teamSlug": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.IssueEdge.Cursor(childComplexity), true + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntry.TeamSlug(childComplexity), true - case "IssueEdge.node": - if e.ComplexityRoot.IssueEdge.Node == nil { + case "GenericKubernetesResourceActivityLogEntryData.apiVersion": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.APIVersion == nil { break } - return e.ComplexityRoot.IssueEdge.Node(childComplexity), true + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.APIVersion(childComplexity), true - case "Job.activityLog": - if e.ComplexityRoot.Job.ActivityLog == nil { + case "GenericKubernetesResourceActivityLogEntryData.changedFields": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.ChangedFields == nil { break } - args, err := ec.field_Job_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.ChangedFields(childComplexity), true + + case "GenericKubernetesResourceActivityLogEntryData.gitHubClaims": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.GitHubClaims == nil { + break } - return e.ComplexityRoot.Job.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.GitHubClaims(childComplexity), true - case "Job.authIntegrations": - if e.ComplexityRoot.Job.AuthIntegrations == nil { + case "GenericKubernetesResourceActivityLogEntryData.kind": + if e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.Kind == nil { break } - return e.ComplexityRoot.Job.AuthIntegrations(childComplexity), true + return e.ComplexityRoot.GenericKubernetesResourceActivityLogEntryData.Kind(childComplexity), true - case "Job.bigQueryDatasets": - if e.ComplexityRoot.Job.BigQueryDatasets == nil { + case "GitHubActorClaims.actor": + if e.ComplexityRoot.GitHubActorClaims.Actor == nil { break } - args, err := ec.field_Job_bigQueryDatasets_args(ctx, rawArgs) - if err != nil { - return 0, false - } + return e.ComplexityRoot.GitHubActorClaims.Actor(childComplexity), true - return e.ComplexityRoot.Job.BigQueryDatasets(childComplexity, args["orderBy"].(*bigquery.BigQueryDatasetOrder)), true - - case "Job.buckets": - if e.ComplexityRoot.Job.Buckets == nil { + case "GitHubActorClaims.environment": + if e.ComplexityRoot.GitHubActorClaims.Environment == nil { break } - args, err := ec.field_Job_buckets_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Buckets(childComplexity, args["orderBy"].(*bucket.BucketOrder)), true + return e.ComplexityRoot.GitHubActorClaims.Environment(childComplexity), true - case "Job.cost": - if e.ComplexityRoot.Job.Cost == nil { + case "GitHubActorClaims.eventName": + if e.ComplexityRoot.GitHubActorClaims.EventName == nil { break } - return e.ComplexityRoot.Job.Cost(childComplexity), true + return e.ComplexityRoot.GitHubActorClaims.EventName(childComplexity), true - case "Job.deletionStartedAt": - if e.ComplexityRoot.Job.DeletionStartedAt == nil { + case "GitHubActorClaims.jobWorkflowRef": + if e.ComplexityRoot.GitHubActorClaims.JobWorkflowRef == nil { break } - return e.ComplexityRoot.Job.DeletionStartedAt(childComplexity), true + return e.ComplexityRoot.GitHubActorClaims.JobWorkflowRef(childComplexity), true - case "Job.deployments": - if e.ComplexityRoot.Job.Deployments == nil { + case "GitHubActorClaims.ref": + if e.ComplexityRoot.GitHubActorClaims.Ref == nil { break } - args, err := ec.field_Job_deployments_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.GitHubActorClaims.Ref(childComplexity), true - case "Job.environment": - if e.ComplexityRoot.Job.Environment == nil { + case "GitHubActorClaims.repository": + if e.ComplexityRoot.GitHubActorClaims.Repository == nil { break } - return e.ComplexityRoot.Job.Environment(childComplexity), true + return e.ComplexityRoot.GitHubActorClaims.Repository(childComplexity), true - case "Job.id": - if e.ComplexityRoot.Job.ID == nil { + case "GitHubActorClaims.repositoryID": + if e.ComplexityRoot.GitHubActorClaims.RepositoryID == nil { break } - return e.ComplexityRoot.Job.ID(childComplexity), true + return e.ComplexityRoot.GitHubActorClaims.RepositoryID(childComplexity), true - case "Job.image": - if e.ComplexityRoot.Job.Image == nil { + case "GitHubActorClaims.runAttempt": + if e.ComplexityRoot.GitHubActorClaims.RunAttempt == nil { break } - return e.ComplexityRoot.Job.Image(childComplexity), true + return e.ComplexityRoot.GitHubActorClaims.RunAttempt(childComplexity), true - case "Job.imageVulnerabilityHistory": - if e.ComplexityRoot.Job.ImageVulnerabilityHistory == nil { + case "GitHubActorClaims.runID": + if e.ComplexityRoot.GitHubActorClaims.RunID == nil { break } - args, err := ec.field_Job_imageVulnerabilityHistory_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.GitHubActorClaims.RunID(childComplexity), true - case "Job.issues": - if e.ComplexityRoot.Job.Issues == nil { + case "GitHubActorClaims.workflow": + if e.ComplexityRoot.GitHubActorClaims.Workflow == nil { break } - args, err := ec.field_Job_issues_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + return e.ComplexityRoot.GitHubActorClaims.Workflow(childComplexity), true - case "Job.kafkaTopicAcls": - if e.ComplexityRoot.Job.KafkaTopicAcls == nil { + case "GrantPostgresAccessPayload.error": + if e.ComplexityRoot.GrantPostgresAccessPayload.Error == nil { break } - args, err := ec.field_Job_kafkaTopicAcls_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.KafkaTopicAcls(childComplexity, args["orderBy"].(*kafkatopic.KafkaTopicACLOrder)), true + return e.ComplexityRoot.GrantPostgresAccessPayload.Error(childComplexity), true - case "Job.logDestinations": - if e.ComplexityRoot.Job.LogDestinations == nil { + case "IDPortenAuthIntegration.name": + if e.ComplexityRoot.IDPortenAuthIntegration.Name == nil { break } - return e.ComplexityRoot.Job.LogDestinations(childComplexity), true + return e.ComplexityRoot.IDPortenAuthIntegration.Name(childComplexity), true - case "Job.manifest": - if e.ComplexityRoot.Job.Manifest == nil { + case "ImageVulnerability.cvssScore": + if e.ComplexityRoot.ImageVulnerability.CvssScore == nil { break } - return e.ComplexityRoot.Job.Manifest(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.CvssScore(childComplexity), true - case "Job.name": - if e.ComplexityRoot.Job.Name == nil { + case "ImageVulnerability.description": + if e.ComplexityRoot.ImageVulnerability.Description == nil { break } - return e.ComplexityRoot.Job.Name(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.Description(childComplexity), true - case "Job.networkPolicy": - if e.ComplexityRoot.Job.NetworkPolicy == nil { + case "ImageVulnerability.id": + if e.ComplexityRoot.ImageVulnerability.ID == nil { break } - return e.ComplexityRoot.Job.NetworkPolicy(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.ID(childComplexity), true - case "Job.openSearch": - if e.ComplexityRoot.Job.OpenSearch == nil { + case "ImageVulnerability.identifier": + if e.ComplexityRoot.ImageVulnerability.Identifier == nil { break } - return e.ComplexityRoot.Job.OpenSearch(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.Identifier(childComplexity), true - case "Job.postgresInstances": - if e.ComplexityRoot.Job.PostgresInstances == nil { + case "ImageVulnerability.package": + if e.ComplexityRoot.ImageVulnerability.Package == nil { break } - args, err := ec.field_Job_postgresInstances_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.PostgresInstances(childComplexity, args["orderBy"].(*postgres.PostgresInstanceOrder)), true + return e.ComplexityRoot.ImageVulnerability.Package(childComplexity), true - case "Job.resources": - if e.ComplexityRoot.Job.Resources == nil { + case "ImageVulnerability.severity": + if e.ComplexityRoot.ImageVulnerability.Severity == nil { break } - return e.ComplexityRoot.Job.Resources(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.Severity(childComplexity), true - case "Job.runs": - if e.ComplexityRoot.Job.Runs == nil { + case "ImageVulnerability.severitySince": + if e.ComplexityRoot.ImageVulnerability.SeveritySince == nil { break } - args, err := ec.field_Job_runs_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Runs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ImageVulnerability.SeveritySince(childComplexity), true - case "Job.sqlInstances": - if e.ComplexityRoot.Job.SQLInstances == nil { + case "ImageVulnerability.suppression": + if e.ComplexityRoot.ImageVulnerability.Suppression == nil { break } - args, err := ec.field_Job_sqlInstances_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.SQLInstances(childComplexity, args["orderBy"].(*sqlinstance.SQLInstanceOrder)), true + return e.ComplexityRoot.ImageVulnerability.Suppression(childComplexity), true - case "Job.schedule": - if e.ComplexityRoot.Job.Schedule == nil { + case "ImageVulnerability.vulnerabilityDetailsLink": + if e.ComplexityRoot.ImageVulnerability.VulnerabilityDetailsLink == nil { break } - return e.ComplexityRoot.Job.Schedule(childComplexity), true + return e.ComplexityRoot.ImageVulnerability.VulnerabilityDetailsLink(childComplexity), true - case "Job.secrets": - if e.ComplexityRoot.Job.Secrets == nil { + case "ImageVulnerabilityConnection.edges": + if e.ComplexityRoot.ImageVulnerabilityConnection.Edges == nil { break } - args, err := ec.field_Job_secrets_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Secrets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ImageVulnerabilityConnection.Edges(childComplexity), true - case "Job.state": - if e.ComplexityRoot.Job.State == nil { + case "ImageVulnerabilityConnection.nodes": + if e.ComplexityRoot.ImageVulnerabilityConnection.Nodes == nil { break } - return e.ComplexityRoot.Job.State(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityConnection.Nodes(childComplexity), true - case "Job.team": - if e.ComplexityRoot.Job.Team == nil { + case "ImageVulnerabilityConnection.pageInfo": + if e.ComplexityRoot.ImageVulnerabilityConnection.PageInfo == nil { break } - return e.ComplexityRoot.Job.Team(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityConnection.PageInfo(childComplexity), true - case "Job.teamEnvironment": - if e.ComplexityRoot.Job.TeamEnvironment == nil { + case "ImageVulnerabilityEdge.cursor": + if e.ComplexityRoot.ImageVulnerabilityEdge.Cursor == nil { break } - return e.ComplexityRoot.Job.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilityEdge.Cursor(childComplexity), true - case "Job.valkeys": - if e.ComplexityRoot.Job.Valkeys == nil { + case "ImageVulnerabilityEdge.node": + if e.ComplexityRoot.ImageVulnerabilityEdge.Node == nil { break } - args, err := ec.field_Job_valkeys_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Job.Valkeys(childComplexity, args["orderBy"].(*valkey.ValkeyOrder)), true + return e.ComplexityRoot.ImageVulnerabilityEdge.Node(childComplexity), true - case "Job.vulnerabilityFixHistory": - if e.ComplexityRoot.Job.VulnerabilityFixHistory == nil { + case "ImageVulnerabilityHistory.samples": + if e.ComplexityRoot.ImageVulnerabilityHistory.Samples == nil { break } - args, err := ec.field_Job_vulnerabilityFixHistory_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ImageVulnerabilityHistory.Samples(childComplexity), true + + case "ImageVulnerabilitySample.date": + if e.ComplexityRoot.ImageVulnerabilitySample.Date == nil { + break } - return e.ComplexityRoot.Job.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.ImageVulnerabilitySample.Date(childComplexity), true - case "JobConnection.edges": - if e.ComplexityRoot.JobConnection.Edges == nil { + case "ImageVulnerabilitySample.summary": + if e.ComplexityRoot.ImageVulnerabilitySample.Summary == nil { break } - return e.ComplexityRoot.JobConnection.Edges(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySample.Summary(childComplexity), true - case "JobConnection.nodes": - if e.ComplexityRoot.JobConnection.Nodes == nil { + case "ImageVulnerabilitySummary.critical": + if e.ComplexityRoot.ImageVulnerabilitySummary.Critical == nil { break } - return e.ComplexityRoot.JobConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Critical(childComplexity), true - case "JobConnection.pageInfo": - if e.ComplexityRoot.JobConnection.PageInfo == nil { + case "ImageVulnerabilitySummary.high": + if e.ComplexityRoot.ImageVulnerabilitySummary.High == nil { break } - return e.ComplexityRoot.JobConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.High(childComplexity), true - case "JobCreatedActivityLogEntry.actor": - if e.ComplexityRoot.JobCreatedActivityLogEntry.Actor == nil { + case "ImageVulnerabilitySummary.lastUpdated": + if e.ComplexityRoot.ImageVulnerabilitySummary.LastUpdated == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.LastUpdated(childComplexity), true - case "JobCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.JobCreatedActivityLogEntry.CreatedAt == nil { + case "ImageVulnerabilitySummary.low": + if e.ComplexityRoot.ImageVulnerabilitySummary.Low == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Low(childComplexity), true - case "JobCreatedActivityLogEntry.data": - if e.ComplexityRoot.JobCreatedActivityLogEntry.Data == nil { + case "ImageVulnerabilitySummary.medium": + if e.ComplexityRoot.ImageVulnerabilitySummary.Medium == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Medium(childComplexity), true - case "JobCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.JobCreatedActivityLogEntry.EnvironmentName == nil { + case "ImageVulnerabilitySummary.riskScore": + if e.ComplexityRoot.ImageVulnerabilitySummary.RiskScore == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.RiskScore(childComplexity), true - case "JobCreatedActivityLogEntry.id": - if e.ComplexityRoot.JobCreatedActivityLogEntry.ID == nil { + case "ImageVulnerabilitySummary.total": + if e.ComplexityRoot.ImageVulnerabilitySummary.Total == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Total(childComplexity), true - case "JobCreatedActivityLogEntry.message": - if e.ComplexityRoot.JobCreatedActivityLogEntry.Message == nil { + case "ImageVulnerabilitySummary.unassigned": + if e.ComplexityRoot.ImageVulnerabilitySummary.Unassigned == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySummary.Unassigned(childComplexity), true - case "JobCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceName == nil { + case "ImageVulnerabilitySuppression.reason": + if e.ComplexityRoot.ImageVulnerabilitySuppression.Reason == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySuppression.Reason(childComplexity), true - case "JobCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceType == nil { + case "ImageVulnerabilitySuppression.state": + if e.ComplexityRoot.ImageVulnerabilitySuppression.State == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ImageVulnerabilitySuppression.State(childComplexity), true - case "JobCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.JobCreatedActivityLogEntry.TeamSlug == nil { + case "InboundNetworkPolicy.rules": + if e.ComplexityRoot.InboundNetworkPolicy.Rules == nil { break } - return e.ComplexityRoot.JobCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.InboundNetworkPolicy.Rules(childComplexity), true - case "JobDeletedActivityLogEntry.actor": - if e.ComplexityRoot.JobDeletedActivityLogEntry.Actor == nil { + case "Ingress.metrics": + if e.ComplexityRoot.Ingress.Metrics == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Ingress.Metrics(childComplexity), true - case "JobDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.JobDeletedActivityLogEntry.CreatedAt == nil { + case "Ingress.type": + if e.ComplexityRoot.Ingress.Type == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Ingress.Type(childComplexity), true - case "JobDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.JobDeletedActivityLogEntry.EnvironmentName == nil { + case "Ingress.url": + if e.ComplexityRoot.Ingress.URL == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Ingress.URL(childComplexity), true - case "JobDeletedActivityLogEntry.id": - if e.ComplexityRoot.JobDeletedActivityLogEntry.ID == nil { + case "IngressMetricSample.timestamp": + if e.ComplexityRoot.IngressMetricSample.Timestamp == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.IngressMetricSample.Timestamp(childComplexity), true - case "JobDeletedActivityLogEntry.message": - if e.ComplexityRoot.JobDeletedActivityLogEntry.Message == nil { + case "IngressMetricSample.value": + if e.ComplexityRoot.IngressMetricSample.Value == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.IngressMetricSample.Value(childComplexity), true - case "JobDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceName == nil { + case "IngressMetrics.errorsPerSecond": + if e.ComplexityRoot.IngressMetrics.ErrorsPerSecond == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.IngressMetrics.ErrorsPerSecond(childComplexity), true - case "JobDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceType == nil { + case "IngressMetrics.requestsPerSecond": + if e.ComplexityRoot.IngressMetrics.RequestsPerSecond == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.IngressMetrics.RequestsPerSecond(childComplexity), true - case "JobDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.JobDeletedActivityLogEntry.TeamSlug == nil { + case "IngressMetrics.series": + if e.ComplexityRoot.IngressMetrics.Series == nil { break } - return e.ComplexityRoot.JobDeletedActivityLogEntry.TeamSlug(childComplexity), true + args, err := ec.field_IngressMetrics_series_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "JobEdge.cursor": - if e.ComplexityRoot.JobEdge.Cursor == nil { + return e.ComplexityRoot.IngressMetrics.Series(childComplexity, args["input"].(application.IngressMetricsInput)), true + + case "InvalidSpecIssue.id": + if e.ComplexityRoot.InvalidSpecIssue.ID == nil { break } - return e.ComplexityRoot.JobEdge.Cursor(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.ID(childComplexity), true - case "JobEdge.node": - if e.ComplexityRoot.JobEdge.Node == nil { + case "InvalidSpecIssue.message": + if e.ComplexityRoot.InvalidSpecIssue.Message == nil { break } - return e.ComplexityRoot.JobEdge.Node(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.Message(childComplexity), true - case "JobManifest.content": - if e.ComplexityRoot.JobManifest.Content == nil { + case "InvalidSpecIssue.severity": + if e.ComplexityRoot.InvalidSpecIssue.Severity == nil { break } - return e.ComplexityRoot.JobManifest.Content(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.Severity(childComplexity), true - case "JobResources.limits": - if e.ComplexityRoot.JobResources.Limits == nil { + case "InvalidSpecIssue.teamEnvironment": + if e.ComplexityRoot.InvalidSpecIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.JobResources.Limits(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.TeamEnvironment(childComplexity), true - case "JobResources.requests": - if e.ComplexityRoot.JobResources.Requests == nil { + case "InvalidSpecIssue.workload": + if e.ComplexityRoot.InvalidSpecIssue.Workload == nil { break } - return e.ComplexityRoot.JobResources.Requests(childComplexity), true + return e.ComplexityRoot.InvalidSpecIssue.Workload(childComplexity), true - case "JobRun.completionTime": - if e.ComplexityRoot.JobRun.CompletionTime == nil { + case "IssueConnection.edges": + if e.ComplexityRoot.IssueConnection.Edges == nil { break } - return e.ComplexityRoot.JobRun.CompletionTime(childComplexity), true + return e.ComplexityRoot.IssueConnection.Edges(childComplexity), true - case "JobRun.duration": - if e.ComplexityRoot.JobRun.Duration == nil { + case "IssueConnection.nodes": + if e.ComplexityRoot.IssueConnection.Nodes == nil { break } - return e.ComplexityRoot.JobRun.Duration(childComplexity), true + return e.ComplexityRoot.IssueConnection.Nodes(childComplexity), true - case "JobRun.id": - if e.ComplexityRoot.JobRun.ID == nil { + case "IssueConnection.pageInfo": + if e.ComplexityRoot.IssueConnection.PageInfo == nil { break } - return e.ComplexityRoot.JobRun.ID(childComplexity), true + return e.ComplexityRoot.IssueConnection.PageInfo(childComplexity), true - case "JobRun.image": - if e.ComplexityRoot.JobRun.Image == nil { + case "IssueEdge.cursor": + if e.ComplexityRoot.IssueEdge.Cursor == nil { break } - return e.ComplexityRoot.JobRun.Image(childComplexity), true + return e.ComplexityRoot.IssueEdge.Cursor(childComplexity), true - case "JobRun.instances": - if e.ComplexityRoot.JobRun.Instances == nil { + case "IssueEdge.node": + if e.ComplexityRoot.IssueEdge.Node == nil { break } - args, err := ec.field_JobRun_instances_args(ctx, rawArgs) + return e.ComplexityRoot.IssueEdge.Node(childComplexity), true + + case "Job.activityLog": + if e.ComplexityRoot.Job.ActivityLog == nil { + break + } + + args, err := ec.field_Job_activityLog_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.JobRun.Instances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Job.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "JobRun.name": - if e.ComplexityRoot.JobRun.Name == nil { + case "Job.authIntegrations": + if e.ComplexityRoot.Job.AuthIntegrations == nil { break } - return e.ComplexityRoot.JobRun.Name(childComplexity), true + return e.ComplexityRoot.Job.AuthIntegrations(childComplexity), true - case "JobRun.startTime": - if e.ComplexityRoot.JobRun.StartTime == nil { + case "Job.bigQueryDatasets": + if e.ComplexityRoot.Job.BigQueryDatasets == nil { break } - return e.ComplexityRoot.JobRun.StartTime(childComplexity), true - - case "JobRun.status": - if e.ComplexityRoot.JobRun.Status == nil { - break + args, err := ec.field_Job_bigQueryDatasets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRun.Status(childComplexity), true + return e.ComplexityRoot.Job.BigQueryDatasets(childComplexity, args["orderBy"].(*bigquery.BigQueryDatasetOrder)), true - case "JobRun.trigger": - if e.ComplexityRoot.JobRun.Trigger == nil { + case "Job.buckets": + if e.ComplexityRoot.Job.Buckets == nil { break } - return e.ComplexityRoot.JobRun.Trigger(childComplexity), true - - case "JobRunConnection.edges": - if e.ComplexityRoot.JobRunConnection.Edges == nil { - break + args, err := ec.field_Job_buckets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunConnection.Edges(childComplexity), true + return e.ComplexityRoot.Job.Buckets(childComplexity, args["orderBy"].(*bucket.BucketOrder)), true - case "JobRunConnection.nodes": - if e.ComplexityRoot.JobRunConnection.Nodes == nil { + case "Job.configs": + if e.ComplexityRoot.Job.Configs == nil { break } - return e.ComplexityRoot.JobRunConnection.Nodes(childComplexity), true - - case "JobRunConnection.pageInfo": - if e.ComplexityRoot.JobRunConnection.PageInfo == nil { - break + args, err := ec.field_Job_configs_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Job.Configs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "JobRunDeletedActivityLogEntry.actor": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.Actor == nil { + case "Job.cost": + if e.ComplexityRoot.Job.Cost == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Job.Cost(childComplexity), true - case "JobRunDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.CreatedAt == nil { + case "Job.deletionStartedAt": + if e.ComplexityRoot.Job.DeletionStartedAt == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Job.DeletionStartedAt(childComplexity), true - case "JobRunDeletedActivityLogEntry.data": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.Data == nil { + case "Job.deployments": + if e.ComplexityRoot.Job.Deployments == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.Data(childComplexity), true - - case "JobRunDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_Job_deployments_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Job.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "JobRunDeletedActivityLogEntry.id": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.ID == nil { + case "Job.environment": + if e.ComplexityRoot.Job.Environment == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Job.Environment(childComplexity), true - case "JobRunDeletedActivityLogEntry.message": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.Message == nil { + case "Job.id": + if e.ComplexityRoot.Job.ID == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Job.ID(childComplexity), true - case "JobRunDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceName == nil { + case "Job.image": + if e.ComplexityRoot.Job.Image == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.Job.Image(childComplexity), true - case "JobRunDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceType == nil { + case "Job.imageVulnerabilityHistory": + if e.ComplexityRoot.Job.ImageVulnerabilityHistory == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceType(childComplexity), true + args, err := ec.field_Job_imageVulnerabilityHistory_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "JobRunDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.JobRunDeletedActivityLogEntry.TeamSlug == nil { + return e.ComplexityRoot.Job.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true + + case "Job.issues": + if e.ComplexityRoot.Job.Issues == nil { break } - return e.ComplexityRoot.JobRunDeletedActivityLogEntry.TeamSlug(childComplexity), true - - case "JobRunDeletedActivityLogEntryData.runName": - if e.ComplexityRoot.JobRunDeletedActivityLogEntryData.RunName == nil { - break + args, err := ec.field_Job_issues_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunDeletedActivityLogEntryData.RunName(childComplexity), true + return e.ComplexityRoot.Job.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true - case "JobRunEdge.cursor": - if e.ComplexityRoot.JobRunEdge.Cursor == nil { + case "Job.kafkaTopicAcls": + if e.ComplexityRoot.Job.KafkaTopicAcls == nil { break } - return e.ComplexityRoot.JobRunEdge.Cursor(childComplexity), true - - case "JobRunEdge.node": - if e.ComplexityRoot.JobRunEdge.Node == nil { - break + args, err := ec.field_Job_kafkaTopicAcls_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunEdge.Node(childComplexity), true + return e.ComplexityRoot.Job.KafkaTopicAcls(childComplexity, args["orderBy"].(*kafkatopic.KafkaTopicACLOrder)), true - case "JobRunInstance.id": - if e.ComplexityRoot.JobRunInstance.ID == nil { + case "Job.logDestinations": + if e.ComplexityRoot.Job.LogDestinations == nil { break } - return e.ComplexityRoot.JobRunInstance.ID(childComplexity), true + return e.ComplexityRoot.Job.LogDestinations(childComplexity), true - case "JobRunInstance.name": - if e.ComplexityRoot.JobRunInstance.Name == nil { + case "Job.manifest": + if e.ComplexityRoot.Job.Manifest == nil { break } - return e.ComplexityRoot.JobRunInstance.Name(childComplexity), true + return e.ComplexityRoot.Job.Manifest(childComplexity), true - case "JobRunInstanceConnection.edges": - if e.ComplexityRoot.JobRunInstanceConnection.Edges == nil { + case "Job.name": + if e.ComplexityRoot.Job.Name == nil { break } - return e.ComplexityRoot.JobRunInstanceConnection.Edges(childComplexity), true + return e.ComplexityRoot.Job.Name(childComplexity), true - case "JobRunInstanceConnection.nodes": - if e.ComplexityRoot.JobRunInstanceConnection.Nodes == nil { + case "Job.networkPolicy": + if e.ComplexityRoot.Job.NetworkPolicy == nil { break } - return e.ComplexityRoot.JobRunInstanceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Job.NetworkPolicy(childComplexity), true - case "JobRunInstanceConnection.pageInfo": - if e.ComplexityRoot.JobRunInstanceConnection.PageInfo == nil { + case "Job.openSearch": + if e.ComplexityRoot.Job.OpenSearch == nil { break } - return e.ComplexityRoot.JobRunInstanceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Job.OpenSearch(childComplexity), true - case "JobRunInstanceEdge.cursor": - if e.ComplexityRoot.JobRunInstanceEdge.Cursor == nil { + case "Job.postgresInstances": + if e.ComplexityRoot.Job.PostgresInstances == nil { break } - return e.ComplexityRoot.JobRunInstanceEdge.Cursor(childComplexity), true - - case "JobRunInstanceEdge.node": - if e.ComplexityRoot.JobRunInstanceEdge.Node == nil { - break + args, err := ec.field_Job_postgresInstances_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunInstanceEdge.Node(childComplexity), true + return e.ComplexityRoot.Job.PostgresInstances(childComplexity, args["orderBy"].(*postgres.PostgresInstanceOrder)), true - case "JobRunStatus.message": - if e.ComplexityRoot.JobRunStatus.Message == nil { + case "Job.resources": + if e.ComplexityRoot.Job.Resources == nil { break } - return e.ComplexityRoot.JobRunStatus.Message(childComplexity), true + return e.ComplexityRoot.Job.Resources(childComplexity), true - case "JobRunStatus.state": - if e.ComplexityRoot.JobRunStatus.State == nil { + case "Job.runs": + if e.ComplexityRoot.Job.Runs == nil { break } - return e.ComplexityRoot.JobRunStatus.State(childComplexity), true - - case "JobRunTrigger.actor": - if e.ComplexityRoot.JobRunTrigger.Actor == nil { - break + args, err := ec.field_Job_runs_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobRunTrigger.Actor(childComplexity), true + return e.ComplexityRoot.Job.Runs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "JobRunTrigger.type": - if e.ComplexityRoot.JobRunTrigger.Type == nil { + case "Job.sqlInstances": + if e.ComplexityRoot.Job.SQLInstances == nil { break } - return e.ComplexityRoot.JobRunTrigger.Type(childComplexity), true - - case "JobSchedule.expression": - if e.ComplexityRoot.JobSchedule.Expression == nil { - break + args, err := ec.field_Job_sqlInstances_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobSchedule.Expression(childComplexity), true + return e.ComplexityRoot.Job.SQLInstances(childComplexity, args["orderBy"].(*sqlinstance.SQLInstanceOrder)), true - case "JobSchedule.timeZone": - if e.ComplexityRoot.JobSchedule.TimeZone == nil { + case "Job.schedule": + if e.ComplexityRoot.Job.Schedule == nil { break } - return e.ComplexityRoot.JobSchedule.TimeZone(childComplexity), true + return e.ComplexityRoot.Job.Schedule(childComplexity), true - case "JobTriggeredActivityLogEntry.actor": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.Actor == nil { + case "Job.secrets": + if e.ComplexityRoot.Job.Secrets == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.Actor(childComplexity), true - - case "JobTriggeredActivityLogEntry.createdAt": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_Job_secrets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Job.Secrets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "JobTriggeredActivityLogEntry.environmentName": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.EnvironmentName == nil { + case "Job.state": + if e.ComplexityRoot.Job.State == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Job.State(childComplexity), true - case "JobTriggeredActivityLogEntry.id": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.ID == nil { + case "Job.team": + if e.ComplexityRoot.Job.Team == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Job.Team(childComplexity), true - case "JobTriggeredActivityLogEntry.message": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.Message == nil { + case "Job.teamEnvironment": + if e.ComplexityRoot.Job.TeamEnvironment == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Job.TeamEnvironment(childComplexity), true - case "JobTriggeredActivityLogEntry.resourceName": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceName == nil { + case "Job.valkeys": + if e.ComplexityRoot.Job.Valkeys == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceName(childComplexity), true - - case "JobTriggeredActivityLogEntry.resourceType": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceType == nil { - break + args, err := ec.field_Job_valkeys_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Job.Valkeys(childComplexity, args["orderBy"].(*valkey.ValkeyOrder)), true - case "JobTriggeredActivityLogEntry.teamSlug": - if e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug == nil { + case "Job.vulnerabilityFixHistory": + if e.ComplexityRoot.Job.VulnerabilityFixHistory == nil { break } - return e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug(childComplexity), true - - case "JobUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.Actor == nil { - break + args, err := ec.field_Job_vulnerabilityFixHistory_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Job.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true - case "JobUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.CreatedAt == nil { + case "JobConnection.edges": + if e.ComplexityRoot.JobConnection.Edges == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.JobConnection.Edges(childComplexity), true - case "JobUpdatedActivityLogEntry.data": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.Data == nil { + case "JobConnection.nodes": + if e.ComplexityRoot.JobConnection.Nodes == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.JobConnection.Nodes(childComplexity), true - case "JobUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.EnvironmentName == nil { + case "JobConnection.pageInfo": + if e.ComplexityRoot.JobConnection.PageInfo == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.JobConnection.PageInfo(childComplexity), true - case "JobUpdatedActivityLogEntry.id": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.ID == nil { + case "JobCreatedActivityLogEntry.actor": + if e.ComplexityRoot.JobCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.Actor(childComplexity), true - case "JobUpdatedActivityLogEntry.message": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.Message == nil { + case "JobCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.JobCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "JobUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceName == nil { + case "JobCreatedActivityLogEntry.data": + if e.ComplexityRoot.JobCreatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.Data(childComplexity), true - case "JobUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceType == nil { + case "JobCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.JobCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "JobUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.JobUpdatedActivityLogEntry.TeamSlug == nil { + case "JobCreatedActivityLogEntry.id": + if e.ComplexityRoot.JobCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.JobUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.ID(childComplexity), true - case "KafkaCredentials.accessCert": - if e.ComplexityRoot.KafkaCredentials.AccessCert == nil { + case "JobCreatedActivityLogEntry.message": + if e.ComplexityRoot.JobCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.KafkaCredentials.AccessCert(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.Message(childComplexity), true - case "KafkaCredentials.accessKey": - if e.ComplexityRoot.KafkaCredentials.AccessKey == nil { + case "JobCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.KafkaCredentials.AccessKey(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceName(childComplexity), true - case "KafkaCredentials.brokers": - if e.ComplexityRoot.KafkaCredentials.Brokers == nil { + case "JobCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.KafkaCredentials.Brokers(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.ResourceType(childComplexity), true - case "KafkaCredentials.caCert": - if e.ComplexityRoot.KafkaCredentials.CaCert == nil { + case "JobCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.KafkaCredentials.CaCert(childComplexity), true + return e.ComplexityRoot.JobCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "KafkaCredentials.schemaRegistry": - if e.ComplexityRoot.KafkaCredentials.SchemaRegistry == nil { + case "JobDeletedActivityLogEntry.actor": + if e.ComplexityRoot.JobDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.KafkaCredentials.SchemaRegistry(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.Actor(childComplexity), true - case "KafkaCredentials.username": - if e.ComplexityRoot.KafkaCredentials.Username == nil { + case "JobDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.JobDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.KafkaCredentials.Username(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "KafkaLagScalingStrategy.consumerGroup": - if e.ComplexityRoot.KafkaLagScalingStrategy.ConsumerGroup == nil { + case "JobDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.JobDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.KafkaLagScalingStrategy.ConsumerGroup(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "KafkaLagScalingStrategy.threshold": - if e.ComplexityRoot.KafkaLagScalingStrategy.Threshold == nil { + case "JobDeletedActivityLogEntry.id": + if e.ComplexityRoot.JobDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.KafkaLagScalingStrategy.Threshold(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.ID(childComplexity), true - case "KafkaLagScalingStrategy.topicName": - if e.ComplexityRoot.KafkaLagScalingStrategy.TopicName == nil { + case "JobDeletedActivityLogEntry.message": + if e.ComplexityRoot.JobDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.KafkaLagScalingStrategy.TopicName(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.Message(childComplexity), true - case "KafkaTopic.acl": - if e.ComplexityRoot.KafkaTopic.ACL == nil { + case "JobDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceName == nil { break } - args, err := ec.field_KafkaTopic_acl_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.KafkaTopic.ACL(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*kafkatopic.KafkaTopicACLFilter), args["orderBy"].(*kafkatopic.KafkaTopicACLOrder)), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceName(childComplexity), true - case "KafkaTopic.configuration": - if e.ComplexityRoot.KafkaTopic.Configuration == nil { + case "JobDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.KafkaTopic.Configuration(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.ResourceType(childComplexity), true - case "KafkaTopic.environment": - if e.ComplexityRoot.KafkaTopic.Environment == nil { + case "JobDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.KafkaTopic.Environment(childComplexity), true + return e.ComplexityRoot.JobDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "KafkaTopic.id": - if e.ComplexityRoot.KafkaTopic.ID == nil { + case "JobEdge.cursor": + if e.ComplexityRoot.JobEdge.Cursor == nil { break } - return e.ComplexityRoot.KafkaTopic.ID(childComplexity), true + return e.ComplexityRoot.JobEdge.Cursor(childComplexity), true - case "KafkaTopic.name": - if e.ComplexityRoot.KafkaTopic.Name == nil { + case "JobEdge.node": + if e.ComplexityRoot.JobEdge.Node == nil { break } - return e.ComplexityRoot.KafkaTopic.Name(childComplexity), true + return e.ComplexityRoot.JobEdge.Node(childComplexity), true - case "KafkaTopic.pool": - if e.ComplexityRoot.KafkaTopic.Pool == nil { + case "JobManifest.content": + if e.ComplexityRoot.JobManifest.Content == nil { break } - return e.ComplexityRoot.KafkaTopic.Pool(childComplexity), true + return e.ComplexityRoot.JobManifest.Content(childComplexity), true - case "KafkaTopic.team": - if e.ComplexityRoot.KafkaTopic.Team == nil { + case "JobResources.limits": + if e.ComplexityRoot.JobResources.Limits == nil { break } - return e.ComplexityRoot.KafkaTopic.Team(childComplexity), true + return e.ComplexityRoot.JobResources.Limits(childComplexity), true - case "KafkaTopic.teamEnvironment": - if e.ComplexityRoot.KafkaTopic.TeamEnvironment == nil { + case "JobResources.requests": + if e.ComplexityRoot.JobResources.Requests == nil { break } - return e.ComplexityRoot.KafkaTopic.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.JobResources.Requests(childComplexity), true - case "KafkaTopicAcl.access": - if e.ComplexityRoot.KafkaTopicAcl.Access == nil { + case "JobRun.completionTime": + if e.ComplexityRoot.JobRun.CompletionTime == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.Access(childComplexity), true + return e.ComplexityRoot.JobRun.CompletionTime(childComplexity), true - case "KafkaTopicAcl.team": - if e.ComplexityRoot.KafkaTopicAcl.Team == nil { + case "JobRun.duration": + if e.ComplexityRoot.JobRun.Duration == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.Team(childComplexity), true + return e.ComplexityRoot.JobRun.Duration(childComplexity), true - case "KafkaTopicAcl.teamName": - if e.ComplexityRoot.KafkaTopicAcl.TeamName == nil { + case "JobRun.id": + if e.ComplexityRoot.JobRun.ID == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.TeamName(childComplexity), true + return e.ComplexityRoot.JobRun.ID(childComplexity), true - case "KafkaTopicAcl.topic": - if e.ComplexityRoot.KafkaTopicAcl.Topic == nil { + case "JobRun.image": + if e.ComplexityRoot.JobRun.Image == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.Topic(childComplexity), true + return e.ComplexityRoot.JobRun.Image(childComplexity), true - case "KafkaTopicAcl.workload": - if e.ComplexityRoot.KafkaTopicAcl.Workload == nil { + case "JobRun.instances": + if e.ComplexityRoot.JobRun.Instances == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.Workload(childComplexity), true + args, err := ec.field_JobRun_instances_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "KafkaTopicAcl.workloadName": - if e.ComplexityRoot.KafkaTopicAcl.WorkloadName == nil { + return e.ComplexityRoot.JobRun.Instances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "JobRun.name": + if e.ComplexityRoot.JobRun.Name == nil { break } - return e.ComplexityRoot.KafkaTopicAcl.WorkloadName(childComplexity), true + return e.ComplexityRoot.JobRun.Name(childComplexity), true - case "KafkaTopicAclConnection.edges": - if e.ComplexityRoot.KafkaTopicAclConnection.Edges == nil { + case "JobRun.startTime": + if e.ComplexityRoot.JobRun.StartTime == nil { break } - return e.ComplexityRoot.KafkaTopicAclConnection.Edges(childComplexity), true + return e.ComplexityRoot.JobRun.StartTime(childComplexity), true - case "KafkaTopicAclConnection.nodes": - if e.ComplexityRoot.KafkaTopicAclConnection.Nodes == nil { + case "JobRun.status": + if e.ComplexityRoot.JobRun.Status == nil { break } - return e.ComplexityRoot.KafkaTopicAclConnection.Nodes(childComplexity), true + return e.ComplexityRoot.JobRun.Status(childComplexity), true - case "KafkaTopicAclConnection.pageInfo": - if e.ComplexityRoot.KafkaTopicAclConnection.PageInfo == nil { + case "JobRun.trigger": + if e.ComplexityRoot.JobRun.Trigger == nil { break } - return e.ComplexityRoot.KafkaTopicAclConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.JobRun.Trigger(childComplexity), true - case "KafkaTopicAclEdge.cursor": - if e.ComplexityRoot.KafkaTopicAclEdge.Cursor == nil { + case "JobRunConnection.edges": + if e.ComplexityRoot.JobRunConnection.Edges == nil { break } - return e.ComplexityRoot.KafkaTopicAclEdge.Cursor(childComplexity), true + return e.ComplexityRoot.JobRunConnection.Edges(childComplexity), true - case "KafkaTopicAclEdge.node": - if e.ComplexityRoot.KafkaTopicAclEdge.Node == nil { + case "JobRunConnection.nodes": + if e.ComplexityRoot.JobRunConnection.Nodes == nil { break } - return e.ComplexityRoot.KafkaTopicAclEdge.Node(childComplexity), true + return e.ComplexityRoot.JobRunConnection.Nodes(childComplexity), true - case "KafkaTopicConfiguration.cleanupPolicy": - if e.ComplexityRoot.KafkaTopicConfiguration.CleanupPolicy == nil { + case "JobRunConnection.pageInfo": + if e.ComplexityRoot.JobRunConnection.PageInfo == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.CleanupPolicy(childComplexity), true + return e.ComplexityRoot.JobRunConnection.PageInfo(childComplexity), true - case "KafkaTopicConfiguration.maxMessageBytes": - if e.ComplexityRoot.KafkaTopicConfiguration.MaxMessageBytes == nil { + case "JobRunDeletedActivityLogEntry.actor": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.MaxMessageBytes(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.Actor(childComplexity), true - case "KafkaTopicConfiguration.minimumInSyncReplicas": - if e.ComplexityRoot.KafkaTopicConfiguration.MinimumInSyncReplicas == nil { + case "JobRunDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.MinimumInSyncReplicas(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "KafkaTopicConfiguration.partitions": - if e.ComplexityRoot.KafkaTopicConfiguration.Partitions == nil { + case "JobRunDeletedActivityLogEntry.data": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.Partitions(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.Data(childComplexity), true - case "KafkaTopicConfiguration.replication": - if e.ComplexityRoot.KafkaTopicConfiguration.Replication == nil { + case "JobRunDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.Replication(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "KafkaTopicConfiguration.retentionBytes": - if e.ComplexityRoot.KafkaTopicConfiguration.RetentionBytes == nil { + case "JobRunDeletedActivityLogEntry.id": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.RetentionBytes(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.ID(childComplexity), true - case "KafkaTopicConfiguration.retentionHours": - if e.ComplexityRoot.KafkaTopicConfiguration.RetentionHours == nil { + case "JobRunDeletedActivityLogEntry.message": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.RetentionHours(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.Message(childComplexity), true - case "KafkaTopicConfiguration.segmentHours": - if e.ComplexityRoot.KafkaTopicConfiguration.SegmentHours == nil { + case "JobRunDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.KafkaTopicConfiguration.SegmentHours(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceName(childComplexity), true - case "KafkaTopicConnection.edges": - if e.ComplexityRoot.KafkaTopicConnection.Edges == nil { + case "JobRunDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.KafkaTopicConnection.Edges(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.ResourceType(childComplexity), true - case "KafkaTopicConnection.nodes": - if e.ComplexityRoot.KafkaTopicConnection.Nodes == nil { + case "JobRunDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobRunDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.KafkaTopicConnection.Nodes(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "KafkaTopicConnection.pageInfo": - if e.ComplexityRoot.KafkaTopicConnection.PageInfo == nil { + case "JobRunDeletedActivityLogEntryData.runName": + if e.ComplexityRoot.JobRunDeletedActivityLogEntryData.RunName == nil { break } - return e.ComplexityRoot.KafkaTopicConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.JobRunDeletedActivityLogEntryData.RunName(childComplexity), true - case "KafkaTopicEdge.cursor": - if e.ComplexityRoot.KafkaTopicEdge.Cursor == nil { + case "JobRunEdge.cursor": + if e.ComplexityRoot.JobRunEdge.Cursor == nil { break } - return e.ComplexityRoot.KafkaTopicEdge.Cursor(childComplexity), true + return e.ComplexityRoot.JobRunEdge.Cursor(childComplexity), true - case "KafkaTopicEdge.node": - if e.ComplexityRoot.KafkaTopicEdge.Node == nil { + case "JobRunEdge.node": + if e.ComplexityRoot.JobRunEdge.Node == nil { break } - return e.ComplexityRoot.KafkaTopicEdge.Node(childComplexity), true + return e.ComplexityRoot.JobRunEdge.Node(childComplexity), true - case "LastRunFailedIssue.id": - if e.ComplexityRoot.LastRunFailedIssue.ID == nil { + case "JobRunInstance.id": + if e.ComplexityRoot.JobRunInstance.ID == nil { break } - return e.ComplexityRoot.LastRunFailedIssue.ID(childComplexity), true + return e.ComplexityRoot.JobRunInstance.ID(childComplexity), true - case "LastRunFailedIssue.job": - if e.ComplexityRoot.LastRunFailedIssue.Job == nil { + case "JobRunInstance.name": + if e.ComplexityRoot.JobRunInstance.Name == nil { break } - return e.ComplexityRoot.LastRunFailedIssue.Job(childComplexity), true + return e.ComplexityRoot.JobRunInstance.Name(childComplexity), true - case "LastRunFailedIssue.message": - if e.ComplexityRoot.LastRunFailedIssue.Message == nil { + case "JobRunInstanceConnection.edges": + if e.ComplexityRoot.JobRunInstanceConnection.Edges == nil { break } - return e.ComplexityRoot.LastRunFailedIssue.Message(childComplexity), true + return e.ComplexityRoot.JobRunInstanceConnection.Edges(childComplexity), true - case "LastRunFailedIssue.severity": - if e.ComplexityRoot.LastRunFailedIssue.Severity == nil { + case "JobRunInstanceConnection.nodes": + if e.ComplexityRoot.JobRunInstanceConnection.Nodes == nil { break } - return e.ComplexityRoot.LastRunFailedIssue.Severity(childComplexity), true + return e.ComplexityRoot.JobRunInstanceConnection.Nodes(childComplexity), true - case "LastRunFailedIssue.teamEnvironment": - if e.ComplexityRoot.LastRunFailedIssue.TeamEnvironment == nil { + case "JobRunInstanceConnection.pageInfo": + if e.ComplexityRoot.JobRunInstanceConnection.PageInfo == nil { break } - return e.ComplexityRoot.LastRunFailedIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.JobRunInstanceConnection.PageInfo(childComplexity), true - case "LogDestinationGeneric.id": - if e.ComplexityRoot.LogDestinationGeneric.ID == nil { + case "JobRunInstanceEdge.cursor": + if e.ComplexityRoot.JobRunInstanceEdge.Cursor == nil { break } - return e.ComplexityRoot.LogDestinationGeneric.ID(childComplexity), true + return e.ComplexityRoot.JobRunInstanceEdge.Cursor(childComplexity), true - case "LogDestinationGeneric.name": - if e.ComplexityRoot.LogDestinationGeneric.Name == nil { + case "JobRunInstanceEdge.node": + if e.ComplexityRoot.JobRunInstanceEdge.Node == nil { break } - return e.ComplexityRoot.LogDestinationGeneric.Name(childComplexity), true + return e.ComplexityRoot.JobRunInstanceEdge.Node(childComplexity), true - case "LogDestinationLoki.grafanaURL": - if e.ComplexityRoot.LogDestinationLoki.GrafanaURL == nil { + case "JobRunStatus.message": + if e.ComplexityRoot.JobRunStatus.Message == nil { break } - return e.ComplexityRoot.LogDestinationLoki.GrafanaURL(childComplexity), true + return e.ComplexityRoot.JobRunStatus.Message(childComplexity), true - case "LogDestinationLoki.id": - if e.ComplexityRoot.LogDestinationLoki.ID == nil { + case "JobRunStatus.state": + if e.ComplexityRoot.JobRunStatus.State == nil { break } - return e.ComplexityRoot.LogDestinationLoki.ID(childComplexity), true + return e.ComplexityRoot.JobRunStatus.State(childComplexity), true - case "LogDestinationSecureLogs.id": - if e.ComplexityRoot.LogDestinationSecureLogs.ID == nil { + case "JobRunTrigger.actor": + if e.ComplexityRoot.JobRunTrigger.Actor == nil { break } - return e.ComplexityRoot.LogDestinationSecureLogs.ID(childComplexity), true + return e.ComplexityRoot.JobRunTrigger.Actor(childComplexity), true - case "LogLine.labels": - if e.ComplexityRoot.LogLine.Labels == nil { + case "JobRunTrigger.type": + if e.ComplexityRoot.JobRunTrigger.Type == nil { break } - return e.ComplexityRoot.LogLine.Labels(childComplexity), true + return e.ComplexityRoot.JobRunTrigger.Type(childComplexity), true - case "LogLine.message": - if e.ComplexityRoot.LogLine.Message == nil { + case "JobSchedule.expression": + if e.ComplexityRoot.JobSchedule.Expression == nil { break } - return e.ComplexityRoot.LogLine.Message(childComplexity), true + return e.ComplexityRoot.JobSchedule.Expression(childComplexity), true - case "LogLine.time": - if e.ComplexityRoot.LogLine.Time == nil { + case "JobSchedule.timeZone": + if e.ComplexityRoot.JobSchedule.TimeZone == nil { break } - return e.ComplexityRoot.LogLine.Time(childComplexity), true + return e.ComplexityRoot.JobSchedule.TimeZone(childComplexity), true - case "LogLineLabel.key": - if e.ComplexityRoot.LogLineLabel.Key == nil { + case "JobTriggeredActivityLogEntry.actor": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.LogLineLabel.Key(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.Actor(childComplexity), true - case "LogLineLabel.value": - if e.ComplexityRoot.LogLineLabel.Value == nil { + case "JobTriggeredActivityLogEntry.createdAt": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.LogLineLabel.Value(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.CreatedAt(childComplexity), true - case "MaintenanceWindow.dayOfWeek": - if e.ComplexityRoot.MaintenanceWindow.DayOfWeek == nil { + case "JobTriggeredActivityLogEntry.environmentName": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.MaintenanceWindow.DayOfWeek(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.EnvironmentName(childComplexity), true - case "MaintenanceWindow.timeOfDay": - if e.ComplexityRoot.MaintenanceWindow.TimeOfDay == nil { + case "JobTriggeredActivityLogEntry.id": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.MaintenanceWindow.TimeOfDay(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.ID(childComplexity), true - case "MaskinportenAuthIntegration.name": - if e.ComplexityRoot.MaskinportenAuthIntegration.Name == nil { + case "JobTriggeredActivityLogEntry.message": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.MaskinportenAuthIntegration.Name(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.Message(childComplexity), true - case "MetricLabel.name": - if e.ComplexityRoot.MetricLabel.Name == nil { + case "JobTriggeredActivityLogEntry.resourceName": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.MetricLabel.Name(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceName(childComplexity), true - case "MetricLabel.value": - if e.ComplexityRoot.MetricLabel.Value == nil { + case "JobTriggeredActivityLogEntry.resourceType": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.MetricLabel.Value(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.ResourceType(childComplexity), true - case "MetricSeries.labels": - if e.ComplexityRoot.MetricSeries.Labels == nil { + case "JobTriggeredActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.MetricSeries.Labels(childComplexity), true + return e.ComplexityRoot.JobTriggeredActivityLogEntry.TeamSlug(childComplexity), true - case "MetricSeries.values": - if e.ComplexityRoot.MetricSeries.Values == nil { + case "JobUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.MetricSeries.Values(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.Actor(childComplexity), true - case "MetricValue.timestamp": - if e.ComplexityRoot.MetricValue.Timestamp == nil { + case "JobUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.MetricValue.Timestamp(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "MetricValue.value": - if e.ComplexityRoot.MetricValue.Value == nil { + case "JobUpdatedActivityLogEntry.data": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.MetricValue.Value(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.Data(childComplexity), true - case "MetricsQueryResult.series": - if e.ComplexityRoot.MetricsQueryResult.Series == nil { + case "JobUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.MetricsQueryResult.Series(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "MetricsQueryResult.warnings": - if e.ComplexityRoot.MetricsQueryResult.Warnings == nil { + case "JobUpdatedActivityLogEntry.id": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.MetricsQueryResult.Warnings(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.ID(childComplexity), true - case "MissingSbomIssue.id": - if e.ComplexityRoot.MissingSbomIssue.ID == nil { + case "JobUpdatedActivityLogEntry.message": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.MissingSbomIssue.ID(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.Message(childComplexity), true - case "MissingSbomIssue.message": - if e.ComplexityRoot.MissingSbomIssue.Message == nil { + case "JobUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.MissingSbomIssue.Message(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "MissingSbomIssue.severity": - if e.ComplexityRoot.MissingSbomIssue.Severity == nil { + case "JobUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.MissingSbomIssue.Severity(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "MissingSbomIssue.teamEnvironment": - if e.ComplexityRoot.MissingSbomIssue.TeamEnvironment == nil { + case "JobUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.JobUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.MissingSbomIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.JobUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "MissingSbomIssue.workload": - if e.ComplexityRoot.MissingSbomIssue.Workload == nil { + case "KafkaCredentials.accessCert": + if e.ComplexityRoot.KafkaCredentials.AccessCert == nil { break } - return e.ComplexityRoot.MissingSbomIssue.Workload(childComplexity), true + return e.ComplexityRoot.KafkaCredentials.AccessCert(childComplexity), true - case "Mutation.addRepositoryToTeam": - if e.ComplexityRoot.Mutation.AddRepositoryToTeam == nil { + case "KafkaCredentials.accessKey": + if e.ComplexityRoot.KafkaCredentials.AccessKey == nil { break } - args, err := ec.field_Mutation_addRepositoryToTeam_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaCredentials.AccessKey(childComplexity), true + + case "KafkaCredentials.brokers": + if e.ComplexityRoot.KafkaCredentials.Brokers == nil { + break } - return e.ComplexityRoot.Mutation.AddRepositoryToTeam(childComplexity, args["input"].(repository.AddRepositoryToTeamInput)), true + return e.ComplexityRoot.KafkaCredentials.Brokers(childComplexity), true - case "Mutation.addSecretValue": - if e.ComplexityRoot.Mutation.AddSecretValue == nil { + case "KafkaCredentials.caCert": + if e.ComplexityRoot.KafkaCredentials.CaCert == nil { break } - args, err := ec.field_Mutation_addSecretValue_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaCredentials.CaCert(childComplexity), true + + case "KafkaCredentials.schemaRegistry": + if e.ComplexityRoot.KafkaCredentials.SchemaRegistry == nil { + break } - return e.ComplexityRoot.Mutation.AddSecretValue(childComplexity, args["input"].(secret.AddSecretValueInput)), true + return e.ComplexityRoot.KafkaCredentials.SchemaRegistry(childComplexity), true - case "Mutation.addTeamMember": - if e.ComplexityRoot.Mutation.AddTeamMember == nil { + case "KafkaCredentials.username": + if e.ComplexityRoot.KafkaCredentials.Username == nil { break } - args, err := ec.field_Mutation_addTeamMember_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaCredentials.Username(childComplexity), true + + case "KafkaLagScalingStrategy.consumerGroup": + if e.ComplexityRoot.KafkaLagScalingStrategy.ConsumerGroup == nil { + break } - return e.ComplexityRoot.Mutation.AddTeamMember(childComplexity, args["input"].(team.AddTeamMemberInput)), true + return e.ComplexityRoot.KafkaLagScalingStrategy.ConsumerGroup(childComplexity), true - case "Mutation.allowTeamAccessToUnleash": - if e.ComplexityRoot.Mutation.AllowTeamAccessToUnleash == nil { + case "KafkaLagScalingStrategy.threshold": + if e.ComplexityRoot.KafkaLagScalingStrategy.Threshold == nil { break } - args, err := ec.field_Mutation_allowTeamAccessToUnleash_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaLagScalingStrategy.Threshold(childComplexity), true + + case "KafkaLagScalingStrategy.topicName": + if e.ComplexityRoot.KafkaLagScalingStrategy.TopicName == nil { + break } - return e.ComplexityRoot.Mutation.AllowTeamAccessToUnleash(childComplexity, args["input"].(unleash.AllowTeamAccessToUnleashInput)), true + return e.ComplexityRoot.KafkaLagScalingStrategy.TopicName(childComplexity), true - case "Mutation.assignRoleToServiceAccount": - if e.ComplexityRoot.Mutation.AssignRoleToServiceAccount == nil { + case "KafkaTopic.acl": + if e.ComplexityRoot.KafkaTopic.ACL == nil { break } - args, err := ec.field_Mutation_assignRoleToServiceAccount_args(ctx, rawArgs) + args, err := ec.field_KafkaTopic_acl_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.AssignRoleToServiceAccount(childComplexity, args["input"].(serviceaccount.AssignRoleToServiceAccountInput)), true + return e.ComplexityRoot.KafkaTopic.ACL(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*kafkatopic.KafkaTopicACLFilter), args["orderBy"].(*kafkatopic.KafkaTopicACLOrder)), true - case "Mutation.changeDeploymentKey": - if e.ComplexityRoot.Mutation.ChangeDeploymentKey == nil { + case "KafkaTopic.configuration": + if e.ComplexityRoot.KafkaTopic.Configuration == nil { break } - args, err := ec.field_Mutation_changeDeploymentKey_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopic.Configuration(childComplexity), true + + case "KafkaTopic.environment": + if e.ComplexityRoot.KafkaTopic.Environment == nil { + break } - return e.ComplexityRoot.Mutation.ChangeDeploymentKey(childComplexity, args["input"].(deployment.ChangeDeploymentKeyInput)), true + return e.ComplexityRoot.KafkaTopic.Environment(childComplexity), true - case "Mutation.configureReconciler": - if e.ComplexityRoot.Mutation.ConfigureReconciler == nil { + case "KafkaTopic.id": + if e.ComplexityRoot.KafkaTopic.ID == nil { break } - args, err := ec.field_Mutation_configureReconciler_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopic.ID(childComplexity), true + + case "KafkaTopic.name": + if e.ComplexityRoot.KafkaTopic.Name == nil { + break } - return e.ComplexityRoot.Mutation.ConfigureReconciler(childComplexity, args["input"].(reconciler.ConfigureReconcilerInput)), true + return e.ComplexityRoot.KafkaTopic.Name(childComplexity), true - case "Mutation.confirmTeamDeletion": - if e.ComplexityRoot.Mutation.ConfirmTeamDeletion == nil { + case "KafkaTopic.pool": + if e.ComplexityRoot.KafkaTopic.Pool == nil { break } - args, err := ec.field_Mutation_confirmTeamDeletion_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopic.Pool(childComplexity), true + + case "KafkaTopic.team": + if e.ComplexityRoot.KafkaTopic.Team == nil { + break } - return e.ComplexityRoot.Mutation.ConfirmTeamDeletion(childComplexity, args["input"].(team.ConfirmTeamDeletionInput)), true + return e.ComplexityRoot.KafkaTopic.Team(childComplexity), true - case "Mutation.createKafkaCredentials": - if e.ComplexityRoot.Mutation.CreateKafkaCredentials == nil { + case "KafkaTopic.teamEnvironment": + if e.ComplexityRoot.KafkaTopic.TeamEnvironment == nil { break } - args, err := ec.field_Mutation_createKafkaCredentials_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopic.TeamEnvironment(childComplexity), true + + case "KafkaTopicAcl.access": + if e.ComplexityRoot.KafkaTopicAcl.Access == nil { + break } - return e.ComplexityRoot.Mutation.CreateKafkaCredentials(childComplexity, args["input"].(aivencredentials.CreateKafkaCredentialsInput)), true + return e.ComplexityRoot.KafkaTopicAcl.Access(childComplexity), true - case "Mutation.createOpenSearch": - if e.ComplexityRoot.Mutation.CreateOpenSearch == nil { + case "KafkaTopicAcl.team": + if e.ComplexityRoot.KafkaTopicAcl.Team == nil { break } - args, err := ec.field_Mutation_createOpenSearch_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicAcl.Team(childComplexity), true + + case "KafkaTopicAcl.teamName": + if e.ComplexityRoot.KafkaTopicAcl.TeamName == nil { + break } - return e.ComplexityRoot.Mutation.CreateOpenSearch(childComplexity, args["input"].(opensearch.CreateOpenSearchInput)), true + return e.ComplexityRoot.KafkaTopicAcl.TeamName(childComplexity), true - case "Mutation.createOpenSearchCredentials": - if e.ComplexityRoot.Mutation.CreateOpenSearchCredentials == nil { + case "KafkaTopicAcl.topic": + if e.ComplexityRoot.KafkaTopicAcl.Topic == nil { break } - args, err := ec.field_Mutation_createOpenSearchCredentials_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicAcl.Topic(childComplexity), true + + case "KafkaTopicAcl.workload": + if e.ComplexityRoot.KafkaTopicAcl.Workload == nil { + break } - return e.ComplexityRoot.Mutation.CreateOpenSearchCredentials(childComplexity, args["input"].(aivencredentials.CreateOpenSearchCredentialsInput)), true + return e.ComplexityRoot.KafkaTopicAcl.Workload(childComplexity), true - case "Mutation.createSecret": - if e.ComplexityRoot.Mutation.CreateSecret == nil { + case "KafkaTopicAcl.workloadName": + if e.ComplexityRoot.KafkaTopicAcl.WorkloadName == nil { break } - args, err := ec.field_Mutation_createSecret_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicAcl.WorkloadName(childComplexity), true + + case "KafkaTopicAclConnection.edges": + if e.ComplexityRoot.KafkaTopicAclConnection.Edges == nil { + break } - return e.ComplexityRoot.Mutation.CreateSecret(childComplexity, args["input"].(secret.CreateSecretInput)), true + return e.ComplexityRoot.KafkaTopicAclConnection.Edges(childComplexity), true - case "Mutation.createServiceAccount": - if e.ComplexityRoot.Mutation.CreateServiceAccount == nil { + case "KafkaTopicAclConnection.nodes": + if e.ComplexityRoot.KafkaTopicAclConnection.Nodes == nil { break } - args, err := ec.field_Mutation_createServiceAccount_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicAclConnection.Nodes(childComplexity), true + + case "KafkaTopicAclConnection.pageInfo": + if e.ComplexityRoot.KafkaTopicAclConnection.PageInfo == nil { + break } - return e.ComplexityRoot.Mutation.CreateServiceAccount(childComplexity, args["input"].(serviceaccount.CreateServiceAccountInput)), true + return e.ComplexityRoot.KafkaTopicAclConnection.PageInfo(childComplexity), true - case "Mutation.createServiceAccountToken": - if e.ComplexityRoot.Mutation.CreateServiceAccountToken == nil { + case "KafkaTopicAclEdge.cursor": + if e.ComplexityRoot.KafkaTopicAclEdge.Cursor == nil { break } - args, err := ec.field_Mutation_createServiceAccountToken_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicAclEdge.Cursor(childComplexity), true + + case "KafkaTopicAclEdge.node": + if e.ComplexityRoot.KafkaTopicAclEdge.Node == nil { + break } - return e.ComplexityRoot.Mutation.CreateServiceAccountToken(childComplexity, args["input"].(serviceaccount.CreateServiceAccountTokenInput)), true + return e.ComplexityRoot.KafkaTopicAclEdge.Node(childComplexity), true - case "Mutation.createTeam": - if e.ComplexityRoot.Mutation.CreateTeam == nil { + case "KafkaTopicConfiguration.cleanupPolicy": + if e.ComplexityRoot.KafkaTopicConfiguration.CleanupPolicy == nil { break } - args, err := ec.field_Mutation_createTeam_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicConfiguration.CleanupPolicy(childComplexity), true + + case "KafkaTopicConfiguration.maxMessageBytes": + if e.ComplexityRoot.KafkaTopicConfiguration.MaxMessageBytes == nil { + break } - return e.ComplexityRoot.Mutation.CreateTeam(childComplexity, args["input"].(team.CreateTeamInput)), true + return e.ComplexityRoot.KafkaTopicConfiguration.MaxMessageBytes(childComplexity), true - case "Mutation.createUnleashForTeam": - if e.ComplexityRoot.Mutation.CreateUnleashForTeam == nil { + case "KafkaTopicConfiguration.minimumInSyncReplicas": + if e.ComplexityRoot.KafkaTopicConfiguration.MinimumInSyncReplicas == nil { break } - args, err := ec.field_Mutation_createUnleashForTeam_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicConfiguration.MinimumInSyncReplicas(childComplexity), true + + case "KafkaTopicConfiguration.partitions": + if e.ComplexityRoot.KafkaTopicConfiguration.Partitions == nil { + break } - return e.ComplexityRoot.Mutation.CreateUnleashForTeam(childComplexity, args["input"].(unleash.CreateUnleashForTeamInput)), true + return e.ComplexityRoot.KafkaTopicConfiguration.Partitions(childComplexity), true - case "Mutation.createValkey": - if e.ComplexityRoot.Mutation.CreateValkey == nil { + case "KafkaTopicConfiguration.replication": + if e.ComplexityRoot.KafkaTopicConfiguration.Replication == nil { break } - args, err := ec.field_Mutation_createValkey_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicConfiguration.Replication(childComplexity), true + + case "KafkaTopicConfiguration.retentionBytes": + if e.ComplexityRoot.KafkaTopicConfiguration.RetentionBytes == nil { + break } - return e.ComplexityRoot.Mutation.CreateValkey(childComplexity, args["input"].(valkey.CreateValkeyInput)), true + return e.ComplexityRoot.KafkaTopicConfiguration.RetentionBytes(childComplexity), true - case "Mutation.createValkeyCredentials": - if e.ComplexityRoot.Mutation.CreateValkeyCredentials == nil { + case "KafkaTopicConfiguration.retentionHours": + if e.ComplexityRoot.KafkaTopicConfiguration.RetentionHours == nil { break } - args, err := ec.field_Mutation_createValkeyCredentials_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicConfiguration.RetentionHours(childComplexity), true + + case "KafkaTopicConfiguration.segmentHours": + if e.ComplexityRoot.KafkaTopicConfiguration.SegmentHours == nil { + break } - return e.ComplexityRoot.Mutation.CreateValkeyCredentials(childComplexity, args["input"].(aivencredentials.CreateValkeyCredentialsInput)), true + return e.ComplexityRoot.KafkaTopicConfiguration.SegmentHours(childComplexity), true - case "Mutation.deleteApplication": - if e.ComplexityRoot.Mutation.DeleteApplication == nil { + case "KafkaTopicConnection.edges": + if e.ComplexityRoot.KafkaTopicConnection.Edges == nil { break } - args, err := ec.field_Mutation_deleteApplication_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicConnection.Edges(childComplexity), true + + case "KafkaTopicConnection.nodes": + if e.ComplexityRoot.KafkaTopicConnection.Nodes == nil { + break } - return e.ComplexityRoot.Mutation.DeleteApplication(childComplexity, args["input"].(application.DeleteApplicationInput)), true + return e.ComplexityRoot.KafkaTopicConnection.Nodes(childComplexity), true - case "Mutation.deleteJob": - if e.ComplexityRoot.Mutation.DeleteJob == nil { + case "KafkaTopicConnection.pageInfo": + if e.ComplexityRoot.KafkaTopicConnection.PageInfo == nil { break } - args, err := ec.field_Mutation_deleteJob_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicConnection.PageInfo(childComplexity), true + + case "KafkaTopicEdge.cursor": + if e.ComplexityRoot.KafkaTopicEdge.Cursor == nil { + break } - return e.ComplexityRoot.Mutation.DeleteJob(childComplexity, args["input"].(job.DeleteJobInput)), true + return e.ComplexityRoot.KafkaTopicEdge.Cursor(childComplexity), true - case "Mutation.deleteJobRun": - if e.ComplexityRoot.Mutation.DeleteJobRun == nil { + case "KafkaTopicEdge.node": + if e.ComplexityRoot.KafkaTopicEdge.Node == nil { break } - args, err := ec.field_Mutation_deleteJobRun_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.KafkaTopicEdge.Node(childComplexity), true + + case "LastRunFailedIssue.id": + if e.ComplexityRoot.LastRunFailedIssue.ID == nil { + break } - return e.ComplexityRoot.Mutation.DeleteJobRun(childComplexity, args["input"].(job.DeleteJobRunInput)), true + return e.ComplexityRoot.LastRunFailedIssue.ID(childComplexity), true - case "Mutation.deleteOpenSearch": - if e.ComplexityRoot.Mutation.DeleteOpenSearch == nil { + case "LastRunFailedIssue.job": + if e.ComplexityRoot.LastRunFailedIssue.Job == nil { break } - args, err := ec.field_Mutation_deleteOpenSearch_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LastRunFailedIssue.Job(childComplexity), true + + case "LastRunFailedIssue.message": + if e.ComplexityRoot.LastRunFailedIssue.Message == nil { + break } - return e.ComplexityRoot.Mutation.DeleteOpenSearch(childComplexity, args["input"].(opensearch.DeleteOpenSearchInput)), true + return e.ComplexityRoot.LastRunFailedIssue.Message(childComplexity), true - case "Mutation.deleteSecret": - if e.ComplexityRoot.Mutation.DeleteSecret == nil { + case "LastRunFailedIssue.severity": + if e.ComplexityRoot.LastRunFailedIssue.Severity == nil { break } - args, err := ec.field_Mutation_deleteSecret_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LastRunFailedIssue.Severity(childComplexity), true + + case "LastRunFailedIssue.teamEnvironment": + if e.ComplexityRoot.LastRunFailedIssue.TeamEnvironment == nil { + break } - return e.ComplexityRoot.Mutation.DeleteSecret(childComplexity, args["input"].(secret.DeleteSecretInput)), true + return e.ComplexityRoot.LastRunFailedIssue.TeamEnvironment(childComplexity), true - case "Mutation.deleteServiceAccount": - if e.ComplexityRoot.Mutation.DeleteServiceAccount == nil { + case "LogDestinationGeneric.id": + if e.ComplexityRoot.LogDestinationGeneric.ID == nil { break } - args, err := ec.field_Mutation_deleteServiceAccount_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LogDestinationGeneric.ID(childComplexity), true + + case "LogDestinationGeneric.name": + if e.ComplexityRoot.LogDestinationGeneric.Name == nil { + break } - return e.ComplexityRoot.Mutation.DeleteServiceAccount(childComplexity, args["input"].(serviceaccount.DeleteServiceAccountInput)), true + return e.ComplexityRoot.LogDestinationGeneric.Name(childComplexity), true - case "Mutation.deleteServiceAccountToken": - if e.ComplexityRoot.Mutation.DeleteServiceAccountToken == nil { + case "LogDestinationLoki.grafanaURL": + if e.ComplexityRoot.LogDestinationLoki.GrafanaURL == nil { break } - args, err := ec.field_Mutation_deleteServiceAccountToken_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LogDestinationLoki.GrafanaURL(childComplexity), true + + case "LogDestinationLoki.id": + if e.ComplexityRoot.LogDestinationLoki.ID == nil { + break } - return e.ComplexityRoot.Mutation.DeleteServiceAccountToken(childComplexity, args["input"].(serviceaccount.DeleteServiceAccountTokenInput)), true + return e.ComplexityRoot.LogDestinationLoki.ID(childComplexity), true - case "Mutation.deleteUnleashInstance": - if e.ComplexityRoot.Mutation.DeleteUnleashInstance == nil { + case "LogDestinationSecureLogs.id": + if e.ComplexityRoot.LogDestinationSecureLogs.ID == nil { break } - args, err := ec.field_Mutation_deleteUnleashInstance_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LogDestinationSecureLogs.ID(childComplexity), true + + case "LogLine.labels": + if e.ComplexityRoot.LogLine.Labels == nil { + break } - return e.ComplexityRoot.Mutation.DeleteUnleashInstance(childComplexity, args["input"].(unleash.DeleteUnleashInstanceInput)), true + return e.ComplexityRoot.LogLine.Labels(childComplexity), true - case "Mutation.deleteValkey": - if e.ComplexityRoot.Mutation.DeleteValkey == nil { + case "LogLine.message": + if e.ComplexityRoot.LogLine.Message == nil { break } - args, err := ec.field_Mutation_deleteValkey_args(ctx, rawArgs) - if err != nil { - return 0, false - } + return e.ComplexityRoot.LogLine.Message(childComplexity), true - return e.ComplexityRoot.Mutation.DeleteValkey(childComplexity, args["input"].(valkey.DeleteValkeyInput)), true + case "LogLine.time": + if e.ComplexityRoot.LogLine.Time == nil { + break + } - case "Mutation.disableReconciler": - if e.ComplexityRoot.Mutation.DisableReconciler == nil { + return e.ComplexityRoot.LogLine.Time(childComplexity), true + + case "LogLineLabel.key": + if e.ComplexityRoot.LogLineLabel.Key == nil { break } - args, err := ec.field_Mutation_disableReconciler_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.LogLineLabel.Key(childComplexity), true + + case "LogLineLabel.value": + if e.ComplexityRoot.LogLineLabel.Value == nil { + break } - return e.ComplexityRoot.Mutation.DisableReconciler(childComplexity, args["input"].(reconciler.DisableReconcilerInput)), true + return e.ComplexityRoot.LogLineLabel.Value(childComplexity), true - case "Mutation.enableReconciler": - if e.ComplexityRoot.Mutation.EnableReconciler == nil { + case "MaintenanceWindow.dayOfWeek": + if e.ComplexityRoot.MaintenanceWindow.DayOfWeek == nil { break } - args, err := ec.field_Mutation_enableReconciler_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MaintenanceWindow.DayOfWeek(childComplexity), true + + case "MaintenanceWindow.timeOfDay": + if e.ComplexityRoot.MaintenanceWindow.TimeOfDay == nil { + break } - return e.ComplexityRoot.Mutation.EnableReconciler(childComplexity, args["input"].(reconciler.EnableReconcilerInput)), true + return e.ComplexityRoot.MaintenanceWindow.TimeOfDay(childComplexity), true - case "Mutation.grantPostgresAccess": - if e.ComplexityRoot.Mutation.GrantPostgresAccess == nil { + case "MaskinportenAuthIntegration.name": + if e.ComplexityRoot.MaskinportenAuthIntegration.Name == nil { break } - args, err := ec.field_Mutation_grantPostgresAccess_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MaskinportenAuthIntegration.Name(childComplexity), true + + case "MetricLabel.name": + if e.ComplexityRoot.MetricLabel.Name == nil { + break } - return e.ComplexityRoot.Mutation.GrantPostgresAccess(childComplexity, args["input"].(postgres.GrantPostgresAccessInput)), true + return e.ComplexityRoot.MetricLabel.Name(childComplexity), true - case "Mutation.removeRepositoryFromTeam": - if e.ComplexityRoot.Mutation.RemoveRepositoryFromTeam == nil { + case "MetricLabel.value": + if e.ComplexityRoot.MetricLabel.Value == nil { break } - args, err := ec.field_Mutation_removeRepositoryFromTeam_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MetricLabel.Value(childComplexity), true + + case "MetricSeries.labels": + if e.ComplexityRoot.MetricSeries.Labels == nil { + break } - return e.ComplexityRoot.Mutation.RemoveRepositoryFromTeam(childComplexity, args["input"].(repository.RemoveRepositoryFromTeamInput)), true + return e.ComplexityRoot.MetricSeries.Labels(childComplexity), true - case "Mutation.removeSecretValue": - if e.ComplexityRoot.Mutation.RemoveSecretValue == nil { + case "MetricSeries.values": + if e.ComplexityRoot.MetricSeries.Values == nil { break } - args, err := ec.field_Mutation_removeSecretValue_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MetricSeries.Values(childComplexity), true + + case "MetricValue.timestamp": + if e.ComplexityRoot.MetricValue.Timestamp == nil { + break } - return e.ComplexityRoot.Mutation.RemoveSecretValue(childComplexity, args["input"].(secret.RemoveSecretValueInput)), true + return e.ComplexityRoot.MetricValue.Timestamp(childComplexity), true - case "Mutation.removeTeamMember": - if e.ComplexityRoot.Mutation.RemoveTeamMember == nil { + case "MetricValue.value": + if e.ComplexityRoot.MetricValue.Value == nil { break } - args, err := ec.field_Mutation_removeTeamMember_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MetricValue.Value(childComplexity), true + + case "MetricsQueryResult.series": + if e.ComplexityRoot.MetricsQueryResult.Series == nil { + break } - return e.ComplexityRoot.Mutation.RemoveTeamMember(childComplexity, args["input"].(team.RemoveTeamMemberInput)), true + return e.ComplexityRoot.MetricsQueryResult.Series(childComplexity), true - case "Mutation.requestTeamDeletion": - if e.ComplexityRoot.Mutation.RequestTeamDeletion == nil { + case "MetricsQueryResult.warnings": + if e.ComplexityRoot.MetricsQueryResult.Warnings == nil { break } - args, err := ec.field_Mutation_requestTeamDeletion_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MetricsQueryResult.Warnings(childComplexity), true + + case "MissingSbomIssue.id": + if e.ComplexityRoot.MissingSbomIssue.ID == nil { + break } - return e.ComplexityRoot.Mutation.RequestTeamDeletion(childComplexity, args["input"].(team.RequestTeamDeletionInput)), true + return e.ComplexityRoot.MissingSbomIssue.ID(childComplexity), true - case "Mutation.restartApplication": - if e.ComplexityRoot.Mutation.RestartApplication == nil { + case "MissingSbomIssue.message": + if e.ComplexityRoot.MissingSbomIssue.Message == nil { break } - args, err := ec.field_Mutation_restartApplication_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MissingSbomIssue.Message(childComplexity), true + + case "MissingSbomIssue.severity": + if e.ComplexityRoot.MissingSbomIssue.Severity == nil { + break } - return e.ComplexityRoot.Mutation.RestartApplication(childComplexity, args["input"].(application.RestartApplicationInput)), true + return e.ComplexityRoot.MissingSbomIssue.Severity(childComplexity), true - case "Mutation.revokeRoleFromServiceAccount": - if e.ComplexityRoot.Mutation.RevokeRoleFromServiceAccount == nil { + case "MissingSbomIssue.teamEnvironment": + if e.ComplexityRoot.MissingSbomIssue.TeamEnvironment == nil { break } - args, err := ec.field_Mutation_revokeRoleFromServiceAccount_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.MissingSbomIssue.TeamEnvironment(childComplexity), true + + case "MissingSbomIssue.workload": + if e.ComplexityRoot.MissingSbomIssue.Workload == nil { + break } - return e.ComplexityRoot.Mutation.RevokeRoleFromServiceAccount(childComplexity, args["input"].(serviceaccount.RevokeRoleFromServiceAccountInput)), true + return e.ComplexityRoot.MissingSbomIssue.Workload(childComplexity), true - case "Mutation.revokeTeamAccessToUnleash": - if e.ComplexityRoot.Mutation.RevokeTeamAccessToUnleash == nil { + case "Mutation.addConfigValue": + if e.ComplexityRoot.Mutation.AddConfigValue == nil { break } - args, err := ec.field_Mutation_revokeTeamAccessToUnleash_args(ctx, rawArgs) + args, err := ec.field_Mutation_addConfigValue_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.RevokeTeamAccessToUnleash(childComplexity, args["input"].(unleash.RevokeTeamAccessToUnleashInput)), true + return e.ComplexityRoot.Mutation.AddConfigValue(childComplexity, args["input"].(configmap.AddConfigValueInput)), true - case "Mutation.setTeamMemberRole": - if e.ComplexityRoot.Mutation.SetTeamMemberRole == nil { + case "Mutation.addRepositoryToTeam": + if e.ComplexityRoot.Mutation.AddRepositoryToTeam == nil { break } - args, err := ec.field_Mutation_setTeamMemberRole_args(ctx, rawArgs) + args, err := ec.field_Mutation_addRepositoryToTeam_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.SetTeamMemberRole(childComplexity, args["input"].(team.SetTeamMemberRoleInput)), true + return e.ComplexityRoot.Mutation.AddRepositoryToTeam(childComplexity, args["input"].(repository.AddRepositoryToTeamInput)), true - case "Mutation.startOpenSearchMaintenance": - if e.ComplexityRoot.Mutation.StartOpenSearchMaintenance == nil { + case "Mutation.addSecretValue": + if e.ComplexityRoot.Mutation.AddSecretValue == nil { break } - args, err := ec.field_Mutation_startOpenSearchMaintenance_args(ctx, rawArgs) + args, err := ec.field_Mutation_addSecretValue_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.StartOpenSearchMaintenance(childComplexity, args["input"].(servicemaintenance.StartOpenSearchMaintenanceInput)), true + return e.ComplexityRoot.Mutation.AddSecretValue(childComplexity, args["input"].(secret.AddSecretValueInput)), true - case "Mutation.startValkeyMaintenance": - if e.ComplexityRoot.Mutation.StartValkeyMaintenance == nil { + case "Mutation.addTeamMember": + if e.ComplexityRoot.Mutation.AddTeamMember == nil { break } - args, err := ec.field_Mutation_startValkeyMaintenance_args(ctx, rawArgs) + args, err := ec.field_Mutation_addTeamMember_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.StartValkeyMaintenance(childComplexity, args["input"].(servicemaintenance.StartValkeyMaintenanceInput)), true + return e.ComplexityRoot.Mutation.AddTeamMember(childComplexity, args["input"].(team.AddTeamMemberInput)), true - case "Mutation.triggerJob": - if e.ComplexityRoot.Mutation.TriggerJob == nil { + case "Mutation.allowTeamAccessToUnleash": + if e.ComplexityRoot.Mutation.AllowTeamAccessToUnleash == nil { break } - args, err := ec.field_Mutation_triggerJob_args(ctx, rawArgs) + args, err := ec.field_Mutation_allowTeamAccessToUnleash_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.TriggerJob(childComplexity, args["input"].(job.TriggerJobInput)), true + return e.ComplexityRoot.Mutation.AllowTeamAccessToUnleash(childComplexity, args["input"].(unleash.AllowTeamAccessToUnleashInput)), true - case "Mutation.updateImageVulnerability": - if e.ComplexityRoot.Mutation.UpdateImageVulnerability == nil { + case "Mutation.assignRoleToServiceAccount": + if e.ComplexityRoot.Mutation.AssignRoleToServiceAccount == nil { break } - args, err := ec.field_Mutation_updateImageVulnerability_args(ctx, rawArgs) + args, err := ec.field_Mutation_assignRoleToServiceAccount_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateImageVulnerability(childComplexity, args["input"].(vulnerability.UpdateImageVulnerabilityInput)), true + return e.ComplexityRoot.Mutation.AssignRoleToServiceAccount(childComplexity, args["input"].(serviceaccount.AssignRoleToServiceAccountInput)), true - case "Mutation.updateOpenSearch": - if e.ComplexityRoot.Mutation.UpdateOpenSearch == nil { + case "Mutation.changeDeploymentKey": + if e.ComplexityRoot.Mutation.ChangeDeploymentKey == nil { break } - args, err := ec.field_Mutation_updateOpenSearch_args(ctx, rawArgs) + args, err := ec.field_Mutation_changeDeploymentKey_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateOpenSearch(childComplexity, args["input"].(opensearch.UpdateOpenSearchInput)), true + return e.ComplexityRoot.Mutation.ChangeDeploymentKey(childComplexity, args["input"].(deployment.ChangeDeploymentKeyInput)), true - case "Mutation.updateSecretValue": - if e.ComplexityRoot.Mutation.UpdateSecretValue == nil { + case "Mutation.configureReconciler": + if e.ComplexityRoot.Mutation.ConfigureReconciler == nil { break } - args, err := ec.field_Mutation_updateSecretValue_args(ctx, rawArgs) + args, err := ec.field_Mutation_configureReconciler_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateSecretValue(childComplexity, args["input"].(secret.UpdateSecretValueInput)), true + return e.ComplexityRoot.Mutation.ConfigureReconciler(childComplexity, args["input"].(reconciler.ConfigureReconcilerInput)), true - case "Mutation.updateServiceAccount": - if e.ComplexityRoot.Mutation.UpdateServiceAccount == nil { + case "Mutation.confirmTeamDeletion": + if e.ComplexityRoot.Mutation.ConfirmTeamDeletion == nil { break } - args, err := ec.field_Mutation_updateServiceAccount_args(ctx, rawArgs) + args, err := ec.field_Mutation_confirmTeamDeletion_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateServiceAccount(childComplexity, args["input"].(serviceaccount.UpdateServiceAccountInput)), true + return e.ComplexityRoot.Mutation.ConfirmTeamDeletion(childComplexity, args["input"].(team.ConfirmTeamDeletionInput)), true - case "Mutation.updateServiceAccountToken": - if e.ComplexityRoot.Mutation.UpdateServiceAccountToken == nil { + case "Mutation.createConfig": + if e.ComplexityRoot.Mutation.CreateConfig == nil { break } - args, err := ec.field_Mutation_updateServiceAccountToken_args(ctx, rawArgs) + args, err := ec.field_Mutation_createConfig_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateServiceAccountToken(childComplexity, args["input"].(serviceaccount.UpdateServiceAccountTokenInput)), true + return e.ComplexityRoot.Mutation.CreateConfig(childComplexity, args["input"].(configmap.CreateConfigInput)), true - case "Mutation.updateTeam": - if e.ComplexityRoot.Mutation.UpdateTeam == nil { + case "Mutation.createKafkaCredentials": + if e.ComplexityRoot.Mutation.CreateKafkaCredentials == nil { break } - args, err := ec.field_Mutation_updateTeam_args(ctx, rawArgs) + args, err := ec.field_Mutation_createKafkaCredentials_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateTeam(childComplexity, args["input"].(team.UpdateTeamInput)), true + return e.ComplexityRoot.Mutation.CreateKafkaCredentials(childComplexity, args["input"].(aivencredentials.CreateKafkaCredentialsInput)), true - case "Mutation.updateTeamEnvironment": - if e.ComplexityRoot.Mutation.UpdateTeamEnvironment == nil { + case "Mutation.createOpenSearch": + if e.ComplexityRoot.Mutation.CreateOpenSearch == nil { break } - args, err := ec.field_Mutation_updateTeamEnvironment_args(ctx, rawArgs) + args, err := ec.field_Mutation_createOpenSearch_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateTeamEnvironment(childComplexity, args["input"].(team.UpdateTeamEnvironmentInput)), true + return e.ComplexityRoot.Mutation.CreateOpenSearch(childComplexity, args["input"].(opensearch.CreateOpenSearchInput)), true - case "Mutation.updateUnleashInstance": - if e.ComplexityRoot.Mutation.UpdateUnleashInstance == nil { + case "Mutation.createOpenSearchCredentials": + if e.ComplexityRoot.Mutation.CreateOpenSearchCredentials == nil { break } - args, err := ec.field_Mutation_updateUnleashInstance_args(ctx, rawArgs) + args, err := ec.field_Mutation_createOpenSearchCredentials_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateUnleashInstance(childComplexity, args["input"].(unleash.UpdateUnleashInstanceInput)), true + return e.ComplexityRoot.Mutation.CreateOpenSearchCredentials(childComplexity, args["input"].(aivencredentials.CreateOpenSearchCredentialsInput)), true - case "Mutation.updateValkey": - if e.ComplexityRoot.Mutation.UpdateValkey == nil { + case "Mutation.createSecret": + if e.ComplexityRoot.Mutation.CreateSecret == nil { break } - args, err := ec.field_Mutation_updateValkey_args(ctx, rawArgs) + args, err := ec.field_Mutation_createSecret_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.UpdateValkey(childComplexity, args["input"].(valkey.UpdateValkeyInput)), true + return e.ComplexityRoot.Mutation.CreateSecret(childComplexity, args["input"].(secret.CreateSecretInput)), true - case "Mutation.viewSecretValues": - if e.ComplexityRoot.Mutation.ViewSecretValues == nil { + case "Mutation.createServiceAccount": + if e.ComplexityRoot.Mutation.CreateServiceAccount == nil { break } - args, err := ec.field_Mutation_viewSecretValues_args(ctx, rawArgs) + args, err := ec.field_Mutation_createServiceAccount_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Mutation.ViewSecretValues(childComplexity, args["input"].(secret.ViewSecretValuesInput)), true + return e.ComplexityRoot.Mutation.CreateServiceAccount(childComplexity, args["input"].(serviceaccount.CreateServiceAccountInput)), true - case "NetworkPolicy.inbound": - if e.ComplexityRoot.NetworkPolicy.Inbound == nil { + case "Mutation.createServiceAccountToken": + if e.ComplexityRoot.Mutation.CreateServiceAccountToken == nil { break } - return e.ComplexityRoot.NetworkPolicy.Inbound(childComplexity), true + args, err := ec.field_Mutation_createServiceAccountToken_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "NetworkPolicy.outbound": - if e.ComplexityRoot.NetworkPolicy.Outbound == nil { + return e.ComplexityRoot.Mutation.CreateServiceAccountToken(childComplexity, args["input"].(serviceaccount.CreateServiceAccountTokenInput)), true + + case "Mutation.createTeam": + if e.ComplexityRoot.Mutation.CreateTeam == nil { break } - return e.ComplexityRoot.NetworkPolicy.Outbound(childComplexity), true - - case "NetworkPolicyRule.mutual": - if e.ComplexityRoot.NetworkPolicyRule.Mutual == nil { - break + args, err := ec.field_Mutation_createTeam_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.NetworkPolicyRule.Mutual(childComplexity), true + return e.ComplexityRoot.Mutation.CreateTeam(childComplexity, args["input"].(team.CreateTeamInput)), true - case "NetworkPolicyRule.targetTeam": - if e.ComplexityRoot.NetworkPolicyRule.TargetTeam == nil { + case "Mutation.createUnleashForTeam": + if e.ComplexityRoot.Mutation.CreateUnleashForTeam == nil { break } - return e.ComplexityRoot.NetworkPolicyRule.TargetTeam(childComplexity), true - - case "NetworkPolicyRule.targetTeamSlug": - if e.ComplexityRoot.NetworkPolicyRule.TargetTeamSlug == nil { - break + args, err := ec.field_Mutation_createUnleashForTeam_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.NetworkPolicyRule.TargetTeamSlug(childComplexity), true + return e.ComplexityRoot.Mutation.CreateUnleashForTeam(childComplexity, args["input"].(unleash.CreateUnleashForTeamInput)), true - case "NetworkPolicyRule.targetWorkload": - if e.ComplexityRoot.NetworkPolicyRule.TargetWorkload == nil { + case "Mutation.createValkey": + if e.ComplexityRoot.Mutation.CreateValkey == nil { break } - return e.ComplexityRoot.NetworkPolicyRule.TargetWorkload(childComplexity), true - - case "NetworkPolicyRule.targetWorkloadName": - if e.ComplexityRoot.NetworkPolicyRule.TargetWorkloadName == nil { - break + args, err := ec.field_Mutation_createValkey_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.NetworkPolicyRule.TargetWorkloadName(childComplexity), true + return e.ComplexityRoot.Mutation.CreateValkey(childComplexity, args["input"].(valkey.CreateValkeyInput)), true - case "NoRunningInstancesIssue.id": - if e.ComplexityRoot.NoRunningInstancesIssue.ID == nil { + case "Mutation.createValkeyCredentials": + if e.ComplexityRoot.Mutation.CreateValkeyCredentials == nil { break } - return e.ComplexityRoot.NoRunningInstancesIssue.ID(childComplexity), true - - case "NoRunningInstancesIssue.message": - if e.ComplexityRoot.NoRunningInstancesIssue.Message == nil { - break + args, err := ec.field_Mutation_createValkeyCredentials_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.NoRunningInstancesIssue.Message(childComplexity), true + return e.ComplexityRoot.Mutation.CreateValkeyCredentials(childComplexity, args["input"].(aivencredentials.CreateValkeyCredentialsInput)), true - case "NoRunningInstancesIssue.severity": - if e.ComplexityRoot.NoRunningInstancesIssue.Severity == nil { + case "Mutation.deleteApplication": + if e.ComplexityRoot.Mutation.DeleteApplication == nil { break } - return e.ComplexityRoot.NoRunningInstancesIssue.Severity(childComplexity), true - - case "NoRunningInstancesIssue.teamEnvironment": - if e.ComplexityRoot.NoRunningInstancesIssue.TeamEnvironment == nil { - break + args, err := ec.field_Mutation_deleteApplication_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.NoRunningInstancesIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteApplication(childComplexity, args["input"].(application.DeleteApplicationInput)), true - case "NoRunningInstancesIssue.workload": - if e.ComplexityRoot.NoRunningInstancesIssue.Workload == nil { + case "Mutation.deleteConfig": + if e.ComplexityRoot.Mutation.DeleteConfig == nil { break } - return e.ComplexityRoot.NoRunningInstancesIssue.Workload(childComplexity), true + args, err := ec.field_Mutation_deleteConfig_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "OpenSearch.access": - if e.ComplexityRoot.OpenSearch.Access == nil { + return e.ComplexityRoot.Mutation.DeleteConfig(childComplexity, args["input"].(configmap.DeleteConfigInput)), true + + case "Mutation.deleteJob": + if e.ComplexityRoot.Mutation.DeleteJob == nil { break } - args, err := ec.field_OpenSearch_access_args(ctx, rawArgs) + args, err := ec.field_Mutation_deleteJob_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.OpenSearch.Access(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*opensearch.OpenSearchAccessOrder)), true + return e.ComplexityRoot.Mutation.DeleteJob(childComplexity, args["input"].(job.DeleteJobInput)), true - case "OpenSearch.activityLog": - if e.ComplexityRoot.OpenSearch.ActivityLog == nil { + case "Mutation.deleteJobRun": + if e.ComplexityRoot.Mutation.DeleteJobRun == nil { break } - args, err := ec.field_OpenSearch_activityLog_args(ctx, rawArgs) + args, err := ec.field_Mutation_deleteJobRun_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.OpenSearch.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.Mutation.DeleteJobRun(childComplexity, args["input"].(job.DeleteJobRunInput)), true - case "OpenSearch.cost": - if e.ComplexityRoot.OpenSearch.Cost == nil { + case "Mutation.deleteOpenSearch": + if e.ComplexityRoot.Mutation.DeleteOpenSearch == nil { break } - return e.ComplexityRoot.OpenSearch.Cost(childComplexity), true - - case "OpenSearch.environment": - if e.ComplexityRoot.OpenSearch.Environment == nil { - break + args, err := ec.field_Mutation_deleteOpenSearch_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearch.Environment(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteOpenSearch(childComplexity, args["input"].(opensearch.DeleteOpenSearchInput)), true - case "OpenSearch.id": - if e.ComplexityRoot.OpenSearch.ID == nil { + case "Mutation.deleteSecret": + if e.ComplexityRoot.Mutation.DeleteSecret == nil { break } - return e.ComplexityRoot.OpenSearch.ID(childComplexity), true + args, err := ec.field_Mutation_deleteSecret_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "OpenSearch.issues": - if e.ComplexityRoot.OpenSearch.Issues == nil { + return e.ComplexityRoot.Mutation.DeleteSecret(childComplexity, args["input"].(secret.DeleteSecretInput)), true + + case "Mutation.deleteServiceAccount": + if e.ComplexityRoot.Mutation.DeleteServiceAccount == nil { break } - args, err := ec.field_OpenSearch_issues_args(ctx, rawArgs) + args, err := ec.field_Mutation_deleteServiceAccount_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.OpenSearch.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + return e.ComplexityRoot.Mutation.DeleteServiceAccount(childComplexity, args["input"].(serviceaccount.DeleteServiceAccountInput)), true - case "OpenSearch.maintenance": - if e.ComplexityRoot.OpenSearch.Maintenance == nil { + case "Mutation.deleteServiceAccountToken": + if e.ComplexityRoot.Mutation.DeleteServiceAccountToken == nil { break } - return e.ComplexityRoot.OpenSearch.Maintenance(childComplexity), true - - case "OpenSearch.memory": - if e.ComplexityRoot.OpenSearch.Memory == nil { - break + args, err := ec.field_Mutation_deleteServiceAccountToken_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearch.Memory(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteServiceAccountToken(childComplexity, args["input"].(serviceaccount.DeleteServiceAccountTokenInput)), true - case "OpenSearch.name": - if e.ComplexityRoot.OpenSearch.Name == nil { + case "Mutation.deleteUnleashInstance": + if e.ComplexityRoot.Mutation.DeleteUnleashInstance == nil { break } - return e.ComplexityRoot.OpenSearch.Name(childComplexity), true - - case "OpenSearch.state": - if e.ComplexityRoot.OpenSearch.State == nil { - break + args, err := ec.field_Mutation_deleteUnleashInstance_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearch.State(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteUnleashInstance(childComplexity, args["input"].(unleash.DeleteUnleashInstanceInput)), true - case "OpenSearch.storageGB": - if e.ComplexityRoot.OpenSearch.StorageGB == nil { + case "Mutation.deleteValkey": + if e.ComplexityRoot.Mutation.DeleteValkey == nil { break } - return e.ComplexityRoot.OpenSearch.StorageGB(childComplexity), true - - case "OpenSearch.team": - if e.ComplexityRoot.OpenSearch.Team == nil { - break + args, err := ec.field_Mutation_deleteValkey_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearch.Team(childComplexity), true + return e.ComplexityRoot.Mutation.DeleteValkey(childComplexity, args["input"].(valkey.DeleteValkeyInput)), true - case "OpenSearch.teamEnvironment": - if e.ComplexityRoot.OpenSearch.TeamEnvironment == nil { + case "Mutation.disableReconciler": + if e.ComplexityRoot.Mutation.DisableReconciler == nil { break } - return e.ComplexityRoot.OpenSearch.TeamEnvironment(childComplexity), true - - case "OpenSearch.terminationProtection": - if e.ComplexityRoot.OpenSearch.TerminationProtection == nil { - break + args, err := ec.field_Mutation_disableReconciler_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearch.TerminationProtection(childComplexity), true + return e.ComplexityRoot.Mutation.DisableReconciler(childComplexity, args["input"].(reconciler.DisableReconcilerInput)), true - case "OpenSearch.tier": - if e.ComplexityRoot.OpenSearch.Tier == nil { + case "Mutation.enableReconciler": + if e.ComplexityRoot.Mutation.EnableReconciler == nil { break } - return e.ComplexityRoot.OpenSearch.Tier(childComplexity), true - - case "OpenSearch.version": - if e.ComplexityRoot.OpenSearch.Version == nil { - break + args, err := ec.field_Mutation_enableReconciler_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearch.Version(childComplexity), true + return e.ComplexityRoot.Mutation.EnableReconciler(childComplexity, args["input"].(reconciler.EnableReconcilerInput)), true - case "OpenSearch.workload": - if e.ComplexityRoot.OpenSearch.Workload == nil { + case "Mutation.grantPostgresAccess": + if e.ComplexityRoot.Mutation.GrantPostgresAccess == nil { break } - return e.ComplexityRoot.OpenSearch.Workload(childComplexity), true - - case "OpenSearchAccess.access": - if e.ComplexityRoot.OpenSearchAccess.Access == nil { - break + args, err := ec.field_Mutation_grantPostgresAccess_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchAccess.Access(childComplexity), true + return e.ComplexityRoot.Mutation.GrantPostgresAccess(childComplexity, args["input"].(postgres.GrantPostgresAccessInput)), true - case "OpenSearchAccess.workload": - if e.ComplexityRoot.OpenSearchAccess.Workload == nil { + case "Mutation.removeConfigValue": + if e.ComplexityRoot.Mutation.RemoveConfigValue == nil { break } - return e.ComplexityRoot.OpenSearchAccess.Workload(childComplexity), true - - case "OpenSearchAccessConnection.edges": - if e.ComplexityRoot.OpenSearchAccessConnection.Edges == nil { - break + args, err := ec.field_Mutation_removeConfigValue_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchAccessConnection.Edges(childComplexity), true + return e.ComplexityRoot.Mutation.RemoveConfigValue(childComplexity, args["input"].(configmap.RemoveConfigValueInput)), true - case "OpenSearchAccessConnection.nodes": - if e.ComplexityRoot.OpenSearchAccessConnection.Nodes == nil { + case "Mutation.removeRepositoryFromTeam": + if e.ComplexityRoot.Mutation.RemoveRepositoryFromTeam == nil { break } - return e.ComplexityRoot.OpenSearchAccessConnection.Nodes(childComplexity), true - - case "OpenSearchAccessConnection.pageInfo": - if e.ComplexityRoot.OpenSearchAccessConnection.PageInfo == nil { - break + args, err := ec.field_Mutation_removeRepositoryFromTeam_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchAccessConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Mutation.RemoveRepositoryFromTeam(childComplexity, args["input"].(repository.RemoveRepositoryFromTeamInput)), true - case "OpenSearchAccessEdge.cursor": - if e.ComplexityRoot.OpenSearchAccessEdge.Cursor == nil { + case "Mutation.removeSecretValue": + if e.ComplexityRoot.Mutation.RemoveSecretValue == nil { break } - return e.ComplexityRoot.OpenSearchAccessEdge.Cursor(childComplexity), true - - case "OpenSearchAccessEdge.node": - if e.ComplexityRoot.OpenSearchAccessEdge.Node == nil { - break + args, err := ec.field_Mutation_removeSecretValue_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchAccessEdge.Node(childComplexity), true + return e.ComplexityRoot.Mutation.RemoveSecretValue(childComplexity, args["input"].(secret.RemoveSecretValueInput)), true - case "OpenSearchConnection.edges": - if e.ComplexityRoot.OpenSearchConnection.Edges == nil { + case "Mutation.removeTeamMember": + if e.ComplexityRoot.Mutation.RemoveTeamMember == nil { break } - return e.ComplexityRoot.OpenSearchConnection.Edges(childComplexity), true - - case "OpenSearchConnection.nodes": - if e.ComplexityRoot.OpenSearchConnection.Nodes == nil { - break + args, err := ec.field_Mutation_removeTeamMember_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Mutation.RemoveTeamMember(childComplexity, args["input"].(team.RemoveTeamMemberInput)), true - case "OpenSearchConnection.pageInfo": - if e.ComplexityRoot.OpenSearchConnection.PageInfo == nil { + case "Mutation.requestTeamDeletion": + if e.ComplexityRoot.Mutation.RequestTeamDeletion == nil { break } - return e.ComplexityRoot.OpenSearchConnection.PageInfo(childComplexity), true - - case "OpenSearchCost.sum": - if e.ComplexityRoot.OpenSearchCost.Sum == nil { - break + args, err := ec.field_Mutation_requestTeamDeletion_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCost.Sum(childComplexity), true + return e.ComplexityRoot.Mutation.RequestTeamDeletion(childComplexity, args["input"].(team.RequestTeamDeletionInput)), true - case "OpenSearchCreatedActivityLogEntry.actor": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Actor == nil { + case "Mutation.restartApplication": + if e.ComplexityRoot.Mutation.RestartApplication == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Actor(childComplexity), true - - case "OpenSearchCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_Mutation_restartApplication_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Mutation.RestartApplication(childComplexity, args["input"].(application.RestartApplicationInput)), true - case "OpenSearchCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.EnvironmentName == nil { + case "Mutation.revokeRoleFromServiceAccount": + if e.ComplexityRoot.Mutation.RevokeRoleFromServiceAccount == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.EnvironmentName(childComplexity), true - - case "OpenSearchCreatedActivityLogEntry.id": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ID == nil { - break + args, err := ec.field_Mutation_revokeRoleFromServiceAccount_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Mutation.RevokeRoleFromServiceAccount(childComplexity, args["input"].(serviceaccount.RevokeRoleFromServiceAccountInput)), true - case "OpenSearchCreatedActivityLogEntry.message": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Message == nil { + case "Mutation.revokeTeamAccessToUnleash": + if e.ComplexityRoot.Mutation.RevokeTeamAccessToUnleash == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Message(childComplexity), true - - case "OpenSearchCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceName == nil { - break + args, err := ec.field_Mutation_revokeTeamAccessToUnleash_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.Mutation.RevokeTeamAccessToUnleash(childComplexity, args["input"].(unleash.RevokeTeamAccessToUnleashInput)), true - case "OpenSearchCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceType == nil { + case "Mutation.setTeamMemberRole": + if e.ComplexityRoot.Mutation.SetTeamMemberRole == nil { break } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceType(childComplexity), true - - case "OpenSearchCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.TeamSlug == nil { - break + args, err := ec.field_Mutation_setTeamMemberRole_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Mutation.SetTeamMemberRole(childComplexity, args["input"].(team.SetTeamMemberRoleInput)), true - case "OpenSearchCredentials.host": - if e.ComplexityRoot.OpenSearchCredentials.Host == nil { + case "Mutation.startOpenSearchMaintenance": + if e.ComplexityRoot.Mutation.StartOpenSearchMaintenance == nil { break } - return e.ComplexityRoot.OpenSearchCredentials.Host(childComplexity), true - - case "OpenSearchCredentials.password": - if e.ComplexityRoot.OpenSearchCredentials.Password == nil { - break + args, err := ec.field_Mutation_startOpenSearchMaintenance_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCredentials.Password(childComplexity), true + return e.ComplexityRoot.Mutation.StartOpenSearchMaintenance(childComplexity, args["input"].(servicemaintenance.StartOpenSearchMaintenanceInput)), true - case "OpenSearchCredentials.port": - if e.ComplexityRoot.OpenSearchCredentials.Port == nil { + case "Mutation.startValkeyMaintenance": + if e.ComplexityRoot.Mutation.StartValkeyMaintenance == nil { break } - return e.ComplexityRoot.OpenSearchCredentials.Port(childComplexity), true - - case "OpenSearchCredentials.uri": - if e.ComplexityRoot.OpenSearchCredentials.URI == nil { - break + args, err := ec.field_Mutation_startValkeyMaintenance_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchCredentials.URI(childComplexity), true + return e.ComplexityRoot.Mutation.StartValkeyMaintenance(childComplexity, args["input"].(servicemaintenance.StartValkeyMaintenanceInput)), true - case "OpenSearchCredentials.username": - if e.ComplexityRoot.OpenSearchCredentials.Username == nil { + case "Mutation.triggerJob": + if e.ComplexityRoot.Mutation.TriggerJob == nil { break } - return e.ComplexityRoot.OpenSearchCredentials.Username(childComplexity), true - - case "OpenSearchDeletedActivityLogEntry.actor": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Actor == nil { - break + args, err := ec.field_Mutation_triggerJob_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Mutation.TriggerJob(childComplexity, args["input"].(job.TriggerJobInput)), true - case "OpenSearchDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.CreatedAt == nil { + case "Mutation.updateConfigValue": + if e.ComplexityRoot.Mutation.UpdateConfigValue == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.CreatedAt(childComplexity), true - - case "OpenSearchDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_Mutation_updateConfigValue_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateConfigValue(childComplexity, args["input"].(configmap.UpdateConfigValueInput)), true - case "OpenSearchDeletedActivityLogEntry.id": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ID == nil { + case "Mutation.updateImageVulnerability": + if e.ComplexityRoot.Mutation.UpdateImageVulnerability == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ID(childComplexity), true - - case "OpenSearchDeletedActivityLogEntry.message": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Message == nil { - break + args, err := ec.field_Mutation_updateImageVulnerability_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateImageVulnerability(childComplexity, args["input"].(vulnerability.UpdateImageVulnerabilityInput)), true - case "OpenSearchDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceName == nil { + case "Mutation.updateOpenSearch": + if e.ComplexityRoot.Mutation.UpdateOpenSearch == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceName(childComplexity), true - - case "OpenSearchDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceType == nil { - break + args, err := ec.field_Mutation_updateOpenSearch_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateOpenSearch(childComplexity, args["input"].(opensearch.UpdateOpenSearchInput)), true - case "OpenSearchDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.TeamSlug == nil { + case "Mutation.updateSecretValue": + if e.ComplexityRoot.Mutation.UpdateSecretValue == nil { break } - return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.TeamSlug(childComplexity), true - - case "OpenSearchEdge.cursor": - if e.ComplexityRoot.OpenSearchEdge.Cursor == nil { - break + args, err := ec.field_Mutation_updateSecretValue_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateSecretValue(childComplexity, args["input"].(secret.UpdateSecretValueInput)), true - case "OpenSearchEdge.node": - if e.ComplexityRoot.OpenSearchEdge.Node == nil { + case "Mutation.updateServiceAccount": + if e.ComplexityRoot.Mutation.UpdateServiceAccount == nil { break } - return e.ComplexityRoot.OpenSearchEdge.Node(childComplexity), true - - case "OpenSearchIssue.event": - if e.ComplexityRoot.OpenSearchIssue.Event == nil { - break + args, err := ec.field_Mutation_updateServiceAccount_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchIssue.Event(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateServiceAccount(childComplexity, args["input"].(serviceaccount.UpdateServiceAccountInput)), true - case "OpenSearchIssue.id": - if e.ComplexityRoot.OpenSearchIssue.ID == nil { + case "Mutation.updateServiceAccountToken": + if e.ComplexityRoot.Mutation.UpdateServiceAccountToken == nil { break } - return e.ComplexityRoot.OpenSearchIssue.ID(childComplexity), true - - case "OpenSearchIssue.message": - if e.ComplexityRoot.OpenSearchIssue.Message == nil { - break + args, err := ec.field_Mutation_updateServiceAccountToken_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchIssue.Message(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateServiceAccountToken(childComplexity, args["input"].(serviceaccount.UpdateServiceAccountTokenInput)), true - case "OpenSearchIssue.openSearch": - if e.ComplexityRoot.OpenSearchIssue.OpenSearch == nil { + case "Mutation.updateTeam": + if e.ComplexityRoot.Mutation.UpdateTeam == nil { break } - return e.ComplexityRoot.OpenSearchIssue.OpenSearch(childComplexity), true - - case "OpenSearchIssue.severity": - if e.ComplexityRoot.OpenSearchIssue.Severity == nil { - break + args, err := ec.field_Mutation_updateTeam_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchIssue.Severity(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateTeam(childComplexity, args["input"].(team.UpdateTeamInput)), true - case "OpenSearchIssue.teamEnvironment": - if e.ComplexityRoot.OpenSearchIssue.TeamEnvironment == nil { + case "Mutation.updateTeamEnvironment": + if e.ComplexityRoot.Mutation.UpdateTeamEnvironment == nil { break } - return e.ComplexityRoot.OpenSearchIssue.TeamEnvironment(childComplexity), true + args, err := ec.field_Mutation_updateTeamEnvironment_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "OpenSearchMaintenance.updates": - if e.ComplexityRoot.OpenSearchMaintenance.Updates == nil { + return e.ComplexityRoot.Mutation.UpdateTeamEnvironment(childComplexity, args["input"].(team.UpdateTeamEnvironmentInput)), true + + case "Mutation.updateUnleashInstance": + if e.ComplexityRoot.Mutation.UpdateUnleashInstance == nil { break } - args, err := ec.field_OpenSearchMaintenance_updates_args(ctx, rawArgs) + args, err := ec.field_Mutation_updateUnleashInstance_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.OpenSearchMaintenance.Updates(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Mutation.UpdateUnleashInstance(childComplexity, args["input"].(unleash.UpdateUnleashInstanceInput)), true - case "OpenSearchMaintenance.window": - if e.ComplexityRoot.OpenSearchMaintenance.Window == nil { + case "Mutation.updateValkey": + if e.ComplexityRoot.Mutation.UpdateValkey == nil { break } - return e.ComplexityRoot.OpenSearchMaintenance.Window(childComplexity), true - - case "OpenSearchMaintenanceUpdate.deadline": - if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Deadline == nil { - break + args, err := ec.field_Mutation_updateValkey_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Deadline(childComplexity), true + return e.ComplexityRoot.Mutation.UpdateValkey(childComplexity, args["input"].(valkey.UpdateValkeyInput)), true - case "OpenSearchMaintenanceUpdate.description": - if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Description == nil { + case "Mutation.viewSecretValues": + if e.ComplexityRoot.Mutation.ViewSecretValues == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Description(childComplexity), true + args, err := ec.field_Mutation_viewSecretValues_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "OpenSearchMaintenanceUpdate.startAt": - if e.ComplexityRoot.OpenSearchMaintenanceUpdate.StartAt == nil { + return e.ComplexityRoot.Mutation.ViewSecretValues(childComplexity, args["input"].(secret.ViewSecretValuesInput)), true + + case "NetworkPolicy.inbound": + if e.ComplexityRoot.NetworkPolicy.Inbound == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdate.StartAt(childComplexity), true + return e.ComplexityRoot.NetworkPolicy.Inbound(childComplexity), true - case "OpenSearchMaintenanceUpdate.title": - if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Title == nil { + case "NetworkPolicy.outbound": + if e.ComplexityRoot.NetworkPolicy.Outbound == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Title(childComplexity), true + return e.ComplexityRoot.NetworkPolicy.Outbound(childComplexity), true - case "OpenSearchMaintenanceUpdateConnection.edges": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Edges == nil { + case "NetworkPolicyRule.mutual": + if e.ComplexityRoot.NetworkPolicyRule.Mutual == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Edges(childComplexity), true + return e.ComplexityRoot.NetworkPolicyRule.Mutual(childComplexity), true - case "OpenSearchMaintenanceUpdateConnection.nodes": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Nodes == nil { + case "NetworkPolicyRule.targetTeam": + if e.ComplexityRoot.NetworkPolicyRule.TargetTeam == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Nodes(childComplexity), true + return e.ComplexityRoot.NetworkPolicyRule.TargetTeam(childComplexity), true - case "OpenSearchMaintenanceUpdateConnection.pageInfo": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.PageInfo == nil { + case "NetworkPolicyRule.targetTeamSlug": + if e.ComplexityRoot.NetworkPolicyRule.TargetTeamSlug == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.NetworkPolicyRule.TargetTeamSlug(childComplexity), true - case "OpenSearchMaintenanceUpdateEdge.cursor": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Cursor == nil { + case "NetworkPolicyRule.targetWorkload": + if e.ComplexityRoot.NetworkPolicyRule.TargetWorkload == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Cursor(childComplexity), true + return e.ComplexityRoot.NetworkPolicyRule.TargetWorkload(childComplexity), true - case "OpenSearchMaintenanceUpdateEdge.node": - if e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Node == nil { + case "NetworkPolicyRule.targetWorkloadName": + if e.ComplexityRoot.NetworkPolicyRule.TargetWorkloadName == nil { break } - return e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Node(childComplexity), true + return e.ComplexityRoot.NetworkPolicyRule.TargetWorkloadName(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Actor == nil { + case "NoRunningInstancesIssue.id": + if e.ComplexityRoot.NoRunningInstancesIssue.ID == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.NoRunningInstancesIssue.ID(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.CreatedAt == nil { + case "NoRunningInstancesIssue.message": + if e.ComplexityRoot.NoRunningInstancesIssue.Message == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.NoRunningInstancesIssue.Message(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.data": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Data == nil { + case "NoRunningInstancesIssue.severity": + if e.ComplexityRoot.NoRunningInstancesIssue.Severity == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.NoRunningInstancesIssue.Severity(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.EnvironmentName == nil { + case "NoRunningInstancesIssue.teamEnvironment": + if e.ComplexityRoot.NoRunningInstancesIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.NoRunningInstancesIssue.TeamEnvironment(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.id": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ID == nil { + case "NoRunningInstancesIssue.workload": + if e.ComplexityRoot.NoRunningInstancesIssue.Workload == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.NoRunningInstancesIssue.Workload(childComplexity), true - case "OpenSearchUpdatedActivityLogEntry.message": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Message == nil { + case "OpenSearch.access": + if e.ComplexityRoot.OpenSearch.Access == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Message(childComplexity), true - - case "OpenSearchUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceName == nil { - break + args, err := ec.field_OpenSearch_access_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.OpenSearch.Access(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*opensearch.OpenSearchAccessOrder)), true - case "OpenSearchUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceType == nil { + case "OpenSearch.activityLog": + if e.ComplexityRoot.OpenSearch.ActivityLog == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceType(childComplexity), true - - case "OpenSearchUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.TeamSlug == nil { - break + args, err := ec.field_OpenSearch_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.OpenSearch.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "OpenSearchUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryData.UpdatedFields == nil { + case "OpenSearch.cost": + if e.ComplexityRoot.OpenSearch.Cost == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.OpenSearch.Cost(childComplexity), true - case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "OpenSearch.environment": + if e.ComplexityRoot.OpenSearch.Environment == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.OpenSearch.Environment(childComplexity), true - case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "OpenSearch.id": + if e.ComplexityRoot.OpenSearch.ID == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.OpenSearch.ID(childComplexity), true - case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "OpenSearch.issues": + if e.ComplexityRoot.OpenSearch.Issues == nil { break } - return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + args, err := ec.field_OpenSearch_issues_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "OpenSearchVersion.actual": - if e.ComplexityRoot.OpenSearchVersion.Actual == nil { + return e.ComplexityRoot.OpenSearch.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + + case "OpenSearch.maintenance": + if e.ComplexityRoot.OpenSearch.Maintenance == nil { break } - return e.ComplexityRoot.OpenSearchVersion.Actual(childComplexity), true + return e.ComplexityRoot.OpenSearch.Maintenance(childComplexity), true - case "OpenSearchVersion.desiredMajor": - if e.ComplexityRoot.OpenSearchVersion.DesiredMajor == nil { + case "OpenSearch.memory": + if e.ComplexityRoot.OpenSearch.Memory == nil { break } - return e.ComplexityRoot.OpenSearchVersion.DesiredMajor(childComplexity), true + return e.ComplexityRoot.OpenSearch.Memory(childComplexity), true - case "OutboundNetworkPolicy.external": - if e.ComplexityRoot.OutboundNetworkPolicy.External == nil { + case "OpenSearch.name": + if e.ComplexityRoot.OpenSearch.Name == nil { break } - return e.ComplexityRoot.OutboundNetworkPolicy.External(childComplexity), true + return e.ComplexityRoot.OpenSearch.Name(childComplexity), true - case "OutboundNetworkPolicy.rules": - if e.ComplexityRoot.OutboundNetworkPolicy.Rules == nil { + case "OpenSearch.state": + if e.ComplexityRoot.OpenSearch.State == nil { break } - return e.ComplexityRoot.OutboundNetworkPolicy.Rules(childComplexity), true + return e.ComplexityRoot.OpenSearch.State(childComplexity), true - case "PageInfo.endCursor": - if e.ComplexityRoot.PageInfo.EndCursor == nil { + case "OpenSearch.storageGB": + if e.ComplexityRoot.OpenSearch.StorageGB == nil { break } - return e.ComplexityRoot.PageInfo.EndCursor(childComplexity), true + return e.ComplexityRoot.OpenSearch.StorageGB(childComplexity), true - case "PageInfo.hasNextPage": - if e.ComplexityRoot.PageInfo.HasNextPage == nil { + case "OpenSearch.team": + if e.ComplexityRoot.OpenSearch.Team == nil { break } - return e.ComplexityRoot.PageInfo.HasNextPage(childComplexity), true + return e.ComplexityRoot.OpenSearch.Team(childComplexity), true - case "PageInfo.hasPreviousPage": - if e.ComplexityRoot.PageInfo.HasPreviousPage == nil { + case "OpenSearch.teamEnvironment": + if e.ComplexityRoot.OpenSearch.TeamEnvironment == nil { break } - return e.ComplexityRoot.PageInfo.HasPreviousPage(childComplexity), true + return e.ComplexityRoot.OpenSearch.TeamEnvironment(childComplexity), true - case "PageInfo.pageEnd": - if e.ComplexityRoot.PageInfo.PageEnd == nil { + case "OpenSearch.terminationProtection": + if e.ComplexityRoot.OpenSearch.TerminationProtection == nil { break } - return e.ComplexityRoot.PageInfo.PageEnd(childComplexity), true + return e.ComplexityRoot.OpenSearch.TerminationProtection(childComplexity), true - case "PageInfo.pageStart": - if e.ComplexityRoot.PageInfo.PageStart == nil { + case "OpenSearch.tier": + if e.ComplexityRoot.OpenSearch.Tier == nil { break } - return e.ComplexityRoot.PageInfo.PageStart(childComplexity), true + return e.ComplexityRoot.OpenSearch.Tier(childComplexity), true - case "PageInfo.startCursor": - if e.ComplexityRoot.PageInfo.StartCursor == nil { + case "OpenSearch.version": + if e.ComplexityRoot.OpenSearch.Version == nil { break } - return e.ComplexityRoot.PageInfo.StartCursor(childComplexity), true + return e.ComplexityRoot.OpenSearch.Version(childComplexity), true - case "PageInfo.totalCount": - if e.ComplexityRoot.PageInfo.TotalCount == nil { + case "OpenSearch.workload": + if e.ComplexityRoot.OpenSearch.Workload == nil { break } - return e.ComplexityRoot.PageInfo.TotalCount(childComplexity), true + return e.ComplexityRoot.OpenSearch.Workload(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.actor": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Actor == nil { + case "OpenSearchAccess.access": + if e.ComplexityRoot.OpenSearchAccess.Access == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.OpenSearchAccess.Access(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.createdAt": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.CreatedAt == nil { + case "OpenSearchAccess.workload": + if e.ComplexityRoot.OpenSearchAccess.Workload == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.OpenSearchAccess.Workload(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.data": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Data == nil { + case "OpenSearchAccessConnection.edges": + if e.ComplexityRoot.OpenSearchAccessConnection.Edges == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.OpenSearchAccessConnection.Edges(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.environmentName": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.EnvironmentName == nil { + case "OpenSearchAccessConnection.nodes": + if e.ComplexityRoot.OpenSearchAccessConnection.Nodes == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.OpenSearchAccessConnection.Nodes(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.id": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ID == nil { + case "OpenSearchAccessConnection.pageInfo": + if e.ComplexityRoot.OpenSearchAccessConnection.PageInfo == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.OpenSearchAccessConnection.PageInfo(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.message": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Message == nil { + case "OpenSearchAccessEdge.cursor": + if e.ComplexityRoot.OpenSearchAccessEdge.Cursor == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.OpenSearchAccessEdge.Cursor(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.resourceName": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceName == nil { + case "OpenSearchAccessEdge.node": + if e.ComplexityRoot.OpenSearchAccessEdge.Node == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.OpenSearchAccessEdge.Node(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.resourceType": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceType == nil { + case "OpenSearchConnection.edges": + if e.ComplexityRoot.OpenSearchConnection.Edges == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.OpenSearchConnection.Edges(childComplexity), true - case "PostgresGrantAccessActivityLogEntry.teamSlug": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.TeamSlug == nil { + case "OpenSearchConnection.nodes": + if e.ComplexityRoot.OpenSearchConnection.Nodes == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.OpenSearchConnection.Nodes(childComplexity), true - case "PostgresGrantAccessActivityLogEntryData.grantee": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Grantee == nil { + case "OpenSearchConnection.pageInfo": + if e.ComplexityRoot.OpenSearchConnection.PageInfo == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Grantee(childComplexity), true + return e.ComplexityRoot.OpenSearchConnection.PageInfo(childComplexity), true - case "PostgresGrantAccessActivityLogEntryData.until": - if e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Until == nil { + case "OpenSearchCost.sum": + if e.ComplexityRoot.OpenSearchCost.Sum == nil { break } - return e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Until(childComplexity), true + return e.ComplexityRoot.OpenSearchCost.Sum(childComplexity), true - case "PostgresInstance.audit": - if e.ComplexityRoot.PostgresInstance.Audit == nil { + case "OpenSearchCreatedActivityLogEntry.actor": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.PostgresInstance.Audit(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Actor(childComplexity), true - case "PostgresInstance.environment": - if e.ComplexityRoot.PostgresInstance.Environment == nil { + case "OpenSearchCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.PostgresInstance.Environment(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "PostgresInstance.highAvailability": - if e.ComplexityRoot.PostgresInstance.HighAvailability == nil { + case "OpenSearchCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.PostgresInstance.HighAvailability(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "PostgresInstance.id": - if e.ComplexityRoot.PostgresInstance.ID == nil { + case "OpenSearchCreatedActivityLogEntry.id": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.PostgresInstance.ID(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ID(childComplexity), true - case "PostgresInstance.maintenanceWindow": - if e.ComplexityRoot.PostgresInstance.MaintenanceWindow == nil { + case "OpenSearchCreatedActivityLogEntry.message": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.PostgresInstance.MaintenanceWindow(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.Message(childComplexity), true - case "PostgresInstance.majorVersion": - if e.ComplexityRoot.PostgresInstance.MajorVersion == nil { + case "OpenSearchCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.PostgresInstance.MajorVersion(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceName(childComplexity), true - case "PostgresInstance.name": - if e.ComplexityRoot.PostgresInstance.Name == nil { + case "OpenSearchCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.PostgresInstance.Name(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.ResourceType(childComplexity), true - case "PostgresInstance.resources": - if e.ComplexityRoot.PostgresInstance.Resources == nil { + case "OpenSearchCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.PostgresInstance.Resources(childComplexity), true + return e.ComplexityRoot.OpenSearchCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "PostgresInstance.state": - if e.ComplexityRoot.PostgresInstance.State == nil { + case "OpenSearchCredentials.host": + if e.ComplexityRoot.OpenSearchCredentials.Host == nil { break } - return e.ComplexityRoot.PostgresInstance.State(childComplexity), true + return e.ComplexityRoot.OpenSearchCredentials.Host(childComplexity), true - case "PostgresInstance.team": - if e.ComplexityRoot.PostgresInstance.Team == nil { + case "OpenSearchCredentials.password": + if e.ComplexityRoot.OpenSearchCredentials.Password == nil { break } - return e.ComplexityRoot.PostgresInstance.Team(childComplexity), true + return e.ComplexityRoot.OpenSearchCredentials.Password(childComplexity), true - case "PostgresInstance.teamEnvironment": - if e.ComplexityRoot.PostgresInstance.TeamEnvironment == nil { + case "OpenSearchCredentials.port": + if e.ComplexityRoot.OpenSearchCredentials.Port == nil { break } - return e.ComplexityRoot.PostgresInstance.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.OpenSearchCredentials.Port(childComplexity), true - case "PostgresInstance.workloads": - if e.ComplexityRoot.PostgresInstance.Workloads == nil { + case "OpenSearchCredentials.uri": + if e.ComplexityRoot.OpenSearchCredentials.URI == nil { break } - args, err := ec.field_PostgresInstance_workloads_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.PostgresInstance.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.OpenSearchCredentials.URI(childComplexity), true - case "PostgresInstanceAudit.enabled": - if e.ComplexityRoot.PostgresInstanceAudit.Enabled == nil { + case "OpenSearchCredentials.username": + if e.ComplexityRoot.OpenSearchCredentials.Username == nil { break } - return e.ComplexityRoot.PostgresInstanceAudit.Enabled(childComplexity), true + return e.ComplexityRoot.OpenSearchCredentials.Username(childComplexity), true - case "PostgresInstanceAudit.statementClasses": - if e.ComplexityRoot.PostgresInstanceAudit.StatementClasses == nil { + case "OpenSearchDeletedActivityLogEntry.actor": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.PostgresInstanceAudit.StatementClasses(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Actor(childComplexity), true - case "PostgresInstanceAudit.url": - if e.ComplexityRoot.PostgresInstanceAudit.URL == nil { + case "OpenSearchDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.PostgresInstanceAudit.URL(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "PostgresInstanceConnection.edges": - if e.ComplexityRoot.PostgresInstanceConnection.Edges == nil { + case "OpenSearchDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.PostgresInstanceConnection.Edges(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "PostgresInstanceConnection.nodes": - if e.ComplexityRoot.PostgresInstanceConnection.Nodes == nil { + case "OpenSearchDeletedActivityLogEntry.id": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.PostgresInstanceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ID(childComplexity), true - case "PostgresInstanceConnection.pageInfo": - if e.ComplexityRoot.PostgresInstanceConnection.PageInfo == nil { + case "OpenSearchDeletedActivityLogEntry.message": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.PostgresInstanceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.Message(childComplexity), true - case "PostgresInstanceEdge.cursor": - if e.ComplexityRoot.PostgresInstanceEdge.Cursor == nil { + case "OpenSearchDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.PostgresInstanceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceName(childComplexity), true - case "PostgresInstanceEdge.node": - if e.ComplexityRoot.PostgresInstanceEdge.Node == nil { + case "OpenSearchDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.PostgresInstanceEdge.Node(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.ResourceType(childComplexity), true - case "PostgresInstanceMaintenanceWindow.day": - if e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Day == nil { + case "OpenSearchDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Day(childComplexity), true + return e.ComplexityRoot.OpenSearchDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "PostgresInstanceMaintenanceWindow.hour": - if e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Hour == nil { + case "OpenSearchEdge.cursor": + if e.ComplexityRoot.OpenSearchEdge.Cursor == nil { break } - return e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Hour(childComplexity), true + return e.ComplexityRoot.OpenSearchEdge.Cursor(childComplexity), true - case "PostgresInstanceResources.cpu": - if e.ComplexityRoot.PostgresInstanceResources.CPU == nil { + case "OpenSearchEdge.node": + if e.ComplexityRoot.OpenSearchEdge.Node == nil { break } - return e.ComplexityRoot.PostgresInstanceResources.CPU(childComplexity), true + return e.ComplexityRoot.OpenSearchEdge.Node(childComplexity), true - case "PostgresInstanceResources.diskSize": - if e.ComplexityRoot.PostgresInstanceResources.DiskSize == nil { + case "OpenSearchIssue.event": + if e.ComplexityRoot.OpenSearchIssue.Event == nil { break } - return e.ComplexityRoot.PostgresInstanceResources.DiskSize(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.Event(childComplexity), true - case "PostgresInstanceResources.memory": - if e.ComplexityRoot.PostgresInstanceResources.Memory == nil { + case "OpenSearchIssue.id": + if e.ComplexityRoot.OpenSearchIssue.ID == nil { break } - return e.ComplexityRoot.PostgresInstanceResources.Memory(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.ID(childComplexity), true - case "Price.value": - if e.ComplexityRoot.Price.Value == nil { + case "OpenSearchIssue.message": + if e.ComplexityRoot.OpenSearchIssue.Message == nil { break } - return e.ComplexityRoot.Price.Value(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.Message(childComplexity), true - case "PrometheusAlarm.action": - if e.ComplexityRoot.PrometheusAlarm.Action == nil { + case "OpenSearchIssue.openSearch": + if e.ComplexityRoot.OpenSearchIssue.OpenSearch == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Action(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.OpenSearch(childComplexity), true - case "PrometheusAlarm.consequence": - if e.ComplexityRoot.PrometheusAlarm.Consequence == nil { + case "OpenSearchIssue.severity": + if e.ComplexityRoot.OpenSearchIssue.Severity == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Consequence(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.Severity(childComplexity), true - case "PrometheusAlarm.since": - if e.ComplexityRoot.PrometheusAlarm.Since == nil { + case "OpenSearchIssue.teamEnvironment": + if e.ComplexityRoot.OpenSearchIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Since(childComplexity), true + return e.ComplexityRoot.OpenSearchIssue.TeamEnvironment(childComplexity), true - case "PrometheusAlarm.state": - if e.ComplexityRoot.PrometheusAlarm.State == nil { + case "OpenSearchMaintenance.updates": + if e.ComplexityRoot.OpenSearchMaintenance.Updates == nil { break } - return e.ComplexityRoot.PrometheusAlarm.State(childComplexity), true + args, err := ec.field_OpenSearchMaintenance_updates_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "PrometheusAlarm.summary": - if e.ComplexityRoot.PrometheusAlarm.Summary == nil { + return e.ComplexityRoot.OpenSearchMaintenance.Updates(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "OpenSearchMaintenance.window": + if e.ComplexityRoot.OpenSearchMaintenance.Window == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Summary(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenance.Window(childComplexity), true - case "PrometheusAlarm.value": - if e.ComplexityRoot.PrometheusAlarm.Value == nil { + case "OpenSearchMaintenanceUpdate.deadline": + if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Deadline == nil { break } - return e.ComplexityRoot.PrometheusAlarm.Value(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Deadline(childComplexity), true - case "PrometheusAlert.alarms": - if e.ComplexityRoot.PrometheusAlert.Alarms == nil { + case "OpenSearchMaintenanceUpdate.description": + if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Description == nil { break } - return e.ComplexityRoot.PrometheusAlert.Alarms(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Description(childComplexity), true - case "PrometheusAlert.duration": - if e.ComplexityRoot.PrometheusAlert.Duration == nil { + case "OpenSearchMaintenanceUpdate.startAt": + if e.ComplexityRoot.OpenSearchMaintenanceUpdate.StartAt == nil { break } - return e.ComplexityRoot.PrometheusAlert.Duration(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdate.StartAt(childComplexity), true - case "PrometheusAlert.id": - if e.ComplexityRoot.PrometheusAlert.ID == nil { + case "OpenSearchMaintenanceUpdate.title": + if e.ComplexityRoot.OpenSearchMaintenanceUpdate.Title == nil { break } - return e.ComplexityRoot.PrometheusAlert.ID(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdate.Title(childComplexity), true - case "PrometheusAlert.name": - if e.ComplexityRoot.PrometheusAlert.Name == nil { + case "OpenSearchMaintenanceUpdateConnection.edges": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Edges == nil { break } - return e.ComplexityRoot.PrometheusAlert.Name(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Edges(childComplexity), true - case "PrometheusAlert.query": - if e.ComplexityRoot.PrometheusAlert.Query == nil { + case "OpenSearchMaintenanceUpdateConnection.nodes": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Nodes == nil { break } - return e.ComplexityRoot.PrometheusAlert.Query(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.Nodes(childComplexity), true - case "PrometheusAlert.ruleGroup": - if e.ComplexityRoot.PrometheusAlert.RuleGroup == nil { + case "OpenSearchMaintenanceUpdateConnection.pageInfo": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.PageInfo == nil { break } - return e.ComplexityRoot.PrometheusAlert.RuleGroup(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateConnection.PageInfo(childComplexity), true - case "PrometheusAlert.state": - if e.ComplexityRoot.PrometheusAlert.State == nil { + case "OpenSearchMaintenanceUpdateEdge.cursor": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Cursor == nil { break } - return e.ComplexityRoot.PrometheusAlert.State(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Cursor(childComplexity), true - case "PrometheusAlert.team": - if e.ComplexityRoot.PrometheusAlert.Team == nil { + case "OpenSearchMaintenanceUpdateEdge.node": + if e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Node == nil { break } - return e.ComplexityRoot.PrometheusAlert.Team(childComplexity), true + return e.ComplexityRoot.OpenSearchMaintenanceUpdateEdge.Node(childComplexity), true - case "PrometheusAlert.teamEnvironment": - if e.ComplexityRoot.PrometheusAlert.TeamEnvironment == nil { + case "OpenSearchUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.PrometheusAlert.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Actor(childComplexity), true - case "Query.cve": - if e.ComplexityRoot.Query.CVE == nil { + case "OpenSearchUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.CreatedAt == nil { break } - args, err := ec.field_Query_cve_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Query.CVE(childComplexity, args["identifier"].(string)), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "Query.costMonthlySummary": - if e.ComplexityRoot.Query.CostMonthlySummary == nil { + case "OpenSearchUpdatedActivityLogEntry.data": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Data == nil { break } - args, err := ec.field_Query_costMonthlySummary_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Data(childComplexity), true + + case "OpenSearchUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.EnvironmentName == nil { + break } - return e.ComplexityRoot.Query.CostMonthlySummary(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "Query.currentUnitPrices": - if e.ComplexityRoot.Query.CurrentUnitPrices == nil { + case "OpenSearchUpdatedActivityLogEntry.id": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.Query.CurrentUnitPrices(childComplexity), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ID(childComplexity), true - case "Query.cves": - if e.ComplexityRoot.Query.Cves == nil { + case "OpenSearchUpdatedActivityLogEntry.message": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Message == nil { break } - args, err := ec.field_Query_cves_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.Message(childComplexity), true + + case "OpenSearchUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceName == nil { + break } - return e.ComplexityRoot.Query.Cves(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*vulnerability.CVEOrder)), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "Query.deployments": - if e.ComplexityRoot.Query.Deployments == nil { + case "OpenSearchUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceType == nil { break } - args, err := ec.field_Query_deployments_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.ResourceType(childComplexity), true + + case "OpenSearchUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.TeamSlug == nil { + break } - return e.ComplexityRoot.Query.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*deployment.DeploymentOrder), args["filter"].(*deployment.DeploymentFilter)), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "Query.environment": - if e.ComplexityRoot.Query.Environment == nil { + case "OpenSearchUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryData.UpdatedFields == nil { break } - args, err := ec.field_Query_environment_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + + case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.Field == nil { + break } - return e.ComplexityRoot.Query.Environment(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "Query.environments": - if e.ComplexityRoot.Query.Environments == nil { + case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - args, err := ec.field_Query_environments_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + + case "OpenSearchUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + break } - return e.ComplexityRoot.Query.Environments(childComplexity, args["orderBy"].(*environment.EnvironmentOrder)), true + return e.ComplexityRoot.OpenSearchUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "Query.features": - if e.ComplexityRoot.Query.Features == nil { + case "OpenSearchVersion.actual": + if e.ComplexityRoot.OpenSearchVersion.Actual == nil { break } - return e.ComplexityRoot.Query.Features(childComplexity), true + return e.ComplexityRoot.OpenSearchVersion.Actual(childComplexity), true - case "Query.imageVulnerabilityHistory": - if e.ComplexityRoot.Query.ImageVulnerabilityHistory == nil { + case "OpenSearchVersion.desiredMajor": + if e.ComplexityRoot.OpenSearchVersion.DesiredMajor == nil { break } - args, err := ec.field_Query_imageVulnerabilityHistory_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.OpenSearchVersion.DesiredMajor(childComplexity), true + + case "OutboundNetworkPolicy.external": + if e.ComplexityRoot.OutboundNetworkPolicy.External == nil { + break } - return e.ComplexityRoot.Query.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.OutboundNetworkPolicy.External(childComplexity), true - case "Query.me": - if e.ComplexityRoot.Query.Me == nil { + case "OutboundNetworkPolicy.rules": + if e.ComplexityRoot.OutboundNetworkPolicy.Rules == nil { break } - return e.ComplexityRoot.Query.Me(childComplexity), true + return e.ComplexityRoot.OutboundNetworkPolicy.Rules(childComplexity), true - case "Query.node": - if e.ComplexityRoot.Query.Node == nil { + case "PageInfo.endCursor": + if e.ComplexityRoot.PageInfo.EndCursor == nil { break } - args, err := ec.field_Query_node_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PageInfo.EndCursor(childComplexity), true + + case "PageInfo.hasNextPage": + if e.ComplexityRoot.PageInfo.HasNextPage == nil { + break } - return e.ComplexityRoot.Query.Node(childComplexity, args["id"].(ident.Ident)), true + return e.ComplexityRoot.PageInfo.HasNextPage(childComplexity), true - case "Query.reconcilers": - if e.ComplexityRoot.Query.Reconcilers == nil { + case "PageInfo.hasPreviousPage": + if e.ComplexityRoot.PageInfo.HasPreviousPage == nil { break } - args, err := ec.field_Query_reconcilers_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PageInfo.HasPreviousPage(childComplexity), true + + case "PageInfo.pageEnd": + if e.ComplexityRoot.PageInfo.PageEnd == nil { + break } - return e.ComplexityRoot.Query.Reconcilers(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.PageInfo.PageEnd(childComplexity), true - case "Query.roles": - if e.ComplexityRoot.Query.Roles == nil { + case "PageInfo.pageStart": + if e.ComplexityRoot.PageInfo.PageStart == nil { break } - args, err := ec.field_Query_roles_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PageInfo.PageStart(childComplexity), true + + case "PageInfo.startCursor": + if e.ComplexityRoot.PageInfo.StartCursor == nil { + break } - return e.ComplexityRoot.Query.Roles(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.PageInfo.StartCursor(childComplexity), true - case "Query.search": - if e.ComplexityRoot.Query.Search == nil { + case "PageInfo.totalCount": + if e.ComplexityRoot.PageInfo.TotalCount == nil { break } - args, err := ec.field_Query_search_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PageInfo.TotalCount(childComplexity), true + + case "PostgresGrantAccessActivityLogEntry.actor": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Actor == nil { + break } - return e.ComplexityRoot.Query.Search(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(search.SearchFilter)), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Actor(childComplexity), true - case "Query.serviceAccount": - if e.ComplexityRoot.Query.ServiceAccount == nil { + case "PostgresGrantAccessActivityLogEntry.createdAt": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.CreatedAt == nil { break } - args, err := ec.field_Query_serviceAccount_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.CreatedAt(childComplexity), true + + case "PostgresGrantAccessActivityLogEntry.data": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Data == nil { + break } - return e.ComplexityRoot.Query.ServiceAccount(childComplexity, args["id"].(ident.Ident)), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Data(childComplexity), true - case "Query.serviceAccounts": - if e.ComplexityRoot.Query.ServiceAccounts == nil { + case "PostgresGrantAccessActivityLogEntry.environmentName": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.EnvironmentName == nil { break } - args, err := ec.field_Query_serviceAccounts_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.EnvironmentName(childComplexity), true + + case "PostgresGrantAccessActivityLogEntry.id": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ID == nil { + break } - return e.ComplexityRoot.Query.ServiceAccounts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ID(childComplexity), true - case "Query.team": - if e.ComplexityRoot.Query.Team == nil { + case "PostgresGrantAccessActivityLogEntry.message": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Message == nil { break } - args, err := ec.field_Query_team_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.Message(childComplexity), true + + case "PostgresGrantAccessActivityLogEntry.resourceName": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceName == nil { + break } - return e.ComplexityRoot.Query.Team(childComplexity, args["slug"].(slug.Slug)), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceName(childComplexity), true - case "Query.teams": - if e.ComplexityRoot.Query.Teams == nil { + case "PostgresGrantAccessActivityLogEntry.resourceType": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceType == nil { break } - args, err := ec.field_Query_teams_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.ResourceType(childComplexity), true + + case "PostgresGrantAccessActivityLogEntry.teamSlug": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.TeamSlug == nil { + break } - return e.ComplexityRoot.Query.Teams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.TeamOrder), args["filter"].(*team.TeamFilter)), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntry.TeamSlug(childComplexity), true - case "Query.teamsUtilization": - if e.ComplexityRoot.Query.TeamsUtilization == nil { + case "PostgresGrantAccessActivityLogEntryData.grantee": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Grantee == nil { break } - args, err := ec.field_Query_teamsUtilization_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Grantee(childComplexity), true + + case "PostgresGrantAccessActivityLogEntryData.until": + if e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Until == nil { + break } - return e.ComplexityRoot.Query.TeamsUtilization(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + return e.ComplexityRoot.PostgresGrantAccessActivityLogEntryData.Until(childComplexity), true - case "Query.unleashReleaseChannels": - if e.ComplexityRoot.Query.UnleashReleaseChannels == nil { + case "PostgresInstance.audit": + if e.ComplexityRoot.PostgresInstance.Audit == nil { break } - return e.ComplexityRoot.Query.UnleashReleaseChannels(childComplexity), true + return e.ComplexityRoot.PostgresInstance.Audit(childComplexity), true - case "Query.user": - if e.ComplexityRoot.Query.User == nil { + case "PostgresInstance.environment": + if e.ComplexityRoot.PostgresInstance.Environment == nil { break } - args, err := ec.field_Query_user_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Query.User(childComplexity, args["email"].(*string)), true - - case "Query.userSyncLog": - if e.ComplexityRoot.Query.UserSyncLog == nil { - break - } - - args, err := ec.field_Query_userSyncLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Query.UserSyncLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.PostgresInstance.Environment(childComplexity), true - case "Query.users": - if e.ComplexityRoot.Query.Users == nil { + case "PostgresInstance.highAvailability": + if e.ComplexityRoot.PostgresInstance.HighAvailability == nil { break } - args, err := ec.field_Query_users_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Query.Users(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*user.UserOrder)), true + return e.ComplexityRoot.PostgresInstance.HighAvailability(childComplexity), true - case "Query.vulnerabilityFixHistory": - if e.ComplexityRoot.Query.VulnerabilityFixHistory == nil { + case "PostgresInstance.id": + if e.ComplexityRoot.PostgresInstance.ID == nil { break } - args, err := ec.field_Query_vulnerabilityFixHistory_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Query.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.PostgresInstance.ID(childComplexity), true - case "Query.vulnerabilitySummary": - if e.ComplexityRoot.Query.VulnerabilitySummary == nil { + case "PostgresInstance.maintenanceWindow": + if e.ComplexityRoot.PostgresInstance.MaintenanceWindow == nil { break } - return e.ComplexityRoot.Query.VulnerabilitySummary(childComplexity), true + return e.ComplexityRoot.PostgresInstance.MaintenanceWindow(childComplexity), true - case "Reconciler.activityLog": - if e.ComplexityRoot.Reconciler.ActivityLog == nil { + case "PostgresInstance.majorVersion": + if e.ComplexityRoot.PostgresInstance.MajorVersion == nil { break } - args, err := ec.field_Reconciler_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Reconciler.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.PostgresInstance.MajorVersion(childComplexity), true - case "Reconciler.config": - if e.ComplexityRoot.Reconciler.Config == nil { + case "PostgresInstance.name": + if e.ComplexityRoot.PostgresInstance.Name == nil { break } - return e.ComplexityRoot.Reconciler.Config(childComplexity), true + return e.ComplexityRoot.PostgresInstance.Name(childComplexity), true - case "Reconciler.configured": - if e.ComplexityRoot.Reconciler.Configured == nil { + case "PostgresInstance.resources": + if e.ComplexityRoot.PostgresInstance.Resources == nil { break } - return e.ComplexityRoot.Reconciler.Configured(childComplexity), true + return e.ComplexityRoot.PostgresInstance.Resources(childComplexity), true - case "Reconciler.description": - if e.ComplexityRoot.Reconciler.Description == nil { + case "PostgresInstance.state": + if e.ComplexityRoot.PostgresInstance.State == nil { break } - return e.ComplexityRoot.Reconciler.Description(childComplexity), true + return e.ComplexityRoot.PostgresInstance.State(childComplexity), true - case "Reconciler.displayName": - if e.ComplexityRoot.Reconciler.DisplayName == nil { + case "PostgresInstance.team": + if e.ComplexityRoot.PostgresInstance.Team == nil { break } - return e.ComplexityRoot.Reconciler.DisplayName(childComplexity), true + return e.ComplexityRoot.PostgresInstance.Team(childComplexity), true - case "Reconciler.enabled": - if e.ComplexityRoot.Reconciler.Enabled == nil { + case "PostgresInstance.teamEnvironment": + if e.ComplexityRoot.PostgresInstance.TeamEnvironment == nil { break } - return e.ComplexityRoot.Reconciler.Enabled(childComplexity), true + return e.ComplexityRoot.PostgresInstance.TeamEnvironment(childComplexity), true - case "Reconciler.errors": - if e.ComplexityRoot.Reconciler.Errors == nil { + case "PostgresInstance.workloads": + if e.ComplexityRoot.PostgresInstance.Workloads == nil { break } - args, err := ec.field_Reconciler_errors_args(ctx, rawArgs) + args, err := ec.field_PostgresInstance_workloads_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Reconciler.Errors(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.PostgresInstance.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "Reconciler.id": - if e.ComplexityRoot.Reconciler.ID == nil { + case "PostgresInstanceAudit.enabled": + if e.ComplexityRoot.PostgresInstanceAudit.Enabled == nil { break } - return e.ComplexityRoot.Reconciler.ID(childComplexity), true + return e.ComplexityRoot.PostgresInstanceAudit.Enabled(childComplexity), true - case "Reconciler.name": - if e.ComplexityRoot.Reconciler.Name == nil { + case "PostgresInstanceAudit.statementClasses": + if e.ComplexityRoot.PostgresInstanceAudit.StatementClasses == nil { break } - return e.ComplexityRoot.Reconciler.Name(childComplexity), true + return e.ComplexityRoot.PostgresInstanceAudit.StatementClasses(childComplexity), true - case "ReconcilerConfig.configured": - if e.ComplexityRoot.ReconcilerConfig.Configured == nil { + case "PostgresInstanceAudit.url": + if e.ComplexityRoot.PostgresInstanceAudit.URL == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Configured(childComplexity), true + return e.ComplexityRoot.PostgresInstanceAudit.URL(childComplexity), true - case "ReconcilerConfig.description": - if e.ComplexityRoot.ReconcilerConfig.Description == nil { + case "PostgresInstanceConnection.edges": + if e.ComplexityRoot.PostgresInstanceConnection.Edges == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Description(childComplexity), true + return e.ComplexityRoot.PostgresInstanceConnection.Edges(childComplexity), true - case "ReconcilerConfig.displayName": - if e.ComplexityRoot.ReconcilerConfig.DisplayName == nil { + case "PostgresInstanceConnection.nodes": + if e.ComplexityRoot.PostgresInstanceConnection.Nodes == nil { break } - return e.ComplexityRoot.ReconcilerConfig.DisplayName(childComplexity), true + return e.ComplexityRoot.PostgresInstanceConnection.Nodes(childComplexity), true - case "ReconcilerConfig.key": - if e.ComplexityRoot.ReconcilerConfig.Key == nil { + case "PostgresInstanceConnection.pageInfo": + if e.ComplexityRoot.PostgresInstanceConnection.PageInfo == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Key(childComplexity), true + return e.ComplexityRoot.PostgresInstanceConnection.PageInfo(childComplexity), true - case "ReconcilerConfig.secret": - if e.ComplexityRoot.ReconcilerConfig.Secret == nil { + case "PostgresInstanceEdge.cursor": + if e.ComplexityRoot.PostgresInstanceEdge.Cursor == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Secret(childComplexity), true + return e.ComplexityRoot.PostgresInstanceEdge.Cursor(childComplexity), true - case "ReconcilerConfig.value": - if e.ComplexityRoot.ReconcilerConfig.Value == nil { + case "PostgresInstanceEdge.node": + if e.ComplexityRoot.PostgresInstanceEdge.Node == nil { break } - return e.ComplexityRoot.ReconcilerConfig.Value(childComplexity), true + return e.ComplexityRoot.PostgresInstanceEdge.Node(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.actor": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Actor == nil { + case "PostgresInstanceMaintenanceWindow.day": + if e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Day == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Day(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.createdAt": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.CreatedAt == nil { + case "PostgresInstanceMaintenanceWindow.hour": + if e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Hour == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.PostgresInstanceMaintenanceWindow.Hour(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.data": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Data == nil { + case "PostgresInstanceResources.cpu": + if e.ComplexityRoot.PostgresInstanceResources.CPU == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.PostgresInstanceResources.CPU(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.environmentName": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.EnvironmentName == nil { + case "PostgresInstanceResources.diskSize": + if e.ComplexityRoot.PostgresInstanceResources.DiskSize == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.PostgresInstanceResources.DiskSize(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.id": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ID == nil { + case "PostgresInstanceResources.memory": + if e.ComplexityRoot.PostgresInstanceResources.Memory == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.PostgresInstanceResources.Memory(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.message": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Message == nil { + case "Price.value": + if e.ComplexityRoot.Price.Value == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Price.Value(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.resourceName": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceName == nil { + case "PrometheusAlarm.action": + if e.ComplexityRoot.PrometheusAlarm.Action == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Action(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.resourceType": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceType == nil { + case "PrometheusAlarm.consequence": + if e.ComplexityRoot.PrometheusAlarm.Consequence == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Consequence(childComplexity), true - case "ReconcilerConfiguredActivityLogEntry.teamSlug": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.TeamSlug == nil { + case "PrometheusAlarm.since": + if e.ComplexityRoot.PrometheusAlarm.Since == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Since(childComplexity), true - case "ReconcilerConfiguredActivityLogEntryData.updatedKeys": - if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntryData.UpdatedKeys == nil { + case "PrometheusAlarm.state": + if e.ComplexityRoot.PrometheusAlarm.State == nil { break } - return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntryData.UpdatedKeys(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.State(childComplexity), true - case "ReconcilerConnection.edges": - if e.ComplexityRoot.ReconcilerConnection.Edges == nil { + case "PrometheusAlarm.summary": + if e.ComplexityRoot.PrometheusAlarm.Summary == nil { break } - return e.ComplexityRoot.ReconcilerConnection.Edges(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Summary(childComplexity), true - case "ReconcilerConnection.nodes": - if e.ComplexityRoot.ReconcilerConnection.Nodes == nil { + case "PrometheusAlarm.value": + if e.ComplexityRoot.PrometheusAlarm.Value == nil { break } - return e.ComplexityRoot.ReconcilerConnection.Nodes(childComplexity), true + return e.ComplexityRoot.PrometheusAlarm.Value(childComplexity), true - case "ReconcilerConnection.pageInfo": - if e.ComplexityRoot.ReconcilerConnection.PageInfo == nil { + case "PrometheusAlert.alarms": + if e.ComplexityRoot.PrometheusAlert.Alarms == nil { break } - return e.ComplexityRoot.ReconcilerConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Alarms(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.actor": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Actor == nil { + case "PrometheusAlert.duration": + if e.ComplexityRoot.PrometheusAlert.Duration == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Duration(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.createdAt": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.CreatedAt == nil { + case "PrometheusAlert.id": + if e.ComplexityRoot.PrometheusAlert.ID == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.ID(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.environmentName": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.EnvironmentName == nil { + case "PrometheusAlert.name": + if e.ComplexityRoot.PrometheusAlert.Name == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Name(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.id": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ID == nil { + case "PrometheusAlert.query": + if e.ComplexityRoot.PrometheusAlert.Query == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Query(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.message": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Message == nil { + case "PrometheusAlert.ruleGroup": + if e.ComplexityRoot.PrometheusAlert.RuleGroup == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.RuleGroup(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.resourceName": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceName == nil { + case "PrometheusAlert.state": + if e.ComplexityRoot.PrometheusAlert.State == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.State(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.resourceType": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceType == nil { + case "PrometheusAlert.team": + if e.ComplexityRoot.PrometheusAlert.Team == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.Team(childComplexity), true - case "ReconcilerDisabledActivityLogEntry.teamSlug": - if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.TeamSlug == nil { + case "PrometheusAlert.teamEnvironment": + if e.ComplexityRoot.PrometheusAlert.TeamEnvironment == nil { break } - return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.PrometheusAlert.TeamEnvironment(childComplexity), true - case "ReconcilerEdge.cursor": - if e.ComplexityRoot.ReconcilerEdge.Cursor == nil { + case "Query.cve": + if e.ComplexityRoot.Query.CVE == nil { break } - return e.ComplexityRoot.ReconcilerEdge.Cursor(childComplexity), true - - case "ReconcilerEdge.node": - if e.ComplexityRoot.ReconcilerEdge.Node == nil { - break + args, err := ec.field_Query_cve_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerEdge.Node(childComplexity), true + return e.ComplexityRoot.Query.CVE(childComplexity, args["identifier"].(string)), true - case "ReconcilerEnabledActivityLogEntry.actor": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Actor == nil { + case "Query.costMonthlySummary": + if e.ComplexityRoot.Query.CostMonthlySummary == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Actor(childComplexity), true - - case "ReconcilerEnabledActivityLogEntry.createdAt": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_Query_costMonthlySummary_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Query.CostMonthlySummary(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true - case "ReconcilerEnabledActivityLogEntry.environmentName": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.EnvironmentName == nil { + case "Query.currentUnitPrices": + if e.ComplexityRoot.Query.CurrentUnitPrices == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Query.CurrentUnitPrices(childComplexity), true - case "ReconcilerEnabledActivityLogEntry.id": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ID == nil { + case "Query.cves": + if e.ComplexityRoot.Query.Cves == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ID(childComplexity), true - - case "ReconcilerEnabledActivityLogEntry.message": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Message == nil { - break + args, err := ec.field_Query_cves_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Query.Cves(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*vulnerability.CVEOrder)), true - case "ReconcilerEnabledActivityLogEntry.resourceName": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceName == nil { + case "Query.deployments": + if e.ComplexityRoot.Query.Deployments == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceName(childComplexity), true - - case "ReconcilerEnabledActivityLogEntry.resourceType": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceType == nil { - break + args, err := ec.field_Query_deployments_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Query.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*deployment.DeploymentOrder), args["filter"].(*deployment.DeploymentFilter)), true - case "ReconcilerEnabledActivityLogEntry.teamSlug": - if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.TeamSlug == nil { + case "Query.environment": + if e.ComplexityRoot.Query.Environment == nil { break } - return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.TeamSlug(childComplexity), true - - case "ReconcilerError.correlationID": - if e.ComplexityRoot.ReconcilerError.CorrelationID == nil { - break + args, err := ec.field_Query_environment_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerError.CorrelationID(childComplexity), true + return e.ComplexityRoot.Query.Environment(childComplexity, args["name"].(string)), true - case "ReconcilerError.createdAt": - if e.ComplexityRoot.ReconcilerError.CreatedAt == nil { + case "Query.environments": + if e.ComplexityRoot.Query.Environments == nil { break } - return e.ComplexityRoot.ReconcilerError.CreatedAt(childComplexity), true - - case "ReconcilerError.id": - if e.ComplexityRoot.ReconcilerError.ID == nil { - break + args, err := ec.field_Query_environments_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerError.ID(childComplexity), true + return e.ComplexityRoot.Query.Environments(childComplexity, args["orderBy"].(*environment.EnvironmentOrder)), true - case "ReconcilerError.message": - if e.ComplexityRoot.ReconcilerError.Message == nil { + case "Query.features": + if e.ComplexityRoot.Query.Features == nil { break } - return e.ComplexityRoot.ReconcilerError.Message(childComplexity), true + return e.ComplexityRoot.Query.Features(childComplexity), true - case "ReconcilerError.team": - if e.ComplexityRoot.ReconcilerError.Team == nil { + case "Query.imageVulnerabilityHistory": + if e.ComplexityRoot.Query.ImageVulnerabilityHistory == nil { break } - return e.ComplexityRoot.ReconcilerError.Team(childComplexity), true - - case "ReconcilerErrorConnection.edges": - if e.ComplexityRoot.ReconcilerErrorConnection.Edges == nil { - break + args, err := ec.field_Query_imageVulnerabilityHistory_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerErrorConnection.Edges(childComplexity), true + return e.ComplexityRoot.Query.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true - case "ReconcilerErrorConnection.nodes": - if e.ComplexityRoot.ReconcilerErrorConnection.Nodes == nil { + case "Query.me": + if e.ComplexityRoot.Query.Me == nil { break } - return e.ComplexityRoot.ReconcilerErrorConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Query.Me(childComplexity), true - case "ReconcilerErrorConnection.pageInfo": - if e.ComplexityRoot.ReconcilerErrorConnection.PageInfo == nil { + case "Query.node": + if e.ComplexityRoot.Query.Node == nil { break } - return e.ComplexityRoot.ReconcilerErrorConnection.PageInfo(childComplexity), true - - case "ReconcilerErrorEdge.cursor": - if e.ComplexityRoot.ReconcilerErrorEdge.Cursor == nil { - break + args, err := ec.field_Query_node_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ReconcilerErrorEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Query.Node(childComplexity, args["id"].(ident.Ident)), true - case "ReconcilerErrorEdge.node": - if e.ComplexityRoot.ReconcilerErrorEdge.Node == nil { + case "Query.reconcilers": + if e.ComplexityRoot.Query.Reconcilers == nil { break } - return e.ComplexityRoot.ReconcilerErrorEdge.Node(childComplexity), true - - case "RemoveRepositoryFromTeamPayload.success": - if e.ComplexityRoot.RemoveRepositoryFromTeamPayload.Success == nil { - break + args, err := ec.field_Query_reconcilers_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RemoveRepositoryFromTeamPayload.Success(childComplexity), true + return e.ComplexityRoot.Query.Reconcilers(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "RemoveSecretValuePayload.secret": - if e.ComplexityRoot.RemoveSecretValuePayload.Secret == nil { + case "Query.roles": + if e.ComplexityRoot.Query.Roles == nil { break } - return e.ComplexityRoot.RemoveSecretValuePayload.Secret(childComplexity), true - - case "RemoveTeamMemberPayload.team": - if e.ComplexityRoot.RemoveTeamMemberPayload.Team == nil { - break + args, err := ec.field_Query_roles_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RemoveTeamMemberPayload.Team(childComplexity), true + return e.ComplexityRoot.Query.Roles(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "RemoveTeamMemberPayload.user": - if e.ComplexityRoot.RemoveTeamMemberPayload.User == nil { + case "Query.search": + if e.ComplexityRoot.Query.Search == nil { break } - return e.ComplexityRoot.RemoveTeamMemberPayload.User(childComplexity), true - - case "Repository.id": - if e.ComplexityRoot.Repository.ID == nil { - break + args, err := ec.field_Query_search_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Repository.ID(childComplexity), true + return e.ComplexityRoot.Query.Search(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(search.SearchFilter)), true - case "Repository.name": - if e.ComplexityRoot.Repository.Name == nil { + case "Query.serviceAccount": + if e.ComplexityRoot.Query.ServiceAccount == nil { break } - return e.ComplexityRoot.Repository.Name(childComplexity), true - - case "Repository.team": - if e.ComplexityRoot.Repository.Team == nil { - break + args, err := ec.field_Query_serviceAccount_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.Repository.Team(childComplexity), true + return e.ComplexityRoot.Query.ServiceAccount(childComplexity, args["id"].(ident.Ident)), true - case "RepositoryAddedActivityLogEntry.actor": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.Actor == nil { + case "Query.serviceAccounts": + if e.ComplexityRoot.Query.ServiceAccounts == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.Actor(childComplexity), true - - case "RepositoryAddedActivityLogEntry.createdAt": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_Query_serviceAccounts_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Query.ServiceAccounts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "RepositoryAddedActivityLogEntry.environmentName": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.EnvironmentName == nil { + case "Query.team": + if e.ComplexityRoot.Query.Team == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.EnvironmentName(childComplexity), true - - case "RepositoryAddedActivityLogEntry.id": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ID == nil { - break + args, err := ec.field_Query_team_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Query.Team(childComplexity, args["slug"].(slug.Slug)), true - case "RepositoryAddedActivityLogEntry.message": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.Message == nil { + case "Query.teams": + if e.ComplexityRoot.Query.Teams == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.Message(childComplexity), true - - case "RepositoryAddedActivityLogEntry.resourceName": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceName == nil { - break + args, err := ec.field_Query_teams_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.Query.Teams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.TeamOrder), args["filter"].(*team.TeamFilter)), true - case "RepositoryAddedActivityLogEntry.resourceType": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceType == nil { + case "Query.teamsUtilization": + if e.ComplexityRoot.Query.TeamsUtilization == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceType(childComplexity), true + args, err := ec.field_Query_teamsUtilization_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "RepositoryAddedActivityLogEntry.teamSlug": - if e.ComplexityRoot.RepositoryAddedActivityLogEntry.TeamSlug == nil { + return e.ComplexityRoot.Query.TeamsUtilization(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + + case "Query.unleashReleaseChannels": + if e.ComplexityRoot.Query.UnleashReleaseChannels == nil { break } - return e.ComplexityRoot.RepositoryAddedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Query.UnleashReleaseChannels(childComplexity), true - case "RepositoryConnection.edges": - if e.ComplexityRoot.RepositoryConnection.Edges == nil { + case "Query.user": + if e.ComplexityRoot.Query.User == nil { break } - return e.ComplexityRoot.RepositoryConnection.Edges(childComplexity), true - - case "RepositoryConnection.nodes": - if e.ComplexityRoot.RepositoryConnection.Nodes == nil { - break + args, err := ec.field_Query_user_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Query.User(childComplexity, args["email"].(*string)), true - case "RepositoryConnection.pageInfo": - if e.ComplexityRoot.RepositoryConnection.PageInfo == nil { + case "Query.userSyncLog": + if e.ComplexityRoot.Query.UserSyncLog == nil { break } - return e.ComplexityRoot.RepositoryConnection.PageInfo(childComplexity), true - - case "RepositoryEdge.cursor": - if e.ComplexityRoot.RepositoryEdge.Cursor == nil { - break + args, err := ec.field_Query_userSyncLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Query.UserSyncLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "RepositoryEdge.node": - if e.ComplexityRoot.RepositoryEdge.Node == nil { + case "Query.users": + if e.ComplexityRoot.Query.Users == nil { break } - return e.ComplexityRoot.RepositoryEdge.Node(childComplexity), true - - case "RepositoryRemovedActivityLogEntry.actor": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Actor == nil { - break + args, err := ec.field_Query_users_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Query.Users(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*user.UserOrder)), true - case "RepositoryRemovedActivityLogEntry.createdAt": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.CreatedAt == nil { + case "Query.vulnerabilityFixHistory": + if e.ComplexityRoot.Query.VulnerabilityFixHistory == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.CreatedAt(childComplexity), true - - case "RepositoryRemovedActivityLogEntry.environmentName": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_Query_vulnerabilityFixHistory_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Query.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true - case "RepositoryRemovedActivityLogEntry.id": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ID == nil { + case "Query.vulnerabilitySummary": + if e.ComplexityRoot.Query.VulnerabilitySummary == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Query.VulnerabilitySummary(childComplexity), true - case "RepositoryRemovedActivityLogEntry.message": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Message == nil { + case "Reconciler.activityLog": + if e.ComplexityRoot.Reconciler.ActivityLog == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Message(childComplexity), true - - case "RepositoryRemovedActivityLogEntry.resourceName": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceName == nil { - break + args, err := ec.field_Reconciler_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.Reconciler.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "RepositoryRemovedActivityLogEntry.resourceType": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceType == nil { + case "Reconciler.config": + if e.ComplexityRoot.Reconciler.Config == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Reconciler.Config(childComplexity), true - case "RepositoryRemovedActivityLogEntry.teamSlug": - if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.TeamSlug == nil { + case "Reconciler.configured": + if e.ComplexityRoot.Reconciler.Configured == nil { break } - return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.Reconciler.Configured(childComplexity), true - case "RequestTeamDeletionPayload.key": - if e.ComplexityRoot.RequestTeamDeletionPayload.Key == nil { + case "Reconciler.description": + if e.ComplexityRoot.Reconciler.Description == nil { break } - return e.ComplexityRoot.RequestTeamDeletionPayload.Key(childComplexity), true + return e.ComplexityRoot.Reconciler.Description(childComplexity), true - case "ResourceChangedField.field": - if e.ComplexityRoot.ResourceChangedField.Field == nil { + case "Reconciler.displayName": + if e.ComplexityRoot.Reconciler.DisplayName == nil { break } - return e.ComplexityRoot.ResourceChangedField.Field(childComplexity), true + return e.ComplexityRoot.Reconciler.DisplayName(childComplexity), true - case "ResourceChangedField.newValue": - if e.ComplexityRoot.ResourceChangedField.NewValue == nil { + case "Reconciler.enabled": + if e.ComplexityRoot.Reconciler.Enabled == nil { break } - return e.ComplexityRoot.ResourceChangedField.NewValue(childComplexity), true + return e.ComplexityRoot.Reconciler.Enabled(childComplexity), true - case "ResourceChangedField.oldValue": - if e.ComplexityRoot.ResourceChangedField.OldValue == nil { + case "Reconciler.errors": + if e.ComplexityRoot.Reconciler.Errors == nil { break } - return e.ComplexityRoot.ResourceChangedField.OldValue(childComplexity), true + args, err := ec.field_Reconciler_errors_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "RestartApplicationPayload.application": - if e.ComplexityRoot.RestartApplicationPayload.Application == nil { + return e.ComplexityRoot.Reconciler.Errors(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "Reconciler.id": + if e.ComplexityRoot.Reconciler.ID == nil { break } - return e.ComplexityRoot.RestartApplicationPayload.Application(childComplexity), true + return e.ComplexityRoot.Reconciler.ID(childComplexity), true - case "RevokeRoleFromServiceAccountPayload.serviceAccount": - if e.ComplexityRoot.RevokeRoleFromServiceAccountPayload.ServiceAccount == nil { + case "Reconciler.name": + if e.ComplexityRoot.Reconciler.Name == nil { break } - return e.ComplexityRoot.RevokeRoleFromServiceAccountPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.Reconciler.Name(childComplexity), true - case "RevokeTeamAccessToUnleashPayload.unleash": - if e.ComplexityRoot.RevokeTeamAccessToUnleashPayload.Unleash == nil { + case "ReconcilerConfig.configured": + if e.ComplexityRoot.ReconcilerConfig.Configured == nil { break } - return e.ComplexityRoot.RevokeTeamAccessToUnleashPayload.Unleash(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Configured(childComplexity), true - case "Role.description": - if e.ComplexityRoot.Role.Description == nil { + case "ReconcilerConfig.description": + if e.ComplexityRoot.ReconcilerConfig.Description == nil { break } - return e.ComplexityRoot.Role.Description(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Description(childComplexity), true - case "Role.id": - if e.ComplexityRoot.Role.ID == nil { + case "ReconcilerConfig.displayName": + if e.ComplexityRoot.ReconcilerConfig.DisplayName == nil { break } - return e.ComplexityRoot.Role.ID(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.DisplayName(childComplexity), true - case "Role.name": - if e.ComplexityRoot.Role.Name == nil { + case "ReconcilerConfig.key": + if e.ComplexityRoot.ReconcilerConfig.Key == nil { break } - return e.ComplexityRoot.Role.Name(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Key(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.actor": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Actor == nil { + case "ReconcilerConfig.secret": + if e.ComplexityRoot.ReconcilerConfig.Secret == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Secret(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.createdAt": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.CreatedAt == nil { + case "ReconcilerConfig.value": + if e.ComplexityRoot.ReconcilerConfig.Value == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ReconcilerConfig.Value(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.data": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Data == nil { + case "ReconcilerConfiguredActivityLogEntry.actor": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Actor(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.environmentName": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.EnvironmentName == nil { + case "ReconcilerConfiguredActivityLogEntry.createdAt": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.CreatedAt(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.id": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ID == nil { + case "ReconcilerConfiguredActivityLogEntry.data": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Data(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.message": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Message == nil { + case "ReconcilerConfiguredActivityLogEntry.environmentName": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.EnvironmentName(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.resourceName": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceName == nil { + case "ReconcilerConfiguredActivityLogEntry.id": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ID(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.resourceType": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceType == nil { + case "ReconcilerConfiguredActivityLogEntry.message": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.Message(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntry.teamSlug": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.TeamSlug == nil { + case "ReconcilerConfiguredActivityLogEntry.resourceName": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceName(childComplexity), true - case "RoleAssignedToServiceAccountActivityLogEntryData.roleName": - if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntryData.RoleName == nil { + case "ReconcilerConfiguredActivityLogEntry.resourceType": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntryData.RoleName(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.ResourceType(childComplexity), true - case "RoleAssignedUserSyncLogEntry.createdAt": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.CreatedAt == nil { + case "ReconcilerConfiguredActivityLogEntry.teamSlug": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntry.TeamSlug(childComplexity), true - case "RoleAssignedUserSyncLogEntry.id": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.ID == nil { + case "ReconcilerConfiguredActivityLogEntryData.updatedKeys": + if e.ComplexityRoot.ReconcilerConfiguredActivityLogEntryData.UpdatedKeys == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ReconcilerConfiguredActivityLogEntryData.UpdatedKeys(childComplexity), true - case "RoleAssignedUserSyncLogEntry.message": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.Message == nil { + case "ReconcilerConnection.edges": + if e.ComplexityRoot.ReconcilerConnection.Edges == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ReconcilerConnection.Edges(childComplexity), true - case "RoleAssignedUserSyncLogEntry.roleName": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.RoleName == nil { + case "ReconcilerConnection.nodes": + if e.ComplexityRoot.ReconcilerConnection.Nodes == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.RoleName(childComplexity), true + return e.ComplexityRoot.ReconcilerConnection.Nodes(childComplexity), true - case "RoleAssignedUserSyncLogEntry.userEmail": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserEmail == nil { + case "ReconcilerConnection.pageInfo": + if e.ComplexityRoot.ReconcilerConnection.PageInfo == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserEmail(childComplexity), true + return e.ComplexityRoot.ReconcilerConnection.PageInfo(childComplexity), true - case "RoleAssignedUserSyncLogEntry.userID": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserID == nil { + case "ReconcilerDisabledActivityLogEntry.actor": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserID(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Actor(childComplexity), true - case "RoleAssignedUserSyncLogEntry.userName": - if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserName == nil { + case "ReconcilerDisabledActivityLogEntry.createdAt": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserName(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.CreatedAt(childComplexity), true - case "RoleConnection.edges": - if e.ComplexityRoot.RoleConnection.Edges == nil { + case "ReconcilerDisabledActivityLogEntry.environmentName": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.RoleConnection.Edges(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.EnvironmentName(childComplexity), true - case "RoleConnection.nodes": - if e.ComplexityRoot.RoleConnection.Nodes == nil { + case "ReconcilerDisabledActivityLogEntry.id": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.RoleConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ID(childComplexity), true - case "RoleConnection.pageInfo": - if e.ComplexityRoot.RoleConnection.PageInfo == nil { + case "ReconcilerDisabledActivityLogEntry.message": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.RoleConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.Message(childComplexity), true - case "RoleEdge.cursor": - if e.ComplexityRoot.RoleEdge.Cursor == nil { + case "ReconcilerDisabledActivityLogEntry.resourceName": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.RoleEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceName(childComplexity), true - case "RoleEdge.node": - if e.ComplexityRoot.RoleEdge.Node == nil { + case "ReconcilerDisabledActivityLogEntry.resourceType": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.RoleEdge.Node(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.ResourceType(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.actor": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Actor == nil { + case "ReconcilerDisabledActivityLogEntry.teamSlug": + if e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ReconcilerDisabledActivityLogEntry.TeamSlug(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.createdAt": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.CreatedAt == nil { + case "ReconcilerEdge.cursor": + if e.ComplexityRoot.ReconcilerEdge.Cursor == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ReconcilerEdge.Cursor(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.data": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Data == nil { + case "ReconcilerEdge.node": + if e.ComplexityRoot.ReconcilerEdge.Node == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.ReconcilerEdge.Node(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.environmentName": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.EnvironmentName == nil { + case "ReconcilerEnabledActivityLogEntry.actor": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Actor(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.id": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ID == nil { + case "ReconcilerEnabledActivityLogEntry.createdAt": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.CreatedAt(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.message": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Message == nil { + case "ReconcilerEnabledActivityLogEntry.environmentName": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.EnvironmentName(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.resourceName": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceName == nil { + case "ReconcilerEnabledActivityLogEntry.id": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ID(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.resourceType": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceType == nil { + case "ReconcilerEnabledActivityLogEntry.message": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.Message(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntry.teamSlug": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.TeamSlug == nil { + case "ReconcilerEnabledActivityLogEntry.resourceName": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceName(childComplexity), true - case "RoleRevokedFromServiceAccountActivityLogEntryData.roleName": - if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntryData.RoleName == nil { + case "ReconcilerEnabledActivityLogEntry.resourceType": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntryData.RoleName(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.ResourceType(childComplexity), true - case "RoleRevokedUserSyncLogEntry.createdAt": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.CreatedAt == nil { + case "ReconcilerEnabledActivityLogEntry.teamSlug": + if e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ReconcilerEnabledActivityLogEntry.TeamSlug(childComplexity), true - case "RoleRevokedUserSyncLogEntry.id": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.ID == nil { + case "ReconcilerError.correlationID": + if e.ComplexityRoot.ReconcilerError.CorrelationID == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ReconcilerError.CorrelationID(childComplexity), true - case "RoleRevokedUserSyncLogEntry.message": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.Message == nil { + case "ReconcilerError.createdAt": + if e.ComplexityRoot.ReconcilerError.CreatedAt == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ReconcilerError.CreatedAt(childComplexity), true - case "RoleRevokedUserSyncLogEntry.roleName": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.RoleName == nil { + case "ReconcilerError.id": + if e.ComplexityRoot.ReconcilerError.ID == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.RoleName(childComplexity), true + return e.ComplexityRoot.ReconcilerError.ID(childComplexity), true - case "RoleRevokedUserSyncLogEntry.userEmail": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserEmail == nil { + case "ReconcilerError.message": + if e.ComplexityRoot.ReconcilerError.Message == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserEmail(childComplexity), true + return e.ComplexityRoot.ReconcilerError.Message(childComplexity), true - case "RoleRevokedUserSyncLogEntry.userID": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserID == nil { + case "ReconcilerError.team": + if e.ComplexityRoot.ReconcilerError.Team == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserID(childComplexity), true + return e.ComplexityRoot.ReconcilerError.Team(childComplexity), true - case "RoleRevokedUserSyncLogEntry.userName": - if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserName == nil { + case "ReconcilerErrorConnection.edges": + if e.ComplexityRoot.ReconcilerErrorConnection.Edges == nil { break } - return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserName(childComplexity), true + return e.ComplexityRoot.ReconcilerErrorConnection.Edges(childComplexity), true - case "SearchNodeConnection.edges": - if e.ComplexityRoot.SearchNodeConnection.Edges == nil { + case "ReconcilerErrorConnection.nodes": + if e.ComplexityRoot.ReconcilerErrorConnection.Nodes == nil { break } - return e.ComplexityRoot.SearchNodeConnection.Edges(childComplexity), true + return e.ComplexityRoot.ReconcilerErrorConnection.Nodes(childComplexity), true - case "SearchNodeConnection.nodes": - if e.ComplexityRoot.SearchNodeConnection.Nodes == nil { + case "ReconcilerErrorConnection.pageInfo": + if e.ComplexityRoot.ReconcilerErrorConnection.PageInfo == nil { break } - return e.ComplexityRoot.SearchNodeConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ReconcilerErrorConnection.PageInfo(childComplexity), true - case "SearchNodeConnection.pageInfo": - if e.ComplexityRoot.SearchNodeConnection.PageInfo == nil { + case "ReconcilerErrorEdge.cursor": + if e.ComplexityRoot.ReconcilerErrorEdge.Cursor == nil { break } - return e.ComplexityRoot.SearchNodeConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ReconcilerErrorEdge.Cursor(childComplexity), true - case "SearchNodeEdge.cursor": - if e.ComplexityRoot.SearchNodeEdge.Cursor == nil { + case "ReconcilerErrorEdge.node": + if e.ComplexityRoot.ReconcilerErrorEdge.Node == nil { break } - return e.ComplexityRoot.SearchNodeEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ReconcilerErrorEdge.Node(childComplexity), true - case "SearchNodeEdge.node": - if e.ComplexityRoot.SearchNodeEdge.Node == nil { + case "RemoveConfigValuePayload.config": + if e.ComplexityRoot.RemoveConfigValuePayload.Config == nil { break } - return e.ComplexityRoot.SearchNodeEdge.Node(childComplexity), true + return e.ComplexityRoot.RemoveConfigValuePayload.Config(childComplexity), true - case "Secret.activityLog": - if e.ComplexityRoot.Secret.ActivityLog == nil { + case "RemoveRepositoryFromTeamPayload.success": + if e.ComplexityRoot.RemoveRepositoryFromTeamPayload.Success == nil { break } - args, err := ec.field_Secret_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.RemoveRepositoryFromTeamPayload.Success(childComplexity), true + + case "RemoveSecretValuePayload.secret": + if e.ComplexityRoot.RemoveSecretValuePayload.Secret == nil { + break } - return e.ComplexityRoot.Secret.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.RemoveSecretValuePayload.Secret(childComplexity), true - case "Secret.applications": - if e.ComplexityRoot.Secret.Applications == nil { + case "RemoveTeamMemberPayload.team": + if e.ComplexityRoot.RemoveTeamMemberPayload.Team == nil { break } - args, err := ec.field_Secret_applications_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.RemoveTeamMemberPayload.Team(childComplexity), true + + case "RemoveTeamMemberPayload.user": + if e.ComplexityRoot.RemoveTeamMemberPayload.User == nil { + break } - return e.ComplexityRoot.Secret.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.RemoveTeamMemberPayload.User(childComplexity), true - case "Secret.environment": - if e.ComplexityRoot.Secret.Environment == nil { + case "Repository.id": + if e.ComplexityRoot.Repository.ID == nil { break } - return e.ComplexityRoot.Secret.Environment(childComplexity), true + return e.ComplexityRoot.Repository.ID(childComplexity), true - case "Secret.id": - if e.ComplexityRoot.Secret.ID == nil { + case "Repository.name": + if e.ComplexityRoot.Repository.Name == nil { break } - return e.ComplexityRoot.Secret.ID(childComplexity), true + return e.ComplexityRoot.Repository.Name(childComplexity), true - case "Secret.jobs": - if e.ComplexityRoot.Secret.Jobs == nil { + case "Repository.team": + if e.ComplexityRoot.Repository.Team == nil { break } - args, err := ec.field_Secret_jobs_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.Repository.Team(childComplexity), true + + case "RepositoryAddedActivityLogEntry.actor": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.Actor == nil { + break } - return e.ComplexityRoot.Secret.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.Actor(childComplexity), true - case "Secret.keys": - if e.ComplexityRoot.Secret.Keys == nil { + case "RepositoryAddedActivityLogEntry.createdAt": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.Secret.Keys(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.CreatedAt(childComplexity), true - case "Secret.lastModifiedAt": - if e.ComplexityRoot.Secret.LastModifiedAt == nil { + case "RepositoryAddedActivityLogEntry.environmentName": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.Secret.LastModifiedAt(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.EnvironmentName(childComplexity), true - case "Secret.lastModifiedBy": - if e.ComplexityRoot.Secret.LastModifiedBy == nil { + case "RepositoryAddedActivityLogEntry.id": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.Secret.LastModifiedBy(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ID(childComplexity), true - case "Secret.name": - if e.ComplexityRoot.Secret.Name == nil { + case "RepositoryAddedActivityLogEntry.message": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.Secret.Name(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.Message(childComplexity), true - case "Secret.team": - if e.ComplexityRoot.Secret.Team == nil { + case "RepositoryAddedActivityLogEntry.resourceName": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.Secret.Team(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceName(childComplexity), true - case "Secret.teamEnvironment": - if e.ComplexityRoot.Secret.TeamEnvironment == nil { + case "RepositoryAddedActivityLogEntry.resourceType": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.Secret.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.ResourceType(childComplexity), true - case "Secret.workloads": - if e.ComplexityRoot.Secret.Workloads == nil { + case "RepositoryAddedActivityLogEntry.teamSlug": + if e.ComplexityRoot.RepositoryAddedActivityLogEntry.TeamSlug == nil { break } - args, err := ec.field_Secret_workloads_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Secret.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.RepositoryAddedActivityLogEntry.TeamSlug(childComplexity), true - case "SecretConnection.edges": - if e.ComplexityRoot.SecretConnection.Edges == nil { + case "RepositoryConnection.edges": + if e.ComplexityRoot.RepositoryConnection.Edges == nil { break } - return e.ComplexityRoot.SecretConnection.Edges(childComplexity), true + return e.ComplexityRoot.RepositoryConnection.Edges(childComplexity), true - case "SecretConnection.nodes": - if e.ComplexityRoot.SecretConnection.Nodes == nil { + case "RepositoryConnection.nodes": + if e.ComplexityRoot.RepositoryConnection.Nodes == nil { break } - return e.ComplexityRoot.SecretConnection.Nodes(childComplexity), true + return e.ComplexityRoot.RepositoryConnection.Nodes(childComplexity), true - case "SecretConnection.pageInfo": - if e.ComplexityRoot.SecretConnection.PageInfo == nil { + case "RepositoryConnection.pageInfo": + if e.ComplexityRoot.RepositoryConnection.PageInfo == nil { break } - return e.ComplexityRoot.SecretConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.RepositoryConnection.PageInfo(childComplexity), true - case "SecretCreatedActivityLogEntry.actor": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.Actor == nil { + case "RepositoryEdge.cursor": + if e.ComplexityRoot.RepositoryEdge.Cursor == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RepositoryEdge.Cursor(childComplexity), true - case "SecretCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.CreatedAt == nil { + case "RepositoryEdge.node": + if e.ComplexityRoot.RepositoryEdge.Node == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RepositoryEdge.Node(childComplexity), true - case "SecretCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.EnvironmentName == nil { + case "RepositoryRemovedActivityLogEntry.actor": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Actor(childComplexity), true - case "SecretCreatedActivityLogEntry.id": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.ID == nil { + case "RepositoryRemovedActivityLogEntry.createdAt": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.CreatedAt(childComplexity), true - case "SecretCreatedActivityLogEntry.message": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.Message == nil { + case "RepositoryRemovedActivityLogEntry.environmentName": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.EnvironmentName(childComplexity), true - case "SecretCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceName == nil { + case "RepositoryRemovedActivityLogEntry.id": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ID(childComplexity), true - case "SecretCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceType == nil { + case "RepositoryRemovedActivityLogEntry.message": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.Message(childComplexity), true - case "SecretCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretCreatedActivityLogEntry.TeamSlug == nil { + case "RepositoryRemovedActivityLogEntry.resourceName": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SecretCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceName(childComplexity), true - case "SecretDeletedActivityLogEntry.actor": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.Actor == nil { + case "RepositoryRemovedActivityLogEntry.resourceType": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.ResourceType(childComplexity), true - case "SecretDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.CreatedAt == nil { + case "RepositoryRemovedActivityLogEntry.teamSlug": + if e.ComplexityRoot.RepositoryRemovedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RepositoryRemovedActivityLogEntry.TeamSlug(childComplexity), true - case "SecretDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.EnvironmentName == nil { + case "RequestTeamDeletionPayload.key": + if e.ComplexityRoot.RequestTeamDeletionPayload.Key == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RequestTeamDeletionPayload.Key(childComplexity), true - case "SecretDeletedActivityLogEntry.id": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.ID == nil { + case "ResourceChangedField.field": + if e.ComplexityRoot.ResourceChangedField.Field == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ResourceChangedField.Field(childComplexity), true - case "SecretDeletedActivityLogEntry.message": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.Message == nil { + case "ResourceChangedField.newValue": + if e.ComplexityRoot.ResourceChangedField.NewValue == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ResourceChangedField.NewValue(childComplexity), true - case "SecretDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceName == nil { + case "ResourceChangedField.oldValue": + if e.ComplexityRoot.ResourceChangedField.OldValue == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ResourceChangedField.OldValue(childComplexity), true - case "SecretDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceType == nil { + case "RestartApplicationPayload.application": + if e.ComplexityRoot.RestartApplicationPayload.Application == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RestartApplicationPayload.Application(childComplexity), true - case "SecretDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretDeletedActivityLogEntry.TeamSlug == nil { + case "RevokeRoleFromServiceAccountPayload.serviceAccount": + if e.ComplexityRoot.RevokeRoleFromServiceAccountPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.SecretDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.RevokeRoleFromServiceAccountPayload.ServiceAccount(childComplexity), true - case "SecretEdge.cursor": - if e.ComplexityRoot.SecretEdge.Cursor == nil { + case "RevokeTeamAccessToUnleashPayload.unleash": + if e.ComplexityRoot.RevokeTeamAccessToUnleashPayload.Unleash == nil { break } - return e.ComplexityRoot.SecretEdge.Cursor(childComplexity), true + return e.ComplexityRoot.RevokeTeamAccessToUnleashPayload.Unleash(childComplexity), true - case "SecretEdge.node": - if e.ComplexityRoot.SecretEdge.Node == nil { + case "Role.description": + if e.ComplexityRoot.Role.Description == nil { break } - return e.ComplexityRoot.SecretEdge.Node(childComplexity), true + return e.ComplexityRoot.Role.Description(childComplexity), true - case "SecretValue.encoding": - if e.ComplexityRoot.SecretValue.Encoding == nil { + case "Role.id": + if e.ComplexityRoot.Role.ID == nil { break } - return e.ComplexityRoot.SecretValue.Encoding(childComplexity), true + return e.ComplexityRoot.Role.ID(childComplexity), true - case "SecretValue.name": - if e.ComplexityRoot.SecretValue.Name == nil { + case "Role.name": + if e.ComplexityRoot.Role.Name == nil { break } - return e.ComplexityRoot.SecretValue.Name(childComplexity), true + return e.ComplexityRoot.Role.Name(childComplexity), true - case "SecretValue.value": - if e.ComplexityRoot.SecretValue.Value == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.actor": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SecretValue.Value(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Actor(childComplexity), true - case "SecretValueAddedActivityLogEntry.actor": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Actor == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.createdAt": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.CreatedAt(childComplexity), true - case "SecretValueAddedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.CreatedAt == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.data": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Data(childComplexity), true - case "SecretValueAddedActivityLogEntry.data": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Data == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.environmentName": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.EnvironmentName(childComplexity), true - case "SecretValueAddedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.EnvironmentName == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.id": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ID(childComplexity), true - case "SecretValueAddedActivityLogEntry.id": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ID == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.message": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.Message(childComplexity), true - case "SecretValueAddedActivityLogEntry.message": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Message == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.resourceName": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceName(childComplexity), true - case "SecretValueAddedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceName == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.resourceType": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.ResourceType(childComplexity), true - case "SecretValueAddedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceType == nil { + case "RoleAssignedToServiceAccountActivityLogEntry.teamSlug": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntry.TeamSlug(childComplexity), true - case "SecretValueAddedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretValueAddedActivityLogEntry.TeamSlug == nil { + case "RoleAssignedToServiceAccountActivityLogEntryData.roleName": + if e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntryData.RoleName == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.RoleAssignedToServiceAccountActivityLogEntryData.RoleName(childComplexity), true - case "SecretValueAddedActivityLogEntryData.valueName": - if e.ComplexityRoot.SecretValueAddedActivityLogEntryData.ValueName == nil { + case "RoleAssignedUserSyncLogEntry.createdAt": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretValueAddedActivityLogEntryData.ValueName(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.CreatedAt(childComplexity), true - case "SecretValueRemovedActivityLogEntry.actor": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Actor == nil { + case "RoleAssignedUserSyncLogEntry.id": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.ID(childComplexity), true - case "SecretValueRemovedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.CreatedAt == nil { + case "RoleAssignedUserSyncLogEntry.message": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.Message(childComplexity), true - case "SecretValueRemovedActivityLogEntry.data": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Data == nil { + case "RoleAssignedUserSyncLogEntry.roleName": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.RoleName == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.RoleName(childComplexity), true - case "SecretValueRemovedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.EnvironmentName == nil { + case "RoleAssignedUserSyncLogEntry.userEmail": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserEmail == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserEmail(childComplexity), true - case "SecretValueRemovedActivityLogEntry.id": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ID == nil { + case "RoleAssignedUserSyncLogEntry.userID": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserID == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserID(childComplexity), true - case "SecretValueRemovedActivityLogEntry.message": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Message == nil { + case "RoleAssignedUserSyncLogEntry.userName": + if e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserName == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RoleAssignedUserSyncLogEntry.UserName(childComplexity), true - case "SecretValueRemovedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceName == nil { + case "RoleConnection.edges": + if e.ComplexityRoot.RoleConnection.Edges == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RoleConnection.Edges(childComplexity), true - case "SecretValueRemovedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceType == nil { + case "RoleConnection.nodes": + if e.ComplexityRoot.RoleConnection.Nodes == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RoleConnection.Nodes(childComplexity), true - case "SecretValueRemovedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.TeamSlug == nil { + case "RoleConnection.pageInfo": + if e.ComplexityRoot.RoleConnection.PageInfo == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.RoleConnection.PageInfo(childComplexity), true - case "SecretValueRemovedActivityLogEntryData.valueName": - if e.ComplexityRoot.SecretValueRemovedActivityLogEntryData.ValueName == nil { + case "RoleEdge.cursor": + if e.ComplexityRoot.RoleEdge.Cursor == nil { break } - return e.ComplexityRoot.SecretValueRemovedActivityLogEntryData.ValueName(childComplexity), true + return e.ComplexityRoot.RoleEdge.Cursor(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Actor == nil { + case "RoleEdge.node": + if e.ComplexityRoot.RoleEdge.Node == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RoleEdge.Node(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.CreatedAt == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.actor": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Actor(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.data": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Data == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.createdAt": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.CreatedAt(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.EnvironmentName == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.data": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Data(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.id": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ID == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.environmentName": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.EnvironmentName(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.message": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Message == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.id": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ID(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceName == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.message": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.Message(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceType == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.resourceName": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceName(childComplexity), true - case "SecretValueUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.TeamSlug == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.resourceType": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.ResourceType(childComplexity), true - case "SecretValueUpdatedActivityLogEntryData.valueName": - if e.ComplexityRoot.SecretValueUpdatedActivityLogEntryData.ValueName == nil { + case "RoleRevokedFromServiceAccountActivityLogEntry.teamSlug": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SecretValueUpdatedActivityLogEntryData.ValueName(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntry.TeamSlug(childComplexity), true - case "SecretValuesViewedActivityLogEntry.actor": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Actor == nil { + case "RoleRevokedFromServiceAccountActivityLogEntryData.roleName": + if e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntryData.RoleName == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.RoleRevokedFromServiceAccountActivityLogEntryData.RoleName(childComplexity), true - case "SecretValuesViewedActivityLogEntry.createdAt": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.CreatedAt == nil { + case "RoleRevokedUserSyncLogEntry.createdAt": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.CreatedAt(childComplexity), true - case "SecretValuesViewedActivityLogEntry.data": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Data == nil { + case "RoleRevokedUserSyncLogEntry.id": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.ID == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.ID(childComplexity), true - case "SecretValuesViewedActivityLogEntry.environmentName": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.EnvironmentName == nil { + case "RoleRevokedUserSyncLogEntry.message": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.Message == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.Message(childComplexity), true - case "SecretValuesViewedActivityLogEntry.id": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ID == nil { + case "RoleRevokedUserSyncLogEntry.roleName": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.RoleName == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.RoleName(childComplexity), true - case "SecretValuesViewedActivityLogEntry.message": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Message == nil { + case "RoleRevokedUserSyncLogEntry.userEmail": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserEmail == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserEmail(childComplexity), true - case "SecretValuesViewedActivityLogEntry.resourceName": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceName == nil { + case "RoleRevokedUserSyncLogEntry.userID": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserID == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserID(childComplexity), true - case "SecretValuesViewedActivityLogEntry.resourceType": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceType == nil { + case "RoleRevokedUserSyncLogEntry.userName": + if e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserName == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.RoleRevokedUserSyncLogEntry.UserName(childComplexity), true - case "SecretValuesViewedActivityLogEntry.teamSlug": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.TeamSlug == nil { + case "SearchNodeConnection.edges": + if e.ComplexityRoot.SearchNodeConnection.Edges == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SearchNodeConnection.Edges(childComplexity), true - case "SecretValuesViewedActivityLogEntryData.reason": - if e.ComplexityRoot.SecretValuesViewedActivityLogEntryData.Reason == nil { + case "SearchNodeConnection.nodes": + if e.ComplexityRoot.SearchNodeConnection.Nodes == nil { break } - return e.ComplexityRoot.SecretValuesViewedActivityLogEntryData.Reason(childComplexity), true + return e.ComplexityRoot.SearchNodeConnection.Nodes(childComplexity), true - case "ServiceAccount.createdAt": - if e.ComplexityRoot.ServiceAccount.CreatedAt == nil { + case "SearchNodeConnection.pageInfo": + if e.ComplexityRoot.SearchNodeConnection.PageInfo == nil { break } - return e.ComplexityRoot.ServiceAccount.CreatedAt(childComplexity), true + return e.ComplexityRoot.SearchNodeConnection.PageInfo(childComplexity), true - case "ServiceAccount.description": - if e.ComplexityRoot.ServiceAccount.Description == nil { + case "SearchNodeEdge.cursor": + if e.ComplexityRoot.SearchNodeEdge.Cursor == nil { break } - return e.ComplexityRoot.ServiceAccount.Description(childComplexity), true + return e.ComplexityRoot.SearchNodeEdge.Cursor(childComplexity), true - case "ServiceAccount.id": - if e.ComplexityRoot.ServiceAccount.ID == nil { + case "SearchNodeEdge.node": + if e.ComplexityRoot.SearchNodeEdge.Node == nil { break } - return e.ComplexityRoot.ServiceAccount.ID(childComplexity), true + return e.ComplexityRoot.SearchNodeEdge.Node(childComplexity), true - case "ServiceAccount.lastUsedAt": - if e.ComplexityRoot.ServiceAccount.LastUsedAt == nil { + case "Secret.activityLog": + if e.ComplexityRoot.Secret.ActivityLog == nil { break } - return e.ComplexityRoot.ServiceAccount.LastUsedAt(childComplexity), true - - case "ServiceAccount.name": - if e.ComplexityRoot.ServiceAccount.Name == nil { - break + args, err := ec.field_Secret_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ServiceAccount.Name(childComplexity), true + return e.ComplexityRoot.Secret.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "ServiceAccount.roles": - if e.ComplexityRoot.ServiceAccount.Roles == nil { + case "Secret.applications": + if e.ComplexityRoot.Secret.Applications == nil { break } - args, err := ec.field_ServiceAccount_roles_args(ctx, rawArgs) + args, err := ec.field_Secret_applications_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.ServiceAccount.Roles(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Secret.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ServiceAccount.team": - if e.ComplexityRoot.ServiceAccount.Team == nil { + case "Secret.environment": + if e.ComplexityRoot.Secret.Environment == nil { break } - return e.ComplexityRoot.ServiceAccount.Team(childComplexity), true + return e.ComplexityRoot.Secret.Environment(childComplexity), true - case "ServiceAccount.tokens": - if e.ComplexityRoot.ServiceAccount.Tokens == nil { + case "Secret.id": + if e.ComplexityRoot.Secret.ID == nil { break } - args, err := ec.field_ServiceAccount_tokens_args(ctx, rawArgs) + return e.ComplexityRoot.Secret.ID(childComplexity), true + + case "Secret.jobs": + if e.ComplexityRoot.Secret.Jobs == nil { + break + } + + args, err := ec.field_Secret_jobs_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.ServiceAccount.Tokens(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.Secret.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ServiceAccount.updatedAt": - if e.ComplexityRoot.ServiceAccount.UpdatedAt == nil { + case "Secret.keys": + if e.ComplexityRoot.Secret.Keys == nil { break } - return e.ComplexityRoot.ServiceAccount.UpdatedAt(childComplexity), true + return e.ComplexityRoot.Secret.Keys(childComplexity), true - case "ServiceAccountConnection.edges": - if e.ComplexityRoot.ServiceAccountConnection.Edges == nil { + case "Secret.lastModifiedAt": + if e.ComplexityRoot.Secret.LastModifiedAt == nil { break } - return e.ComplexityRoot.ServiceAccountConnection.Edges(childComplexity), true + return e.ComplexityRoot.Secret.LastModifiedAt(childComplexity), true - case "ServiceAccountConnection.nodes": - if e.ComplexityRoot.ServiceAccountConnection.Nodes == nil { + case "Secret.lastModifiedBy": + if e.ComplexityRoot.Secret.LastModifiedBy == nil { break } - return e.ComplexityRoot.ServiceAccountConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Secret.LastModifiedBy(childComplexity), true - case "ServiceAccountConnection.pageInfo": - if e.ComplexityRoot.ServiceAccountConnection.PageInfo == nil { + case "Secret.name": + if e.ComplexityRoot.Secret.Name == nil { break } - return e.ComplexityRoot.ServiceAccountConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Secret.Name(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Actor == nil { + case "Secret.team": + if e.ComplexityRoot.Secret.Team == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Secret.Team(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.CreatedAt == nil { + case "Secret.teamEnvironment": + if e.ComplexityRoot.Secret.TeamEnvironment == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Secret.TeamEnvironment(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.EnvironmentName == nil { + case "Secret.workloads": + if e.ComplexityRoot.Secret.Workloads == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.EnvironmentName(childComplexity), true - - case "ServiceAccountCreatedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ID == nil { - break + args, err := ec.field_Secret_workloads_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Secret.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ServiceAccountCreatedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Message == nil { + case "SecretConnection.edges": + if e.ComplexityRoot.SecretConnection.Edges == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretConnection.Edges(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceName == nil { + case "SecretConnection.nodes": + if e.ComplexityRoot.SecretConnection.Nodes == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretConnection.Nodes(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceType == nil { + case "SecretConnection.pageInfo": + if e.ComplexityRoot.SecretConnection.PageInfo == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretConnection.PageInfo(childComplexity), true - case "ServiceAccountCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.TeamSlug == nil { + case "SecretCreatedActivityLogEntry.actor": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Actor == nil { + case "SecretCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.CreatedAt == nil { + case "SecretCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.EnvironmentName == nil { + case "SecretCreatedActivityLogEntry.id": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ID == nil { + case "SecretCreatedActivityLogEntry.message": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Message == nil { + case "SecretCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceName == nil { + case "SecretCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceType == nil { + case "SecretCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.TeamSlug == nil { + case "SecretDeletedActivityLogEntry.actor": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountEdge.cursor": - if e.ComplexityRoot.ServiceAccountEdge.Cursor == nil { + case "SecretDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountEdge.Cursor(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountEdge.node": - if e.ComplexityRoot.ServiceAccountEdge.Node == nil { + case "SecretDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountEdge.Node(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountToken.createdAt": - if e.ComplexityRoot.ServiceAccountToken.CreatedAt == nil { + case "SecretDeletedActivityLogEntry.id": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountToken.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountToken.description": - if e.ComplexityRoot.ServiceAccountToken.Description == nil { + case "SecretDeletedActivityLogEntry.message": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountToken.Description(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountToken.expiresAt": - if e.ComplexityRoot.ServiceAccountToken.ExpiresAt == nil { + case "SecretDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountToken.ExpiresAt(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountToken.id": - if e.ComplexityRoot.ServiceAccountToken.ID == nil { + case "SecretDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountToken.ID(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountToken.lastUsedAt": - if e.ComplexityRoot.ServiceAccountToken.LastUsedAt == nil { + case "SecretDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountToken.LastUsedAt(childComplexity), true + return e.ComplexityRoot.SecretDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountToken.name": - if e.ComplexityRoot.ServiceAccountToken.Name == nil { + case "SecretEdge.cursor": + if e.ComplexityRoot.SecretEdge.Cursor == nil { break } - return e.ComplexityRoot.ServiceAccountToken.Name(childComplexity), true + return e.ComplexityRoot.SecretEdge.Cursor(childComplexity), true - case "ServiceAccountToken.updatedAt": - if e.ComplexityRoot.ServiceAccountToken.UpdatedAt == nil { + case "SecretEdge.node": + if e.ComplexityRoot.SecretEdge.Node == nil { break } - return e.ComplexityRoot.ServiceAccountToken.UpdatedAt(childComplexity), true + return e.ComplexityRoot.SecretEdge.Node(childComplexity), true - case "ServiceAccountTokenConnection.edges": - if e.ComplexityRoot.ServiceAccountTokenConnection.Edges == nil { + case "SecretValue.encoding": + if e.ComplexityRoot.SecretValue.Encoding == nil { break } - return e.ComplexityRoot.ServiceAccountTokenConnection.Edges(childComplexity), true + return e.ComplexityRoot.SecretValue.Encoding(childComplexity), true - case "ServiceAccountTokenConnection.nodes": - if e.ComplexityRoot.ServiceAccountTokenConnection.Nodes == nil { + case "SecretValue.name": + if e.ComplexityRoot.SecretValue.Name == nil { break } - return e.ComplexityRoot.ServiceAccountTokenConnection.Nodes(childComplexity), true + return e.ComplexityRoot.SecretValue.Name(childComplexity), true - case "ServiceAccountTokenConnection.pageInfo": - if e.ComplexityRoot.ServiceAccountTokenConnection.PageInfo == nil { + case "SecretValue.value": + if e.ComplexityRoot.SecretValue.Value == nil { break } - return e.ComplexityRoot.ServiceAccountTokenConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.SecretValue.Value(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Actor == nil { + case "SecretValueAddedActivityLogEntry.actor": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.CreatedAt == nil { + case "SecretValueAddedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.data": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Data == nil { + case "SecretValueAddedActivityLogEntry.data": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Data(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.EnvironmentName == nil { + case "SecretValueAddedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ID == nil { + case "SecretValueAddedActivityLogEntry.id": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Message == nil { + case "SecretValueAddedActivityLogEntry.message": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceName == nil { + case "SecretValueAddedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceType == nil { + case "SecretValueAddedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.TeamSlug == nil { + case "SecretValueAddedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretValueAddedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountTokenCreatedActivityLogEntryData.tokenName": - if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntryData.TokenName == nil { + case "SecretValueAddedActivityLogEntryData.valueName": + if e.ComplexityRoot.SecretValueAddedActivityLogEntryData.ValueName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntryData.TokenName(childComplexity), true + return e.ComplexityRoot.SecretValueAddedActivityLogEntryData.ValueName(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Actor == nil { + case "SecretValueRemovedActivityLogEntry.actor": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.CreatedAt == nil { + case "SecretValueRemovedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.data": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Data == nil { + case "SecretValueRemovedActivityLogEntry.data": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Data(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.EnvironmentName == nil { + case "SecretValueRemovedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ID == nil { + case "SecretValueRemovedActivityLogEntry.id": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Message == nil { + case "SecretValueRemovedActivityLogEntry.message": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceName == nil { + case "SecretValueRemovedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceType == nil { + case "SecretValueRemovedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.TeamSlug == nil { + case "SecretValueRemovedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountTokenDeletedActivityLogEntryData.tokenName": - if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntryData.TokenName == nil { + case "SecretValueRemovedActivityLogEntryData.valueName": + if e.ComplexityRoot.SecretValueRemovedActivityLogEntryData.ValueName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntryData.TokenName(childComplexity), true + return e.ComplexityRoot.SecretValueRemovedActivityLogEntryData.ValueName(childComplexity), true - case "ServiceAccountTokenEdge.cursor": - if e.ComplexityRoot.ServiceAccountTokenEdge.Cursor == nil { + case "SecretValueUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountTokenEdge.Cursor(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountTokenEdge.node": - if e.ComplexityRoot.ServiceAccountTokenEdge.Node == nil { + case "SecretValueUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountTokenEdge.Node(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Actor == nil { + case "SecretValueUpdatedActivityLogEntry.data": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Data(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.CreatedAt == nil { + case "SecretValueUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.data": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Data == nil { + case "SecretValueUpdatedActivityLogEntry.id": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.EnvironmentName == nil { + case "SecretValueUpdatedActivityLogEntry.message": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ID == nil { + case "SecretValueUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Message == nil { + case "SecretValueUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceName == nil { + case "SecretValueUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceType == nil { + case "SecretValueUpdatedActivityLogEntryData.valueName": + if e.ComplexityRoot.SecretValueUpdatedActivityLogEntryData.ValueName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SecretValueUpdatedActivityLogEntryData.ValueName(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.TeamSlug == nil { + case "SecretValuesViewedActivityLogEntry.actor": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Actor(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryData.UpdatedFields == nil { + case "SecretValuesViewedActivityLogEntry.createdAt": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "SecretValuesViewedActivityLogEntry.data": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Data(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "SecretValuesViewedActivityLogEntry.environmentName": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "SecretValuesViewedActivityLogEntry.id": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ID(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Actor == nil { + case "SecretValuesViewedActivityLogEntry.message": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.Message(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.CreatedAt == nil { + case "SecretValuesViewedActivityLogEntry.resourceName": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.data": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Data == nil { + case "SecretValuesViewedActivityLogEntry.resourceType": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.ResourceType(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.EnvironmentName == nil { + case "SecretValuesViewedActivityLogEntry.teamSlug": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntry.TeamSlug(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.id": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ID == nil { + case "SecretValuesViewedActivityLogEntryData.reason": + if e.ComplexityRoot.SecretValuesViewedActivityLogEntryData.Reason == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SecretValuesViewedActivityLogEntryData.Reason(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.message": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Message == nil { + case "ServiceAccount.createdAt": + if e.ComplexityRoot.ServiceAccount.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ServiceAccount.CreatedAt(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceName == nil { + case "ServiceAccount.description": + if e.ComplexityRoot.ServiceAccount.Description == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Description(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceType == nil { + case "ServiceAccount.id": + if e.ComplexityRoot.ServiceAccount.ID == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ServiceAccount.ID(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.TeamSlug == nil { + case "ServiceAccount.lastUsedAt": + if e.ComplexityRoot.ServiceAccount.LastUsedAt == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ServiceAccount.LastUsedAt(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryData.UpdatedFields == nil { + case "ServiceAccount.name": + if e.ComplexityRoot.ServiceAccount.Name == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Name(childComplexity), true - case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "ServiceAccount.roles": + if e.ComplexityRoot.ServiceAccount.Roles == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - - case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { - break + args, err := ec.field_ServiceAccount_roles_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Roles(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "ServiceAccount.team": + if e.ComplexityRoot.ServiceAccount.Team == nil { break } - return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Team(childComplexity), true - case "ServiceCostSample.cost": - if e.ComplexityRoot.ServiceCostSample.Cost == nil { + case "ServiceAccount.tokens": + if e.ComplexityRoot.ServiceAccount.Tokens == nil { break } - return e.ComplexityRoot.ServiceCostSample.Cost(childComplexity), true - - case "ServiceCostSample.service": - if e.ComplexityRoot.ServiceCostSample.Service == nil { - break + args, err := ec.field_ServiceAccount_tokens_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ServiceCostSample.Service(childComplexity), true + return e.ComplexityRoot.ServiceAccount.Tokens(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "ServiceCostSeries.date": - if e.ComplexityRoot.ServiceCostSeries.Date == nil { + case "ServiceAccount.updatedAt": + if e.ComplexityRoot.ServiceAccount.UpdatedAt == nil { break } - return e.ComplexityRoot.ServiceCostSeries.Date(childComplexity), true + return e.ComplexityRoot.ServiceAccount.UpdatedAt(childComplexity), true - case "ServiceCostSeries.services": - if e.ComplexityRoot.ServiceCostSeries.Services == nil { + case "ServiceAccountConnection.edges": + if e.ComplexityRoot.ServiceAccountConnection.Edges == nil { break } - return e.ComplexityRoot.ServiceCostSeries.Services(childComplexity), true + return e.ComplexityRoot.ServiceAccountConnection.Edges(childComplexity), true - case "ServiceCostSeries.sum": - if e.ComplexityRoot.ServiceCostSeries.Sum == nil { + case "ServiceAccountConnection.nodes": + if e.ComplexityRoot.ServiceAccountConnection.Nodes == nil { break } - return e.ComplexityRoot.ServiceCostSeries.Sum(childComplexity), true + return e.ComplexityRoot.ServiceAccountConnection.Nodes(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.actor": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Actor == nil { + case "ServiceAccountConnection.pageInfo": + if e.ComplexityRoot.ServiceAccountConnection.PageInfo == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.ServiceAccountConnection.PageInfo(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.createdAt": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.CreatedAt == nil { + case "ServiceAccountCreatedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Actor(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.environmentName": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.EnvironmentName == nil { + case "ServiceAccountCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.id": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ID == nil { + case "ServiceAccountCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.message": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Message == nil { + case "ServiceAccountCreatedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ID(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.resourceName": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceName == nil { + case "ServiceAccountCreatedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.Message(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.resourceType": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceType == nil { + case "ServiceAccountCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceName(childComplexity), true - case "ServiceMaintenanceActivityLogEntry.teamSlug": - if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.TeamSlug == nil { + case "ServiceAccountCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.ResourceType(childComplexity), true - case "SetTeamMemberRolePayload.member": - if e.ComplexityRoot.SetTeamMemberRolePayload.Member == nil { + case "ServiceAccountCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SetTeamMemberRolePayload.Member(childComplexity), true + return e.ComplexityRoot.ServiceAccountCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "SqlDatabase.charset": - if e.ComplexityRoot.SqlDatabase.Charset == nil { + case "ServiceAccountDeletedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SqlDatabase.Charset(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Actor(childComplexity), true - case "SqlDatabase.collation": - if e.ComplexityRoot.SqlDatabase.Collation == nil { + case "ServiceAccountDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SqlDatabase.Collation(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "SqlDatabase.deletionPolicy": - if e.ComplexityRoot.SqlDatabase.DeletionPolicy == nil { + case "ServiceAccountDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SqlDatabase.DeletionPolicy(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "SqlDatabase.environment": - if e.ComplexityRoot.SqlDatabase.Environment == nil { + case "ServiceAccountDeletedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SqlDatabase.Environment(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ID(childComplexity), true - case "SqlDatabase.healthy": - if e.ComplexityRoot.SqlDatabase.Healthy == nil { + case "ServiceAccountDeletedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SqlDatabase.Healthy(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.Message(childComplexity), true - case "SqlDatabase.id": - if e.ComplexityRoot.SqlDatabase.ID == nil { + case "ServiceAccountDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SqlDatabase.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceName(childComplexity), true - case "SqlDatabase.name": - if e.ComplexityRoot.SqlDatabase.Name == nil { + case "ServiceAccountDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SqlDatabase.Name(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.ResourceType(childComplexity), true - case "SqlDatabase.team": - if e.ComplexityRoot.SqlDatabase.Team == nil { + case "ServiceAccountDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SqlDatabase.Team(childComplexity), true + return e.ComplexityRoot.ServiceAccountDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "SqlDatabase.teamEnvironment": - if e.ComplexityRoot.SqlDatabase.TeamEnvironment == nil { + case "ServiceAccountEdge.cursor": + if e.ComplexityRoot.ServiceAccountEdge.Cursor == nil { break } - return e.ComplexityRoot.SqlDatabase.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.ServiceAccountEdge.Cursor(childComplexity), true - case "SqlInstance.auditLog": - if e.ComplexityRoot.SqlInstance.AuditLog == nil { + case "ServiceAccountEdge.node": + if e.ComplexityRoot.ServiceAccountEdge.Node == nil { break } - return e.ComplexityRoot.SqlInstance.AuditLog(childComplexity), true + return e.ComplexityRoot.ServiceAccountEdge.Node(childComplexity), true - case "SqlInstance.backupConfiguration": - if e.ComplexityRoot.SqlInstance.BackupConfiguration == nil { + case "ServiceAccountToken.createdAt": + if e.ComplexityRoot.ServiceAccountToken.CreatedAt == nil { break } - return e.ComplexityRoot.SqlInstance.BackupConfiguration(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.CreatedAt(childComplexity), true - case "SqlInstance.cascadingDelete": - if e.ComplexityRoot.SqlInstance.CascadingDelete == nil { + case "ServiceAccountToken.description": + if e.ComplexityRoot.ServiceAccountToken.Description == nil { break } - return e.ComplexityRoot.SqlInstance.CascadingDelete(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.Description(childComplexity), true - case "SqlInstance.connectionName": - if e.ComplexityRoot.SqlInstance.ConnectionName == nil { + case "ServiceAccountToken.expiresAt": + if e.ComplexityRoot.ServiceAccountToken.ExpiresAt == nil { break } - return e.ComplexityRoot.SqlInstance.ConnectionName(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.ExpiresAt(childComplexity), true - case "SqlInstance.cost": - if e.ComplexityRoot.SqlInstance.Cost == nil { + case "ServiceAccountToken.id": + if e.ComplexityRoot.ServiceAccountToken.ID == nil { break } - return e.ComplexityRoot.SqlInstance.Cost(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.ID(childComplexity), true - case "SqlInstance.database": - if e.ComplexityRoot.SqlInstance.Database == nil { + case "ServiceAccountToken.lastUsedAt": + if e.ComplexityRoot.ServiceAccountToken.LastUsedAt == nil { break } - return e.ComplexityRoot.SqlInstance.Database(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.LastUsedAt(childComplexity), true - case "SqlInstance.diskAutoresize": - if e.ComplexityRoot.SqlInstance.DiskAutoresize == nil { + case "ServiceAccountToken.name": + if e.ComplexityRoot.ServiceAccountToken.Name == nil { break } - return e.ComplexityRoot.SqlInstance.DiskAutoresize(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.Name(childComplexity), true - case "SqlInstance.diskAutoresizeLimit": - if e.ComplexityRoot.SqlInstance.DiskAutoresizeLimit == nil { + case "ServiceAccountToken.updatedAt": + if e.ComplexityRoot.ServiceAccountToken.UpdatedAt == nil { break } - return e.ComplexityRoot.SqlInstance.DiskAutoresizeLimit(childComplexity), true + return e.ComplexityRoot.ServiceAccountToken.UpdatedAt(childComplexity), true - case "SqlInstance.environment": - if e.ComplexityRoot.SqlInstance.Environment == nil { + case "ServiceAccountTokenConnection.edges": + if e.ComplexityRoot.ServiceAccountTokenConnection.Edges == nil { break } - return e.ComplexityRoot.SqlInstance.Environment(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenConnection.Edges(childComplexity), true - case "SqlInstance.flags": - if e.ComplexityRoot.SqlInstance.Flags == nil { + case "ServiceAccountTokenConnection.nodes": + if e.ComplexityRoot.ServiceAccountTokenConnection.Nodes == nil { break } - args, err := ec.field_SqlInstance_flags_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.SqlInstance.Flags(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.ServiceAccountTokenConnection.Nodes(childComplexity), true - case "SqlInstance.healthy": - if e.ComplexityRoot.SqlInstance.Healthy == nil { + case "ServiceAccountTokenConnection.pageInfo": + if e.ComplexityRoot.ServiceAccountTokenConnection.PageInfo == nil { break } - return e.ComplexityRoot.SqlInstance.Healthy(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenConnection.PageInfo(childComplexity), true - case "SqlInstance.highAvailability": - if e.ComplexityRoot.SqlInstance.HighAvailability == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SqlInstance.HighAvailability(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Actor(childComplexity), true - case "SqlInstance.id": - if e.ComplexityRoot.SqlInstance.ID == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SqlInstance.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "SqlInstance.issues": - if e.ComplexityRoot.SqlInstance.Issues == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.data": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Data == nil { break } - args, err := ec.field_SqlInstance_issues_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.SqlInstance.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Data(childComplexity), true - case "SqlInstance.maintenanceVersion": - if e.ComplexityRoot.SqlInstance.MaintenanceVersion == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SqlInstance.MaintenanceVersion(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "SqlInstance.maintenanceWindow": - if e.ComplexityRoot.SqlInstance.MaintenanceWindow == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SqlInstance.MaintenanceWindow(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ID(childComplexity), true - case "SqlInstance.metrics": - if e.ComplexityRoot.SqlInstance.Metrics == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SqlInstance.Metrics(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.Message(childComplexity), true - case "SqlInstance.name": - if e.ComplexityRoot.SqlInstance.Name == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SqlInstance.Name(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceName(childComplexity), true - case "SqlInstance.projectID": - if e.ComplexityRoot.SqlInstance.ProjectID == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SqlInstance.ProjectID(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.ResourceType(childComplexity), true - case "SqlInstance.state": - if e.ComplexityRoot.SqlInstance.State == nil { + case "ServiceAccountTokenCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SqlInstance.State(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "SqlInstance.status": - if e.ComplexityRoot.SqlInstance.Status == nil { + case "ServiceAccountTokenCreatedActivityLogEntryData.tokenName": + if e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntryData.TokenName == nil { break } - return e.ComplexityRoot.SqlInstance.Status(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenCreatedActivityLogEntryData.TokenName(childComplexity), true - case "SqlInstance.team": - if e.ComplexityRoot.SqlInstance.Team == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SqlInstance.Team(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Actor(childComplexity), true - case "SqlInstance.teamEnvironment": - if e.ComplexityRoot.SqlInstance.TeamEnvironment == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SqlInstance.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "SqlInstance.tier": - if e.ComplexityRoot.SqlInstance.Tier == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.data": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SqlInstance.Tier(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Data(childComplexity), true - case "SqlInstance.users": - if e.ComplexityRoot.SqlInstance.Users == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.EnvironmentName == nil { break } - args, err := ec.field_SqlInstance_users_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.SqlInstance.Users(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*sqlinstance.SQLInstanceUserOrder)), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "SqlInstance.version": - if e.ComplexityRoot.SqlInstance.Version == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SqlInstance.Version(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ID(childComplexity), true - case "SqlInstance.workload": - if e.ComplexityRoot.SqlInstance.Workload == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SqlInstance.Workload(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.Message(childComplexity), true - case "SqlInstanceBackupConfiguration.enabled": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.Enabled == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.Enabled(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceName(childComplexity), true - case "SqlInstanceBackupConfiguration.pointInTimeRecovery": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.PointInTimeRecovery == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.PointInTimeRecovery(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.ResourceType(childComplexity), true - case "SqlInstanceBackupConfiguration.retainedBackups": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.RetainedBackups == nil { + case "ServiceAccountTokenDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.RetainedBackups(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "SqlInstanceBackupConfiguration.startTime": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.StartTime == nil { + case "ServiceAccountTokenDeletedActivityLogEntryData.tokenName": + if e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntryData.TokenName == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.StartTime(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenDeletedActivityLogEntryData.TokenName(childComplexity), true - case "SqlInstanceBackupConfiguration.transactionLogRetentionDays": - if e.ComplexityRoot.SqlInstanceBackupConfiguration.TransactionLogRetentionDays == nil { + case "ServiceAccountTokenEdge.cursor": + if e.ComplexityRoot.ServiceAccountTokenEdge.Cursor == nil { break } - return e.ComplexityRoot.SqlInstanceBackupConfiguration.TransactionLogRetentionDays(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenEdge.Cursor(childComplexity), true - case "SqlInstanceConnection.edges": - if e.ComplexityRoot.SqlInstanceConnection.Edges == nil { + case "ServiceAccountTokenEdge.node": + if e.ComplexityRoot.ServiceAccountTokenEdge.Node == nil { break } - return e.ComplexityRoot.SqlInstanceConnection.Edges(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenEdge.Node(childComplexity), true - case "SqlInstanceConnection.nodes": - if e.ComplexityRoot.SqlInstanceConnection.Nodes == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SqlInstanceConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Actor(childComplexity), true - case "SqlInstanceConnection.pageInfo": - if e.ComplexityRoot.SqlInstanceConnection.PageInfo == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SqlInstanceConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "SqlInstanceCost.sum": - if e.ComplexityRoot.SqlInstanceCost.Sum == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.data": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SqlInstanceCost.Sum(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Data(childComplexity), true - case "SqlInstanceCpu.cores": - if e.ComplexityRoot.SqlInstanceCpu.Cores == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SqlInstanceCpu.Cores(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "SqlInstanceCpu.utilization": - if e.ComplexityRoot.SqlInstanceCpu.Utilization == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SqlInstanceCpu.Utilization(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ID(childComplexity), true - case "SqlInstanceDisk.quotaBytes": - if e.ComplexityRoot.SqlInstanceDisk.QuotaBytes == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SqlInstanceDisk.QuotaBytes(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.Message(childComplexity), true - case "SqlInstanceDisk.utilization": - if e.ComplexityRoot.SqlInstanceDisk.Utilization == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SqlInstanceDisk.Utilization(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "SqlInstanceEdge.cursor": - if e.ComplexityRoot.SqlInstanceEdge.Cursor == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SqlInstanceEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "SqlInstanceEdge.node": - if e.ComplexityRoot.SqlInstanceEdge.Node == nil { + case "ServiceAccountTokenUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SqlInstanceEdge.Node(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "SqlInstanceFlag.name": - if e.ComplexityRoot.SqlInstanceFlag.Name == nil { + case "ServiceAccountTokenUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.SqlInstanceFlag.Name(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "SqlInstanceFlag.value": - if e.ComplexityRoot.SqlInstanceFlag.Value == nil { + case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.SqlInstanceFlag.Value(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "SqlInstanceFlagConnection.edges": - if e.ComplexityRoot.SqlInstanceFlagConnection.Edges == nil { + case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.SqlInstanceFlagConnection.Edges(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "SqlInstanceFlagConnection.nodes": - if e.ComplexityRoot.SqlInstanceFlagConnection.Nodes == nil { + case "ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.SqlInstanceFlagConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ServiceAccountTokenUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "SqlInstanceFlagConnection.pageInfo": - if e.ComplexityRoot.SqlInstanceFlagConnection.PageInfo == nil { + case "ServiceAccountUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SqlInstanceFlagConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Actor(childComplexity), true - case "SqlInstanceFlagEdge.cursor": - if e.ComplexityRoot.SqlInstanceFlagEdge.Cursor == nil { + case "ServiceAccountUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SqlInstanceFlagEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "SqlInstanceFlagEdge.node": - if e.ComplexityRoot.SqlInstanceFlagEdge.Node == nil { + case "ServiceAccountUpdatedActivityLogEntry.data": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.SqlInstanceFlagEdge.Node(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Data(childComplexity), true - case "SqlInstanceMaintenanceWindow.day": - if e.ComplexityRoot.SqlInstanceMaintenanceWindow.Day == nil { + case "ServiceAccountUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SqlInstanceMaintenanceWindow.Day(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "SqlInstanceMaintenanceWindow.hour": - if e.ComplexityRoot.SqlInstanceMaintenanceWindow.Hour == nil { + case "ServiceAccountUpdatedActivityLogEntry.id": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SqlInstanceMaintenanceWindow.Hour(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ID(childComplexity), true - case "SqlInstanceMemory.quotaBytes": - if e.ComplexityRoot.SqlInstanceMemory.QuotaBytes == nil { + case "ServiceAccountUpdatedActivityLogEntry.message": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SqlInstanceMemory.QuotaBytes(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.Message(childComplexity), true - case "SqlInstanceMemory.utilization": - if e.ComplexityRoot.SqlInstanceMemory.Utilization == nil { + case "ServiceAccountUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SqlInstanceMemory.Utilization(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "SqlInstanceMetrics.cpu": - if e.ComplexityRoot.SqlInstanceMetrics.CPU == nil { + case "ServiceAccountUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SqlInstanceMetrics.CPU(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "SqlInstanceMetrics.disk": - if e.ComplexityRoot.SqlInstanceMetrics.Disk == nil { + case "ServiceAccountUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SqlInstanceMetrics.Disk(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "SqlInstanceMetrics.memory": - if e.ComplexityRoot.SqlInstanceMetrics.Memory == nil { + case "ServiceAccountUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.SqlInstanceMetrics.Memory(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "SqlInstanceStateIssue.id": - if e.ComplexityRoot.SqlInstanceStateIssue.ID == nil { + case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.ID(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "SqlInstanceStateIssue.message": - if e.ComplexityRoot.SqlInstanceStateIssue.Message == nil { + case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.Message(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "SqlInstanceStateIssue.sqlInstance": - if e.ComplexityRoot.SqlInstanceStateIssue.SQLInstance == nil { + case "ServiceAccountUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.SQLInstance(childComplexity), true + return e.ComplexityRoot.ServiceAccountUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "SqlInstanceStateIssue.severity": - if e.ComplexityRoot.SqlInstanceStateIssue.Severity == nil { + case "ServiceCostSample.cost": + if e.ComplexityRoot.ServiceCostSample.Cost == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.Severity(childComplexity), true + return e.ComplexityRoot.ServiceCostSample.Cost(childComplexity), true - case "SqlInstanceStateIssue.state": - if e.ComplexityRoot.SqlInstanceStateIssue.State == nil { + case "ServiceCostSample.service": + if e.ComplexityRoot.ServiceCostSample.Service == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.State(childComplexity), true + return e.ComplexityRoot.ServiceCostSample.Service(childComplexity), true - case "SqlInstanceStateIssue.teamEnvironment": - if e.ComplexityRoot.SqlInstanceStateIssue.TeamEnvironment == nil { + case "ServiceCostSeries.date": + if e.ComplexityRoot.ServiceCostSeries.Date == nil { break } - return e.ComplexityRoot.SqlInstanceStateIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.ServiceCostSeries.Date(childComplexity), true - case "SqlInstanceStatus.privateIpAddress": - if e.ComplexityRoot.SqlInstanceStatus.PrivateIPAddress == nil { + case "ServiceCostSeries.services": + if e.ComplexityRoot.ServiceCostSeries.Services == nil { break } - return e.ComplexityRoot.SqlInstanceStatus.PrivateIPAddress(childComplexity), true + return e.ComplexityRoot.ServiceCostSeries.Services(childComplexity), true - case "SqlInstanceStatus.publicIpAddress": - if e.ComplexityRoot.SqlInstanceStatus.PublicIPAddress == nil { + case "ServiceCostSeries.sum": + if e.ComplexityRoot.ServiceCostSeries.Sum == nil { break } - return e.ComplexityRoot.SqlInstanceStatus.PublicIPAddress(childComplexity), true + return e.ComplexityRoot.ServiceCostSeries.Sum(childComplexity), true - case "SqlInstanceUser.authentication": - if e.ComplexityRoot.SqlInstanceUser.Authentication == nil { + case "ServiceMaintenanceActivityLogEntry.actor": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.SqlInstanceUser.Authentication(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Actor(childComplexity), true - case "SqlInstanceUser.name": - if e.ComplexityRoot.SqlInstanceUser.Name == nil { + case "ServiceMaintenanceActivityLogEntry.createdAt": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.SqlInstanceUser.Name(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.CreatedAt(childComplexity), true - case "SqlInstanceUserConnection.edges": - if e.ComplexityRoot.SqlInstanceUserConnection.Edges == nil { + case "ServiceMaintenanceActivityLogEntry.environmentName": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.SqlInstanceUserConnection.Edges(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.EnvironmentName(childComplexity), true - case "SqlInstanceUserConnection.nodes": - if e.ComplexityRoot.SqlInstanceUserConnection.Nodes == nil { + case "ServiceMaintenanceActivityLogEntry.id": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.SqlInstanceUserConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ID(childComplexity), true - case "SqlInstanceUserConnection.pageInfo": - if e.ComplexityRoot.SqlInstanceUserConnection.PageInfo == nil { + case "ServiceMaintenanceActivityLogEntry.message": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.SqlInstanceUserConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.Message(childComplexity), true - case "SqlInstanceUserEdge.cursor": - if e.ComplexityRoot.SqlInstanceUserEdge.Cursor == nil { + case "ServiceMaintenanceActivityLogEntry.resourceName": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.SqlInstanceUserEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceName(childComplexity), true - case "SqlInstanceUserEdge.node": - if e.ComplexityRoot.SqlInstanceUserEdge.Node == nil { + case "ServiceMaintenanceActivityLogEntry.resourceType": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.SqlInstanceUserEdge.Node(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.ResourceType(childComplexity), true - case "SqlInstanceVersionIssue.id": - if e.ComplexityRoot.SqlInstanceVersionIssue.ID == nil { + case "ServiceMaintenanceActivityLogEntry.teamSlug": + if e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.SqlInstanceVersionIssue.ID(childComplexity), true + return e.ComplexityRoot.ServiceMaintenanceActivityLogEntry.TeamSlug(childComplexity), true - case "SqlInstanceVersionIssue.message": - if e.ComplexityRoot.SqlInstanceVersionIssue.Message == nil { + case "SetTeamMemberRolePayload.member": + if e.ComplexityRoot.SetTeamMemberRolePayload.Member == nil { break } - return e.ComplexityRoot.SqlInstanceVersionIssue.Message(childComplexity), true + return e.ComplexityRoot.SetTeamMemberRolePayload.Member(childComplexity), true - case "SqlInstanceVersionIssue.sqlInstance": - if e.ComplexityRoot.SqlInstanceVersionIssue.SQLInstance == nil { + case "SqlDatabase.charset": + if e.ComplexityRoot.SqlDatabase.Charset == nil { break } - return e.ComplexityRoot.SqlInstanceVersionIssue.SQLInstance(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Charset(childComplexity), true - case "SqlInstanceVersionIssue.severity": - if e.ComplexityRoot.SqlInstanceVersionIssue.Severity == nil { - break + case "SqlDatabase.collation": + if e.ComplexityRoot.SqlDatabase.Collation == nil { + break } - return e.ComplexityRoot.SqlInstanceVersionIssue.Severity(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Collation(childComplexity), true - case "SqlInstanceVersionIssue.teamEnvironment": - if e.ComplexityRoot.SqlInstanceVersionIssue.TeamEnvironment == nil { + case "SqlDatabase.deletionPolicy": + if e.ComplexityRoot.SqlDatabase.DeletionPolicy == nil { break } - return e.ComplexityRoot.SqlInstanceVersionIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.SqlDatabase.DeletionPolicy(childComplexity), true - case "StartOpenSearchMaintenancePayload.error": - if e.ComplexityRoot.StartOpenSearchMaintenancePayload.Error == nil { + case "SqlDatabase.environment": + if e.ComplexityRoot.SqlDatabase.Environment == nil { break } - return e.ComplexityRoot.StartOpenSearchMaintenancePayload.Error(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Environment(childComplexity), true - case "StartValkeyMaintenancePayload.error": - if e.ComplexityRoot.StartValkeyMaintenancePayload.Error == nil { + case "SqlDatabase.healthy": + if e.ComplexityRoot.SqlDatabase.Healthy == nil { break } - return e.ComplexityRoot.StartValkeyMaintenancePayload.Error(childComplexity), true + return e.ComplexityRoot.SqlDatabase.Healthy(childComplexity), true - case "Subscription.log": - if e.ComplexityRoot.Subscription.Log == nil { + case "SqlDatabase.id": + if e.ComplexityRoot.SqlDatabase.ID == nil { break } - args, err := ec.field_Subscription_log_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Subscription.Log(childComplexity, args["filter"].(loki.LogSubscriptionFilter)), true + return e.ComplexityRoot.SqlDatabase.ID(childComplexity), true - case "Subscription.workloadLog": - if e.ComplexityRoot.Subscription.WorkloadLog == nil { + case "SqlDatabase.name": + if e.ComplexityRoot.SqlDatabase.Name == nil { break } - args, err := ec.field_Subscription_workloadLog_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Subscription.WorkloadLog(childComplexity, args["filter"].(podlog.WorkloadLogSubscriptionFilter)), true + return e.ComplexityRoot.SqlDatabase.Name(childComplexity), true - case "Team.activityLog": - if e.ComplexityRoot.Team.ActivityLog == nil { + case "SqlDatabase.team": + if e.ComplexityRoot.SqlDatabase.Team == nil { break } - args, err := ec.field_Team_activityLog_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlDatabase.Team(childComplexity), true + + case "SqlDatabase.teamEnvironment": + if e.ComplexityRoot.SqlDatabase.TeamEnvironment == nil { + break } - return e.ComplexityRoot.Team.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.SqlDatabase.TeamEnvironment(childComplexity), true - case "Team.alerts": - if e.ComplexityRoot.Team.Alerts == nil { + case "SqlInstance.auditLog": + if e.ComplexityRoot.SqlInstance.AuditLog == nil { break } - args, err := ec.field_Team_alerts_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.AuditLog(childComplexity), true + + case "SqlInstance.backupConfiguration": + if e.ComplexityRoot.SqlInstance.BackupConfiguration == nil { + break } - return e.ComplexityRoot.Team.Alerts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*alerts.AlertOrder), args["filter"].(*alerts.TeamAlertsFilter)), true + return e.ComplexityRoot.SqlInstance.BackupConfiguration(childComplexity), true - case "Team.applications": - if e.ComplexityRoot.Team.Applications == nil { + case "SqlInstance.cascadingDelete": + if e.ComplexityRoot.SqlInstance.CascadingDelete == nil { break } - args, err := ec.field_Team_applications_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.CascadingDelete(childComplexity), true + + case "SqlInstance.connectionName": + if e.ComplexityRoot.SqlInstance.ConnectionName == nil { + break } - return e.ComplexityRoot.Team.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*application.ApplicationOrder), args["filter"].(*application.TeamApplicationsFilter)), true + return e.ComplexityRoot.SqlInstance.ConnectionName(childComplexity), true - case "Team.bigQueryDatasets": - if e.ComplexityRoot.Team.BigQueryDatasets == nil { + case "SqlInstance.cost": + if e.ComplexityRoot.SqlInstance.Cost == nil { break } - args, err := ec.field_Team_bigQueryDatasets_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.Cost(childComplexity), true + + case "SqlInstance.database": + if e.ComplexityRoot.SqlInstance.Database == nil { + break } - return e.ComplexityRoot.Team.BigQueryDatasets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*bigquery.BigQueryDatasetOrder)), true + return e.ComplexityRoot.SqlInstance.Database(childComplexity), true - case "Team.buckets": - if e.ComplexityRoot.Team.Buckets == nil { + case "SqlInstance.diskAutoresize": + if e.ComplexityRoot.SqlInstance.DiskAutoresize == nil { break } - args, err := ec.field_Team_buckets_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.DiskAutoresize(childComplexity), true + + case "SqlInstance.diskAutoresizeLimit": + if e.ComplexityRoot.SqlInstance.DiskAutoresizeLimit == nil { + break } - return e.ComplexityRoot.Team.Buckets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*bucket.BucketOrder)), true + return e.ComplexityRoot.SqlInstance.DiskAutoresizeLimit(childComplexity), true - case "Team.cost": - if e.ComplexityRoot.Team.Cost == nil { + case "SqlInstance.environment": + if e.ComplexityRoot.SqlInstance.Environment == nil { break } - return e.ComplexityRoot.Team.Cost(childComplexity), true + return e.ComplexityRoot.SqlInstance.Environment(childComplexity), true - case "Team.deleteKey": - if e.ComplexityRoot.Team.DeleteKey == nil { + case "SqlInstance.flags": + if e.ComplexityRoot.SqlInstance.Flags == nil { break } - args, err := ec.field_Team_deleteKey_args(ctx, rawArgs) + args, err := ec.field_SqlInstance_flags_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Team.DeleteKey(childComplexity, args["key"].(string)), true + return e.ComplexityRoot.SqlInstance.Flags(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "Team.deletionInProgress": - if e.ComplexityRoot.Team.DeletionInProgress == nil { + case "SqlInstance.healthy": + if e.ComplexityRoot.SqlInstance.Healthy == nil { break } - return e.ComplexityRoot.Team.DeletionInProgress(childComplexity), true + return e.ComplexityRoot.SqlInstance.Healthy(childComplexity), true - case "Team.deploymentKey": - if e.ComplexityRoot.Team.DeploymentKey == nil { + case "SqlInstance.highAvailability": + if e.ComplexityRoot.SqlInstance.HighAvailability == nil { break } - return e.ComplexityRoot.Team.DeploymentKey(childComplexity), true + return e.ComplexityRoot.SqlInstance.HighAvailability(childComplexity), true - case "Team.deployments": - if e.ComplexityRoot.Team.Deployments == nil { + case "SqlInstance.id": + if e.ComplexityRoot.SqlInstance.ID == nil { break } - args, err := ec.field_Team_deployments_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.SqlInstance.ID(childComplexity), true - case "Team.environment": - if e.ComplexityRoot.Team.Environment == nil { + case "SqlInstance.issues": + if e.ComplexityRoot.SqlInstance.Issues == nil { break } - args, err := ec.field_Team_environment_args(ctx, rawArgs) + args, err := ec.field_SqlInstance_issues_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Team.Environment(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.SqlInstance.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true - case "Team.environments": - if e.ComplexityRoot.Team.Environments == nil { + case "SqlInstance.maintenanceVersion": + if e.ComplexityRoot.SqlInstance.MaintenanceVersion == nil { break } - return e.ComplexityRoot.Team.Environments(childComplexity), true + return e.ComplexityRoot.SqlInstance.MaintenanceVersion(childComplexity), true - case "Team.externalResources": - if e.ComplexityRoot.Team.ExternalResources == nil { + case "SqlInstance.maintenanceWindow": + if e.ComplexityRoot.SqlInstance.MaintenanceWindow == nil { break } - return e.ComplexityRoot.Team.ExternalResources(childComplexity), true + return e.ComplexityRoot.SqlInstance.MaintenanceWindow(childComplexity), true - case "Team.id": - if e.ComplexityRoot.Team.ID == nil { + case "SqlInstance.metrics": + if e.ComplexityRoot.SqlInstance.Metrics == nil { break } - return e.ComplexityRoot.Team.ID(childComplexity), true + return e.ComplexityRoot.SqlInstance.Metrics(childComplexity), true - case "Team.imageVulnerabilityHistory": - if e.ComplexityRoot.Team.ImageVulnerabilityHistory == nil { + case "SqlInstance.name": + if e.ComplexityRoot.SqlInstance.Name == nil { break } - args, err := ec.field_Team_imageVulnerabilityHistory_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.Name(childComplexity), true + + case "SqlInstance.projectID": + if e.ComplexityRoot.SqlInstance.ProjectID == nil { + break } - return e.ComplexityRoot.Team.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.SqlInstance.ProjectID(childComplexity), true - case "Team.inventoryCounts": - if e.ComplexityRoot.Team.InventoryCounts == nil { + case "SqlInstance.state": + if e.ComplexityRoot.SqlInstance.State == nil { break } - return e.ComplexityRoot.Team.InventoryCounts(childComplexity), true + return e.ComplexityRoot.SqlInstance.State(childComplexity), true - case "Team.issues": - if e.ComplexityRoot.Team.Issues == nil { + case "SqlInstance.status": + if e.ComplexityRoot.SqlInstance.Status == nil { break } - args, err := ec.field_Team_issues_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.Status(childComplexity), true + + case "SqlInstance.team": + if e.ComplexityRoot.SqlInstance.Team == nil { + break } - return e.ComplexityRoot.Team.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.IssueFilter)), true + return e.ComplexityRoot.SqlInstance.Team(childComplexity), true - case "Team.jobs": - if e.ComplexityRoot.Team.Jobs == nil { + case "SqlInstance.teamEnvironment": + if e.ComplexityRoot.SqlInstance.TeamEnvironment == nil { break } - args, err := ec.field_Team_jobs_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstance.TeamEnvironment(childComplexity), true + + case "SqlInstance.tier": + if e.ComplexityRoot.SqlInstance.Tier == nil { + break } - return e.ComplexityRoot.Team.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*job.JobOrder), args["filter"].(*job.TeamJobsFilter)), true + return e.ComplexityRoot.SqlInstance.Tier(childComplexity), true - case "Team.kafkaTopics": - if e.ComplexityRoot.Team.KafkaTopics == nil { + case "SqlInstance.users": + if e.ComplexityRoot.SqlInstance.Users == nil { break } - args, err := ec.field_Team_kafkaTopics_args(ctx, rawArgs) + args, err := ec.field_SqlInstance_users_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Team.KafkaTopics(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*kafkatopic.KafkaTopicOrder)), true + return e.ComplexityRoot.SqlInstance.Users(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*sqlinstance.SQLInstanceUserOrder)), true - case "Team.lastSuccessfulSync": - if e.ComplexityRoot.Team.LastSuccessfulSync == nil { + case "SqlInstance.version": + if e.ComplexityRoot.SqlInstance.Version == nil { break } - return e.ComplexityRoot.Team.LastSuccessfulSync(childComplexity), true + return e.ComplexityRoot.SqlInstance.Version(childComplexity), true - case "Team.member": - if e.ComplexityRoot.Team.Member == nil { + case "SqlInstance.workload": + if e.ComplexityRoot.SqlInstance.Workload == nil { break } - args, err := ec.field_Team_member_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Member(childComplexity, args["email"].(string)), true + return e.ComplexityRoot.SqlInstance.Workload(childComplexity), true - case "Team.members": - if e.ComplexityRoot.Team.Members == nil { + case "SqlInstanceBackupConfiguration.enabled": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.Enabled == nil { break } - args, err := ec.field_Team_members_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Members(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.TeamMemberOrder)), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.Enabled(childComplexity), true - case "Team.openSearches": - if e.ComplexityRoot.Team.OpenSearches == nil { + case "SqlInstanceBackupConfiguration.pointInTimeRecovery": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.PointInTimeRecovery == nil { break } - args, err := ec.field_Team_openSearches_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.OpenSearches(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*opensearch.OpenSearchOrder)), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.PointInTimeRecovery(childComplexity), true - case "Team.postgresInstances": - if e.ComplexityRoot.Team.PostgresInstances == nil { + case "SqlInstanceBackupConfiguration.retainedBackups": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.RetainedBackups == nil { break } - args, err := ec.field_Team_postgresInstances_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.PostgresInstances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*postgres.PostgresInstanceOrder)), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.RetainedBackups(childComplexity), true - case "Team.purpose": - if e.ComplexityRoot.Team.Purpose == nil { + case "SqlInstanceBackupConfiguration.startTime": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.StartTime == nil { break } - return e.ComplexityRoot.Team.Purpose(childComplexity), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.StartTime(childComplexity), true - case "Team.repositories": - if e.ComplexityRoot.Team.Repositories == nil { + case "SqlInstanceBackupConfiguration.transactionLogRetentionDays": + if e.ComplexityRoot.SqlInstanceBackupConfiguration.TransactionLogRetentionDays == nil { break } - args, err := ec.field_Team_repositories_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Repositories(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*repository.RepositoryOrder), args["filter"].(*repository.TeamRepositoryFilter)), true + return e.ComplexityRoot.SqlInstanceBackupConfiguration.TransactionLogRetentionDays(childComplexity), true - case "Team.sqlInstances": - if e.ComplexityRoot.Team.SQLInstances == nil { + case "SqlInstanceConnection.edges": + if e.ComplexityRoot.SqlInstanceConnection.Edges == nil { break } - args, err := ec.field_Team_sqlInstances_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.SQLInstances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*sqlinstance.SQLInstanceOrder)), true + return e.ComplexityRoot.SqlInstanceConnection.Edges(childComplexity), true - case "Team.secrets": - if e.ComplexityRoot.Team.Secrets == nil { + case "SqlInstanceConnection.nodes": + if e.ComplexityRoot.SqlInstanceConnection.Nodes == nil { break } - args, err := ec.field_Team_secrets_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Secrets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*secret.SecretOrder), args["filter"].(*secret.SecretFilter)), true + return e.ComplexityRoot.SqlInstanceConnection.Nodes(childComplexity), true - case "Team.serviceUtilization": - if e.ComplexityRoot.Team.ServiceUtilization == nil { + case "SqlInstanceConnection.pageInfo": + if e.ComplexityRoot.SqlInstanceConnection.PageInfo == nil { break } - return e.ComplexityRoot.Team.ServiceUtilization(childComplexity), true + return e.ComplexityRoot.SqlInstanceConnection.PageInfo(childComplexity), true - case "Team.slackChannel": - if e.ComplexityRoot.Team.SlackChannel == nil { + case "SqlInstanceCost.sum": + if e.ComplexityRoot.SqlInstanceCost.Sum == nil { break } - return e.ComplexityRoot.Team.SlackChannel(childComplexity), true + return e.ComplexityRoot.SqlInstanceCost.Sum(childComplexity), true - case "Team.slug": - if e.ComplexityRoot.Team.Slug == nil { + case "SqlInstanceCpu.cores": + if e.ComplexityRoot.SqlInstanceCpu.Cores == nil { break } - return e.ComplexityRoot.Team.Slug(childComplexity), true + return e.ComplexityRoot.SqlInstanceCpu.Cores(childComplexity), true - case "Team.unleash": - if e.ComplexityRoot.Team.Unleash == nil { + case "SqlInstanceCpu.utilization": + if e.ComplexityRoot.SqlInstanceCpu.Utilization == nil { break } - return e.ComplexityRoot.Team.Unleash(childComplexity), true + return e.ComplexityRoot.SqlInstanceCpu.Utilization(childComplexity), true - case "Team.valkeys": - if e.ComplexityRoot.Team.Valkeys == nil { + case "SqlInstanceDisk.quotaBytes": + if e.ComplexityRoot.SqlInstanceDisk.QuotaBytes == nil { break } - args, err := ec.field_Team_valkeys_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Team.Valkeys(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*valkey.ValkeyOrder)), true + return e.ComplexityRoot.SqlInstanceDisk.QuotaBytes(childComplexity), true - case "Team.viewerIsMember": - if e.ComplexityRoot.Team.ViewerIsMember == nil { + case "SqlInstanceDisk.utilization": + if e.ComplexityRoot.SqlInstanceDisk.Utilization == nil { break } - return e.ComplexityRoot.Team.ViewerIsMember(childComplexity), true + return e.ComplexityRoot.SqlInstanceDisk.Utilization(childComplexity), true - case "Team.viewerIsOwner": - if e.ComplexityRoot.Team.ViewerIsOwner == nil { + case "SqlInstanceEdge.cursor": + if e.ComplexityRoot.SqlInstanceEdge.Cursor == nil { break } - return e.ComplexityRoot.Team.ViewerIsOwner(childComplexity), true + return e.ComplexityRoot.SqlInstanceEdge.Cursor(childComplexity), true - case "Team.vulnerabilityFixHistory": - if e.ComplexityRoot.Team.VulnerabilityFixHistory == nil { + case "SqlInstanceEdge.node": + if e.ComplexityRoot.SqlInstanceEdge.Node == nil { break } - args, err := ec.field_Team_vulnerabilityFixHistory_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstanceEdge.Node(childComplexity), true + + case "SqlInstanceFlag.name": + if e.ComplexityRoot.SqlInstanceFlag.Name == nil { + break } - return e.ComplexityRoot.Team.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true + return e.ComplexityRoot.SqlInstanceFlag.Name(childComplexity), true - case "Team.vulnerabilitySummaries": - if e.ComplexityRoot.Team.VulnerabilitySummaries == nil { + case "SqlInstanceFlag.value": + if e.ComplexityRoot.SqlInstanceFlag.Value == nil { break } - args, err := ec.field_Team_vulnerabilitySummaries_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstanceFlag.Value(childComplexity), true + + case "SqlInstanceFlagConnection.edges": + if e.ComplexityRoot.SqlInstanceFlagConnection.Edges == nil { + break } - return e.ComplexityRoot.Team.VulnerabilitySummaries(childComplexity, args["filter"].(*vulnerability.TeamVulnerabilitySummaryFilter), args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*vulnerability.VulnerabilitySummaryOrder)), true + return e.ComplexityRoot.SqlInstanceFlagConnection.Edges(childComplexity), true - case "Team.vulnerabilitySummary": - if e.ComplexityRoot.Team.VulnerabilitySummary == nil { + case "SqlInstanceFlagConnection.nodes": + if e.ComplexityRoot.SqlInstanceFlagConnection.Nodes == nil { break } - args, err := ec.field_Team_vulnerabilitySummary_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstanceFlagConnection.Nodes(childComplexity), true + + case "SqlInstanceFlagConnection.pageInfo": + if e.ComplexityRoot.SqlInstanceFlagConnection.PageInfo == nil { + break } - return e.ComplexityRoot.Team.VulnerabilitySummary(childComplexity, args["filter"].(*vulnerability.TeamVulnerabilitySummaryFilter)), true + return e.ComplexityRoot.SqlInstanceFlagConnection.PageInfo(childComplexity), true - case "Team.workloadUtilization": - if e.ComplexityRoot.Team.WorkloadUtilization == nil { + case "SqlInstanceFlagEdge.cursor": + if e.ComplexityRoot.SqlInstanceFlagEdge.Cursor == nil { break } - args, err := ec.field_Team_workloadUtilization_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstanceFlagEdge.Cursor(childComplexity), true + + case "SqlInstanceFlagEdge.node": + if e.ComplexityRoot.SqlInstanceFlagEdge.Node == nil { + break } - return e.ComplexityRoot.Team.WorkloadUtilization(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + return e.ComplexityRoot.SqlInstanceFlagEdge.Node(childComplexity), true - case "Team.workloads": - if e.ComplexityRoot.Team.Workloads == nil { + case "SqlInstanceMaintenanceWindow.day": + if e.ComplexityRoot.SqlInstanceMaintenanceWindow.Day == nil { break } - args, err := ec.field_Team_workloads_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.SqlInstanceMaintenanceWindow.Day(childComplexity), true + + case "SqlInstanceMaintenanceWindow.hour": + if e.ComplexityRoot.SqlInstanceMaintenanceWindow.Hour == nil { + break } - return e.ComplexityRoot.Team.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*workload.WorkloadOrder), args["filter"].(*workload.TeamWorkloadsFilter)), true + return e.ComplexityRoot.SqlInstanceMaintenanceWindow.Hour(childComplexity), true - case "TeamCDN.bucket": - if e.ComplexityRoot.TeamCDN.Bucket == nil { + case "SqlInstanceMemory.quotaBytes": + if e.ComplexityRoot.SqlInstanceMemory.QuotaBytes == nil { break } - return e.ComplexityRoot.TeamCDN.Bucket(childComplexity), true + return e.ComplexityRoot.SqlInstanceMemory.QuotaBytes(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.actor": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Actor == nil { + case "SqlInstanceMemory.utilization": + if e.ComplexityRoot.SqlInstanceMemory.Utilization == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SqlInstanceMemory.Utilization(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.CreatedAt == nil { + case "SqlInstanceMetrics.cpu": + if e.ComplexityRoot.SqlInstanceMetrics.CPU == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SqlInstanceMetrics.CPU(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.EnvironmentName == nil { + case "SqlInstanceMetrics.disk": + if e.ComplexityRoot.SqlInstanceMetrics.Disk == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SqlInstanceMetrics.Disk(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.id": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ID == nil { + case "SqlInstanceMetrics.memory": + if e.ComplexityRoot.SqlInstanceMetrics.Memory == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SqlInstanceMetrics.Memory(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.message": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Message == nil { + case "SqlInstanceStateIssue.id": + if e.ComplexityRoot.SqlInstanceStateIssue.ID == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.ID(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceName == nil { + case "SqlInstanceStateIssue.message": + if e.ComplexityRoot.SqlInstanceStateIssue.Message == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.Message(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceType == nil { + case "SqlInstanceStateIssue.sqlInstance": + if e.ComplexityRoot.SqlInstanceStateIssue.SQLInstance == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.SQLInstance(childComplexity), true - case "TeamConfirmDeleteKeyActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.TeamSlug == nil { + case "SqlInstanceStateIssue.severity": + if e.ComplexityRoot.SqlInstanceStateIssue.Severity == nil { break } - return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.Severity(childComplexity), true - case "TeamConnection.edges": - if e.ComplexityRoot.TeamConnection.Edges == nil { + case "SqlInstanceStateIssue.state": + if e.ComplexityRoot.SqlInstanceStateIssue.State == nil { break } - return e.ComplexityRoot.TeamConnection.Edges(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.State(childComplexity), true - case "TeamConnection.nodes": - if e.ComplexityRoot.TeamConnection.Nodes == nil { + case "SqlInstanceStateIssue.teamEnvironment": + if e.ComplexityRoot.SqlInstanceStateIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.TeamConnection.Nodes(childComplexity), true + return e.ComplexityRoot.SqlInstanceStateIssue.TeamEnvironment(childComplexity), true - case "TeamConnection.pageInfo": - if e.ComplexityRoot.TeamConnection.PageInfo == nil { + case "SqlInstanceStatus.privateIpAddress": + if e.ComplexityRoot.SqlInstanceStatus.PrivateIPAddress == nil { break } - return e.ComplexityRoot.TeamConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.SqlInstanceStatus.PrivateIPAddress(childComplexity), true - case "TeamCost.daily": - if e.ComplexityRoot.TeamCost.Daily == nil { + case "SqlInstanceStatus.publicIpAddress": + if e.ComplexityRoot.SqlInstanceStatus.PublicIPAddress == nil { break } - args, err := ec.field_TeamCost_daily_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date), args["filter"].(*cost.TeamCostDailyFilter)), true + return e.ComplexityRoot.SqlInstanceStatus.PublicIPAddress(childComplexity), true - case "TeamCost.monthlySummary": - if e.ComplexityRoot.TeamCost.MonthlySummary == nil { + case "SqlInstanceUser.authentication": + if e.ComplexityRoot.SqlInstanceUser.Authentication == nil { break } - return e.ComplexityRoot.TeamCost.MonthlySummary(childComplexity), true + return e.ComplexityRoot.SqlInstanceUser.Authentication(childComplexity), true - case "TeamCostMonthlySample.cost": - if e.ComplexityRoot.TeamCostMonthlySample.Cost == nil { + case "SqlInstanceUser.name": + if e.ComplexityRoot.SqlInstanceUser.Name == nil { break } - return e.ComplexityRoot.TeamCostMonthlySample.Cost(childComplexity), true + return e.ComplexityRoot.SqlInstanceUser.Name(childComplexity), true - case "TeamCostMonthlySample.date": - if e.ComplexityRoot.TeamCostMonthlySample.Date == nil { + case "SqlInstanceUserConnection.edges": + if e.ComplexityRoot.SqlInstanceUserConnection.Edges == nil { break } - return e.ComplexityRoot.TeamCostMonthlySample.Date(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserConnection.Edges(childComplexity), true - case "TeamCostMonthlySummary.series": - if e.ComplexityRoot.TeamCostMonthlySummary.Series == nil { + case "SqlInstanceUserConnection.nodes": + if e.ComplexityRoot.SqlInstanceUserConnection.Nodes == nil { break } - return e.ComplexityRoot.TeamCostMonthlySummary.Series(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserConnection.Nodes(childComplexity), true - case "TeamCostMonthlySummary.sum": - if e.ComplexityRoot.TeamCostMonthlySummary.Sum == nil { + case "SqlInstanceUserConnection.pageInfo": + if e.ComplexityRoot.SqlInstanceUserConnection.PageInfo == nil { break } - return e.ComplexityRoot.TeamCostMonthlySummary.Sum(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserConnection.PageInfo(childComplexity), true - case "TeamCostPeriod.series": - if e.ComplexityRoot.TeamCostPeriod.Series == nil { + case "SqlInstanceUserEdge.cursor": + if e.ComplexityRoot.SqlInstanceUserEdge.Cursor == nil { break } - return e.ComplexityRoot.TeamCostPeriod.Series(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserEdge.Cursor(childComplexity), true - case "TeamCostPeriod.sum": - if e.ComplexityRoot.TeamCostPeriod.Sum == nil { + case "SqlInstanceUserEdge.node": + if e.ComplexityRoot.SqlInstanceUserEdge.Node == nil { break } - return e.ComplexityRoot.TeamCostPeriod.Sum(childComplexity), true + return e.ComplexityRoot.SqlInstanceUserEdge.Node(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.actor": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Actor == nil { + case "SqlInstanceVersionIssue.id": + if e.ComplexityRoot.SqlInstanceVersionIssue.ID == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.ID(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.CreatedAt == nil { + case "SqlInstanceVersionIssue.message": + if e.ComplexityRoot.SqlInstanceVersionIssue.Message == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.Message(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.EnvironmentName == nil { + case "SqlInstanceVersionIssue.sqlInstance": + if e.ComplexityRoot.SqlInstanceVersionIssue.SQLInstance == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.SQLInstance(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.id": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ID == nil { + case "SqlInstanceVersionIssue.severity": + if e.ComplexityRoot.SqlInstanceVersionIssue.Severity == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.Severity(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.message": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Message == nil { + case "SqlInstanceVersionIssue.teamEnvironment": + if e.ComplexityRoot.SqlInstanceVersionIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.SqlInstanceVersionIssue.TeamEnvironment(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceName == nil { + case "StartOpenSearchMaintenancePayload.error": + if e.ComplexityRoot.StartOpenSearchMaintenancePayload.Error == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.StartOpenSearchMaintenancePayload.Error(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceType == nil { + case "StartValkeyMaintenancePayload.error": + if e.ComplexityRoot.StartValkeyMaintenancePayload.Error == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.StartValkeyMaintenancePayload.Error(childComplexity), true - case "TeamCreateDeleteKeyActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.TeamSlug == nil { + case "Subscription.log": + if e.ComplexityRoot.Subscription.Log == nil { break } - return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.TeamSlug(childComplexity), true - - case "TeamCreatedActivityLogEntry.actor": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.Actor == nil { - break + args, err := ec.field_Subscription_log_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Subscription.Log(childComplexity, args["filter"].(loki.LogSubscriptionFilter)), true - case "TeamCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.CreatedAt == nil { + case "Subscription.workloadLog": + if e.ComplexityRoot.Subscription.WorkloadLog == nil { break } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.CreatedAt(childComplexity), true - - case "TeamCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_Subscription_workloadLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Subscription.WorkloadLog(childComplexity, args["filter"].(podlog.WorkloadLogSubscriptionFilter)), true - case "TeamCreatedActivityLogEntry.id": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.ID == nil { + case "Team.activityLog": + if e.ComplexityRoot.Team.ActivityLog == nil { break } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.ID(childComplexity), true - - case "TeamCreatedActivityLogEntry.message": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.Message == nil { - break + args, err := ec.field_Team_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Team.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true - case "TeamCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceName == nil { + case "Team.alerts": + if e.ComplexityRoot.Team.Alerts == nil { break } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceName(childComplexity), true - - case "TeamCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceType == nil { - break + args, err := ec.field_Team_alerts_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Team.Alerts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*alerts.AlertOrder), args["filter"].(*alerts.TeamAlertsFilter)), true - case "TeamCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamCreatedActivityLogEntry.TeamSlug == nil { + case "Team.applications": + if e.ComplexityRoot.Team.Applications == nil { break } - return e.ComplexityRoot.TeamCreatedActivityLogEntry.TeamSlug(childComplexity), true - - case "TeamDeleteKey.createdAt": - if e.ComplexityRoot.TeamDeleteKey.CreatedAt == nil { - break + args, err := ec.field_Team_applications_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamDeleteKey.CreatedAt(childComplexity), true + return e.ComplexityRoot.Team.Applications(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*application.ApplicationOrder), args["filter"].(*application.TeamApplicationsFilter)), true - case "TeamDeleteKey.createdBy": - if e.ComplexityRoot.TeamDeleteKey.CreatedBy == nil { + case "Team.bigQueryDatasets": + if e.ComplexityRoot.Team.BigQueryDatasets == nil { break } - return e.ComplexityRoot.TeamDeleteKey.CreatedBy(childComplexity), true - - case "TeamDeleteKey.expires": - if e.ComplexityRoot.TeamDeleteKey.Expires == nil { - break + args, err := ec.field_Team_bigQueryDatasets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamDeleteKey.Expires(childComplexity), true + return e.ComplexityRoot.Team.BigQueryDatasets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*bigquery.BigQueryDatasetOrder)), true - case "TeamDeleteKey.key": - if e.ComplexityRoot.TeamDeleteKey.Key == nil { + case "Team.buckets": + if e.ComplexityRoot.Team.Buckets == nil { break } - return e.ComplexityRoot.TeamDeleteKey.Key(childComplexity), true - - case "TeamDeleteKey.team": - if e.ComplexityRoot.TeamDeleteKey.Team == nil { - break + args, err := ec.field_Team_buckets_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamDeleteKey.Team(childComplexity), true + return e.ComplexityRoot.Team.Buckets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*bucket.BucketOrder)), true - case "TeamDeployKeyUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Actor == nil { + case "Team.configs": + if e.ComplexityRoot.Team.Configs == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Actor(childComplexity), true - - case "TeamDeployKeyUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_Team_configs_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Team.Configs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*configmap.ConfigOrder), args["filter"].(*configmap.ConfigFilter)), true - case "TeamDeployKeyUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.EnvironmentName == nil { + case "Team.cost": + if e.ComplexityRoot.Team.Cost == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Team.Cost(childComplexity), true - case "TeamDeployKeyUpdatedActivityLogEntry.id": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ID == nil { + case "Team.deleteKey": + if e.ComplexityRoot.Team.DeleteKey == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ID(childComplexity), true - - case "TeamDeployKeyUpdatedActivityLogEntry.message": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Message == nil { - break + args, err := ec.field_Team_deleteKey_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Team.DeleteKey(childComplexity, args["key"].(string)), true - case "TeamDeployKeyUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceName == nil { + case "Team.deletionInProgress": + if e.ComplexityRoot.Team.DeletionInProgress == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.Team.DeletionInProgress(childComplexity), true - case "TeamDeployKeyUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceType == nil { + case "Team.deploymentKey": + if e.ComplexityRoot.Team.DeploymentKey == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Team.DeploymentKey(childComplexity), true - case "TeamDeployKeyUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.TeamSlug == nil { + case "Team.deployments": + if e.ComplexityRoot.Team.Deployments == nil { break } - return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.TeamSlug(childComplexity), true - - case "TeamEdge.cursor": - if e.ComplexityRoot.TeamEdge.Cursor == nil { - break + args, err := ec.field_Team_deployments_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Team.Deployments(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "TeamEdge.node": - if e.ComplexityRoot.TeamEdge.Node == nil { + case "Team.environment": + if e.ComplexityRoot.Team.Environment == nil { break } - return e.ComplexityRoot.TeamEdge.Node(childComplexity), true - - case "TeamEntraIDGroup.groupID": - if e.ComplexityRoot.TeamEntraIDGroup.GroupID == nil { - break - } - - return e.ComplexityRoot.TeamEntraIDGroup.GroupID(childComplexity), true - - case "TeamEnvironment.alerts": - if e.ComplexityRoot.TeamEnvironment.Alerts == nil { - break - } - - args, err := ec.field_TeamEnvironment_alerts_args(ctx, rawArgs) + args, err := ec.field_Team_environment_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.Alerts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*alerts.AlertOrder), args["filter"].(*alerts.TeamAlertsFilter)), true + return e.ComplexityRoot.Team.Environment(childComplexity, args["name"].(string)), true - case "TeamEnvironment.application": - if e.ComplexityRoot.TeamEnvironment.Application == nil { + case "Team.environments": + if e.ComplexityRoot.Team.Environments == nil { break } - args, err := ec.field_TeamEnvironment_application_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.TeamEnvironment.Application(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.Environments(childComplexity), true - case "TeamEnvironment.bigQueryDataset": - if e.ComplexityRoot.TeamEnvironment.BigQueryDataset == nil { + case "Team.externalResources": + if e.ComplexityRoot.Team.ExternalResources == nil { break } - args, err := ec.field_TeamEnvironment_bigQueryDataset_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.Team.ExternalResources(childComplexity), true + + case "Team.id": + if e.ComplexityRoot.Team.ID == nil { + break } - return e.ComplexityRoot.TeamEnvironment.BigQueryDataset(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.ID(childComplexity), true - case "TeamEnvironment.bucket": - if e.ComplexityRoot.TeamEnvironment.Bucket == nil { + case "Team.imageVulnerabilityHistory": + if e.ComplexityRoot.Team.ImageVulnerabilityHistory == nil { break } - args, err := ec.field_TeamEnvironment_bucket_args(ctx, rawArgs) + args, err := ec.field_Team_imageVulnerabilityHistory_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.Bucket(childComplexity, args["name"].(string)), true - - case "TeamEnvironment.cost": - if e.ComplexityRoot.TeamEnvironment.Cost == nil { - break - } - - return e.ComplexityRoot.TeamEnvironment.Cost(childComplexity), true + return e.ComplexityRoot.Team.ImageVulnerabilityHistory(childComplexity, args["from"].(scalar.Date)), true - case "TeamEnvironment.environment": - if e.ComplexityRoot.TeamEnvironment.Environment == nil { + case "Team.inventoryCounts": + if e.ComplexityRoot.Team.InventoryCounts == nil { break } - return e.ComplexityRoot.TeamEnvironment.Environment(childComplexity), true + return e.ComplexityRoot.Team.InventoryCounts(childComplexity), true - case "TeamEnvironment.gcpProjectID": - if e.ComplexityRoot.TeamEnvironment.GCPProjectID == nil { + case "Team.issues": + if e.ComplexityRoot.Team.Issues == nil { break } - return e.ComplexityRoot.TeamEnvironment.GCPProjectID(childComplexity), true - - case "TeamEnvironment.id": - if e.ComplexityRoot.TeamEnvironment.ID == nil { - break + args, err := ec.field_Team_issues_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamEnvironment.ID(childComplexity), true + return e.ComplexityRoot.Team.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.IssueFilter)), true - case "TeamEnvironment.job": - if e.ComplexityRoot.TeamEnvironment.Job == nil { + case "Team.jobs": + if e.ComplexityRoot.Team.Jobs == nil { break } - args, err := ec.field_TeamEnvironment_job_args(ctx, rawArgs) + args, err := ec.field_Team_jobs_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.Job(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.Jobs(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*job.JobOrder), args["filter"].(*job.TeamJobsFilter)), true - case "TeamEnvironment.kafkaTopic": - if e.ComplexityRoot.TeamEnvironment.KafkaTopic == nil { + case "Team.kafkaTopics": + if e.ComplexityRoot.Team.KafkaTopics == nil { break } - args, err := ec.field_TeamEnvironment_kafkaTopic_args(ctx, rawArgs) + args, err := ec.field_Team_kafkaTopics_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.KafkaTopic(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.KafkaTopics(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*kafkatopic.KafkaTopicOrder)), true - case "TeamEnvironment.name": - if e.ComplexityRoot.TeamEnvironment.Name == nil { + case "Team.lastSuccessfulSync": + if e.ComplexityRoot.Team.LastSuccessfulSync == nil { break } - return e.ComplexityRoot.TeamEnvironment.Name(childComplexity), true + return e.ComplexityRoot.Team.LastSuccessfulSync(childComplexity), true - case "TeamEnvironment.openSearch": - if e.ComplexityRoot.TeamEnvironment.OpenSearch == nil { + case "Team.member": + if e.ComplexityRoot.Team.Member == nil { break } - args, err := ec.field_TeamEnvironment_openSearch_args(ctx, rawArgs) + args, err := ec.field_Team_member_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.OpenSearch(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.Member(childComplexity, args["email"].(string)), true - case "TeamEnvironment.postgresInstance": - if e.ComplexityRoot.TeamEnvironment.PostgresInstance == nil { + case "Team.members": + if e.ComplexityRoot.Team.Members == nil { break } - args, err := ec.field_TeamEnvironment_postgresInstance_args(ctx, rawArgs) + args, err := ec.field_Team_members_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.PostgresInstance(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.Members(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.TeamMemberOrder)), true - case "TeamEnvironment.sqlInstance": - if e.ComplexityRoot.TeamEnvironment.SQLInstance == nil { + case "Team.openSearches": + if e.ComplexityRoot.Team.OpenSearches == nil { break } - args, err := ec.field_TeamEnvironment_sqlInstance_args(ctx, rawArgs) + args, err := ec.field_Team_openSearches_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.SQLInstance(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.OpenSearches(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*opensearch.OpenSearchOrder)), true - case "TeamEnvironment.secret": - if e.ComplexityRoot.TeamEnvironment.Secret == nil { + case "Team.postgresInstances": + if e.ComplexityRoot.Team.PostgresInstances == nil { break } - args, err := ec.field_TeamEnvironment_secret_args(ctx, rawArgs) + args, err := ec.field_Team_postgresInstances_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.Secret(childComplexity, args["name"].(string)), true - - case "TeamEnvironment.slackAlertsChannel": - if e.ComplexityRoot.TeamEnvironment.SlackAlertsChannel == nil { - break - } - - return e.ComplexityRoot.TeamEnvironment.SlackAlertsChannel(childComplexity), true + return e.ComplexityRoot.Team.PostgresInstances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*postgres.PostgresInstanceOrder)), true - case "TeamEnvironment.team": - if e.ComplexityRoot.TeamEnvironment.Team == nil { + case "Team.purpose": + if e.ComplexityRoot.Team.Purpose == nil { break } - return e.ComplexityRoot.TeamEnvironment.Team(childComplexity), true + return e.ComplexityRoot.Team.Purpose(childComplexity), true - case "TeamEnvironment.valkey": - if e.ComplexityRoot.TeamEnvironment.Valkey == nil { + case "Team.repositories": + if e.ComplexityRoot.Team.Repositories == nil { break } - args, err := ec.field_TeamEnvironment_valkey_args(ctx, rawArgs) + args, err := ec.field_Team_repositories_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.Valkey(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.Repositories(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*repository.RepositoryOrder), args["filter"].(*repository.TeamRepositoryFilter)), true - case "TeamEnvironment.workload": - if e.ComplexityRoot.TeamEnvironment.Workload == nil { + case "Team.sqlInstances": + if e.ComplexityRoot.Team.SQLInstances == nil { break } - args, err := ec.field_TeamEnvironment_workload_args(ctx, rawArgs) + args, err := ec.field_Team_sqlInstances_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironment.Workload(childComplexity, args["name"].(string)), true + return e.ComplexityRoot.Team.SQLInstances(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*sqlinstance.SQLInstanceOrder)), true - case "TeamEnvironmentCost.daily": - if e.ComplexityRoot.TeamEnvironmentCost.Daily == nil { + case "Team.secrets": + if e.ComplexityRoot.Team.Secrets == nil { break } - args, err := ec.field_TeamEnvironmentCost_daily_args(ctx, rawArgs) + args, err := ec.field_Team_secrets_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.TeamEnvironmentCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + return e.ComplexityRoot.Team.Secrets(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*secret.SecretOrder), args["filter"].(*secret.SecretFilter)), true - case "TeamEnvironmentCostPeriod.series": - if e.ComplexityRoot.TeamEnvironmentCostPeriod.Series == nil { + case "Team.serviceUtilization": + if e.ComplexityRoot.Team.ServiceUtilization == nil { break } - return e.ComplexityRoot.TeamEnvironmentCostPeriod.Series(childComplexity), true + return e.ComplexityRoot.Team.ServiceUtilization(childComplexity), true - case "TeamEnvironmentCostPeriod.sum": - if e.ComplexityRoot.TeamEnvironmentCostPeriod.Sum == nil { + case "Team.slackChannel": + if e.ComplexityRoot.Team.SlackChannel == nil { break } - return e.ComplexityRoot.TeamEnvironmentCostPeriod.Sum(childComplexity), true + return e.ComplexityRoot.Team.SlackChannel(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Actor == nil { + case "Team.slug": + if e.ComplexityRoot.Team.Slug == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.Team.Slug(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.CreatedAt == nil { + case "Team.unleash": + if e.ComplexityRoot.Team.Unleash == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.Team.Unleash(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.data": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Data == nil { + case "Team.valkeys": + if e.ComplexityRoot.Team.Valkeys == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Data(childComplexity), true - - case "TeamEnvironmentUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_Team_valkeys_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.Team.Valkeys(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*valkey.ValkeyOrder)), true - case "TeamEnvironmentUpdatedActivityLogEntry.id": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ID == nil { + case "Team.viewerIsMember": + if e.ComplexityRoot.Team.ViewerIsMember == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.Team.ViewerIsMember(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.message": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Message == nil { + case "Team.viewerIsOwner": + if e.ComplexityRoot.Team.ViewerIsOwner == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.Team.ViewerIsOwner(childComplexity), true - case "TeamEnvironmentUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceName == nil { + case "Team.vulnerabilityFixHistory": + if e.ComplexityRoot.Team.VulnerabilityFixHistory == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceName(childComplexity), true - - case "TeamEnvironmentUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceType == nil { - break + args, err := ec.field_Team_vulnerabilityFixHistory_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.Team.VulnerabilityFixHistory(childComplexity, args["from"].(scalar.Date)), true - case "TeamEnvironmentUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.TeamSlug == nil { + case "Team.vulnerabilitySummaries": + if e.ComplexityRoot.Team.VulnerabilitySummaries == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.TeamSlug(childComplexity), true - - case "TeamEnvironmentUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryData.UpdatedFields == nil { - break + args, err := ec.field_Team_vulnerabilitySummaries_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.Team.VulnerabilitySummaries(childComplexity, args["filter"].(*vulnerability.TeamVulnerabilitySummaryFilter), args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*vulnerability.VulnerabilitySummaryOrder)), true - case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "Team.vulnerabilitySummary": + if e.ComplexityRoot.Team.VulnerabilitySummary == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - - case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { - break + args, err := ec.field_Team_vulnerabilitySummary_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.Team.VulnerabilitySummary(childComplexity, args["filter"].(*vulnerability.TeamVulnerabilitySummaryFilter)), true - case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "Team.workloadUtilization": + if e.ComplexityRoot.Team.WorkloadUtilization == nil { break } - return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - - case "TeamExternalResources.cdn": - if e.ComplexityRoot.TeamExternalResources.CDN == nil { - break + args, err := ec.field_Team_workloadUtilization_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamExternalResources.CDN(childComplexity), true + return e.ComplexityRoot.Team.WorkloadUtilization(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true - case "TeamExternalResources.entraIDGroup": - if e.ComplexityRoot.TeamExternalResources.EntraIDGroup == nil { + case "Team.workloads": + if e.ComplexityRoot.Team.Workloads == nil { break } - return e.ComplexityRoot.TeamExternalResources.EntraIDGroup(childComplexity), true - - case "TeamExternalResources.gitHubTeam": - if e.ComplexityRoot.TeamExternalResources.GitHubTeam == nil { - break + args, err := ec.field_Team_workloads_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamExternalResources.GitHubTeam(childComplexity), true + return e.ComplexityRoot.Team.Workloads(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*workload.WorkloadOrder), args["filter"].(*workload.TeamWorkloadsFilter)), true - case "TeamExternalResources.googleArtifactRegistry": - if e.ComplexityRoot.TeamExternalResources.GoogleArtifactRegistry == nil { + case "TeamCDN.bucket": + if e.ComplexityRoot.TeamCDN.Bucket == nil { break } - return e.ComplexityRoot.TeamExternalResources.GoogleArtifactRegistry(childComplexity), true + return e.ComplexityRoot.TeamCDN.Bucket(childComplexity), true - case "TeamExternalResources.googleGroup": - if e.ComplexityRoot.TeamExternalResources.GoogleGroup == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.actor": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.TeamExternalResources.GoogleGroup(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Actor(childComplexity), true - case "TeamGitHubTeam.slug": - if e.ComplexityRoot.TeamGitHubTeam.Slug == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.TeamGitHubTeam.Slug(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.CreatedAt(childComplexity), true - case "TeamGoogleArtifactRegistry.repository": - if e.ComplexityRoot.TeamGoogleArtifactRegistry.Repository == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.TeamGoogleArtifactRegistry.Repository(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.EnvironmentName(childComplexity), true - case "TeamGoogleGroup.email": - if e.ComplexityRoot.TeamGoogleGroup.Email == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.id": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.TeamGoogleGroup.Email(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ID(childComplexity), true - case "TeamInventoryCountApplications.total": - if e.ComplexityRoot.TeamInventoryCountApplications.Total == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.message": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.TeamInventoryCountApplications.Total(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.Message(childComplexity), true - case "TeamInventoryCountBigQueryDatasets.total": - if e.ComplexityRoot.TeamInventoryCountBigQueryDatasets.Total == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.TeamInventoryCountBigQueryDatasets.Total(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceName(childComplexity), true - case "TeamInventoryCountBuckets.total": - if e.ComplexityRoot.TeamInventoryCountBuckets.Total == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.TeamInventoryCountBuckets.Total(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.ResourceType(childComplexity), true - case "TeamInventoryCountJobs.total": - if e.ComplexityRoot.TeamInventoryCountJobs.Total == nil { + case "TeamConfirmDeleteKeyActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.TeamInventoryCountJobs.Total(childComplexity), true + return e.ComplexityRoot.TeamConfirmDeleteKeyActivityLogEntry.TeamSlug(childComplexity), true - case "TeamInventoryCountKafkaTopics.total": - if e.ComplexityRoot.TeamInventoryCountKafkaTopics.Total == nil { + case "TeamConnection.edges": + if e.ComplexityRoot.TeamConnection.Edges == nil { break } - return e.ComplexityRoot.TeamInventoryCountKafkaTopics.Total(childComplexity), true + return e.ComplexityRoot.TeamConnection.Edges(childComplexity), true - case "TeamInventoryCountOpenSearches.total": - if e.ComplexityRoot.TeamInventoryCountOpenSearches.Total == nil { + case "TeamConnection.nodes": + if e.ComplexityRoot.TeamConnection.Nodes == nil { break } - return e.ComplexityRoot.TeamInventoryCountOpenSearches.Total(childComplexity), true + return e.ComplexityRoot.TeamConnection.Nodes(childComplexity), true - case "TeamInventoryCountPostgresInstances.total": - if e.ComplexityRoot.TeamInventoryCountPostgresInstances.Total == nil { + case "TeamConnection.pageInfo": + if e.ComplexityRoot.TeamConnection.PageInfo == nil { break } - return e.ComplexityRoot.TeamInventoryCountPostgresInstances.Total(childComplexity), true + return e.ComplexityRoot.TeamConnection.PageInfo(childComplexity), true - case "TeamInventoryCountSecrets.total": - if e.ComplexityRoot.TeamInventoryCountSecrets.Total == nil { + case "TeamCost.daily": + if e.ComplexityRoot.TeamCost.Daily == nil { break } - return e.ComplexityRoot.TeamInventoryCountSecrets.Total(childComplexity), true + args, err := ec.field_TeamCost_daily_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "TeamInventoryCountSqlInstances.total": - if e.ComplexityRoot.TeamInventoryCountSqlInstances.Total == nil { + return e.ComplexityRoot.TeamCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date), args["filter"].(*cost.TeamCostDailyFilter)), true + + case "TeamCost.monthlySummary": + if e.ComplexityRoot.TeamCost.MonthlySummary == nil { break } - return e.ComplexityRoot.TeamInventoryCountSqlInstances.Total(childComplexity), true + return e.ComplexityRoot.TeamCost.MonthlySummary(childComplexity), true - case "TeamInventoryCountValkeys.total": - if e.ComplexityRoot.TeamInventoryCountValkeys.Total == nil { + case "TeamCostMonthlySample.cost": + if e.ComplexityRoot.TeamCostMonthlySample.Cost == nil { break } - return e.ComplexityRoot.TeamInventoryCountValkeys.Total(childComplexity), true + return e.ComplexityRoot.TeamCostMonthlySample.Cost(childComplexity), true - case "TeamInventoryCounts.applications": - if e.ComplexityRoot.TeamInventoryCounts.Applications == nil { + case "TeamCostMonthlySample.date": + if e.ComplexityRoot.TeamCostMonthlySample.Date == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.Applications(childComplexity), true + return e.ComplexityRoot.TeamCostMonthlySample.Date(childComplexity), true - case "TeamInventoryCounts.bigQueryDatasets": - if e.ComplexityRoot.TeamInventoryCounts.BigQueryDatasets == nil { + case "TeamCostMonthlySummary.series": + if e.ComplexityRoot.TeamCostMonthlySummary.Series == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.BigQueryDatasets(childComplexity), true + return e.ComplexityRoot.TeamCostMonthlySummary.Series(childComplexity), true - case "TeamInventoryCounts.buckets": - if e.ComplexityRoot.TeamInventoryCounts.Buckets == nil { + case "TeamCostMonthlySummary.sum": + if e.ComplexityRoot.TeamCostMonthlySummary.Sum == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.Buckets(childComplexity), true + return e.ComplexityRoot.TeamCostMonthlySummary.Sum(childComplexity), true - case "TeamInventoryCounts.jobs": - if e.ComplexityRoot.TeamInventoryCounts.Jobs == nil { + case "TeamCostPeriod.series": + if e.ComplexityRoot.TeamCostPeriod.Series == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.Jobs(childComplexity), true + return e.ComplexityRoot.TeamCostPeriod.Series(childComplexity), true - case "TeamInventoryCounts.kafkaTopics": - if e.ComplexityRoot.TeamInventoryCounts.KafkaTopics == nil { + case "TeamCostPeriod.sum": + if e.ComplexityRoot.TeamCostPeriod.Sum == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.KafkaTopics(childComplexity), true + return e.ComplexityRoot.TeamCostPeriod.Sum(childComplexity), true - case "TeamInventoryCounts.openSearches": - if e.ComplexityRoot.TeamInventoryCounts.OpenSearches == nil { + case "TeamCreateDeleteKeyActivityLogEntry.actor": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.OpenSearches(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Actor(childComplexity), true - case "TeamInventoryCounts.postgresInstances": - if e.ComplexityRoot.TeamInventoryCounts.PostgresInstances == nil { + case "TeamCreateDeleteKeyActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.PostgresInstances(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.CreatedAt(childComplexity), true - case "TeamInventoryCounts.sqlInstances": - if e.ComplexityRoot.TeamInventoryCounts.SQLInstances == nil { + case "TeamCreateDeleteKeyActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.SQLInstances(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.EnvironmentName(childComplexity), true - case "TeamInventoryCounts.secrets": - if e.ComplexityRoot.TeamInventoryCounts.Secrets == nil { + case "TeamCreateDeleteKeyActivityLogEntry.id": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.Secrets(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ID(childComplexity), true - case "TeamInventoryCounts.valkeys": - if e.ComplexityRoot.TeamInventoryCounts.Valkeys == nil { + case "TeamCreateDeleteKeyActivityLogEntry.message": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.TeamInventoryCounts.Valkeys(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.Message(childComplexity), true - case "TeamMember.role": - if e.ComplexityRoot.TeamMember.Role == nil { + case "TeamCreateDeleteKeyActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.TeamMember.Role(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceName(childComplexity), true - case "TeamMember.team": - if e.ComplexityRoot.TeamMember.Team == nil { + case "TeamCreateDeleteKeyActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.TeamMember.Team(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.ResourceType(childComplexity), true - case "TeamMember.user": - if e.ComplexityRoot.TeamMember.User == nil { + case "TeamCreateDeleteKeyActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.TeamMember.User(childComplexity), true + return e.ComplexityRoot.TeamCreateDeleteKeyActivityLogEntry.TeamSlug(childComplexity), true - case "TeamMemberAddedActivityLogEntry.actor": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Actor == nil { + case "TeamCreatedActivityLogEntry.actor": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.Actor(childComplexity), true - case "TeamMemberAddedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.CreatedAt == nil { + case "TeamCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "TeamMemberAddedActivityLogEntry.data": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Data == nil { + case "TeamCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "TeamMemberAddedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.EnvironmentName == nil { + case "TeamCreatedActivityLogEntry.id": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.ID(childComplexity), true - case "TeamMemberAddedActivityLogEntry.id": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ID == nil { + case "TeamCreatedActivityLogEntry.message": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.Message(childComplexity), true - case "TeamMemberAddedActivityLogEntry.message": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Message == nil { + case "TeamCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceName(childComplexity), true - case "TeamMemberAddedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceName == nil { + case "TeamCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.ResourceType(childComplexity), true - case "TeamMemberAddedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceType == nil { + case "TeamCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "TeamMemberAddedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.TeamSlug == nil { + case "TeamDeleteKey.createdAt": + if e.ComplexityRoot.TeamDeleteKey.CreatedAt == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamDeleteKey.CreatedAt(childComplexity), true - case "TeamMemberAddedActivityLogEntryData.role": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.Role == nil { + case "TeamDeleteKey.createdBy": + if e.ComplexityRoot.TeamDeleteKey.CreatedBy == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.Role(childComplexity), true + return e.ComplexityRoot.TeamDeleteKey.CreatedBy(childComplexity), true - case "TeamMemberAddedActivityLogEntryData.userEmail": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserEmail == nil { + case "TeamDeleteKey.expires": + if e.ComplexityRoot.TeamDeleteKey.Expires == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserEmail(childComplexity), true + return e.ComplexityRoot.TeamDeleteKey.Expires(childComplexity), true - case "TeamMemberAddedActivityLogEntryData.userID": - if e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserID == nil { + case "TeamDeleteKey.key": + if e.ComplexityRoot.TeamDeleteKey.Key == nil { break } - return e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserID(childComplexity), true + return e.ComplexityRoot.TeamDeleteKey.Key(childComplexity), true - case "TeamMemberConnection.edges": - if e.ComplexityRoot.TeamMemberConnection.Edges == nil { + case "TeamDeleteKey.team": + if e.ComplexityRoot.TeamDeleteKey.Team == nil { break } - return e.ComplexityRoot.TeamMemberConnection.Edges(childComplexity), true + return e.ComplexityRoot.TeamDeleteKey.Team(childComplexity), true - case "TeamMemberConnection.nodes": - if e.ComplexityRoot.TeamMemberConnection.Nodes == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.TeamMemberConnection.Nodes(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Actor(childComplexity), true - case "TeamMemberConnection.pageInfo": - if e.ComplexityRoot.TeamMemberConnection.PageInfo == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.TeamMemberConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "TeamMemberEdge.cursor": - if e.ComplexityRoot.TeamMemberEdge.Cursor == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.TeamMemberEdge.Cursor(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "TeamMemberEdge.node": - if e.ComplexityRoot.TeamMemberEdge.Node == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.id": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.TeamMemberEdge.Node(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ID(childComplexity), true - case "TeamMemberRemovedActivityLogEntry.actor": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Actor == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.message": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.Message(childComplexity), true - case "TeamMemberRemovedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.CreatedAt == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "TeamMemberRemovedActivityLogEntry.data": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Data == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "TeamMemberRemovedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.EnvironmentName == nil { + case "TeamDeployKeyUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamDeployKeyUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "TeamMemberRemovedActivityLogEntry.id": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ID == nil { + case "TeamEdge.cursor": + if e.ComplexityRoot.TeamEdge.Cursor == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamEdge.Cursor(childComplexity), true - case "TeamMemberRemovedActivityLogEntry.message": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Message == nil { + case "TeamEdge.node": + if e.ComplexityRoot.TeamEdge.Node == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamEdge.Node(childComplexity), true - case "TeamMemberRemovedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceName == nil { + case "TeamEntraIDGroup.groupID": + if e.ComplexityRoot.TeamEntraIDGroup.GroupID == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamEntraIDGroup.GroupID(childComplexity), true - case "TeamMemberRemovedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceType == nil { + case "TeamEnvironment.alerts": + if e.ComplexityRoot.TeamEnvironment.Alerts == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceType(childComplexity), true - - case "TeamMemberRemovedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.TeamSlug == nil { - break + args, err := ec.field_TeamEnvironment_alerts_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Alerts(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*alerts.AlertOrder), args["filter"].(*alerts.TeamAlertsFilter)), true - case "TeamMemberRemovedActivityLogEntryData.userEmail": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserEmail == nil { + case "TeamEnvironment.application": + if e.ComplexityRoot.TeamEnvironment.Application == nil { break } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserEmail(childComplexity), true - - case "TeamMemberRemovedActivityLogEntryData.userID": - if e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserID == nil { - break + args, err := ec.field_TeamEnvironment_application_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserID(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Application(childComplexity, args["name"].(string)), true - case "TeamMemberSetRoleActivityLogEntry.actor": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Actor == nil { + case "TeamEnvironment.bigQueryDataset": + if e.ComplexityRoot.TeamEnvironment.BigQueryDataset == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Actor(childComplexity), true - - case "TeamMemberSetRoleActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_TeamEnvironment_bigQueryDataset_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.BigQueryDataset(childComplexity, args["name"].(string)), true - case "TeamMemberSetRoleActivityLogEntry.data": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Data == nil { + case "TeamEnvironment.bucket": + if e.ComplexityRoot.TeamEnvironment.Bucket == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Data(childComplexity), true - - case "TeamMemberSetRoleActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_TeamEnvironment_bucket_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Bucket(childComplexity, args["name"].(string)), true - case "TeamMemberSetRoleActivityLogEntry.id": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ID == nil { + case "TeamEnvironment.config": + if e.ComplexityRoot.TeamEnvironment.Config == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ID(childComplexity), true - - case "TeamMemberSetRoleActivityLogEntry.message": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Message == nil { - break + args, err := ec.field_TeamEnvironment_config_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Config(childComplexity, args["name"].(string)), true - case "TeamMemberSetRoleActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceName == nil { + case "TeamEnvironment.cost": + if e.ComplexityRoot.TeamEnvironment.Cost == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Cost(childComplexity), true - case "TeamMemberSetRoleActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceType == nil { + case "TeamEnvironment.environment": + if e.ComplexityRoot.TeamEnvironment.Environment == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Environment(childComplexity), true - case "TeamMemberSetRoleActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.TeamSlug == nil { + case "TeamEnvironment.gcpProjectID": + if e.ComplexityRoot.TeamEnvironment.GCPProjectID == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.GCPProjectID(childComplexity), true - case "TeamMemberSetRoleActivityLogEntryData.role": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.Role == nil { + case "TeamEnvironment.id": + if e.ComplexityRoot.TeamEnvironment.ID == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.Role(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.ID(childComplexity), true - case "TeamMemberSetRoleActivityLogEntryData.userEmail": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserEmail == nil { + case "TeamEnvironment.job": + if e.ComplexityRoot.TeamEnvironment.Job == nil { break } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserEmail(childComplexity), true - - case "TeamMemberSetRoleActivityLogEntryData.userID": - if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserID == nil { - break + args, err := ec.field_TeamEnvironment_job_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserID(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Job(childComplexity, args["name"].(string)), true - case "TeamServiceUtilization.sqlInstances": - if e.ComplexityRoot.TeamServiceUtilization.SQLInstances == nil { + case "TeamEnvironment.kafkaTopic": + if e.ComplexityRoot.TeamEnvironment.KafkaTopic == nil { break } - return e.ComplexityRoot.TeamServiceUtilization.SQLInstances(childComplexity), true - - case "TeamServiceUtilizationSqlInstances.cpu": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstances.CPU == nil { - break + args, err := ec.field_TeamEnvironment_kafkaTopic_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstances.CPU(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.KafkaTopic(childComplexity, args["name"].(string)), true - case "TeamServiceUtilizationSqlInstances.disk": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Disk == nil { + case "TeamEnvironment.name": + if e.ComplexityRoot.TeamEnvironment.Name == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Disk(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Name(childComplexity), true - case "TeamServiceUtilizationSqlInstances.memory": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Memory == nil { + case "TeamEnvironment.openSearch": + if e.ComplexityRoot.TeamEnvironment.OpenSearch == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Memory(childComplexity), true - - case "TeamServiceUtilizationSqlInstancesCPU.requested": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Requested == nil { - break + args, err := ec.field_TeamEnvironment_openSearch_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Requested(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.OpenSearch(childComplexity, args["name"].(string)), true - case "TeamServiceUtilizationSqlInstancesCPU.used": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Used == nil { + case "TeamEnvironment.postgresInstance": + if e.ComplexityRoot.TeamEnvironment.PostgresInstance == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Used(childComplexity), true - - case "TeamServiceUtilizationSqlInstancesCPU.utilization": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Utilization == nil { - break + args, err := ec.field_TeamEnvironment_postgresInstance_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Utilization(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.PostgresInstance(childComplexity, args["name"].(string)), true - case "TeamServiceUtilizationSqlInstancesDisk.requested": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Requested == nil { + case "TeamEnvironment.sqlInstance": + if e.ComplexityRoot.TeamEnvironment.SQLInstance == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Requested(childComplexity), true - - case "TeamServiceUtilizationSqlInstancesDisk.used": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Used == nil { - break + args, err := ec.field_TeamEnvironment_sqlInstance_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Used(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.SQLInstance(childComplexity, args["name"].(string)), true - case "TeamServiceUtilizationSqlInstancesDisk.utilization": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Utilization == nil { + case "TeamEnvironment.secret": + if e.ComplexityRoot.TeamEnvironment.Secret == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Utilization(childComplexity), true - - case "TeamServiceUtilizationSqlInstancesMemory.requested": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Requested == nil { - break + args, err := ec.field_TeamEnvironment_secret_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Requested(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Secret(childComplexity, args["name"].(string)), true - case "TeamServiceUtilizationSqlInstancesMemory.used": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Used == nil { + case "TeamEnvironment.slackAlertsChannel": + if e.ComplexityRoot.TeamEnvironment.SlackAlertsChannel == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Used(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.SlackAlertsChannel(childComplexity), true - case "TeamServiceUtilizationSqlInstancesMemory.utilization": - if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Utilization == nil { + case "TeamEnvironment.team": + if e.ComplexityRoot.TeamEnvironment.Team == nil { break } - return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Utilization(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Team(childComplexity), true - case "TeamUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.Actor == nil { + case "TeamEnvironment.valkey": + if e.ComplexityRoot.TeamEnvironment.Valkey == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.Actor(childComplexity), true - - case "TeamUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.CreatedAt == nil { - break + args, err := ec.field_TeamEnvironment_valkey_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Valkey(childComplexity, args["name"].(string)), true - case "TeamUpdatedActivityLogEntry.data": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.Data == nil { + case "TeamEnvironment.workload": + if e.ComplexityRoot.TeamEnvironment.Workload == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.Data(childComplexity), true - - case "TeamUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.EnvironmentName == nil { - break + args, err := ec.field_TeamEnvironment_workload_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamEnvironment.Workload(childComplexity, args["name"].(string)), true - case "TeamUpdatedActivityLogEntry.id": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.ID == nil { + case "TeamEnvironmentCost.daily": + if e.ComplexityRoot.TeamEnvironmentCost.Daily == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.ID(childComplexity), true - - case "TeamUpdatedActivityLogEntry.message": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.Message == nil { - break + args, err := ec.field_TeamEnvironmentCost_daily_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true - case "TeamUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceName == nil { + case "TeamEnvironmentCostPeriod.series": + if e.ComplexityRoot.TeamEnvironmentCostPeriod.Series == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentCostPeriod.Series(childComplexity), true - case "TeamUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceType == nil { + case "TeamEnvironmentCostPeriod.sum": + if e.ComplexityRoot.TeamEnvironmentCostPeriod.Sum == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentCostPeriod.Sum(childComplexity), true - case "TeamUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.TeamUpdatedActivityLogEntry.TeamSlug == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Actor(childComplexity), true - case "TeamUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.TeamUpdatedActivityLogEntryData.UpdatedFields == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "TeamUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.data": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Data(childComplexity), true - case "TeamUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "TeamUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.id": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ID(childComplexity), true - case "TeamUtilizationData.environment": - if e.ComplexityRoot.TeamUtilizationData.Environment == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.message": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.TeamUtilizationData.Environment(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.Message(childComplexity), true - case "TeamUtilizationData.requested": - if e.ComplexityRoot.TeamUtilizationData.Requested == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.TeamUtilizationData.Requested(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "TeamUtilizationData.team": - if e.ComplexityRoot.TeamUtilizationData.Team == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.TeamUtilizationData.Team(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "TeamUtilizationData.teamEnvironment": - if e.ComplexityRoot.TeamUtilizationData.TeamEnvironment == nil { + case "TeamEnvironmentUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.TeamUtilizationData.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "TeamUtilizationData.used": - if e.ComplexityRoot.TeamUtilizationData.Used == nil { + case "TeamEnvironmentUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.TeamUtilizationData.Used(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "TeamVulnerabilitySummary.coverage": - if e.ComplexityRoot.TeamVulnerabilitySummary.Coverage == nil { + case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.Coverage(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "TeamVulnerabilitySummary.critical": - if e.ComplexityRoot.TeamVulnerabilitySummary.Critical == nil { + case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.Critical(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "TeamVulnerabilitySummary.high": - if e.ComplexityRoot.TeamVulnerabilitySummary.High == nil { + case "TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.High(childComplexity), true + return e.ComplexityRoot.TeamEnvironmentUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "TeamVulnerabilitySummary.lastUpdated": - if e.ComplexityRoot.TeamVulnerabilitySummary.LastUpdated == nil { + case "TeamExternalResources.cdn": + if e.ComplexityRoot.TeamExternalResources.CDN == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.LastUpdated(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.CDN(childComplexity), true - case "TeamVulnerabilitySummary.low": - if e.ComplexityRoot.TeamVulnerabilitySummary.Low == nil { + case "TeamExternalResources.entraIDGroup": + if e.ComplexityRoot.TeamExternalResources.EntraIDGroup == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.Low(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.EntraIDGroup(childComplexity), true - case "TeamVulnerabilitySummary.medium": - if e.ComplexityRoot.TeamVulnerabilitySummary.Medium == nil { + case "TeamExternalResources.gitHubTeam": + if e.ComplexityRoot.TeamExternalResources.GitHubTeam == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.Medium(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.GitHubTeam(childComplexity), true - case "TeamVulnerabilitySummary.riskScore": - if e.ComplexityRoot.TeamVulnerabilitySummary.RiskScore == nil { + case "TeamExternalResources.googleArtifactRegistry": + if e.ComplexityRoot.TeamExternalResources.GoogleArtifactRegistry == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.RiskScore(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.GoogleArtifactRegistry(childComplexity), true - case "TeamVulnerabilitySummary.riskScoreTrend": - if e.ComplexityRoot.TeamVulnerabilitySummary.RiskScoreTrend == nil { + case "TeamExternalResources.googleGroup": + if e.ComplexityRoot.TeamExternalResources.GoogleGroup == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.RiskScoreTrend(childComplexity), true + return e.ComplexityRoot.TeamExternalResources.GoogleGroup(childComplexity), true - case "TeamVulnerabilitySummary.sbomCount": - if e.ComplexityRoot.TeamVulnerabilitySummary.SBOMCount == nil { + case "TeamGitHubTeam.slug": + if e.ComplexityRoot.TeamGitHubTeam.Slug == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.SBOMCount(childComplexity), true + return e.ComplexityRoot.TeamGitHubTeam.Slug(childComplexity), true - case "TeamVulnerabilitySummary.unassigned": - if e.ComplexityRoot.TeamVulnerabilitySummary.Unassigned == nil { + case "TeamGoogleArtifactRegistry.repository": + if e.ComplexityRoot.TeamGoogleArtifactRegistry.Repository == nil { break } - return e.ComplexityRoot.TeamVulnerabilitySummary.Unassigned(childComplexity), true + return e.ComplexityRoot.TeamGoogleArtifactRegistry.Repository(childComplexity), true - case "TenantVulnerabilitySummary.coverage": - if e.ComplexityRoot.TenantVulnerabilitySummary.Coverage == nil { + case "TeamGoogleGroup.email": + if e.ComplexityRoot.TeamGoogleGroup.Email == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.Coverage(childComplexity), true + return e.ComplexityRoot.TeamGoogleGroup.Email(childComplexity), true - case "TenantVulnerabilitySummary.critical": - if e.ComplexityRoot.TenantVulnerabilitySummary.Critical == nil { + case "TeamInventoryCountApplications.total": + if e.ComplexityRoot.TeamInventoryCountApplications.Total == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.Critical(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountApplications.Total(childComplexity), true - case "TenantVulnerabilitySummary.high": - if e.ComplexityRoot.TenantVulnerabilitySummary.High == nil { + case "TeamInventoryCountBigQueryDatasets.total": + if e.ComplexityRoot.TeamInventoryCountBigQueryDatasets.Total == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.High(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountBigQueryDatasets.Total(childComplexity), true - case "TenantVulnerabilitySummary.lastUpdated": - if e.ComplexityRoot.TenantVulnerabilitySummary.LastUpdated == nil { + case "TeamInventoryCountBuckets.total": + if e.ComplexityRoot.TeamInventoryCountBuckets.Total == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.LastUpdated(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountBuckets.Total(childComplexity), true - case "TenantVulnerabilitySummary.low": - if e.ComplexityRoot.TenantVulnerabilitySummary.Low == nil { + case "TeamInventoryCountConfigs.total": + if e.ComplexityRoot.TeamInventoryCountConfigs.Total == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.Low(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountConfigs.Total(childComplexity), true - case "TenantVulnerabilitySummary.medium": - if e.ComplexityRoot.TenantVulnerabilitySummary.Medium == nil { + case "TeamInventoryCountJobs.total": + if e.ComplexityRoot.TeamInventoryCountJobs.Total == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.Medium(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountJobs.Total(childComplexity), true - case "TenantVulnerabilitySummary.riskScore": - if e.ComplexityRoot.TenantVulnerabilitySummary.RiskScore == nil { + case "TeamInventoryCountKafkaTopics.total": + if e.ComplexityRoot.TeamInventoryCountKafkaTopics.Total == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.RiskScore(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountKafkaTopics.Total(childComplexity), true - case "TenantVulnerabilitySummary.sbomCount": - if e.ComplexityRoot.TenantVulnerabilitySummary.SbomCount == nil { + case "TeamInventoryCountOpenSearches.total": + if e.ComplexityRoot.TeamInventoryCountOpenSearches.Total == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.SbomCount(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountOpenSearches.Total(childComplexity), true - case "TenantVulnerabilitySummary.unassigned": - if e.ComplexityRoot.TenantVulnerabilitySummary.Unassigned == nil { + case "TeamInventoryCountPostgresInstances.total": + if e.ComplexityRoot.TeamInventoryCountPostgresInstances.Total == nil { break } - return e.ComplexityRoot.TenantVulnerabilitySummary.Unassigned(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountPostgresInstances.Total(childComplexity), true - case "TokenXAuthIntegration.name": - if e.ComplexityRoot.TokenXAuthIntegration.Name == nil { + case "TeamInventoryCountSecrets.total": + if e.ComplexityRoot.TeamInventoryCountSecrets.Total == nil { break } - return e.ComplexityRoot.TokenXAuthIntegration.Name(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountSecrets.Total(childComplexity), true - case "TriggerJobPayload.job": - if e.ComplexityRoot.TriggerJobPayload.Job == nil { + case "TeamInventoryCountSqlInstances.total": + if e.ComplexityRoot.TeamInventoryCountSqlInstances.Total == nil { break } - return e.ComplexityRoot.TriggerJobPayload.Job(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountSqlInstances.Total(childComplexity), true - case "TriggerJobPayload.jobRun": - if e.ComplexityRoot.TriggerJobPayload.JobRun == nil { + case "TeamInventoryCountValkeys.total": + if e.ComplexityRoot.TeamInventoryCountValkeys.Total == nil { break } - return e.ComplexityRoot.TriggerJobPayload.JobRun(childComplexity), true + return e.ComplexityRoot.TeamInventoryCountValkeys.Total(childComplexity), true - case "UnleashInstance.apiIngress": - if e.ComplexityRoot.UnleashInstance.APIIngress == nil { + case "TeamInventoryCounts.applications": + if e.ComplexityRoot.TeamInventoryCounts.Applications == nil { break } - return e.ComplexityRoot.UnleashInstance.APIIngress(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Applications(childComplexity), true - case "UnleashInstance.allowedTeams": - if e.ComplexityRoot.UnleashInstance.AllowedTeams == nil { + case "TeamInventoryCounts.bigQueryDatasets": + if e.ComplexityRoot.TeamInventoryCounts.BigQueryDatasets == nil { break } - args, err := ec.field_UnleashInstance_allowedTeams_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.UnleashInstance.AllowedTeams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.TeamInventoryCounts.BigQueryDatasets(childComplexity), true - case "UnleashInstance.id": - if e.ComplexityRoot.UnleashInstance.ID == nil { + case "TeamInventoryCounts.buckets": + if e.ComplexityRoot.TeamInventoryCounts.Buckets == nil { break } - return e.ComplexityRoot.UnleashInstance.ID(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Buckets(childComplexity), true - case "UnleashInstance.metrics": - if e.ComplexityRoot.UnleashInstance.Metrics == nil { + case "TeamInventoryCounts.configs": + if e.ComplexityRoot.TeamInventoryCounts.Configs == nil { break } - return e.ComplexityRoot.UnleashInstance.Metrics(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Configs(childComplexity), true - case "UnleashInstance.name": - if e.ComplexityRoot.UnleashInstance.Name == nil { + case "TeamInventoryCounts.jobs": + if e.ComplexityRoot.TeamInventoryCounts.Jobs == nil { break } - return e.ComplexityRoot.UnleashInstance.Name(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Jobs(childComplexity), true - case "UnleashInstance.ready": - if e.ComplexityRoot.UnleashInstance.Ready == nil { + case "TeamInventoryCounts.kafkaTopics": + if e.ComplexityRoot.TeamInventoryCounts.KafkaTopics == nil { break } - return e.ComplexityRoot.UnleashInstance.Ready(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.KafkaTopics(childComplexity), true - case "UnleashInstance.releaseChannel": - if e.ComplexityRoot.UnleashInstance.ReleaseChannel == nil { + case "TeamInventoryCounts.openSearches": + if e.ComplexityRoot.TeamInventoryCounts.OpenSearches == nil { break } - return e.ComplexityRoot.UnleashInstance.ReleaseChannel(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.OpenSearches(childComplexity), true - case "UnleashInstance.releaseChannelName": - if e.ComplexityRoot.UnleashInstance.ReleaseChannelName == nil { + case "TeamInventoryCounts.postgresInstances": + if e.ComplexityRoot.TeamInventoryCounts.PostgresInstances == nil { break } - return e.ComplexityRoot.UnleashInstance.ReleaseChannelName(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.PostgresInstances(childComplexity), true - case "UnleashInstance.version": - if e.ComplexityRoot.UnleashInstance.Version == nil { + case "TeamInventoryCounts.sqlInstances": + if e.ComplexityRoot.TeamInventoryCounts.SQLInstances == nil { break } - return e.ComplexityRoot.UnleashInstance.Version(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.SQLInstances(childComplexity), true - case "UnleashInstance.webIngress": - if e.ComplexityRoot.UnleashInstance.WebIngress == nil { + case "TeamInventoryCounts.secrets": + if e.ComplexityRoot.TeamInventoryCounts.Secrets == nil { break } - return e.ComplexityRoot.UnleashInstance.WebIngress(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Secrets(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.actor": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Actor == nil { + case "TeamInventoryCounts.valkeys": + if e.ComplexityRoot.TeamInventoryCounts.Valkeys == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamInventoryCounts.Valkeys(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.CreatedAt == nil { + case "TeamMember.role": + if e.ComplexityRoot.TeamMember.Role == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamMember.Role(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.EnvironmentName == nil { + case "TeamMember.team": + if e.ComplexityRoot.TeamMember.Team == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamMember.Team(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.id": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ID == nil { + case "TeamMember.user": + if e.ComplexityRoot.TeamMember.User == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamMember.User(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.message": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Message == nil { + case "TeamMemberAddedActivityLogEntry.actor": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Actor(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceName == nil { + case "TeamMemberAddedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.CreatedAt(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceType == nil { + case "TeamMemberAddedActivityLogEntry.data": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Data(childComplexity), true - case "UnleashInstanceCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.TeamSlug == nil { + case "TeamMemberAddedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.EnvironmentName(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.actor": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Actor == nil { + case "TeamMemberAddedActivityLogEntry.id": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ID(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.CreatedAt == nil { + case "TeamMemberAddedActivityLogEntry.message": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.Message(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.EnvironmentName == nil { + case "TeamMemberAddedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceName(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.id": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ID == nil { + case "TeamMemberAddedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.ResourceType(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.message": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Message == nil { + case "TeamMemberAddedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntry.TeamSlug(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceName == nil { + case "TeamMemberAddedActivityLogEntryData.role": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.Role == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.Role(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceType == nil { + case "TeamMemberAddedActivityLogEntryData.userEmail": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserEmail == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserEmail(childComplexity), true - case "UnleashInstanceDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.TeamSlug == nil { + case "TeamMemberAddedActivityLogEntryData.userID": + if e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserID == nil { break } - return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamMemberAddedActivityLogEntryData.UserID(childComplexity), true - case "UnleashInstanceMetrics.apiTokens": - if e.ComplexityRoot.UnleashInstanceMetrics.APITokens == nil { + case "TeamMemberConnection.edges": + if e.ComplexityRoot.TeamMemberConnection.Edges == nil { break } - return e.ComplexityRoot.UnleashInstanceMetrics.APITokens(childComplexity), true + return e.ComplexityRoot.TeamMemberConnection.Edges(childComplexity), true - case "UnleashInstanceMetrics.cpuRequests": - if e.ComplexityRoot.UnleashInstanceMetrics.CPURequests == nil { + case "TeamMemberConnection.nodes": + if e.ComplexityRoot.TeamMemberConnection.Nodes == nil { break } - return e.ComplexityRoot.UnleashInstanceMetrics.CPURequests(childComplexity), true + return e.ComplexityRoot.TeamMemberConnection.Nodes(childComplexity), true - case "UnleashInstanceMetrics.cpuUtilization": - if e.ComplexityRoot.UnleashInstanceMetrics.CPUUtilization == nil { + case "TeamMemberConnection.pageInfo": + if e.ComplexityRoot.TeamMemberConnection.PageInfo == nil { break } - return e.ComplexityRoot.UnleashInstanceMetrics.CPUUtilization(childComplexity), true + return e.ComplexityRoot.TeamMemberConnection.PageInfo(childComplexity), true - case "UnleashInstanceMetrics.memoryRequests": - if e.ComplexityRoot.UnleashInstanceMetrics.MemoryRequests == nil { + case "TeamMemberEdge.cursor": + if e.ComplexityRoot.TeamMemberEdge.Cursor == nil { break } - return e.ComplexityRoot.UnleashInstanceMetrics.MemoryRequests(childComplexity), true + return e.ComplexityRoot.TeamMemberEdge.Cursor(childComplexity), true - case "UnleashInstanceMetrics.memoryUtilization": - if e.ComplexityRoot.UnleashInstanceMetrics.MemoryUtilization == nil { + case "TeamMemberEdge.node": + if e.ComplexityRoot.TeamMemberEdge.Node == nil { break } - return e.ComplexityRoot.UnleashInstanceMetrics.MemoryUtilization(childComplexity), true + return e.ComplexityRoot.TeamMemberEdge.Node(childComplexity), true - case "UnleashInstanceMetrics.toggles": - if e.ComplexityRoot.UnleashInstanceMetrics.Toggles == nil { + case "TeamMemberRemovedActivityLogEntry.actor": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.UnleashInstanceMetrics.Toggles(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Actor(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Actor == nil { + case "TeamMemberRemovedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.CreatedAt(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.CreatedAt == nil { + case "TeamMemberRemovedActivityLogEntry.data": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Data(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.data": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Data == nil { + case "TeamMemberRemovedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.EnvironmentName(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.EnvironmentName == nil { + case "TeamMemberRemovedActivityLogEntry.id": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ID(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.id": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ID == nil { + case "TeamMemberRemovedActivityLogEntry.message": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.Message(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.message": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Message == nil { + case "TeamMemberRemovedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceName(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceName == nil { + case "TeamMemberRemovedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.ResourceType(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceType == nil { + case "TeamMemberRemovedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntry.TeamSlug(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.TeamSlug == nil { + case "TeamMemberRemovedActivityLogEntryData.userEmail": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserEmail == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserEmail(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntryData.allowedTeamSlug": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.AllowedTeamSlug == nil { + case "TeamMemberRemovedActivityLogEntryData.userID": + if e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserID == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.AllowedTeamSlug(childComplexity), true + return e.ComplexityRoot.TeamMemberRemovedActivityLogEntryData.UserID(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntryData.revokedTeamSlug": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.RevokedTeamSlug == nil { + case "TeamMemberSetRoleActivityLogEntry.actor": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.RevokedTeamSlug(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Actor(childComplexity), true - case "UnleashInstanceUpdatedActivityLogEntryData.updatedReleaseChannel": - if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.UpdatedReleaseChannel == nil { + case "TeamMemberSetRoleActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.UpdatedReleaseChannel(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.CreatedAt(childComplexity), true - case "UnleashReleaseChannel.currentVersion": - if e.ComplexityRoot.UnleashReleaseChannel.CurrentVersion == nil { + case "TeamMemberSetRoleActivityLogEntry.data": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.UnleashReleaseChannel.CurrentVersion(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Data(childComplexity), true - case "UnleashReleaseChannel.lastUpdated": - if e.ComplexityRoot.UnleashReleaseChannel.LastUpdated == nil { + case "TeamMemberSetRoleActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.UnleashReleaseChannel.LastUpdated(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.EnvironmentName(childComplexity), true - case "UnleashReleaseChannel.name": - if e.ComplexityRoot.UnleashReleaseChannel.Name == nil { + case "TeamMemberSetRoleActivityLogEntry.id": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.UnleashReleaseChannel.Name(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ID(childComplexity), true - case "UnleashReleaseChannel.type": - if e.ComplexityRoot.UnleashReleaseChannel.Type == nil { + case "TeamMemberSetRoleActivityLogEntry.message": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.UnleashReleaseChannel.Type(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.Message(childComplexity), true - case "UnleashReleaseChannelIssue.channelName": - if e.ComplexityRoot.UnleashReleaseChannelIssue.ChannelName == nil { + case "TeamMemberSetRoleActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.ChannelName(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceName(childComplexity), true - case "UnleashReleaseChannelIssue.currentMajorVersion": - if e.ComplexityRoot.UnleashReleaseChannelIssue.CurrentMajorVersion == nil { + case "TeamMemberSetRoleActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.CurrentMajorVersion(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.ResourceType(childComplexity), true - case "UnleashReleaseChannelIssue.id": - if e.ComplexityRoot.UnleashReleaseChannelIssue.ID == nil { + case "TeamMemberSetRoleActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.ID(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntry.TeamSlug(childComplexity), true - case "UnleashReleaseChannelIssue.majorVersion": - if e.ComplexityRoot.UnleashReleaseChannelIssue.MajorVersion == nil { + case "TeamMemberSetRoleActivityLogEntryData.role": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.Role == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.MajorVersion(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.Role(childComplexity), true - case "UnleashReleaseChannelIssue.message": - if e.ComplexityRoot.UnleashReleaseChannelIssue.Message == nil { + case "TeamMemberSetRoleActivityLogEntryData.userEmail": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserEmail == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.Message(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserEmail(childComplexity), true - case "UnleashReleaseChannelIssue.severity": - if e.ComplexityRoot.UnleashReleaseChannelIssue.Severity == nil { + case "TeamMemberSetRoleActivityLogEntryData.userID": + if e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserID == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.Severity(childComplexity), true + return e.ComplexityRoot.TeamMemberSetRoleActivityLogEntryData.UserID(childComplexity), true - case "UnleashReleaseChannelIssue.teamEnvironment": - if e.ComplexityRoot.UnleashReleaseChannelIssue.TeamEnvironment == nil { + case "TeamServiceUtilization.sqlInstances": + if e.ComplexityRoot.TeamServiceUtilization.SQLInstances == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilization.SQLInstances(childComplexity), true - case "UnleashReleaseChannelIssue.unleash": - if e.ComplexityRoot.UnleashReleaseChannelIssue.Unleash == nil { + case "TeamServiceUtilizationSqlInstances.cpu": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstances.CPU == nil { break } - return e.ComplexityRoot.UnleashReleaseChannelIssue.Unleash(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstances.CPU(childComplexity), true - case "UpdateImageVulnerabilityPayload.vulnerability": - if e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability == nil { + case "TeamServiceUtilizationSqlInstances.disk": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Disk == nil { break } - return e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Disk(childComplexity), true - case "UpdateOpenSearchPayload.openSearch": - if e.ComplexityRoot.UpdateOpenSearchPayload.OpenSearch == nil { + case "TeamServiceUtilizationSqlInstances.memory": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Memory == nil { break } - return e.ComplexityRoot.UpdateOpenSearchPayload.OpenSearch(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstances.Memory(childComplexity), true - case "UpdateSecretValuePayload.secret": - if e.ComplexityRoot.UpdateSecretValuePayload.Secret == nil { + case "TeamServiceUtilizationSqlInstancesCPU.requested": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Requested == nil { break } - return e.ComplexityRoot.UpdateSecretValuePayload.Secret(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Requested(childComplexity), true - case "UpdateServiceAccountPayload.serviceAccount": - if e.ComplexityRoot.UpdateServiceAccountPayload.ServiceAccount == nil { + case "TeamServiceUtilizationSqlInstancesCPU.used": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Used == nil { break } - return e.ComplexityRoot.UpdateServiceAccountPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Used(childComplexity), true - case "UpdateServiceAccountTokenPayload.serviceAccount": - if e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccount == nil { + case "TeamServiceUtilizationSqlInstancesCPU.utilization": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Utilization == nil { break } - return e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccount(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesCPU.Utilization(childComplexity), true - case "UpdateServiceAccountTokenPayload.serviceAccountToken": - if e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccountToken == nil { + case "TeamServiceUtilizationSqlInstancesDisk.requested": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Requested == nil { break } - return e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccountToken(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Requested(childComplexity), true - case "UpdateTeamEnvironmentPayload.environment": - if e.ComplexityRoot.UpdateTeamEnvironmentPayload.Environment == nil { + case "TeamServiceUtilizationSqlInstancesDisk.used": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Used == nil { break } - return e.ComplexityRoot.UpdateTeamEnvironmentPayload.Environment(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Used(childComplexity), true - case "UpdateTeamEnvironmentPayload.teamEnvironment": - if e.ComplexityRoot.UpdateTeamEnvironmentPayload.TeamEnvironment == nil { + case "TeamServiceUtilizationSqlInstancesDisk.utilization": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Utilization == nil { break } - return e.ComplexityRoot.UpdateTeamEnvironmentPayload.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesDisk.Utilization(childComplexity), true - case "UpdateTeamPayload.team": - if e.ComplexityRoot.UpdateTeamPayload.Team == nil { + case "TeamServiceUtilizationSqlInstancesMemory.requested": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Requested == nil { break } - return e.ComplexityRoot.UpdateTeamPayload.Team(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Requested(childComplexity), true - case "UpdateUnleashInstancePayload.unleash": - if e.ComplexityRoot.UpdateUnleashInstancePayload.Unleash == nil { + case "TeamServiceUtilizationSqlInstancesMemory.used": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Used == nil { break } - return e.ComplexityRoot.UpdateUnleashInstancePayload.Unleash(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Used(childComplexity), true - case "UpdateValkeyPayload.valkey": - if e.ComplexityRoot.UpdateValkeyPayload.Valkey == nil { + case "TeamServiceUtilizationSqlInstancesMemory.utilization": + if e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Utilization == nil { break } - return e.ComplexityRoot.UpdateValkeyPayload.Valkey(childComplexity), true + return e.ComplexityRoot.TeamServiceUtilizationSqlInstancesMemory.Utilization(childComplexity), true - case "User.email": - if e.ComplexityRoot.User.Email == nil { + case "TeamUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.User.Email(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.Actor(childComplexity), true - case "User.externalID": - if e.ComplexityRoot.User.ExternalID == nil { + case "TeamUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.User.ExternalID(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "User.id": - if e.ComplexityRoot.User.ID == nil { + case "TeamUpdatedActivityLogEntry.data": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.User.ID(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.Data(childComplexity), true - case "User.isAdmin": - if e.ComplexityRoot.User.IsAdmin == nil { + case "TeamUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.User.IsAdmin(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "User.name": - if e.ComplexityRoot.User.Name == nil { + case "TeamUpdatedActivityLogEntry.id": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.User.Name(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.ID(childComplexity), true - case "User.teams": - if e.ComplexityRoot.User.Teams == nil { + case "TeamUpdatedActivityLogEntry.message": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.Message == nil { break } - args, err := ec.field_User_teams_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.User.Teams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.UserTeamOrder)), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.Message(childComplexity), true - case "UserConnection.edges": - if e.ComplexityRoot.UserConnection.Edges == nil { + case "TeamUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.UserConnection.Edges(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "UserConnection.nodes": - if e.ComplexityRoot.UserConnection.Nodes == nil { + case "TeamUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.UserConnection.Nodes(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "UserConnection.pageInfo": - if e.ComplexityRoot.UserConnection.PageInfo == nil { + case "TeamUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.TeamUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.UserConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "UserCreatedUserSyncLogEntry.createdAt": - if e.ComplexityRoot.UserCreatedUserSyncLogEntry.CreatedAt == nil { + case "TeamUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.TeamUpdatedActivityLogEntryData.UpdatedFields == nil { break } - return e.ComplexityRoot.UserCreatedUserSyncLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true - case "UserCreatedUserSyncLogEntry.id": - if e.ComplexityRoot.UserCreatedUserSyncLogEntry.ID == nil { + case "TeamUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.Field == nil { break } - return e.ComplexityRoot.UserCreatedUserSyncLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true - case "UserCreatedUserSyncLogEntry.message": - if e.ComplexityRoot.UserCreatedUserSyncLogEntry.Message == nil { + case "TeamUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { break } - return e.ComplexityRoot.UserCreatedUserSyncLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true - case "UserCreatedUserSyncLogEntry.userEmail": - if e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserEmail == nil { + case "TeamUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { break } - return e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserEmail(childComplexity), true + return e.ComplexityRoot.TeamUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true - case "UserCreatedUserSyncLogEntry.userID": - if e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserID == nil { + case "TeamUtilizationData.environment": + if e.ComplexityRoot.TeamUtilizationData.Environment == nil { break } - return e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserID(childComplexity), true + return e.ComplexityRoot.TeamUtilizationData.Environment(childComplexity), true - case "UserCreatedUserSyncLogEntry.userName": - if e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserName == nil { + case "TeamUtilizationData.requested": + if e.ComplexityRoot.TeamUtilizationData.Requested == nil { break } - return e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserName(childComplexity), true + return e.ComplexityRoot.TeamUtilizationData.Requested(childComplexity), true - case "UserDeletedUserSyncLogEntry.createdAt": - if e.ComplexityRoot.UserDeletedUserSyncLogEntry.CreatedAt == nil { + case "TeamUtilizationData.team": + if e.ComplexityRoot.TeamUtilizationData.Team == nil { break } - return e.ComplexityRoot.UserDeletedUserSyncLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TeamUtilizationData.Team(childComplexity), true - case "UserDeletedUserSyncLogEntry.id": - if e.ComplexityRoot.UserDeletedUserSyncLogEntry.ID == nil { + case "TeamUtilizationData.teamEnvironment": + if e.ComplexityRoot.TeamUtilizationData.TeamEnvironment == nil { break } - return e.ComplexityRoot.UserDeletedUserSyncLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TeamUtilizationData.TeamEnvironment(childComplexity), true - case "UserDeletedUserSyncLogEntry.message": - if e.ComplexityRoot.UserDeletedUserSyncLogEntry.Message == nil { + case "TeamUtilizationData.used": + if e.ComplexityRoot.TeamUtilizationData.Used == nil { break } - return e.ComplexityRoot.UserDeletedUserSyncLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TeamUtilizationData.Used(childComplexity), true - case "UserDeletedUserSyncLogEntry.userEmail": - if e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserEmail == nil { + case "TeamVulnerabilitySummary.coverage": + if e.ComplexityRoot.TeamVulnerabilitySummary.Coverage == nil { break } - return e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserEmail(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.Coverage(childComplexity), true - case "UserDeletedUserSyncLogEntry.userID": - if e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserID == nil { + case "TeamVulnerabilitySummary.critical": + if e.ComplexityRoot.TeamVulnerabilitySummary.Critical == nil { break } - return e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserID(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.Critical(childComplexity), true - case "UserDeletedUserSyncLogEntry.userName": - if e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserName == nil { + case "TeamVulnerabilitySummary.high": + if e.ComplexityRoot.TeamVulnerabilitySummary.High == nil { break } - return e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserName(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.High(childComplexity), true - case "UserEdge.cursor": - if e.ComplexityRoot.UserEdge.Cursor == nil { + case "TeamVulnerabilitySummary.lastUpdated": + if e.ComplexityRoot.TeamVulnerabilitySummary.LastUpdated == nil { break } - return e.ComplexityRoot.UserEdge.Cursor(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.LastUpdated(childComplexity), true - case "UserEdge.node": - if e.ComplexityRoot.UserEdge.Node == nil { + case "TeamVulnerabilitySummary.low": + if e.ComplexityRoot.TeamVulnerabilitySummary.Low == nil { break } - return e.ComplexityRoot.UserEdge.Node(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.Low(childComplexity), true - case "UserSyncLogEntryConnection.edges": - if e.ComplexityRoot.UserSyncLogEntryConnection.Edges == nil { + case "TeamVulnerabilitySummary.medium": + if e.ComplexityRoot.TeamVulnerabilitySummary.Medium == nil { break } - return e.ComplexityRoot.UserSyncLogEntryConnection.Edges(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.Medium(childComplexity), true - case "UserSyncLogEntryConnection.nodes": - if e.ComplexityRoot.UserSyncLogEntryConnection.Nodes == nil { + case "TeamVulnerabilitySummary.riskScore": + if e.ComplexityRoot.TeamVulnerabilitySummary.RiskScore == nil { break } - return e.ComplexityRoot.UserSyncLogEntryConnection.Nodes(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.RiskScore(childComplexity), true - case "UserSyncLogEntryConnection.pageInfo": - if e.ComplexityRoot.UserSyncLogEntryConnection.PageInfo == nil { + case "TeamVulnerabilitySummary.riskScoreTrend": + if e.ComplexityRoot.TeamVulnerabilitySummary.RiskScoreTrend == nil { break } - return e.ComplexityRoot.UserSyncLogEntryConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.RiskScoreTrend(childComplexity), true - case "UserSyncLogEntryEdge.cursor": - if e.ComplexityRoot.UserSyncLogEntryEdge.Cursor == nil { + case "TeamVulnerabilitySummary.sbomCount": + if e.ComplexityRoot.TeamVulnerabilitySummary.SBOMCount == nil { break } - return e.ComplexityRoot.UserSyncLogEntryEdge.Cursor(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.SBOMCount(childComplexity), true - case "UserSyncLogEntryEdge.node": - if e.ComplexityRoot.UserSyncLogEntryEdge.Node == nil { + case "TeamVulnerabilitySummary.unassigned": + if e.ComplexityRoot.TeamVulnerabilitySummary.Unassigned == nil { break } - return e.ComplexityRoot.UserSyncLogEntryEdge.Node(childComplexity), true + return e.ComplexityRoot.TeamVulnerabilitySummary.Unassigned(childComplexity), true - case "UserUpdatedUserSyncLogEntry.createdAt": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.CreatedAt == nil { + case "TenantVulnerabilitySummary.coverage": + if e.ComplexityRoot.TenantVulnerabilitySummary.Coverage == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.Coverage(childComplexity), true - case "UserUpdatedUserSyncLogEntry.id": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.ID == nil { + case "TenantVulnerabilitySummary.critical": + if e.ComplexityRoot.TenantVulnerabilitySummary.Critical == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.ID(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.Critical(childComplexity), true - case "UserUpdatedUserSyncLogEntry.message": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.Message == nil { + case "TenantVulnerabilitySummary.high": + if e.ComplexityRoot.TenantVulnerabilitySummary.High == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.Message(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.High(childComplexity), true - case "UserUpdatedUserSyncLogEntry.oldUserEmail": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserEmail == nil { + case "TenantVulnerabilitySummary.lastUpdated": + if e.ComplexityRoot.TenantVulnerabilitySummary.LastUpdated == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserEmail(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.LastUpdated(childComplexity), true - case "UserUpdatedUserSyncLogEntry.oldUserName": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserName == nil { + case "TenantVulnerabilitySummary.low": + if e.ComplexityRoot.TenantVulnerabilitySummary.Low == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserName(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.Low(childComplexity), true - case "UserUpdatedUserSyncLogEntry.userEmail": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserEmail == nil { + case "TenantVulnerabilitySummary.medium": + if e.ComplexityRoot.TenantVulnerabilitySummary.Medium == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserEmail(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.Medium(childComplexity), true - case "UserUpdatedUserSyncLogEntry.userID": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserID == nil { + case "TenantVulnerabilitySummary.riskScore": + if e.ComplexityRoot.TenantVulnerabilitySummary.RiskScore == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserID(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.RiskScore(childComplexity), true - case "UserUpdatedUserSyncLogEntry.userName": - if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserName == nil { + case "TenantVulnerabilitySummary.sbomCount": + if e.ComplexityRoot.TenantVulnerabilitySummary.SbomCount == nil { break } - return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserName(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.SbomCount(childComplexity), true - case "UtilizationSample.instance": - if e.ComplexityRoot.UtilizationSample.Instance == nil { + case "TenantVulnerabilitySummary.unassigned": + if e.ComplexityRoot.TenantVulnerabilitySummary.Unassigned == nil { break } - return e.ComplexityRoot.UtilizationSample.Instance(childComplexity), true + return e.ComplexityRoot.TenantVulnerabilitySummary.Unassigned(childComplexity), true - case "UtilizationSample.timestamp": - if e.ComplexityRoot.UtilizationSample.Timestamp == nil { + case "TokenXAuthIntegration.name": + if e.ComplexityRoot.TokenXAuthIntegration.Name == nil { break } - return e.ComplexityRoot.UtilizationSample.Timestamp(childComplexity), true + return e.ComplexityRoot.TokenXAuthIntegration.Name(childComplexity), true - case "UtilizationSample.value": - if e.ComplexityRoot.UtilizationSample.Value == nil { + case "TriggerJobPayload.job": + if e.ComplexityRoot.TriggerJobPayload.Job == nil { break } - return e.ComplexityRoot.UtilizationSample.Value(childComplexity), true + return e.ComplexityRoot.TriggerJobPayload.Job(childComplexity), true - case "Valkey.access": - if e.ComplexityRoot.Valkey.Access == nil { + case "TriggerJobPayload.jobRun": + if e.ComplexityRoot.TriggerJobPayload.JobRun == nil { break } - args, err := ec.field_Valkey_access_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.TriggerJobPayload.JobRun(childComplexity), true + + case "UnleashInstance.apiIngress": + if e.ComplexityRoot.UnleashInstance.APIIngress == nil { + break } - return e.ComplexityRoot.Valkey.Access(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*valkey.ValkeyAccessOrder)), true + return e.ComplexityRoot.UnleashInstance.APIIngress(childComplexity), true - case "Valkey.activityLog": - if e.ComplexityRoot.Valkey.ActivityLog == nil { + case "UnleashInstance.allowedTeams": + if e.ComplexityRoot.UnleashInstance.AllowedTeams == nil { break } - args, err := ec.field_Valkey_activityLog_args(ctx, rawArgs) + args, err := ec.field_UnleashInstance_allowedTeams_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.Valkey.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + return e.ComplexityRoot.UnleashInstance.AllowedTeams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true - case "Valkey.cost": - if e.ComplexityRoot.Valkey.Cost == nil { + case "UnleashInstance.id": + if e.ComplexityRoot.UnleashInstance.ID == nil { break } - return e.ComplexityRoot.Valkey.Cost(childComplexity), true + return e.ComplexityRoot.UnleashInstance.ID(childComplexity), true - case "Valkey.databases": - if e.ComplexityRoot.Valkey.Databases == nil { + case "UnleashInstance.metrics": + if e.ComplexityRoot.UnleashInstance.Metrics == nil { break } - return e.ComplexityRoot.Valkey.Databases(childComplexity), true + return e.ComplexityRoot.UnleashInstance.Metrics(childComplexity), true - case "Valkey.environment": - if e.ComplexityRoot.Valkey.Environment == nil { + case "UnleashInstance.name": + if e.ComplexityRoot.UnleashInstance.Name == nil { break } - return e.ComplexityRoot.Valkey.Environment(childComplexity), true + return e.ComplexityRoot.UnleashInstance.Name(childComplexity), true - case "Valkey.id": - if e.ComplexityRoot.Valkey.ID == nil { + case "UnleashInstance.ready": + if e.ComplexityRoot.UnleashInstance.Ready == nil { break } - return e.ComplexityRoot.Valkey.ID(childComplexity), true + return e.ComplexityRoot.UnleashInstance.Ready(childComplexity), true - case "Valkey.issues": - if e.ComplexityRoot.Valkey.Issues == nil { + case "UnleashInstance.releaseChannel": + if e.ComplexityRoot.UnleashInstance.ReleaseChannel == nil { break } - args, err := ec.field_Valkey_issues_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.Valkey.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true + return e.ComplexityRoot.UnleashInstance.ReleaseChannel(childComplexity), true - case "Valkey.maintenance": - if e.ComplexityRoot.Valkey.Maintenance == nil { + case "UnleashInstance.releaseChannelName": + if e.ComplexityRoot.UnleashInstance.ReleaseChannelName == nil { break } - return e.ComplexityRoot.Valkey.Maintenance(childComplexity), true + return e.ComplexityRoot.UnleashInstance.ReleaseChannelName(childComplexity), true - case "Valkey.maxMemoryPolicy": - if e.ComplexityRoot.Valkey.MaxMemoryPolicy == nil { + case "UnleashInstance.version": + if e.ComplexityRoot.UnleashInstance.Version == nil { break } - return e.ComplexityRoot.Valkey.MaxMemoryPolicy(childComplexity), true + return e.ComplexityRoot.UnleashInstance.Version(childComplexity), true - case "Valkey.memory": - if e.ComplexityRoot.Valkey.Memory == nil { + case "UnleashInstance.webIngress": + if e.ComplexityRoot.UnleashInstance.WebIngress == nil { break } - return e.ComplexityRoot.Valkey.Memory(childComplexity), true + return e.ComplexityRoot.UnleashInstance.WebIngress(childComplexity), true - case "Valkey.name": - if e.ComplexityRoot.Valkey.Name == nil { + case "UnleashInstanceCreatedActivityLogEntry.actor": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.Valkey.Name(childComplexity), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Actor(childComplexity), true - case "Valkey.notifyKeyspaceEvents": - if e.ComplexityRoot.Valkey.NotifyKeyspaceEvents == nil { + case "UnleashInstanceCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.Valkey.NotifyKeyspaceEvents(childComplexity), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "Valkey.state": - if e.ComplexityRoot.Valkey.State == nil { + case "UnleashInstanceCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.Valkey.State(childComplexity), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.EnvironmentName(childComplexity), true - case "Valkey.team": - if e.ComplexityRoot.Valkey.Team == nil { + case "UnleashInstanceCreatedActivityLogEntry.id": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.Valkey.Team(childComplexity), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ID(childComplexity), true - case "Valkey.teamEnvironment": - if e.ComplexityRoot.Valkey.TeamEnvironment == nil { + case "UnleashInstanceCreatedActivityLogEntry.message": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.Valkey.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.Message(childComplexity), true - case "Valkey.terminationProtection": - if e.ComplexityRoot.Valkey.TerminationProtection == nil { + case "UnleashInstanceCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.Valkey.TerminationProtection(childComplexity), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceName(childComplexity), true - case "Valkey.tier": - if e.ComplexityRoot.Valkey.Tier == nil { + case "UnleashInstanceCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.Valkey.Tier(childComplexity), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.ResourceType(childComplexity), true - case "Valkey.workload": - if e.ComplexityRoot.Valkey.Workload == nil { + case "UnleashInstanceCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.Valkey.Workload(childComplexity), true + return e.ComplexityRoot.UnleashInstanceCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "ValkeyAccess.access": - if e.ComplexityRoot.ValkeyAccess.Access == nil { + case "UnleashInstanceDeletedActivityLogEntry.actor": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ValkeyAccess.Access(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Actor(childComplexity), true - case "ValkeyAccess.workload": - if e.ComplexityRoot.ValkeyAccess.Workload == nil { + case "UnleashInstanceDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ValkeyAccess.Workload(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "ValkeyAccessConnection.edges": - if e.ComplexityRoot.ValkeyAccessConnection.Edges == nil { + case "UnleashInstanceDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ValkeyAccessConnection.Edges(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "ValkeyAccessConnection.nodes": - if e.ComplexityRoot.ValkeyAccessConnection.Nodes == nil { + case "UnleashInstanceDeletedActivityLogEntry.id": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ValkeyAccessConnection.Nodes(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ID(childComplexity), true - case "ValkeyAccessConnection.pageInfo": - if e.ComplexityRoot.ValkeyAccessConnection.PageInfo == nil { + case "UnleashInstanceDeletedActivityLogEntry.message": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ValkeyAccessConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.Message(childComplexity), true - case "ValkeyAccessEdge.cursor": - if e.ComplexityRoot.ValkeyAccessEdge.Cursor == nil { + case "UnleashInstanceDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ValkeyAccessEdge.Cursor(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceName(childComplexity), true - case "ValkeyAccessEdge.node": - if e.ComplexityRoot.ValkeyAccessEdge.Node == nil { + case "UnleashInstanceDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ValkeyAccessEdge.Node(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.ResourceType(childComplexity), true - case "ValkeyConnection.edges": - if e.ComplexityRoot.ValkeyConnection.Edges == nil { + case "UnleashInstanceDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ValkeyConnection.Edges(childComplexity), true + return e.ComplexityRoot.UnleashInstanceDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "ValkeyConnection.nodes": - if e.ComplexityRoot.ValkeyConnection.Nodes == nil { + case "UnleashInstanceMetrics.apiTokens": + if e.ComplexityRoot.UnleashInstanceMetrics.APITokens == nil { break } - return e.ComplexityRoot.ValkeyConnection.Nodes(childComplexity), true + return e.ComplexityRoot.UnleashInstanceMetrics.APITokens(childComplexity), true - case "ValkeyConnection.pageInfo": - if e.ComplexityRoot.ValkeyConnection.PageInfo == nil { + case "UnleashInstanceMetrics.cpuRequests": + if e.ComplexityRoot.UnleashInstanceMetrics.CPURequests == nil { break } - return e.ComplexityRoot.ValkeyConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.UnleashInstanceMetrics.CPURequests(childComplexity), true - case "ValkeyCost.sum": - if e.ComplexityRoot.ValkeyCost.Sum == nil { + case "UnleashInstanceMetrics.cpuUtilization": + if e.ComplexityRoot.UnleashInstanceMetrics.CPUUtilization == nil { break } - return e.ComplexityRoot.ValkeyCost.Sum(childComplexity), true + return e.ComplexityRoot.UnleashInstanceMetrics.CPUUtilization(childComplexity), true - case "ValkeyCreatedActivityLogEntry.actor": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Actor == nil { + case "UnleashInstanceMetrics.memoryRequests": + if e.ComplexityRoot.UnleashInstanceMetrics.MemoryRequests == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.UnleashInstanceMetrics.MemoryRequests(childComplexity), true - case "ValkeyCreatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.CreatedAt == nil { + case "UnleashInstanceMetrics.memoryUtilization": + if e.ComplexityRoot.UnleashInstanceMetrics.MemoryUtilization == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.UnleashInstanceMetrics.MemoryUtilization(childComplexity), true - case "ValkeyCreatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.EnvironmentName == nil { + case "UnleashInstanceMetrics.toggles": + if e.ComplexityRoot.UnleashInstanceMetrics.Toggles == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.UnleashInstanceMetrics.Toggles(childComplexity), true - case "ValkeyCreatedActivityLogEntry.id": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ID == nil { + case "UnleashInstanceUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Actor(childComplexity), true - case "ValkeyCreatedActivityLogEntry.message": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Message == nil { + case "UnleashInstanceUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.CreatedAt(childComplexity), true - case "ValkeyCreatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceName == nil { + case "UnleashInstanceUpdatedActivityLogEntry.data": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Data == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Data(childComplexity), true - case "ValkeyCreatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceType == nil { + case "UnleashInstanceUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.EnvironmentName(childComplexity), true - case "ValkeyCreatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.TeamSlug == nil { + case "UnleashInstanceUpdatedActivityLogEntry.id": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ID(childComplexity), true - case "ValkeyCredentials.host": - if e.ComplexityRoot.ValkeyCredentials.Host == nil { + case "UnleashInstanceUpdatedActivityLogEntry.message": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.ValkeyCredentials.Host(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.Message(childComplexity), true - case "ValkeyCredentials.password": - if e.ComplexityRoot.ValkeyCredentials.Password == nil { + case "UnleashInstanceUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.ValkeyCredentials.Password(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceName(childComplexity), true - case "ValkeyCredentials.port": - if e.ComplexityRoot.ValkeyCredentials.Port == nil { + case "UnleashInstanceUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.ValkeyCredentials.Port(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.ResourceType(childComplexity), true - case "ValkeyCredentials.uri": - if e.ComplexityRoot.ValkeyCredentials.URI == nil { + case "UnleashInstanceUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.ValkeyCredentials.URI(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntry.TeamSlug(childComplexity), true - case "ValkeyCredentials.username": - if e.ComplexityRoot.ValkeyCredentials.Username == nil { + case "UnleashInstanceUpdatedActivityLogEntryData.allowedTeamSlug": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.AllowedTeamSlug == nil { break } - return e.ComplexityRoot.ValkeyCredentials.Username(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.AllowedTeamSlug(childComplexity), true - case "ValkeyDeletedActivityLogEntry.actor": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Actor == nil { + case "UnleashInstanceUpdatedActivityLogEntryData.revokedTeamSlug": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.RevokedTeamSlug == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.RevokedTeamSlug(childComplexity), true - case "ValkeyDeletedActivityLogEntry.createdAt": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.CreatedAt == nil { + case "UnleashInstanceUpdatedActivityLogEntryData.updatedReleaseChannel": + if e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.UpdatedReleaseChannel == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.UnleashInstanceUpdatedActivityLogEntryData.UpdatedReleaseChannel(childComplexity), true - case "ValkeyDeletedActivityLogEntry.environmentName": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.EnvironmentName == nil { + case "UnleashReleaseChannel.currentVersion": + if e.ComplexityRoot.UnleashReleaseChannel.CurrentVersion == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannel.CurrentVersion(childComplexity), true - case "ValkeyDeletedActivityLogEntry.id": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ID == nil { + case "UnleashReleaseChannel.lastUpdated": + if e.ComplexityRoot.UnleashReleaseChannel.LastUpdated == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannel.LastUpdated(childComplexity), true - case "ValkeyDeletedActivityLogEntry.message": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Message == nil { + case "UnleashReleaseChannel.name": + if e.ComplexityRoot.UnleashReleaseChannel.Name == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannel.Name(childComplexity), true - case "ValkeyDeletedActivityLogEntry.resourceName": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceName == nil { + case "UnleashReleaseChannel.type": + if e.ComplexityRoot.UnleashReleaseChannel.Type == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannel.Type(childComplexity), true - case "ValkeyDeletedActivityLogEntry.resourceType": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceType == nil { + case "UnleashReleaseChannelIssue.channelName": + if e.ComplexityRoot.UnleashReleaseChannelIssue.ChannelName == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.ChannelName(childComplexity), true - case "ValkeyDeletedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.TeamSlug == nil { + case "UnleashReleaseChannelIssue.currentMajorVersion": + if e.ComplexityRoot.UnleashReleaseChannelIssue.CurrentMajorVersion == nil { break } - return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.CurrentMajorVersion(childComplexity), true - case "ValkeyEdge.cursor": - if e.ComplexityRoot.ValkeyEdge.Cursor == nil { + case "UnleashReleaseChannelIssue.id": + if e.ComplexityRoot.UnleashReleaseChannelIssue.ID == nil { break } - return e.ComplexityRoot.ValkeyEdge.Cursor(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.ID(childComplexity), true - case "ValkeyEdge.node": - if e.ComplexityRoot.ValkeyEdge.Node == nil { + case "UnleashReleaseChannelIssue.majorVersion": + if e.ComplexityRoot.UnleashReleaseChannelIssue.MajorVersion == nil { break } - return e.ComplexityRoot.ValkeyEdge.Node(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.MajorVersion(childComplexity), true - case "ValkeyIssue.event": - if e.ComplexityRoot.ValkeyIssue.Event == nil { + case "UnleashReleaseChannelIssue.message": + if e.ComplexityRoot.UnleashReleaseChannelIssue.Message == nil { break } - return e.ComplexityRoot.ValkeyIssue.Event(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.Message(childComplexity), true - case "ValkeyIssue.id": - if e.ComplexityRoot.ValkeyIssue.ID == nil { + case "UnleashReleaseChannelIssue.severity": + if e.ComplexityRoot.UnleashReleaseChannelIssue.Severity == nil { break } - return e.ComplexityRoot.ValkeyIssue.ID(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.Severity(childComplexity), true - case "ValkeyIssue.message": - if e.ComplexityRoot.ValkeyIssue.Message == nil { + case "UnleashReleaseChannelIssue.teamEnvironment": + if e.ComplexityRoot.UnleashReleaseChannelIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.ValkeyIssue.Message(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.TeamEnvironment(childComplexity), true - case "ValkeyIssue.severity": - if e.ComplexityRoot.ValkeyIssue.Severity == nil { + case "UnleashReleaseChannelIssue.unleash": + if e.ComplexityRoot.UnleashReleaseChannelIssue.Unleash == nil { break } - return e.ComplexityRoot.ValkeyIssue.Severity(childComplexity), true + return e.ComplexityRoot.UnleashReleaseChannelIssue.Unleash(childComplexity), true - case "ValkeyIssue.teamEnvironment": - if e.ComplexityRoot.ValkeyIssue.TeamEnvironment == nil { + case "UpdateConfigValuePayload.config": + if e.ComplexityRoot.UpdateConfigValuePayload.Config == nil { break } - return e.ComplexityRoot.ValkeyIssue.TeamEnvironment(childComplexity), true + return e.ComplexityRoot.UpdateConfigValuePayload.Config(childComplexity), true - case "ValkeyIssue.valkey": - if e.ComplexityRoot.ValkeyIssue.Valkey == nil { + case "UpdateImageVulnerabilityPayload.vulnerability": + if e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability == nil { break } - return e.ComplexityRoot.ValkeyIssue.Valkey(childComplexity), true + return e.ComplexityRoot.UpdateImageVulnerabilityPayload.Vulnerability(childComplexity), true - case "ValkeyMaintenance.updates": - if e.ComplexityRoot.ValkeyMaintenance.Updates == nil { + case "UpdateOpenSearchPayload.openSearch": + if e.ComplexityRoot.UpdateOpenSearchPayload.OpenSearch == nil { break } - args, err := ec.field_ValkeyMaintenance_updates_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.ValkeyMaintenance.Updates(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + return e.ComplexityRoot.UpdateOpenSearchPayload.OpenSearch(childComplexity), true - case "ValkeyMaintenance.window": - if e.ComplexityRoot.ValkeyMaintenance.Window == nil { + case "UpdateSecretValuePayload.secret": + if e.ComplexityRoot.UpdateSecretValuePayload.Secret == nil { break } - return e.ComplexityRoot.ValkeyMaintenance.Window(childComplexity), true + return e.ComplexityRoot.UpdateSecretValuePayload.Secret(childComplexity), true - case "ValkeyMaintenanceUpdate.deadline": - if e.ComplexityRoot.ValkeyMaintenanceUpdate.Deadline == nil { + case "UpdateServiceAccountPayload.serviceAccount": + if e.ComplexityRoot.UpdateServiceAccountPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdate.Deadline(childComplexity), true + return e.ComplexityRoot.UpdateServiceAccountPayload.ServiceAccount(childComplexity), true - case "ValkeyMaintenanceUpdate.description": - if e.ComplexityRoot.ValkeyMaintenanceUpdate.Description == nil { + case "UpdateServiceAccountTokenPayload.serviceAccount": + if e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccount == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdate.Description(childComplexity), true + return e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccount(childComplexity), true - case "ValkeyMaintenanceUpdate.startAt": - if e.ComplexityRoot.ValkeyMaintenanceUpdate.StartAt == nil { + case "UpdateServiceAccountTokenPayload.serviceAccountToken": + if e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccountToken == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdate.StartAt(childComplexity), true + return e.ComplexityRoot.UpdateServiceAccountTokenPayload.ServiceAccountToken(childComplexity), true - case "ValkeyMaintenanceUpdate.title": - if e.ComplexityRoot.ValkeyMaintenanceUpdate.Title == nil { + case "UpdateTeamEnvironmentPayload.environment": + if e.ComplexityRoot.UpdateTeamEnvironmentPayload.Environment == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdate.Title(childComplexity), true + return e.ComplexityRoot.UpdateTeamEnvironmentPayload.Environment(childComplexity), true - case "ValkeyMaintenanceUpdateConnection.edges": - if e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Edges == nil { + case "UpdateTeamEnvironmentPayload.teamEnvironment": + if e.ComplexityRoot.UpdateTeamEnvironmentPayload.TeamEnvironment == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Edges(childComplexity), true + return e.ComplexityRoot.UpdateTeamEnvironmentPayload.TeamEnvironment(childComplexity), true - case "ValkeyMaintenanceUpdateConnection.nodes": - if e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Nodes == nil { + case "UpdateTeamPayload.team": + if e.ComplexityRoot.UpdateTeamPayload.Team == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Nodes(childComplexity), true + return e.ComplexityRoot.UpdateTeamPayload.Team(childComplexity), true - case "ValkeyMaintenanceUpdateConnection.pageInfo": - if e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.PageInfo == nil { + case "UpdateUnleashInstancePayload.unleash": + if e.ComplexityRoot.UpdateUnleashInstancePayload.Unleash == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.UpdateUnleashInstancePayload.Unleash(childComplexity), true - case "ValkeyMaintenanceUpdateEdge.cursor": - if e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Cursor == nil { + case "UpdateValkeyPayload.valkey": + if e.ComplexityRoot.UpdateValkeyPayload.Valkey == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Cursor(childComplexity), true + return e.ComplexityRoot.UpdateValkeyPayload.Valkey(childComplexity), true - case "ValkeyMaintenanceUpdateEdge.node": - if e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Node == nil { + case "User.email": + if e.ComplexityRoot.User.Email == nil { break } - return e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Node(childComplexity), true + return e.ComplexityRoot.User.Email(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Actor == nil { + case "User.externalID": + if e.ComplexityRoot.User.ExternalID == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.User.ExternalID(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.CreatedAt == nil { + case "User.id": + if e.ComplexityRoot.User.ID == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.User.ID(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.data": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Data == nil { + case "User.isAdmin": + if e.ComplexityRoot.User.IsAdmin == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.User.IsAdmin(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.EnvironmentName == nil { + case "User.name": + if e.ComplexityRoot.User.Name == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.User.Name(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.id": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ID == nil { + case "User.teams": + if e.ComplexityRoot.User.Teams == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ID(childComplexity), true - - case "ValkeyUpdatedActivityLogEntry.message": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Message == nil { - break + args, err := ec.field_User_teams_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.User.Teams(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*team.UserTeamOrder)), true - case "ValkeyUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceName == nil { + case "UserConnection.edges": + if e.ComplexityRoot.UserConnection.Edges == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.UserConnection.Edges(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceType == nil { + case "UserConnection.nodes": + if e.ComplexityRoot.UserConnection.Nodes == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.UserConnection.Nodes(childComplexity), true - case "ValkeyUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.TeamSlug == nil { + case "UserConnection.pageInfo": + if e.ComplexityRoot.UserConnection.PageInfo == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.UserConnection.PageInfo(childComplexity), true - case "ValkeyUpdatedActivityLogEntryData.updatedFields": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryData.UpdatedFields == nil { + case "UserCreatedUserSyncLogEntry.createdAt": + if e.ComplexityRoot.UserCreatedUserSyncLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + return e.ComplexityRoot.UserCreatedUserSyncLogEntry.CreatedAt(childComplexity), true - case "ValkeyUpdatedActivityLogEntryDataUpdatedField.field": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.Field == nil { + case "UserCreatedUserSyncLogEntry.id": + if e.ComplexityRoot.UserCreatedUserSyncLogEntry.ID == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + return e.ComplexityRoot.UserCreatedUserSyncLogEntry.ID(childComplexity), true - case "ValkeyUpdatedActivityLogEntryDataUpdatedField.newValue": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + case "UserCreatedUserSyncLogEntry.message": + if e.ComplexityRoot.UserCreatedUserSyncLogEntry.Message == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + return e.ComplexityRoot.UserCreatedUserSyncLogEntry.Message(childComplexity), true - case "ValkeyUpdatedActivityLogEntryDataUpdatedField.oldValue": - if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + case "UserCreatedUserSyncLogEntry.userEmail": + if e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserEmail == nil { break } - return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + return e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserEmail(childComplexity), true - case "ViewSecretValuesPayload.values": - if e.ComplexityRoot.ViewSecretValuesPayload.Values == nil { + case "UserCreatedUserSyncLogEntry.userID": + if e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserID == nil { break } - return e.ComplexityRoot.ViewSecretValuesPayload.Values(childComplexity), true + return e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserID(childComplexity), true - case "VulnerabilityActivityLogEntryData.identifier": - if e.ComplexityRoot.VulnerabilityActivityLogEntryData.Identifier == nil { + case "UserCreatedUserSyncLogEntry.userName": + if e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserName == nil { break } - return e.ComplexityRoot.VulnerabilityActivityLogEntryData.Identifier(childComplexity), true + return e.ComplexityRoot.UserCreatedUserSyncLogEntry.UserName(childComplexity), true - case "VulnerabilityActivityLogEntryData.newSuppression": - if e.ComplexityRoot.VulnerabilityActivityLogEntryData.NewSuppression == nil { + case "UserDeletedUserSyncLogEntry.createdAt": + if e.ComplexityRoot.UserDeletedUserSyncLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.VulnerabilityActivityLogEntryData.NewSuppression(childComplexity), true + return e.ComplexityRoot.UserDeletedUserSyncLogEntry.CreatedAt(childComplexity), true - case "VulnerabilityActivityLogEntryData.package": - if e.ComplexityRoot.VulnerabilityActivityLogEntryData.Package == nil { + case "UserDeletedUserSyncLogEntry.id": + if e.ComplexityRoot.UserDeletedUserSyncLogEntry.ID == nil { break } - return e.ComplexityRoot.VulnerabilityActivityLogEntryData.Package(childComplexity), true + return e.ComplexityRoot.UserDeletedUserSyncLogEntry.ID(childComplexity), true - case "VulnerabilityActivityLogEntryData.previousSuppression": - if e.ComplexityRoot.VulnerabilityActivityLogEntryData.PreviousSuppression == nil { + case "UserDeletedUserSyncLogEntry.message": + if e.ComplexityRoot.UserDeletedUserSyncLogEntry.Message == nil { break } - return e.ComplexityRoot.VulnerabilityActivityLogEntryData.PreviousSuppression(childComplexity), true + return e.ComplexityRoot.UserDeletedUserSyncLogEntry.Message(childComplexity), true - case "VulnerabilityActivityLogEntryData.severity": - if e.ComplexityRoot.VulnerabilityActivityLogEntryData.Severity == nil { + case "UserDeletedUserSyncLogEntry.userEmail": + if e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserEmail == nil { break } - return e.ComplexityRoot.VulnerabilityActivityLogEntryData.Severity(childComplexity), true + return e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserEmail(childComplexity), true - case "VulnerabilityFixHistory.samples": - if e.ComplexityRoot.VulnerabilityFixHistory.Samples == nil { + case "UserDeletedUserSyncLogEntry.userID": + if e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserID == nil { break } - return e.ComplexityRoot.VulnerabilityFixHistory.Samples(childComplexity), true + return e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserID(childComplexity), true - case "VulnerabilityFixSample.date": - if e.ComplexityRoot.VulnerabilityFixSample.Date == nil { + case "UserDeletedUserSyncLogEntry.userName": + if e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserName == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.Date(childComplexity), true + return e.ComplexityRoot.UserDeletedUserSyncLogEntry.UserName(childComplexity), true - case "VulnerabilityFixSample.days": - if e.ComplexityRoot.VulnerabilityFixSample.Days == nil { + case "UserEdge.cursor": + if e.ComplexityRoot.UserEdge.Cursor == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.Days(childComplexity), true + return e.ComplexityRoot.UserEdge.Cursor(childComplexity), true - case "VulnerabilityFixSample.firstFixedAt": - if e.ComplexityRoot.VulnerabilityFixSample.FirstFixedAt == nil { + case "UserEdge.node": + if e.ComplexityRoot.UserEdge.Node == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.FirstFixedAt(childComplexity), true + return e.ComplexityRoot.UserEdge.Node(childComplexity), true - case "VulnerabilityFixSample.fixedCount": - if e.ComplexityRoot.VulnerabilityFixSample.FixedCount == nil { + case "UserSyncLogEntryConnection.edges": + if e.ComplexityRoot.UserSyncLogEntryConnection.Edges == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.FixedCount(childComplexity), true + return e.ComplexityRoot.UserSyncLogEntryConnection.Edges(childComplexity), true - case "VulnerabilityFixSample.lastFixedAt": - if e.ComplexityRoot.VulnerabilityFixSample.LastFixedAt == nil { + case "UserSyncLogEntryConnection.nodes": + if e.ComplexityRoot.UserSyncLogEntryConnection.Nodes == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.LastFixedAt(childComplexity), true + return e.ComplexityRoot.UserSyncLogEntryConnection.Nodes(childComplexity), true - case "VulnerabilityFixSample.severity": - if e.ComplexityRoot.VulnerabilityFixSample.Severity == nil { + case "UserSyncLogEntryConnection.pageInfo": + if e.ComplexityRoot.UserSyncLogEntryConnection.PageInfo == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.Severity(childComplexity), true + return e.ComplexityRoot.UserSyncLogEntryConnection.PageInfo(childComplexity), true - case "VulnerabilityFixSample.totalWorkloads": - if e.ComplexityRoot.VulnerabilityFixSample.TotalWorkloads == nil { + case "UserSyncLogEntryEdge.cursor": + if e.ComplexityRoot.UserSyncLogEntryEdge.Cursor == nil { break } - return e.ComplexityRoot.VulnerabilityFixSample.TotalWorkloads(childComplexity), true + return e.ComplexityRoot.UserSyncLogEntryEdge.Cursor(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.actor": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Actor == nil { + case "UserSyncLogEntryEdge.node": + if e.ComplexityRoot.UserSyncLogEntryEdge.Node == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Actor(childComplexity), true + return e.ComplexityRoot.UserSyncLogEntryEdge.Node(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.createdAt": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.CreatedAt == nil { + case "UserUpdatedUserSyncLogEntry.createdAt": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.CreatedAt(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.CreatedAt(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.data": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Data == nil { + case "UserUpdatedUserSyncLogEntry.id": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.ID == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Data(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.ID(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.environmentName": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.EnvironmentName == nil { + case "UserUpdatedUserSyncLogEntry.message": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.Message == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.Message(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.id": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ID == nil { + case "UserUpdatedUserSyncLogEntry.oldUserEmail": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserEmail == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ID(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserEmail(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.message": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Message == nil { + case "UserUpdatedUserSyncLogEntry.oldUserName": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserName == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Message(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.OldUserName(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.resourceName": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceName == nil { + case "UserUpdatedUserSyncLogEntry.userEmail": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserEmail == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceName(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserEmail(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.resourceType": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceType == nil { + case "UserUpdatedUserSyncLogEntry.userID": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserID == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceType(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserID(childComplexity), true - case "VulnerabilityUpdatedActivityLogEntry.teamSlug": - if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.TeamSlug == nil { + case "UserUpdatedUserSyncLogEntry.userName": + if e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserName == nil { break } - return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.TeamSlug(childComplexity), true + return e.ComplexityRoot.UserUpdatedUserSyncLogEntry.UserName(childComplexity), true - case "VulnerableImageIssue.critical": - if e.ComplexityRoot.VulnerableImageIssue.Critical == nil { + case "UtilizationSample.instance": + if e.ComplexityRoot.UtilizationSample.Instance == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.Critical(childComplexity), true + return e.ComplexityRoot.UtilizationSample.Instance(childComplexity), true - case "VulnerableImageIssue.id": - if e.ComplexityRoot.VulnerableImageIssue.ID == nil { + case "UtilizationSample.timestamp": + if e.ComplexityRoot.UtilizationSample.Timestamp == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.ID(childComplexity), true + return e.ComplexityRoot.UtilizationSample.Timestamp(childComplexity), true - case "VulnerableImageIssue.message": - if e.ComplexityRoot.VulnerableImageIssue.Message == nil { + case "UtilizationSample.value": + if e.ComplexityRoot.UtilizationSample.Value == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.Message(childComplexity), true + return e.ComplexityRoot.UtilizationSample.Value(childComplexity), true - case "VulnerableImageIssue.riskScore": - if e.ComplexityRoot.VulnerableImageIssue.RiskScore == nil { + case "Valkey.access": + if e.ComplexityRoot.Valkey.Access == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.RiskScore(childComplexity), true - - case "VulnerableImageIssue.severity": - if e.ComplexityRoot.VulnerableImageIssue.Severity == nil { - break + args, err := ec.field_Valkey_access_args(ctx, rawArgs) + if err != nil { + return 0, false } - return e.ComplexityRoot.VulnerableImageIssue.Severity(childComplexity), true + return e.ComplexityRoot.Valkey.Access(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*valkey.ValkeyAccessOrder)), true - case "VulnerableImageIssue.teamEnvironment": - if e.ComplexityRoot.VulnerableImageIssue.TeamEnvironment == nil { + case "Valkey.activityLog": + if e.ComplexityRoot.Valkey.ActivityLog == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.TeamEnvironment(childComplexity), true + args, err := ec.field_Valkey_activityLog_args(ctx, rawArgs) + if err != nil { + return 0, false + } - case "VulnerableImageIssue.workload": - if e.ComplexityRoot.VulnerableImageIssue.Workload == nil { + return e.ComplexityRoot.Valkey.ActivityLog(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["filter"].(*activitylog.ActivityLogFilter)), true + + case "Valkey.cost": + if e.ComplexityRoot.Valkey.Cost == nil { break } - return e.ComplexityRoot.VulnerableImageIssue.Workload(childComplexity), true + return e.ComplexityRoot.Valkey.Cost(childComplexity), true - case "WorkloadConnection.edges": - if e.ComplexityRoot.WorkloadConnection.Edges == nil { + case "Valkey.databases": + if e.ComplexityRoot.Valkey.Databases == nil { break } - return e.ComplexityRoot.WorkloadConnection.Edges(childComplexity), true + return e.ComplexityRoot.Valkey.Databases(childComplexity), true - case "WorkloadConnection.nodes": - if e.ComplexityRoot.WorkloadConnection.Nodes == nil { + case "Valkey.environment": + if e.ComplexityRoot.Valkey.Environment == nil { break } - return e.ComplexityRoot.WorkloadConnection.Nodes(childComplexity), true + return e.ComplexityRoot.Valkey.Environment(childComplexity), true - case "WorkloadConnection.pageInfo": - if e.ComplexityRoot.WorkloadConnection.PageInfo == nil { + case "Valkey.id": + if e.ComplexityRoot.Valkey.ID == nil { break } - return e.ComplexityRoot.WorkloadConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.Valkey.ID(childComplexity), true - case "WorkloadCost.daily": - if e.ComplexityRoot.WorkloadCost.Daily == nil { + case "Valkey.issues": + if e.ComplexityRoot.Valkey.Issues == nil { break } - args, err := ec.field_WorkloadCost_daily_args(ctx, rawArgs) + args, err := ec.field_Valkey_issues_args(ctx, rawArgs) if err != nil { return 0, false } - return e.ComplexityRoot.WorkloadCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + return e.ComplexityRoot.Valkey.Issues(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor), args["orderBy"].(*issue.IssueOrder), args["filter"].(*issue.ResourceIssueFilter)), true - case "WorkloadCost.monthly": - if e.ComplexityRoot.WorkloadCost.Monthly == nil { + case "Valkey.maintenance": + if e.ComplexityRoot.Valkey.Maintenance == nil { break } - return e.ComplexityRoot.WorkloadCost.Monthly(childComplexity), true + return e.ComplexityRoot.Valkey.Maintenance(childComplexity), true - case "WorkloadCostPeriod.series": - if e.ComplexityRoot.WorkloadCostPeriod.Series == nil { + case "Valkey.maxMemoryPolicy": + if e.ComplexityRoot.Valkey.MaxMemoryPolicy == nil { break } - return e.ComplexityRoot.WorkloadCostPeriod.Series(childComplexity), true + return e.ComplexityRoot.Valkey.MaxMemoryPolicy(childComplexity), true - case "WorkloadCostPeriod.sum": - if e.ComplexityRoot.WorkloadCostPeriod.Sum == nil { + case "Valkey.memory": + if e.ComplexityRoot.Valkey.Memory == nil { break } - return e.ComplexityRoot.WorkloadCostPeriod.Sum(childComplexity), true + return e.ComplexityRoot.Valkey.Memory(childComplexity), true - case "WorkloadCostSample.cost": - if e.ComplexityRoot.WorkloadCostSample.Cost == nil { + case "Valkey.name": + if e.ComplexityRoot.Valkey.Name == nil { break } - return e.ComplexityRoot.WorkloadCostSample.Cost(childComplexity), true + return e.ComplexityRoot.Valkey.Name(childComplexity), true - case "WorkloadCostSample.workload": - if e.ComplexityRoot.WorkloadCostSample.Workload == nil { + case "Valkey.notifyKeyspaceEvents": + if e.ComplexityRoot.Valkey.NotifyKeyspaceEvents == nil { break } - return e.ComplexityRoot.WorkloadCostSample.Workload(childComplexity), true + return e.ComplexityRoot.Valkey.NotifyKeyspaceEvents(childComplexity), true - case "WorkloadCostSample.workloadName": - if e.ComplexityRoot.WorkloadCostSample.WorkloadName == nil { + case "Valkey.state": + if e.ComplexityRoot.Valkey.State == nil { break } - return e.ComplexityRoot.WorkloadCostSample.WorkloadName(childComplexity), true + return e.ComplexityRoot.Valkey.State(childComplexity), true - case "WorkloadCostSeries.date": - if e.ComplexityRoot.WorkloadCostSeries.Date == nil { + case "Valkey.team": + if e.ComplexityRoot.Valkey.Team == nil { break } - return e.ComplexityRoot.WorkloadCostSeries.Date(childComplexity), true + return e.ComplexityRoot.Valkey.Team(childComplexity), true - case "WorkloadCostSeries.sum": - if e.ComplexityRoot.WorkloadCostSeries.Sum == nil { + case "Valkey.teamEnvironment": + if e.ComplexityRoot.Valkey.TeamEnvironment == nil { break } - return e.ComplexityRoot.WorkloadCostSeries.Sum(childComplexity), true + return e.ComplexityRoot.Valkey.TeamEnvironment(childComplexity), true - case "WorkloadCostSeries.workloads": - if e.ComplexityRoot.WorkloadCostSeries.Workloads == nil { + case "Valkey.terminationProtection": + if e.ComplexityRoot.Valkey.TerminationProtection == nil { break } - return e.ComplexityRoot.WorkloadCostSeries.Workloads(childComplexity), true + return e.ComplexityRoot.Valkey.TerminationProtection(childComplexity), true - case "WorkloadEdge.cursor": - if e.ComplexityRoot.WorkloadEdge.Cursor == nil { + case "Valkey.tier": + if e.ComplexityRoot.Valkey.Tier == nil { break } - return e.ComplexityRoot.WorkloadEdge.Cursor(childComplexity), true + return e.ComplexityRoot.Valkey.Tier(childComplexity), true - case "WorkloadEdge.node": - if e.ComplexityRoot.WorkloadEdge.Node == nil { + case "Valkey.workload": + if e.ComplexityRoot.Valkey.Workload == nil { break } - return e.ComplexityRoot.WorkloadEdge.Node(childComplexity), true + return e.ComplexityRoot.Valkey.Workload(childComplexity), true - case "WorkloadLogLine.instance": - if e.ComplexityRoot.WorkloadLogLine.Instance == nil { + case "ValkeyAccess.access": + if e.ComplexityRoot.ValkeyAccess.Access == nil { break } - return e.ComplexityRoot.WorkloadLogLine.Instance(childComplexity), true + return e.ComplexityRoot.ValkeyAccess.Access(childComplexity), true - case "WorkloadLogLine.message": - if e.ComplexityRoot.WorkloadLogLine.Message == nil { + case "ValkeyAccess.workload": + if e.ComplexityRoot.ValkeyAccess.Workload == nil { break } - return e.ComplexityRoot.WorkloadLogLine.Message(childComplexity), true + return e.ComplexityRoot.ValkeyAccess.Workload(childComplexity), true - case "WorkloadLogLine.time": - if e.ComplexityRoot.WorkloadLogLine.Time == nil { + case "ValkeyAccessConnection.edges": + if e.ComplexityRoot.ValkeyAccessConnection.Edges == nil { break } - return e.ComplexityRoot.WorkloadLogLine.Time(childComplexity), true + return e.ComplexityRoot.ValkeyAccessConnection.Edges(childComplexity), true - case "WorkloadResourceQuantity.cpu": - if e.ComplexityRoot.WorkloadResourceQuantity.CPU == nil { + case "ValkeyAccessConnection.nodes": + if e.ComplexityRoot.ValkeyAccessConnection.Nodes == nil { break } - return e.ComplexityRoot.WorkloadResourceQuantity.CPU(childComplexity), true + return e.ComplexityRoot.ValkeyAccessConnection.Nodes(childComplexity), true - case "WorkloadResourceQuantity.memory": - if e.ComplexityRoot.WorkloadResourceQuantity.Memory == nil { + case "ValkeyAccessConnection.pageInfo": + if e.ComplexityRoot.ValkeyAccessConnection.PageInfo == nil { break } - return e.ComplexityRoot.WorkloadResourceQuantity.Memory(childComplexity), true + return e.ComplexityRoot.ValkeyAccessConnection.PageInfo(childComplexity), true - case "WorkloadUtilization.current": - if e.ComplexityRoot.WorkloadUtilization.Current == nil { + case "ValkeyAccessEdge.cursor": + if e.ComplexityRoot.ValkeyAccessEdge.Cursor == nil { break } - args, err := ec.field_WorkloadUtilization_current_args(ctx, rawArgs) - if err != nil { - return 0, false - } - - return e.ComplexityRoot.WorkloadUtilization.Current(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + return e.ComplexityRoot.ValkeyAccessEdge.Cursor(childComplexity), true - case "WorkloadUtilization.limit": - if e.ComplexityRoot.WorkloadUtilization.Limit == nil { + case "ValkeyAccessEdge.node": + if e.ComplexityRoot.ValkeyAccessEdge.Node == nil { break } - args, err := ec.field_WorkloadUtilization_limit_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ValkeyAccessEdge.Node(childComplexity), true + + case "ValkeyConnection.edges": + if e.ComplexityRoot.ValkeyConnection.Edges == nil { + break } - return e.ComplexityRoot.WorkloadUtilization.Limit(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + return e.ComplexityRoot.ValkeyConnection.Edges(childComplexity), true - case "WorkloadUtilization.limitSeries": - if e.ComplexityRoot.WorkloadUtilization.LimitSeries == nil { + case "ValkeyConnection.nodes": + if e.ComplexityRoot.ValkeyConnection.Nodes == nil { break } - args, err := ec.field_WorkloadUtilization_limitSeries_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ValkeyConnection.Nodes(childComplexity), true + + case "ValkeyConnection.pageInfo": + if e.ComplexityRoot.ValkeyConnection.PageInfo == nil { + break } - return e.ComplexityRoot.WorkloadUtilization.LimitSeries(childComplexity, args["input"].(utilization.WorkloadUtilizationSeriesInput)), true + return e.ComplexityRoot.ValkeyConnection.PageInfo(childComplexity), true - case "WorkloadUtilization.recommendations": - if e.ComplexityRoot.WorkloadUtilization.Recommendations == nil { + case "ValkeyCost.sum": + if e.ComplexityRoot.ValkeyCost.Sum == nil { break } - return e.ComplexityRoot.WorkloadUtilization.Recommendations(childComplexity), true + return e.ComplexityRoot.ValkeyCost.Sum(childComplexity), true - case "WorkloadUtilization.requested": - if e.ComplexityRoot.WorkloadUtilization.Requested == nil { + case "ValkeyCreatedActivityLogEntry.actor": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Actor == nil { break } - args, err := ec.field_WorkloadUtilization_requested_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Actor(childComplexity), true + + case "ValkeyCreatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.CreatedAt == nil { + break } - return e.ComplexityRoot.WorkloadUtilization.Requested(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.CreatedAt(childComplexity), true - case "WorkloadUtilization.requestedSeries": - if e.ComplexityRoot.WorkloadUtilization.RequestedSeries == nil { + case "ValkeyCreatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.EnvironmentName == nil { break } - args, err := ec.field_WorkloadUtilization_requestedSeries_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.EnvironmentName(childComplexity), true + + case "ValkeyCreatedActivityLogEntry.id": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ID == nil { + break } - return e.ComplexityRoot.WorkloadUtilization.RequestedSeries(childComplexity, args["input"].(utilization.WorkloadUtilizationSeriesInput)), true + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ID(childComplexity), true - case "WorkloadUtilization.series": - if e.ComplexityRoot.WorkloadUtilization.Series == nil { + case "ValkeyCreatedActivityLogEntry.message": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Message == nil { break } - args, err := ec.field_WorkloadUtilization_series_args(ctx, rawArgs) - if err != nil { - return 0, false + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.Message(childComplexity), true + + case "ValkeyCreatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceName == nil { + break } - return e.ComplexityRoot.WorkloadUtilization.Series(childComplexity, args["input"].(utilization.WorkloadUtilizationSeriesInput)), true + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceName(childComplexity), true - case "WorkloadUtilizationData.requested": - if e.ComplexityRoot.WorkloadUtilizationData.Requested == nil { + case "ValkeyCreatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.WorkloadUtilizationData.Requested(childComplexity), true + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.ResourceType(childComplexity), true - case "WorkloadUtilizationData.used": - if e.ComplexityRoot.WorkloadUtilizationData.Used == nil { + case "ValkeyCreatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ValkeyCreatedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.WorkloadUtilizationData.Used(childComplexity), true + return e.ComplexityRoot.ValkeyCreatedActivityLogEntry.TeamSlug(childComplexity), true - case "WorkloadUtilizationData.workload": - if e.ComplexityRoot.WorkloadUtilizationData.Workload == nil { + case "ValkeyCredentials.host": + if e.ComplexityRoot.ValkeyCredentials.Host == nil { break } - return e.ComplexityRoot.WorkloadUtilizationData.Workload(childComplexity), true + return e.ComplexityRoot.ValkeyCredentials.Host(childComplexity), true - case "WorkloadUtilizationRecommendations.cpuRequestCores": - if e.ComplexityRoot.WorkloadUtilizationRecommendations.CPURequestCores == nil { + case "ValkeyCredentials.password": + if e.ComplexityRoot.ValkeyCredentials.Password == nil { break } - return e.ComplexityRoot.WorkloadUtilizationRecommendations.CPURequestCores(childComplexity), true + return e.ComplexityRoot.ValkeyCredentials.Password(childComplexity), true - case "WorkloadUtilizationRecommendations.memoryLimitBytes": - if e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryLimitBytes == nil { + case "ValkeyCredentials.port": + if e.ComplexityRoot.ValkeyCredentials.Port == nil { break } - return e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryLimitBytes(childComplexity), true + return e.ComplexityRoot.ValkeyCredentials.Port(childComplexity), true - case "WorkloadUtilizationRecommendations.memoryRequestBytes": - if e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryRequestBytes == nil { + case "ValkeyCredentials.uri": + if e.ComplexityRoot.ValkeyCredentials.URI == nil { break } - return e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryRequestBytes(childComplexity), true + return e.ComplexityRoot.ValkeyCredentials.URI(childComplexity), true - case "WorkloadVulnerabilitySummary.hasSBOM": - if e.ComplexityRoot.WorkloadVulnerabilitySummary.HasSbom == nil { + case "ValkeyCredentials.username": + if e.ComplexityRoot.ValkeyCredentials.Username == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummary.HasSbom(childComplexity), true + return e.ComplexityRoot.ValkeyCredentials.Username(childComplexity), true - case "WorkloadVulnerabilitySummary.id": - if e.ComplexityRoot.WorkloadVulnerabilitySummary.ID == nil { + case "ValkeyDeletedActivityLogEntry.actor": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Actor == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummary.ID(childComplexity), true + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Actor(childComplexity), true - case "WorkloadVulnerabilitySummary.summary": - if e.ComplexityRoot.WorkloadVulnerabilitySummary.Summary == nil { + case "ValkeyDeletedActivityLogEntry.createdAt": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.CreatedAt == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummary.Summary(childComplexity), true + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.CreatedAt(childComplexity), true - case "WorkloadVulnerabilitySummary.workload": - if e.ComplexityRoot.WorkloadVulnerabilitySummary.Workload == nil { + case "ValkeyDeletedActivityLogEntry.environmentName": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.EnvironmentName == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummary.Workload(childComplexity), true + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.EnvironmentName(childComplexity), true - case "WorkloadVulnerabilitySummaryConnection.edges": - if e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Edges == nil { + case "ValkeyDeletedActivityLogEntry.id": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ID == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Edges(childComplexity), true + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ID(childComplexity), true - case "WorkloadVulnerabilitySummaryConnection.nodes": - if e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Nodes == nil { + case "ValkeyDeletedActivityLogEntry.message": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Message == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.Message(childComplexity), true - case "WorkloadVulnerabilitySummaryConnection.pageInfo": - if e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.PageInfo == nil { + case "ValkeyDeletedActivityLogEntry.resourceName": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceName == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceName(childComplexity), true - case "WorkloadVulnerabilitySummaryEdge.cursor": - if e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Cursor == nil { + case "ValkeyDeletedActivityLogEntry.resourceType": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceType == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.ResourceType(childComplexity), true - case "WorkloadVulnerabilitySummaryEdge.node": - if e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Node == nil { + case "ValkeyDeletedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ValkeyDeletedActivityLogEntry.TeamSlug == nil { break } - return e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Node(childComplexity), true + return e.ComplexityRoot.ValkeyDeletedActivityLogEntry.TeamSlug(childComplexity), true - case "WorkloadWithVulnerability.vulnerability": - if e.ComplexityRoot.WorkloadWithVulnerability.Vulnerability == nil { + case "ValkeyEdge.cursor": + if e.ComplexityRoot.ValkeyEdge.Cursor == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerability.Vulnerability(childComplexity), true + return e.ComplexityRoot.ValkeyEdge.Cursor(childComplexity), true - case "WorkloadWithVulnerability.workload": - if e.ComplexityRoot.WorkloadWithVulnerability.Workload == nil { + case "ValkeyEdge.node": + if e.ComplexityRoot.ValkeyEdge.Node == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerability.Workload(childComplexity), true + return e.ComplexityRoot.ValkeyEdge.Node(childComplexity), true - case "WorkloadWithVulnerabilityConnection.edges": - if e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Edges == nil { + case "ValkeyIssue.event": + if e.ComplexityRoot.ValkeyIssue.Event == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Edges(childComplexity), true + return e.ComplexityRoot.ValkeyIssue.Event(childComplexity), true - case "WorkloadWithVulnerabilityConnection.nodes": - if e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Nodes == nil { + case "ValkeyIssue.id": + if e.ComplexityRoot.ValkeyIssue.ID == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Nodes(childComplexity), true + return e.ComplexityRoot.ValkeyIssue.ID(childComplexity), true - case "WorkloadWithVulnerabilityConnection.pageInfo": - if e.ComplexityRoot.WorkloadWithVulnerabilityConnection.PageInfo == nil { + case "ValkeyIssue.message": + if e.ComplexityRoot.ValkeyIssue.Message == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerabilityConnection.PageInfo(childComplexity), true + return e.ComplexityRoot.ValkeyIssue.Message(childComplexity), true - case "WorkloadWithVulnerabilityEdge.cursor": - if e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Cursor == nil { + case "ValkeyIssue.severity": + if e.ComplexityRoot.ValkeyIssue.Severity == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Cursor(childComplexity), true + return e.ComplexityRoot.ValkeyIssue.Severity(childComplexity), true - case "WorkloadWithVulnerabilityEdge.node": - if e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Node == nil { + case "ValkeyIssue.teamEnvironment": + if e.ComplexityRoot.ValkeyIssue.TeamEnvironment == nil { break } - return e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Node(childComplexity), true + return e.ComplexityRoot.ValkeyIssue.TeamEnvironment(childComplexity), true - } - return 0, false -} + case "ValkeyIssue.valkey": + if e.ComplexityRoot.ValkeyIssue.Valkey == nil { + break + } -func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { - opCtx := graphql.GetOperationContext(ctx) - ec := newExecutionContext(opCtx, e, make(chan graphql.DeferredResult)) - inputUnmarshalMap := graphql.BuildUnmarshalerMap( - ec.unmarshalInputActivityLogFilter, - ec.unmarshalInputAddRepositoryToTeamInput, - ec.unmarshalInputAddSecretValueInput, - ec.unmarshalInputAddTeamMemberInput, - ec.unmarshalInputAlertOrder, - ec.unmarshalInputAllowTeamAccessToUnleashInput, - ec.unmarshalInputApplicationOrder, - ec.unmarshalInputAssignRoleToServiceAccountInput, - ec.unmarshalInputBigQueryDatasetAccessOrder, - ec.unmarshalInputBigQueryDatasetOrder, - ec.unmarshalInputBucketOrder, - ec.unmarshalInputCVEOrder, - ec.unmarshalInputChangeDeploymentKeyInput, - ec.unmarshalInputConfigureReconcilerInput, - ec.unmarshalInputConfirmTeamDeletionInput, - ec.unmarshalInputCreateKafkaCredentialsInput, - ec.unmarshalInputCreateOpenSearchCredentialsInput, - ec.unmarshalInputCreateOpenSearchInput, - ec.unmarshalInputCreateSecretInput, - ec.unmarshalInputCreateServiceAccountInput, - ec.unmarshalInputCreateServiceAccountTokenInput, - ec.unmarshalInputCreateTeamInput, - ec.unmarshalInputCreateUnleashForTeamInput, - ec.unmarshalInputCreateValkeyCredentialsInput, - ec.unmarshalInputCreateValkeyInput, - ec.unmarshalInputDeleteApplicationInput, - ec.unmarshalInputDeleteJobInput, - ec.unmarshalInputDeleteJobRunInput, - ec.unmarshalInputDeleteOpenSearchInput, - ec.unmarshalInputDeleteSecretInput, - ec.unmarshalInputDeleteServiceAccountInput, - ec.unmarshalInputDeleteServiceAccountTokenInput, - ec.unmarshalInputDeleteUnleashInstanceInput, - ec.unmarshalInputDeleteValkeyInput, - ec.unmarshalInputDeploymentFilter, - ec.unmarshalInputDeploymentOrder, - ec.unmarshalInputDisableReconcilerInput, - ec.unmarshalInputEnableReconcilerInput, - ec.unmarshalInputEnvironmentOrder, - ec.unmarshalInputEnvironmentWorkloadOrder, - ec.unmarshalInputGrantPostgresAccessInput, - ec.unmarshalInputImageVulnerabilityFilter, - ec.unmarshalInputImageVulnerabilityOrder, - ec.unmarshalInputIngressMetricsInput, - ec.unmarshalInputIssueFilter, - ec.unmarshalInputIssueOrder, - ec.unmarshalInputJobOrder, - ec.unmarshalInputKafkaTopicAclFilter, - ec.unmarshalInputKafkaTopicAclOrder, - ec.unmarshalInputKafkaTopicOrder, - ec.unmarshalInputLogSubscriptionFilter, - ec.unmarshalInputLogSubscriptionInitialBatch, - ec.unmarshalInputMetricsQueryInput, - ec.unmarshalInputMetricsRangeInput, - ec.unmarshalInputOpenSearchAccessOrder, - ec.unmarshalInputOpenSearchOrder, - ec.unmarshalInputPostgresInstanceOrder, - ec.unmarshalInputReconcilerConfigInput, - ec.unmarshalInputRemoveRepositoryFromTeamInput, - ec.unmarshalInputRemoveSecretValueInput, - ec.unmarshalInputRemoveTeamMemberInput, - ec.unmarshalInputRepositoryOrder, - ec.unmarshalInputRequestTeamDeletionInput, - ec.unmarshalInputResourceIssueFilter, - ec.unmarshalInputRestartApplicationInput, - ec.unmarshalInputRevokeRoleFromServiceAccountInput, - ec.unmarshalInputRevokeTeamAccessToUnleashInput, - ec.unmarshalInputSearchFilter, - ec.unmarshalInputSecretFilter, - ec.unmarshalInputSecretOrder, - ec.unmarshalInputSecretValueInput, - ec.unmarshalInputSetTeamMemberRoleInput, - ec.unmarshalInputSqlInstanceOrder, - ec.unmarshalInputSqlInstanceUserOrder, - ec.unmarshalInputStartOpenSearchMaintenanceInput, - ec.unmarshalInputStartValkeyMaintenanceInput, - ec.unmarshalInputTeamAlertsFilter, - ec.unmarshalInputTeamApplicationsFilter, - ec.unmarshalInputTeamCostDailyFilter, - ec.unmarshalInputTeamFilter, - ec.unmarshalInputTeamJobsFilter, - ec.unmarshalInputTeamMemberOrder, - ec.unmarshalInputTeamOrder, - ec.unmarshalInputTeamRepositoryFilter, - ec.unmarshalInputTeamVulnerabilitySummaryFilter, + return e.ComplexityRoot.ValkeyIssue.Valkey(childComplexity), true + + case "ValkeyMaintenance.updates": + if e.ComplexityRoot.ValkeyMaintenance.Updates == nil { + break + } + + args, err := ec.field_ValkeyMaintenance_updates_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.ValkeyMaintenance.Updates(childComplexity, args["first"].(*int), args["after"].(*pagination.Cursor), args["last"].(*int), args["before"].(*pagination.Cursor)), true + + case "ValkeyMaintenance.window": + if e.ComplexityRoot.ValkeyMaintenance.Window == nil { + break + } + + return e.ComplexityRoot.ValkeyMaintenance.Window(childComplexity), true + + case "ValkeyMaintenanceUpdate.deadline": + if e.ComplexityRoot.ValkeyMaintenanceUpdate.Deadline == nil { + break + } + + return e.ComplexityRoot.ValkeyMaintenanceUpdate.Deadline(childComplexity), true + + case "ValkeyMaintenanceUpdate.description": + if e.ComplexityRoot.ValkeyMaintenanceUpdate.Description == nil { + break + } + + return e.ComplexityRoot.ValkeyMaintenanceUpdate.Description(childComplexity), true + + case "ValkeyMaintenanceUpdate.startAt": + if e.ComplexityRoot.ValkeyMaintenanceUpdate.StartAt == nil { + break + } + + return e.ComplexityRoot.ValkeyMaintenanceUpdate.StartAt(childComplexity), true + + case "ValkeyMaintenanceUpdate.title": + if e.ComplexityRoot.ValkeyMaintenanceUpdate.Title == nil { + break + } + + return e.ComplexityRoot.ValkeyMaintenanceUpdate.Title(childComplexity), true + + case "ValkeyMaintenanceUpdateConnection.edges": + if e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Edges == nil { + break + } + + return e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Edges(childComplexity), true + + case "ValkeyMaintenanceUpdateConnection.nodes": + if e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Nodes == nil { + break + } + + return e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.Nodes(childComplexity), true + + case "ValkeyMaintenanceUpdateConnection.pageInfo": + if e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.PageInfo == nil { + break + } + + return e.ComplexityRoot.ValkeyMaintenanceUpdateConnection.PageInfo(childComplexity), true + + case "ValkeyMaintenanceUpdateEdge.cursor": + if e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Cursor == nil { + break + } + + return e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Cursor(childComplexity), true + + case "ValkeyMaintenanceUpdateEdge.node": + if e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Node == nil { + break + } + + return e.ComplexityRoot.ValkeyMaintenanceUpdateEdge.Node(childComplexity), true + + case "ValkeyUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Actor == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Actor(childComplexity), true + + case "ValkeyUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.CreatedAt == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.CreatedAt(childComplexity), true + + case "ValkeyUpdatedActivityLogEntry.data": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Data == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Data(childComplexity), true + + case "ValkeyUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.EnvironmentName == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + + case "ValkeyUpdatedActivityLogEntry.id": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ID == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ID(childComplexity), true + + case "ValkeyUpdatedActivityLogEntry.message": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Message == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.Message(childComplexity), true + + case "ValkeyUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceName == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceName(childComplexity), true + + case "ValkeyUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceType == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.ResourceType(childComplexity), true + + case "ValkeyUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.TeamSlug == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntry.TeamSlug(childComplexity), true + + case "ValkeyUpdatedActivityLogEntryData.updatedFields": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryData.UpdatedFields == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryData.UpdatedFields(childComplexity), true + + case "ValkeyUpdatedActivityLogEntryDataUpdatedField.field": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.Field == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.Field(childComplexity), true + + case "ValkeyUpdatedActivityLogEntryDataUpdatedField.newValue": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.NewValue == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.NewValue(childComplexity), true + + case "ValkeyUpdatedActivityLogEntryDataUpdatedField.oldValue": + if e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.OldValue == nil { + break + } + + return e.ComplexityRoot.ValkeyUpdatedActivityLogEntryDataUpdatedField.OldValue(childComplexity), true + + case "ViewSecretValuesPayload.values": + if e.ComplexityRoot.ViewSecretValuesPayload.Values == nil { + break + } + + return e.ComplexityRoot.ViewSecretValuesPayload.Values(childComplexity), true + + case "VulnerabilityActivityLogEntryData.identifier": + if e.ComplexityRoot.VulnerabilityActivityLogEntryData.Identifier == nil { + break + } + + return e.ComplexityRoot.VulnerabilityActivityLogEntryData.Identifier(childComplexity), true + + case "VulnerabilityActivityLogEntryData.newSuppression": + if e.ComplexityRoot.VulnerabilityActivityLogEntryData.NewSuppression == nil { + break + } + + return e.ComplexityRoot.VulnerabilityActivityLogEntryData.NewSuppression(childComplexity), true + + case "VulnerabilityActivityLogEntryData.package": + if e.ComplexityRoot.VulnerabilityActivityLogEntryData.Package == nil { + break + } + + return e.ComplexityRoot.VulnerabilityActivityLogEntryData.Package(childComplexity), true + + case "VulnerabilityActivityLogEntryData.previousSuppression": + if e.ComplexityRoot.VulnerabilityActivityLogEntryData.PreviousSuppression == nil { + break + } + + return e.ComplexityRoot.VulnerabilityActivityLogEntryData.PreviousSuppression(childComplexity), true + + case "VulnerabilityActivityLogEntryData.severity": + if e.ComplexityRoot.VulnerabilityActivityLogEntryData.Severity == nil { + break + } + + return e.ComplexityRoot.VulnerabilityActivityLogEntryData.Severity(childComplexity), true + + case "VulnerabilityFixHistory.samples": + if e.ComplexityRoot.VulnerabilityFixHistory.Samples == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixHistory.Samples(childComplexity), true + + case "VulnerabilityFixSample.date": + if e.ComplexityRoot.VulnerabilityFixSample.Date == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.Date(childComplexity), true + + case "VulnerabilityFixSample.days": + if e.ComplexityRoot.VulnerabilityFixSample.Days == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.Days(childComplexity), true + + case "VulnerabilityFixSample.firstFixedAt": + if e.ComplexityRoot.VulnerabilityFixSample.FirstFixedAt == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.FirstFixedAt(childComplexity), true + + case "VulnerabilityFixSample.fixedCount": + if e.ComplexityRoot.VulnerabilityFixSample.FixedCount == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.FixedCount(childComplexity), true + + case "VulnerabilityFixSample.lastFixedAt": + if e.ComplexityRoot.VulnerabilityFixSample.LastFixedAt == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.LastFixedAt(childComplexity), true + + case "VulnerabilityFixSample.severity": + if e.ComplexityRoot.VulnerabilityFixSample.Severity == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.Severity(childComplexity), true + + case "VulnerabilityFixSample.totalWorkloads": + if e.ComplexityRoot.VulnerabilityFixSample.TotalWorkloads == nil { + break + } + + return e.ComplexityRoot.VulnerabilityFixSample.TotalWorkloads(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.actor": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Actor == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Actor(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.createdAt": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.CreatedAt == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.CreatedAt(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.data": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Data == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Data(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.environmentName": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.EnvironmentName == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.EnvironmentName(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.id": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ID == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ID(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.message": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Message == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.Message(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.resourceName": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceName == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceName(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.resourceType": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceType == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.ResourceType(childComplexity), true + + case "VulnerabilityUpdatedActivityLogEntry.teamSlug": + if e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.TeamSlug == nil { + break + } + + return e.ComplexityRoot.VulnerabilityUpdatedActivityLogEntry.TeamSlug(childComplexity), true + + case "VulnerableImageIssue.critical": + if e.ComplexityRoot.VulnerableImageIssue.Critical == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.Critical(childComplexity), true + + case "VulnerableImageIssue.id": + if e.ComplexityRoot.VulnerableImageIssue.ID == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.ID(childComplexity), true + + case "VulnerableImageIssue.message": + if e.ComplexityRoot.VulnerableImageIssue.Message == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.Message(childComplexity), true + + case "VulnerableImageIssue.riskScore": + if e.ComplexityRoot.VulnerableImageIssue.RiskScore == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.RiskScore(childComplexity), true + + case "VulnerableImageIssue.severity": + if e.ComplexityRoot.VulnerableImageIssue.Severity == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.Severity(childComplexity), true + + case "VulnerableImageIssue.teamEnvironment": + if e.ComplexityRoot.VulnerableImageIssue.TeamEnvironment == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.TeamEnvironment(childComplexity), true + + case "VulnerableImageIssue.workload": + if e.ComplexityRoot.VulnerableImageIssue.Workload == nil { + break + } + + return e.ComplexityRoot.VulnerableImageIssue.Workload(childComplexity), true + + case "WorkloadConnection.edges": + if e.ComplexityRoot.WorkloadConnection.Edges == nil { + break + } + + return e.ComplexityRoot.WorkloadConnection.Edges(childComplexity), true + + case "WorkloadConnection.nodes": + if e.ComplexityRoot.WorkloadConnection.Nodes == nil { + break + } + + return e.ComplexityRoot.WorkloadConnection.Nodes(childComplexity), true + + case "WorkloadConnection.pageInfo": + if e.ComplexityRoot.WorkloadConnection.PageInfo == nil { + break + } + + return e.ComplexityRoot.WorkloadConnection.PageInfo(childComplexity), true + + case "WorkloadCost.daily": + if e.ComplexityRoot.WorkloadCost.Daily == nil { + break + } + + args, err := ec.field_WorkloadCost_daily_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadCost.Daily(childComplexity, args["from"].(scalar.Date), args["to"].(scalar.Date)), true + + case "WorkloadCost.monthly": + if e.ComplexityRoot.WorkloadCost.Monthly == nil { + break + } + + return e.ComplexityRoot.WorkloadCost.Monthly(childComplexity), true + + case "WorkloadCostPeriod.series": + if e.ComplexityRoot.WorkloadCostPeriod.Series == nil { + break + } + + return e.ComplexityRoot.WorkloadCostPeriod.Series(childComplexity), true + + case "WorkloadCostPeriod.sum": + if e.ComplexityRoot.WorkloadCostPeriod.Sum == nil { + break + } + + return e.ComplexityRoot.WorkloadCostPeriod.Sum(childComplexity), true + + case "WorkloadCostSample.cost": + if e.ComplexityRoot.WorkloadCostSample.Cost == nil { + break + } + + return e.ComplexityRoot.WorkloadCostSample.Cost(childComplexity), true + + case "WorkloadCostSample.workload": + if e.ComplexityRoot.WorkloadCostSample.Workload == nil { + break + } + + return e.ComplexityRoot.WorkloadCostSample.Workload(childComplexity), true + + case "WorkloadCostSample.workloadName": + if e.ComplexityRoot.WorkloadCostSample.WorkloadName == nil { + break + } + + return e.ComplexityRoot.WorkloadCostSample.WorkloadName(childComplexity), true + + case "WorkloadCostSeries.date": + if e.ComplexityRoot.WorkloadCostSeries.Date == nil { + break + } + + return e.ComplexityRoot.WorkloadCostSeries.Date(childComplexity), true + + case "WorkloadCostSeries.sum": + if e.ComplexityRoot.WorkloadCostSeries.Sum == nil { + break + } + + return e.ComplexityRoot.WorkloadCostSeries.Sum(childComplexity), true + + case "WorkloadCostSeries.workloads": + if e.ComplexityRoot.WorkloadCostSeries.Workloads == nil { + break + } + + return e.ComplexityRoot.WorkloadCostSeries.Workloads(childComplexity), true + + case "WorkloadEdge.cursor": + if e.ComplexityRoot.WorkloadEdge.Cursor == nil { + break + } + + return e.ComplexityRoot.WorkloadEdge.Cursor(childComplexity), true + + case "WorkloadEdge.node": + if e.ComplexityRoot.WorkloadEdge.Node == nil { + break + } + + return e.ComplexityRoot.WorkloadEdge.Node(childComplexity), true + + case "WorkloadLogLine.instance": + if e.ComplexityRoot.WorkloadLogLine.Instance == nil { + break + } + + return e.ComplexityRoot.WorkloadLogLine.Instance(childComplexity), true + + case "WorkloadLogLine.message": + if e.ComplexityRoot.WorkloadLogLine.Message == nil { + break + } + + return e.ComplexityRoot.WorkloadLogLine.Message(childComplexity), true + + case "WorkloadLogLine.time": + if e.ComplexityRoot.WorkloadLogLine.Time == nil { + break + } + + return e.ComplexityRoot.WorkloadLogLine.Time(childComplexity), true + + case "WorkloadResourceQuantity.cpu": + if e.ComplexityRoot.WorkloadResourceQuantity.CPU == nil { + break + } + + return e.ComplexityRoot.WorkloadResourceQuantity.CPU(childComplexity), true + + case "WorkloadResourceQuantity.memory": + if e.ComplexityRoot.WorkloadResourceQuantity.Memory == nil { + break + } + + return e.ComplexityRoot.WorkloadResourceQuantity.Memory(childComplexity), true + + case "WorkloadUtilization.current": + if e.ComplexityRoot.WorkloadUtilization.Current == nil { + break + } + + args, err := ec.field_WorkloadUtilization_current_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadUtilization.Current(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + + case "WorkloadUtilization.limit": + if e.ComplexityRoot.WorkloadUtilization.Limit == nil { + break + } + + args, err := ec.field_WorkloadUtilization_limit_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadUtilization.Limit(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + + case "WorkloadUtilization.limitSeries": + if e.ComplexityRoot.WorkloadUtilization.LimitSeries == nil { + break + } + + args, err := ec.field_WorkloadUtilization_limitSeries_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadUtilization.LimitSeries(childComplexity, args["input"].(utilization.WorkloadUtilizationSeriesInput)), true + + case "WorkloadUtilization.recommendations": + if e.ComplexityRoot.WorkloadUtilization.Recommendations == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilization.Recommendations(childComplexity), true + + case "WorkloadUtilization.requested": + if e.ComplexityRoot.WorkloadUtilization.Requested == nil { + break + } + + args, err := ec.field_WorkloadUtilization_requested_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadUtilization.Requested(childComplexity, args["resourceType"].(utilization.UtilizationResourceType)), true + + case "WorkloadUtilization.requestedSeries": + if e.ComplexityRoot.WorkloadUtilization.RequestedSeries == nil { + break + } + + args, err := ec.field_WorkloadUtilization_requestedSeries_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadUtilization.RequestedSeries(childComplexity, args["input"].(utilization.WorkloadUtilizationSeriesInput)), true + + case "WorkloadUtilization.series": + if e.ComplexityRoot.WorkloadUtilization.Series == nil { + break + } + + args, err := ec.field_WorkloadUtilization_series_args(ctx, rawArgs) + if err != nil { + return 0, false + } + + return e.ComplexityRoot.WorkloadUtilization.Series(childComplexity, args["input"].(utilization.WorkloadUtilizationSeriesInput)), true + + case "WorkloadUtilizationData.requested": + if e.ComplexityRoot.WorkloadUtilizationData.Requested == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilizationData.Requested(childComplexity), true + + case "WorkloadUtilizationData.used": + if e.ComplexityRoot.WorkloadUtilizationData.Used == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilizationData.Used(childComplexity), true + + case "WorkloadUtilizationData.workload": + if e.ComplexityRoot.WorkloadUtilizationData.Workload == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilizationData.Workload(childComplexity), true + + case "WorkloadUtilizationRecommendations.cpuRequestCores": + if e.ComplexityRoot.WorkloadUtilizationRecommendations.CPURequestCores == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilizationRecommendations.CPURequestCores(childComplexity), true + + case "WorkloadUtilizationRecommendations.memoryLimitBytes": + if e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryLimitBytes == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryLimitBytes(childComplexity), true + + case "WorkloadUtilizationRecommendations.memoryRequestBytes": + if e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryRequestBytes == nil { + break + } + + return e.ComplexityRoot.WorkloadUtilizationRecommendations.MemoryRequestBytes(childComplexity), true + + case "WorkloadVulnerabilitySummary.hasSBOM": + if e.ComplexityRoot.WorkloadVulnerabilitySummary.HasSbom == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummary.HasSbom(childComplexity), true + + case "WorkloadVulnerabilitySummary.id": + if e.ComplexityRoot.WorkloadVulnerabilitySummary.ID == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummary.ID(childComplexity), true + + case "WorkloadVulnerabilitySummary.summary": + if e.ComplexityRoot.WorkloadVulnerabilitySummary.Summary == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummary.Summary(childComplexity), true + + case "WorkloadVulnerabilitySummary.workload": + if e.ComplexityRoot.WorkloadVulnerabilitySummary.Workload == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummary.Workload(childComplexity), true + + case "WorkloadVulnerabilitySummaryConnection.edges": + if e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Edges == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Edges(childComplexity), true + + case "WorkloadVulnerabilitySummaryConnection.nodes": + if e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Nodes == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.Nodes(childComplexity), true + + case "WorkloadVulnerabilitySummaryConnection.pageInfo": + if e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.PageInfo == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummaryConnection.PageInfo(childComplexity), true + + case "WorkloadVulnerabilitySummaryEdge.cursor": + if e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Cursor == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Cursor(childComplexity), true + + case "WorkloadVulnerabilitySummaryEdge.node": + if e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Node == nil { + break + } + + return e.ComplexityRoot.WorkloadVulnerabilitySummaryEdge.Node(childComplexity), true + + case "WorkloadWithVulnerability.vulnerability": + if e.ComplexityRoot.WorkloadWithVulnerability.Vulnerability == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerability.Vulnerability(childComplexity), true + + case "WorkloadWithVulnerability.workload": + if e.ComplexityRoot.WorkloadWithVulnerability.Workload == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerability.Workload(childComplexity), true + + case "WorkloadWithVulnerabilityConnection.edges": + if e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Edges == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Edges(childComplexity), true + + case "WorkloadWithVulnerabilityConnection.nodes": + if e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Nodes == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerabilityConnection.Nodes(childComplexity), true + + case "WorkloadWithVulnerabilityConnection.pageInfo": + if e.ComplexityRoot.WorkloadWithVulnerabilityConnection.PageInfo == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerabilityConnection.PageInfo(childComplexity), true + + case "WorkloadWithVulnerabilityEdge.cursor": + if e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Cursor == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Cursor(childComplexity), true + + case "WorkloadWithVulnerabilityEdge.node": + if e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Node == nil { + break + } + + return e.ComplexityRoot.WorkloadWithVulnerabilityEdge.Node(childComplexity), true + + } + return 0, false +} + +func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { + opCtx := graphql.GetOperationContext(ctx) + ec := newExecutionContext(opCtx, e, make(chan graphql.DeferredResult)) + inputUnmarshalMap := graphql.BuildUnmarshalerMap( + ec.unmarshalInputActivityLogFilter, + ec.unmarshalInputAddConfigValueInput, + ec.unmarshalInputAddRepositoryToTeamInput, + ec.unmarshalInputAddSecretValueInput, + ec.unmarshalInputAddTeamMemberInput, + ec.unmarshalInputAlertOrder, + ec.unmarshalInputAllowTeamAccessToUnleashInput, + ec.unmarshalInputApplicationOrder, + ec.unmarshalInputAssignRoleToServiceAccountInput, + ec.unmarshalInputBigQueryDatasetAccessOrder, + ec.unmarshalInputBigQueryDatasetOrder, + ec.unmarshalInputBucketOrder, + ec.unmarshalInputCVEOrder, + ec.unmarshalInputChangeDeploymentKeyInput, + ec.unmarshalInputConfigFilter, + ec.unmarshalInputConfigOrder, + ec.unmarshalInputConfigValueInput, + ec.unmarshalInputConfigureReconcilerInput, + ec.unmarshalInputConfirmTeamDeletionInput, + ec.unmarshalInputCreateConfigInput, + ec.unmarshalInputCreateKafkaCredentialsInput, + ec.unmarshalInputCreateOpenSearchCredentialsInput, + ec.unmarshalInputCreateOpenSearchInput, + ec.unmarshalInputCreateSecretInput, + ec.unmarshalInputCreateServiceAccountInput, + ec.unmarshalInputCreateServiceAccountTokenInput, + ec.unmarshalInputCreateTeamInput, + ec.unmarshalInputCreateUnleashForTeamInput, + ec.unmarshalInputCreateValkeyCredentialsInput, + ec.unmarshalInputCreateValkeyInput, + ec.unmarshalInputDeleteApplicationInput, + ec.unmarshalInputDeleteConfigInput, + ec.unmarshalInputDeleteJobInput, + ec.unmarshalInputDeleteJobRunInput, + ec.unmarshalInputDeleteOpenSearchInput, + ec.unmarshalInputDeleteSecretInput, + ec.unmarshalInputDeleteServiceAccountInput, + ec.unmarshalInputDeleteServiceAccountTokenInput, + ec.unmarshalInputDeleteUnleashInstanceInput, + ec.unmarshalInputDeleteValkeyInput, + ec.unmarshalInputDeploymentFilter, + ec.unmarshalInputDeploymentOrder, + ec.unmarshalInputDisableReconcilerInput, + ec.unmarshalInputEnableReconcilerInput, + ec.unmarshalInputEnvironmentOrder, + ec.unmarshalInputEnvironmentWorkloadOrder, + ec.unmarshalInputGrantPostgresAccessInput, + ec.unmarshalInputImageVulnerabilityFilter, + ec.unmarshalInputImageVulnerabilityOrder, + ec.unmarshalInputIngressMetricsInput, + ec.unmarshalInputIssueFilter, + ec.unmarshalInputIssueOrder, + ec.unmarshalInputJobOrder, + ec.unmarshalInputKafkaTopicAclFilter, + ec.unmarshalInputKafkaTopicAclOrder, + ec.unmarshalInputKafkaTopicOrder, + ec.unmarshalInputLogSubscriptionFilter, + ec.unmarshalInputLogSubscriptionInitialBatch, + ec.unmarshalInputMetricsQueryInput, + ec.unmarshalInputMetricsRangeInput, + ec.unmarshalInputOpenSearchAccessOrder, + ec.unmarshalInputOpenSearchOrder, + ec.unmarshalInputPostgresInstanceOrder, + ec.unmarshalInputReconcilerConfigInput, + ec.unmarshalInputRemoveConfigValueInput, + ec.unmarshalInputRemoveRepositoryFromTeamInput, + ec.unmarshalInputRemoveSecretValueInput, + ec.unmarshalInputRemoveTeamMemberInput, + ec.unmarshalInputRepositoryOrder, + ec.unmarshalInputRequestTeamDeletionInput, + ec.unmarshalInputResourceIssueFilter, + ec.unmarshalInputRestartApplicationInput, + ec.unmarshalInputRevokeRoleFromServiceAccountInput, + ec.unmarshalInputRevokeTeamAccessToUnleashInput, + ec.unmarshalInputSearchFilter, + ec.unmarshalInputSecretFilter, + ec.unmarshalInputSecretOrder, + ec.unmarshalInputSecretValueInput, + ec.unmarshalInputSetTeamMemberRoleInput, + ec.unmarshalInputSqlInstanceOrder, + ec.unmarshalInputSqlInstanceUserOrder, + ec.unmarshalInputStartOpenSearchMaintenanceInput, + ec.unmarshalInputStartValkeyMaintenanceInput, + ec.unmarshalInputTeamAlertsFilter, + ec.unmarshalInputTeamApplicationsFilter, + ec.unmarshalInputTeamCostDailyFilter, + ec.unmarshalInputTeamFilter, + ec.unmarshalInputTeamJobsFilter, + ec.unmarshalInputTeamMemberOrder, + ec.unmarshalInputTeamOrder, + ec.unmarshalInputTeamRepositoryFilter, + ec.unmarshalInputTeamVulnerabilitySummaryFilter, ec.unmarshalInputTeamWorkloadsFilter, ec.unmarshalInputTriggerJobInput, + ec.unmarshalInputUpdateConfigValueInput, ec.unmarshalInputUpdateImageVulnerabilityInput, ec.unmarshalInputUpdateOpenSearchInput, ec.unmarshalInputUpdateSecretValueInput, @@ -16243,228 +16977,800 @@ func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler { ) first := true - switch opCtx.Operation.Operation { - case ast.Query: - return func(ctx context.Context) *graphql.Response { - var response graphql.Response - var data graphql.Marshaler - if first { - first = false - ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap) - data = ec._Query(ctx, opCtx.Operation.SelectionSet) - } else { - if atomic.LoadInt32(&ec.PendingDeferred) > 0 { - result := <-ec.DeferredResults - atomic.AddInt32(&ec.PendingDeferred, -1) - data = result.Result - response.Path = result.Path - response.Label = result.Label - response.Errors = result.Errors - } else { - return nil - } - } - var buf bytes.Buffer - data.MarshalGQL(&buf) - response.Data = buf.Bytes() - if atomic.LoadInt32(&ec.Deferred) > 0 { - hasNext := atomic.LoadInt32(&ec.PendingDeferred) > 0 - response.HasNext = &hasNext - } + switch opCtx.Operation.Operation { + case ast.Query: + return func(ctx context.Context) *graphql.Response { + var response graphql.Response + var data graphql.Marshaler + if first { + first = false + ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap) + data = ec._Query(ctx, opCtx.Operation.SelectionSet) + } else { + if atomic.LoadInt32(&ec.PendingDeferred) > 0 { + result := <-ec.DeferredResults + atomic.AddInt32(&ec.PendingDeferred, -1) + data = result.Result + response.Path = result.Path + response.Label = result.Label + response.Errors = result.Errors + } else { + return nil + } + } + var buf bytes.Buffer + data.MarshalGQL(&buf) + response.Data = buf.Bytes() + if atomic.LoadInt32(&ec.Deferred) > 0 { + hasNext := atomic.LoadInt32(&ec.PendingDeferred) > 0 + response.HasNext = &hasNext + } + + return &response + } + case ast.Mutation: + return func(ctx context.Context) *graphql.Response { + if !first { + return nil + } + first = false + ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap) + data := ec._Mutation(ctx, opCtx.Operation.SelectionSet) + var buf bytes.Buffer + data.MarshalGQL(&buf) + + return &graphql.Response{ + Data: buf.Bytes(), + } + } + case ast.Subscription: + next := ec._Subscription(ctx, opCtx.Operation.SelectionSet) + + var buf bytes.Buffer + return func(ctx context.Context) *graphql.Response { + buf.Reset() + data := next(ctx) + + if data == nil { + return nil + } + data.MarshalGQL(&buf) + + return &graphql.Response{ + Data: buf.Bytes(), + } + } + + default: + return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation")) + } +} + +type executionContext struct { + *graphql.ExecutionContextState[ResolverRoot, DirectiveRoot, ComplexityRoot] +} + +func newExecutionContext( + opCtx *graphql.OperationContext, + execSchema *executableSchema, + deferredResults chan graphql.DeferredResult, +) executionContext { + return executionContext{ + ExecutionContextState: graphql.NewExecutionContextState[ResolverRoot, DirectiveRoot, ComplexityRoot]( + opCtx, + (*graphql.ExecutableSchemaState[ResolverRoot, DirectiveRoot, ComplexityRoot])(execSchema), + parsedSchema, + deferredResults, + ), + } +} + +var sources = []*ast.Source{ + {Name: "../schema/activitylog.graphqls", Input: `extend type Team implements ActivityLogger { + """ + Activity log associated with the team. + """ + activityLog( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int + + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Filter items. + """ + filter: ActivityLogFilter + ): ActivityLogEntryConnection! +} + +interface ActivityLogger { + """ + Activity log associated with the type. + """ + activityLog( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int + + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Filter items. + """ + filter: ActivityLogFilter + ): ActivityLogEntryConnection! +} + +extend type Reconciler implements ActivityLogger { + """ + Activity log associated with the reconciler. + """ + activityLog( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int + + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Filter items. + """ + filter: ActivityLogFilter + ): ActivityLogEntryConnection! +} + +extend type OpenSearch implements ActivityLogger { + """ + Activity log associated with the reconciler. + """ + activityLog( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int + + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Filter items. + """ + filter: ActivityLogFilter + ): ActivityLogEntryConnection! +} + +extend type Valkey implements ActivityLogger { + """ + Activity log associated with the reconciler. + """ + activityLog( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int + + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Filter items. + """ + filter: ActivityLogFilter + ): ActivityLogEntryConnection! +} + +input ActivityLogFilter { + activityTypes: [ActivityLogActivityType!] +} + +enum ActivityLogActivityType + +""" +Interface for activity log entries. +""" +interface ActivityLogEntry implements Node { + """ + ID of the entry. + """ + id: ID! + + """ + The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user. + """ + actor: String! + + """ + Creation time of the entry. + """ + createdAt: Time! + + """ + Message that summarizes the entry. + """ + message: String! + + """ + Type of the resource that was affected by the action. + """ + resourceType: ActivityLogEntryResourceType! + + """ + Name of the resource that was affected by the action. + """ + resourceName: String! + + """ + The team slug that the entry belongs to. + """ + teamSlug: Slug + + """ + The environment name that the entry belongs to. + """ + environmentName: String +} + +""" +The type of the resource that was affected by the activity. +""" +enum ActivityLogEntryResourceType { + """ + Unknown type. + """ + UNKNOWN +} + +""" +Activity log connection. +""" +type ActivityLogEntryConnection { + """ + Pagination information. + """ + pageInfo: PageInfo! + + """ + List of nodes. + """ + nodes: [ActivityLogEntry!]! + + """ + List of edges. + """ + edges: [ActivityLogEntryEdge!]! +} + +""" +Activity log edge. +""" +type ActivityLogEntryEdge { + """ + Cursor for this edge that can be used for pagination. + """ + cursor: Cursor! + + """ + The log entry. + """ + node: ActivityLogEntry! +} +`, BuiltIn: false}, + {Name: "../schema/aiven_credentials.graphqls", Input: `"Permission level for OpenSearch and Valkey credentials." +enum CredentialPermission { + READ + WRITE + READWRITE + ADMIN +} + +input CreateOpenSearchCredentialsInput { + "The team that owns the OpenSearch instance." + teamSlug: Slug! + "The environment name that the OpenSearch instance belongs to." + environmentName: String! + "Name of the OpenSearch instance." + instanceName: String! + "Permission level for the credentials." + permission: CredentialPermission! + "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." + ttl: String! +} + +type OpenSearchCredentials { + "Username for the OpenSearch instance." + username: String! + "Password for the OpenSearch instance." + password: String! + "Hostname of the OpenSearch instance." + host: String! + "Port of the OpenSearch instance." + port: Int! + "Full connection URI for the OpenSearch instance." + uri: String! +} + +type CreateOpenSearchCredentialsPayload { + "The generated credentials." + credentials: OpenSearchCredentials! +} + +input CreateValkeyCredentialsInput { + "The team that owns the Valkey instance." + teamSlug: Slug! + "The environment name that the Valkey instance belongs to." + environmentName: String! + "Name of the Valkey instance." + instanceName: String! + "Permission level for the credentials." + permission: CredentialPermission! + "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." + ttl: String! +} + +type ValkeyCredentials { + "Username for the Valkey instance." + username: String! + "Password for the Valkey instance." + password: String! + "Hostname of the Valkey instance." + host: String! + "Port of the Valkey instance." + port: Int! + "Full connection URI for the Valkey instance." + uri: String! +} + +type CreateValkeyCredentialsPayload { + "The generated credentials." + credentials: ValkeyCredentials! +} + +input CreateKafkaCredentialsInput { + "The team that owns the Kafka topic." + teamSlug: Slug! + "The environment name that the Kafka topic belongs to." + environmentName: String! + "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." + ttl: String! +} + +type KafkaCredentials { + "Username for the Kafka broker." + username: String! + "Client certificate in PEM format." + accessCert: String! + "Client private key in PEM format." + accessKey: String! + "CA certificate in PEM format." + caCert: String! + "Comma-separated list of broker addresses." + brokers: String! + "Schema registry URL." + schemaRegistry: String! +} + +type CreateKafkaCredentialsPayload { + "The generated credentials." + credentials: KafkaCredentials! +} - return &response - } - case ast.Mutation: - return func(ctx context.Context) *graphql.Response { - if !first { - return nil - } - first = false - ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap) - data := ec._Mutation(ctx, opCtx.Operation.SelectionSet) - var buf bytes.Buffer - data.MarshalGQL(&buf) +extend enum ActivityLogEntryResourceType { + "All activity log entries related to credential creation will use this resource type." + CREDENTIALS +} - return &graphql.Response{ - Data: buf.Bytes(), - } - } - case ast.Subscription: - next := ec._Subscription(ctx, opCtx.Operation.SelectionSet) +type CredentialsActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! - var buf bytes.Buffer - return func(ctx context.Context) *graphql.Response { - buf.Reset() - data := next(ctx) + "The identity of the actor who performed the action." + actor: String! - if data == nil { - return nil - } - data.MarshalGQL(&buf) + "Creation time of the entry." + createdAt: Time! - return &graphql.Response{ - Data: buf.Bytes(), - } - } + "Message that summarizes the entry." + message: String! - default: - return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation")) - } + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the credential creation." + data: CredentialsActivityLogEntryData! } -type executionContext struct { - *graphql.ExecutionContextState[ResolverRoot, DirectiveRoot, ComplexityRoot] +type CredentialsActivityLogEntryData { + "The service type (OPENSEARCH, VALKEY, KAFKA)." + serviceType: String! + "The instance name, if applicable." + instanceName: String + "The permission level, if applicable." + permission: String + "The TTL that was requested for the credentials." + ttl: String! } -func newExecutionContext( - opCtx *graphql.OperationContext, - execSchema *executableSchema, - deferredResults chan graphql.DeferredResult, -) executionContext { - return executionContext{ - ExecutionContextState: graphql.NewExecutionContextState[ResolverRoot, DirectiveRoot, ComplexityRoot]( - opCtx, - (*graphql.ExecutableSchemaState[ResolverRoot, DirectiveRoot, ComplexityRoot])(execSchema), - parsedSchema, - deferredResults, - ), - } +extend enum ActivityLogActivityType { + "Filter for credential creation events." + CREDENTIALS_CREATE +} + +extend type Mutation { + "Create temporary credentials for an OpenSearch instance." + createOpenSearchCredentials( + input: CreateOpenSearchCredentialsInput! + ): CreateOpenSearchCredentialsPayload! + "Create temporary credentials for a Valkey instance." + createValkeyCredentials(input: CreateValkeyCredentialsInput!): CreateValkeyCredentialsPayload! + "Create temporary credentials for Kafka." + createKafkaCredentials(input: CreateKafkaCredentialsInput!): CreateKafkaCredentialsPayload! +} +`, BuiltIn: false}, + {Name: "../schema/alerts.graphqls", Input: `extend type TeamEnvironment { + """ + EXPERIMENTAL: DO NOT USE + """ + alerts( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int + + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Ordering options for items returned from the connection. + """ + orderBy: AlertOrder + + """ + Filter the returned objects + """ + filter: TeamAlertsFilter + ): AlertConnection! +} + +extend type Team { + """ + EXPERIMENTAL: DO NOT USE + """ + alerts( + """ + Get the first n items in the connection. This can be used in combination with the after parameter. + """ + first: Int + + """ + Get items after this cursor. + """ + after: Cursor + + """ + Get the last n items in the connection. This can be used in combination with the before parameter. + """ + last: Int + + """ + Get items before this cursor. + """ + before: Cursor + + """ + Ordering options for items returned from the connection. + """ + orderBy: AlertOrder + + """ + Filter the returned objects + """ + filter: TeamAlertsFilter + ): AlertConnection! +} + +""" +Alert interface. +""" +interface Alert implements Node { + """ + The unique identifier of the alert. + """ + id: ID! + """ + The name of the alert. + """ + name: String! + """ + The team responsible for the alert. + """ + team: Team! + """ + The team environment associated with the alert. + """ + teamEnvironment: TeamEnvironment! + """ + The current state of the alert (e.g. FIRING, PENDING, INACTIVE). + """ + state: AlertState! + """ + The query or expression evaluated for the alert. + """ + query: String! + """ + The time in seconds the alert condition must be met before it activates. + """ + duration: Float! } -var sources = []*ast.Source{ - {Name: "../schema/activitylog.graphqls", Input: `extend type Team implements ActivityLogger { +""" +PrometheusAlert type +""" +type PrometheusAlert implements Node & Alert { + "The unique identifier for the alert." + id: ID! + "The name of the alert." + name: String! + """ + The team that owns the alert. + """ + team: Team! + """ + The team environment for the alert. + """ + teamEnvironment: TeamEnvironment! + """ + The state of the alert. + """ + state: AlertState! + + """ + The query for the alert. + """ + query: String! + """ + The duration for the alert. + """ + duration: Float! + + """ + The prometheus rule group for the alert. + """ + ruleGroup: String! + """ - Activity log associated with the team. + The alarms of the alert available if state is firing. """ - activityLog( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int + alarms: [PrometheusAlarm!]! +} - """ - Get items after this cursor. - """ - after: Cursor +type PrometheusAlarm { + """ + The action to take when the alert fires. + """ + action: String! - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int + """ + The consequence of the alert firing. + """ + consequence: String! - """ - Get items before this cursor. - """ - before: Cursor + """ + A summary of the alert. + """ + summary: String! - """ - Filter items. - """ - filter: ActivityLogFilter - ): ActivityLogEntryConnection! -} + """ + The state of the alert. + """ + state: AlertState! -interface ActivityLogger { """ - Activity log associated with the type. + The current value of the metric that triggered the alert. """ - activityLog( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int + value: Float! - """ - Get items after this cursor. - """ - after: Cursor + """ + The time when the alert started firing. + """ + since: Time! +} - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int +""" +AlertConnection connection. +""" +type AlertConnection { + """ + Pagination information. + """ + pageInfo: PageInfo! - """ - Get items before this cursor. - """ - before: Cursor + """ + List of nodes. + """ + nodes: [Alert!]! - """ - Filter items. - """ - filter: ActivityLogFilter - ): ActivityLogEntryConnection! + """ + List of edges. + """ + edges: [AlertEdge!]! } -extend type Reconciler implements ActivityLogger { +""" +Alert edge. +""" +type AlertEdge { """ - Activity log associated with the reconciler. + Cursor for this edge that can be used for pagination. """ - activityLog( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int + cursor: Cursor! - """ - Get items after this cursor. - """ - after: Cursor + """ + The Alert. + """ + node: Alert! +} - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int +""" +Fields to order alerts in an environment by. +""" +enum AlertOrderField { + """ + Order by name. + """ + NAME + """ + Order by state. + """ + STATE + """ + ENVIRONMENT + """ + ENVIRONMENT +} - """ - Get items before this cursor. - """ - before: Cursor +""" +Ordering options when fetching alerts. +""" +input AlertOrder { + """ + The field to order items by. + """ + field: AlertOrderField! - """ - Filter items. - """ - filter: ActivityLogFilter - ): ActivityLogEntryConnection! + """ + The direction to order items by. + """ + direction: OrderDirection! } -extend type OpenSearch implements ActivityLogger { +""" +Input for filtering alerts. +""" +input TeamAlertsFilter { """ - Activity log associated with the reconciler. + Filter by the name of the application. """ - activityLog( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int - - """ - Get items after this cursor. - """ - after: Cursor + name: String + """ + Filter by the name of the environment. + """ + environments: [String!] + """ + Only return alerts from the given named states. + """ + states: [AlertState!] +} - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int +enum AlertState { + """ + Only return alerts that are firing. + """ + FIRING - """ - Get items before this cursor. - """ - before: Cursor + """ + Only return alerts that are inactive. + """ + INACTIVE - """ - Filter items. - """ - filter: ActivityLogFilter - ): ActivityLogEntryConnection! + """ + Only return alerts that are pending. + """ + PENDING } - -extend type Valkey implements ActivityLogger { +`, BuiltIn: false}, + {Name: "../schema/applications.graphqls", Input: `extend type Team { """ - Activity log associated with the reconciler. + Nais applications owned by the team. """ - activityLog( + applications( """ Get the first n items in the connection. This can be used in combination with the after parameter. """ @@ -16486,223 +17792,128 @@ extend type Valkey implements ActivityLogger { before: Cursor """ - Filter items. + Ordering options for items returned from the connection. """ - filter: ActivityLogFilter - ): ActivityLogEntryConnection! -} - -input ActivityLogFilter { - activityTypes: [ActivityLogActivityType!] -} - -enum ActivityLogActivityType - -""" -Interface for activity log entries. -""" -interface ActivityLogEntry implements Node { - """ - ID of the entry. - """ - id: ID! - - """ - The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user. - """ - actor: String! - - """ - Creation time of the entry. - """ - createdAt: Time! + orderBy: ApplicationOrder - """ - Message that summarizes the entry. - """ - message: String! + """ + Filtering options for items returned from the connection. + """ + filter: TeamApplicationsFilter + ): ApplicationConnection! +} +extend type TeamEnvironment { """ - Type of the resource that was affected by the action. + Nais application in the team environment. """ - resourceType: ActivityLogEntryResourceType! + application( + """ + The name of the application. + """ + name: String! + ): Application! +} +extend type Mutation { """ - Name of the resource that was affected by the action. + Delete an application. """ - resourceName: String! + deleteApplication( + """ + Input for deleting an application. + """ + input: DeleteApplicationInput! + ): DeleteApplicationPayload! """ - The team slug that the entry belongs to. + Restart an application. """ - teamSlug: Slug + restartApplication( + """ + Input for restarting an application. + """ + input: RestartApplicationInput! + ): RestartApplicationPayload! +} +extend type TeamInventoryCounts { """ - The environment name that the entry belongs to. + Application inventory count for a team. """ - environmentName: String + applications: TeamInventoryCountApplications! } """ -The type of the resource that was affected by the activity. +Application inventory count for a team. """ -enum ActivityLogEntryResourceType { +type TeamInventoryCountApplications { """ - Unknown type. + Total number of applications. """ - UNKNOWN + total: Int! } """ -Activity log connection. +An application lets you run one or more instances of a container image on the [Nais platform](https://nais.io/). + +Learn more about how to create and configure your applications in the [Nais documentation](https://docs.nais.io/workloads/application/). """ -type ActivityLogEntryConnection { +type Application implements Node & Workload & ActivityLogger { """ - Pagination information. + The globally unique ID of the application. """ - pageInfo: PageInfo! + id: ID! """ - List of nodes. + The name of the application. """ - nodes: [ActivityLogEntry!]! + name: String! """ - List of edges. + The team that owns the application. """ - edges: [ActivityLogEntryEdge!]! -} + team: Team! -""" -Activity log edge. -""" -type ActivityLogEntryEdge { """ - Cursor for this edge that can be used for pagination. + The environment the application is deployed in. """ - cursor: Cursor! + environment: TeamEnvironment! @deprecated(reason: "Use the ` + "`" + `teamEnvironment` + "`" + ` field instead.") """ - The log entry. + The team environment for the application. """ - node: ActivityLogEntry! -} -`, BuiltIn: false}, - {Name: "../schema/aiven_credentials.graphqls", Input: `"Permission level for OpenSearch and Valkey credentials." -enum AivenPermission { - READ - WRITE - READWRITE - ADMIN -} - -input CreateOpenSearchCredentialsInput { - "The team that owns the OpenSearch instance." - teamSlug: Slug! - "The environment name that the OpenSearch instance belongs to." - environmentName: String! - "Name of the OpenSearch instance." - instanceName: String! - "Permission level for the credentials." - permission: AivenPermission! - "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." - ttl: String! -} - -type OpenSearchCredentials { - "Username for the OpenSearch instance." - username: String! - "Password for the OpenSearch instance." - password: String! - "Hostname of the OpenSearch instance." - host: String! - "Port of the OpenSearch instance." - port: Int! - "Full connection URI for the OpenSearch instance." - uri: String! -} - -type CreateOpenSearchCredentialsPayload { - "The generated credentials." - credentials: OpenSearchCredentials! -} - -input CreateValkeyCredentialsInput { - "The team that owns the Valkey instance." - teamSlug: Slug! - "The environment name that the Valkey instance belongs to." - environmentName: String! - "Name of the Valkey instance." - instanceName: String! - "Permission level for the credentials." - permission: AivenPermission! - "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." - ttl: String! -} + teamEnvironment: TeamEnvironment! -type ValkeyCredentials { - "Username for the Valkey instance." - username: String! - "Password for the Valkey instance." - password: String! - "Hostname of the Valkey instance." - host: String! - "Port of the Valkey instance." - port: Int! - "Full connection URI for the Valkey instance." - uri: String! -} + """ + The container image of the application. + """ + image: ContainerImage! -type CreateValkeyCredentialsPayload { - "The generated credentials." - credentials: ValkeyCredentials! -} + """ + Resources for the application. + """ + resources: ApplicationResources! -input CreateKafkaCredentialsInput { - "The team that owns the Kafka topic." - teamSlug: Slug! - "The environment name that the Kafka topic belongs to." - environmentName: String! - "Time-to-live for the credentials (e.g. '1d', '7d'). Maximum 30 days." - ttl: String! -} + """ + List of ingresses for the application. + """ + ingresses: [Ingress!]! -type KafkaCredentials { - "Username for the Kafka broker." - username: String! - "Client certificate in PEM format." - accessCert: String! - "Client private key in PEM format." - accessKey: String! - "CA certificate in PEM format." - caCert: String! - "Comma-separated list of broker addresses." - brokers: String! - "Schema registry URL." - schemaRegistry: String! -} + """ + List of authentication and authorization for the application. + """ + authIntegrations: [ApplicationAuthIntegrations!]! -type CreateKafkaCredentialsPayload { - "The generated credentials." - credentials: KafkaCredentials! -} + """ + The application manifest. + """ + manifest: ApplicationManifest! -extend type Mutation { - "Create temporary credentials for an OpenSearch instance." - createOpenSearchCredentials( - input: CreateOpenSearchCredentialsInput! - ): CreateOpenSearchCredentialsPayload! - "Create temporary credentials for a Valkey instance." - createValkeyCredentials(input: CreateValkeyCredentialsInput!): CreateValkeyCredentialsPayload! - "Create temporary credentials for Kafka." - createKafkaCredentials(input: CreateKafkaCredentialsInput!): CreateKafkaCredentialsPayload! -} -`, BuiltIn: false}, - {Name: "../schema/alerts.graphqls", Input: `extend type TeamEnvironment { """ - EXPERIMENTAL: DO NOT USE + The application instances. """ - alerts( + instances( """ Get the first n items in the connection. This can be used in combination with the after parameter. """ @@ -16722,24 +17933,17 @@ extend type Mutation { Get items before this cursor. """ before: Cursor + ): ApplicationInstanceConnection! - """ - Ordering options for items returned from the connection. - """ - orderBy: AlertOrder - - """ - Filter the returned objects - """ - filter: TeamAlertsFilter - ): AlertConnection! -} + """ + If set, when the application was marked for deletion. + """ + deletionStartedAt: Time -extend type Team { """ - EXPERIMENTAL: DO NOT USE + Activity log associated with the application. """ - alerts( + activityLog( """ Get the first n items in the connection. This can be used in combination with the after parameter. """ @@ -16761,128 +17965,162 @@ extend type Team { before: Cursor """ - Ordering options for items returned from the connection. + Filter items. """ - orderBy: AlertOrder + filter: ActivityLogFilter + ): ActivityLogEntryConnection! - """ - Filter the returned objects - """ - filter: TeamAlertsFilter - ): AlertConnection! + "The application state." + state: ApplicationState! + + "Issues that affect the application." + issues( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + + "Ordering options for items returned from the connection." + orderBy: IssueOrder + + "Filtering options for items returned from the connection." + filter: ResourceIssueFilter + ): IssueConnection! } -""" -Alert interface. -""" -interface Alert implements Node { - """ - The unique identifier of the alert. - """ - id: ID! - """ - The name of the alert. - """ - name: String! +enum ApplicationState { """ - The team responsible for the alert. + The application is running. """ - team: Team! + RUNNING + """ - The team environment associated with the alert. + The application is not running. """ - teamEnvironment: TeamEnvironment! + NOT_RUNNING + """ - The current state of the alert (e.g. FIRING, PENDING, INACTIVE). + The application state is unknown. """ - state: AlertState! + UNKNOWN +} + +""" +Input for filtering the applications of a team. +""" +input TeamApplicationsFilter { """ - The query or expression evaluated for the alert. + Filter by the name of the application. """ - query: String! + name: String + """ - The time in seconds the alert condition must be met before it activates. + Filter by the name of the environment. """ - duration: Float! + environments: [String!] } """ -PrometheusAlert type +The manifest that describes the application. """ -type PrometheusAlert implements Node & Alert { - "The unique identifier for the alert." - id: ID! - "The name of the alert." - name: String! +type ApplicationManifest implements WorkloadManifest { """ - The team that owns the alert. + The manifest content, serialized as a YAML document. """ - team: Team! + content: String! +} + +""" +Authentication integrations for the application. +""" +union ApplicationAuthIntegrations = + | EntraIDAuthIntegration + | IDPortenAuthIntegration + | MaskinportenAuthIntegration + | TokenXAuthIntegration + +type ApplicationResources implements WorkloadResources { """ - The team environment for the alert. + Instances using resources above this threshold will be killed. """ - teamEnvironment: TeamEnvironment! + limits: WorkloadResourceQuantity! + """ - The state of the alert. + How many resources are allocated to each instance. """ - state: AlertState! + requests: WorkloadResourceQuantity! """ - The query for the alert. + Scaling strategies for the application. """ - query: String! + scaling: ApplicationScaling! +} + +""" +The scaling configuration of an application. +""" +type ApplicationScaling { """ - The duration for the alert. + The minimum number of application instances. """ - duration: Float! + minInstances: Int! """ - The prometheus rule group for the alert. + The maximum number of application instances. """ - ruleGroup: String! + maxInstances: Int! """ - The alarms of the alert available if state is firing. + Scaling strategies for the application. """ - alarms: [PrometheusAlarm!]! + strategies: [ScalingStrategy!]! } -type PrometheusAlarm { - """ - The action to take when the alert fires. - """ - action: String! +""" +Types of scaling strategies. +""" +union ScalingStrategy = CPUScalingStrategy | KafkaLagScalingStrategy - """ - The consequence of the alert firing. - """ - consequence: String! +""" +A scaling strategy based on CPU usage +Read more: https://docs.nais.io/workloads/application/reference/automatic-scaling/#cpu-based-scaling +""" +type CPUScalingStrategy { """ - A summary of the alert. + The threshold that must be met for the scaling to trigger. """ - summary: String! + threshold: Int! +} +type KafkaLagScalingStrategy { """ - The state of the alert. + The threshold that must be met for the scaling to trigger. """ - state: AlertState! + threshold: Int! """ - The current value of the metric that triggered the alert. + The consumer group of the topic. """ - value: Float! + consumerGroup: String! """ - The time when the alert started firing. + The name of the Kafka topic. """ - since: Time! + topicName: String! } """ -AlertConnection connection. +Application connection. """ -type AlertConnection { +type ApplicationConnection { """ Pagination information. """ @@ -16891,55 +18129,37 @@ type AlertConnection { """ List of nodes. """ - nodes: [Alert!]! + nodes: [Application!]! """ List of edges. """ - edges: [AlertEdge!]! + edges: [ApplicationEdge!]! } """ -Alert edge. +Application edge. """ -type AlertEdge { +type ApplicationEdge { """ Cursor for this edge that can be used for pagination. """ cursor: Cursor! """ - The Alert. - """ - node: Alert! -} - -""" -Fields to order alerts in an environment by. -""" -enum AlertOrderField { - """ - Order by name. - """ - NAME - """ - Order by state. - """ - STATE - """ - ENVIRONMENT + The application. """ - ENVIRONMENT + node: Application! } """ -Ordering options when fetching alerts. +Ordering options when fetching applications. """ -input AlertOrder { +input ApplicationOrder { """ The field to order items by. """ - field: AlertOrderField! + field: ApplicationOrderField! """ The direction to order items by. @@ -16948,789 +18168,796 @@ input AlertOrder { } """ -Input for filtering alerts. +Fields to order applications by. """ -input TeamAlertsFilter { +enum ApplicationOrderField { """ - Filter by the name of the application. + Order applications by name. """ - name: String + NAME + """ - Filter by the name of the environment. + Order applications by the name of the environment. """ - environments: [String!] + ENVIRONMENT + """ - Only return alerts from the given named states. + Order applications by state. """ - states: [AlertState!] + STATE } -enum AlertState { +extend union SearchNode = Application + +extend enum SearchType { """ - Only return alerts that are firing. + Search for applications. """ - FIRING + APPLICATION +} +input DeleteApplicationInput { """ - Only return alerts that are inactive. + Name of the application. """ - INACTIVE + name: String! """ - Only return alerts that are pending. + Slug of the team that owns the application. """ - PENDING -} -`, BuiltIn: false}, - {Name: "../schema/applications.graphqls", Input: `extend type Team { + teamSlug: Slug! + """ - Nais applications owned by the team. + Name of the environment where the application runs. """ - applications( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int - - """ - Get items after this cursor. - """ - after: Cursor - - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int - - """ - Get items before this cursor. - """ - before: Cursor - - """ - Ordering options for items returned from the connection. - """ - orderBy: ApplicationOrder - - """ - Filtering options for items returned from the connection. - """ - filter: TeamApplicationsFilter - ): ApplicationConnection! + environmentName: String! } -extend type TeamEnvironment { +type DeleteApplicationPayload { + """ + The team that owned the deleted application. + """ + team: Team + """ - Nais application in the team environment. + Whether or not the application was deleted. """ - application( - """ - The name of the application. - """ - name: String! - ): Application! + success: Boolean } -extend type Mutation { +input RestartApplicationInput { """ - Delete an application. + Name of the application. """ - deleteApplication( - """ - Input for deleting an application. - """ - input: DeleteApplicationInput! - ): DeleteApplicationPayload! + name: String! """ - Restart an application. + Slug of the team that owns the application. """ - restartApplication( - """ - Input for restarting an application. - """ - input: RestartApplicationInput! - ): RestartApplicationPayload! -} + teamSlug: Slug! -extend type TeamInventoryCounts { """ - Application inventory count for a team. + Name of the environment where the application runs. """ - applications: TeamInventoryCountApplications! + environmentName: String! } -""" -Application inventory count for a team. -""" -type TeamInventoryCountApplications { +type RestartApplicationPayload { """ - Total number of applications. + The application that was restarted. """ - total: Int! + application: Application } -""" -An application lets you run one or more instances of a container image on the [Nais platform](https://nais.io/). - -Learn more about how to create and configure your applications in the [Nais documentation](https://docs.nais.io/workloads/application/). -""" -type Application implements Node & Workload & ActivityLogger { +type Ingress { """ - The globally unique ID of the application. + URL for the ingress. """ - id: ID! + url: String! """ - The name of the application. + Type of ingress. """ - name: String! + type: IngressType! """ - The team that owns the application. + Metrics for the ingress. """ - team: Team! + metrics: IngressMetrics! +} +type IngressMetrics { """ - The environment the application is deployed in. + Number of requests to the ingress per second. """ - environment: TeamEnvironment! @deprecated(reason: "Use the ` + "`" + `teamEnvironment` + "`" + ` field instead.") + requestsPerSecond: Float! """ - The team environment for the application. + Number of errors in the ingress per second. """ - teamEnvironment: TeamEnvironment! - + errorsPerSecond: Float! """ - The container image of the application. + Ingress metrics between start and end with step size. """ - image: ContainerImage! + series(input: IngressMetricsInput!): [IngressMetricSample!]! +} +input IngressMetricsInput { """ - Resources for the application. + Fetch metrics from this timestamp. """ - resources: ApplicationResources! + start: Time! """ - List of ingresses for the application. + Fetch metrics until this timestamp. """ - ingresses: [Ingress!]! + end: Time! """ - List of authentication and authorization for the application. + Type of metric to fetch. """ - authIntegrations: [ApplicationAuthIntegrations!]! + type: IngressMetricsType! +} +""" +Type of ingress metrics to fetch. +""" +enum IngressMetricsType { """ - The application manifest. + Number of requests to the ingress per second. """ - manifest: ApplicationManifest! - + REQUESTS_PER_SECOND """ - The application instances. + Number of errors in the ingress per second. """ - instances( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int + ERRORS_PER_SECOND +} - """ - Get items after this cursor. - """ - after: Cursor +""" +Ingress metric type. +""" +type IngressMetricSample { + "Timestamp of the value." + timestamp: Time! + "Value of the IngressMetricsType at the given timestamp." + value: Float! +} - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int +enum IngressType { + UNKNOWN + EXTERNAL + INTERNAL + AUTHENTICATED +} - """ - Get items before this cursor. - """ - before: Cursor - ): ApplicationInstanceConnection! +type ApplicationInstance implements Node { + id: ID! + name: String! + image: ContainerImage! + restarts: Int! + created: Time! + status: ApplicationInstanceStatus! +} + +type ApplicationInstanceStatus { + state: ApplicationInstanceState! + message: String! +} + +enum ApplicationInstanceState { + RUNNING + STARTING + FAILING + UNKNOWN +} +type ApplicationInstanceConnection { """ - If set, when the application was marked for deletion. + Pagination information. """ - deletionStartedAt: Time + pageInfo: PageInfo! """ - Activity log associated with the application. + List of nodes. """ - activityLog( - """ - Get the first n items in the connection. This can be used in combination with the after parameter. - """ - first: Int + nodes: [ApplicationInstance!]! - """ - Get items after this cursor. - """ - after: Cursor + """ + List of edges. + """ + edges: [ApplicationInstanceEdge!]! +} - """ - Get the last n items in the connection. This can be used in combination with the before parameter. - """ - last: Int +type ApplicationInstanceEdge { + """ + Cursor for this edge that can be used for pagination. + """ + cursor: Cursor! + + """ + The instance. + """ + node: ApplicationInstance! +} + +extend enum ActivityLogEntryResourceType { + "All activity log entries related to applications will use this resource type." + APP +} + +type ApplicationDeletedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String +} + +type ApplicationRestartedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String +} - """ - Get items before this cursor. - """ - before: Cursor +# This is managed directly by the activitylog package since it +# combines data within the database. +type ApplicationScaledActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! - """ - Filter items. - """ - filter: ActivityLogFilter - ): ActivityLogEntryConnection! + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! - "The application state." - state: ApplicationState! + "Creation time of the entry." + createdAt: Time! - "Issues that affect the application." - issues( - "Get the first n items in the connection. This can be used in combination with the after parameter." - first: Int + "Message that summarizes the entry." + message: String! - "Get items after this cursor." - after: Cursor + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! - "Get the last n items in the connection. This can be used in combination with the before parameter." - last: Int + "Name of the resource that was affected by the action." + resourceName: String! - "Get items before this cursor." - before: Cursor + "The team slug that the entry belongs to." + teamSlug: Slug! - "Ordering options for items returned from the connection." - orderBy: IssueOrder + "The environment name that the entry belongs to." + environmentName: String - "Filtering options for items returned from the connection." - filter: ResourceIssueFilter - ): IssueConnection! + "Data associated with the update." + data: ApplicationScaledActivityLogEntryData! } -enum ApplicationState { +enum ScalingDirection { """ - The application is running. + The scaling direction is up. """ - RUNNING + UP """ - The application is not running. + The scaling direction is down. """ - NOT_RUNNING + DOWN +} - """ - The application state is unknown. - """ - UNKNOWN +type ApplicationScaledActivityLogEntryData { + newSize: Int! + direction: ScalingDirection! } -""" -Input for filtering the applications of a team. -""" -input TeamApplicationsFilter { - """ - Filter by the name of the application. - """ - name: String +type ApplicationCreatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! - """ - Filter by the name of the environment. - """ - environments: [String!] -} + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! -""" -The manifest that describes the application. -""" -type ApplicationManifest implements WorkloadManifest { - """ - The manifest content, serialized as a YAML document. - """ - content: String! -} + "Creation time of the entry." + createdAt: Time! -""" -Authentication integrations for the application. -""" -union ApplicationAuthIntegrations = - | EntraIDAuthIntegration - | IDPortenAuthIntegration - | MaskinportenAuthIntegration - | TokenXAuthIntegration + "Message that summarizes the entry." + message: String! -type ApplicationResources implements WorkloadResources { - """ - Instances using resources above this threshold will be killed. - """ - limits: WorkloadResourceQuantity! + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! - """ - How many resources are allocated to each instance. - """ - requests: WorkloadResourceQuantity! + "Name of the resource that was affected by the action." + resourceName: String! - """ - Scaling strategies for the application. - """ - scaling: ApplicationScaling! + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String + + "Data associated with the creation." + data: GenericKubernetesResourceActivityLogEntryData! } -""" -The scaling configuration of an application. -""" -type ApplicationScaling { - """ - The minimum number of application instances. - """ - minInstances: Int! +type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! - """ - The maximum number of application instances. - """ - maxInstances: Int! + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! - """ - Scaling strategies for the application. - """ - strategies: [ScalingStrategy!]! -} + "Creation time of the entry." + createdAt: Time! -""" -Types of scaling strategies. -""" -union ScalingStrategy = CPUScalingStrategy | KafkaLagScalingStrategy + "Message that summarizes the entry." + message: String! -""" -A scaling strategy based on CPU usage + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! -Read more: https://docs.nais.io/workloads/application/reference/automatic-scaling/#cpu-based-scaling -""" -type CPUScalingStrategy { - """ - The threshold that must be met for the scaling to trigger. - """ - threshold: Int! -} + "Name of the resource that was affected by the action." + resourceName: String! -type KafkaLagScalingStrategy { - """ - The threshold that must be met for the scaling to trigger. - """ - threshold: Int! + "The team slug that the entry belongs to." + teamSlug: Slug! - """ - The consumer group of the topic. - """ - consumerGroup: String! + "The environment name that the entry belongs to." + environmentName: String - """ - The name of the Kafka topic. - """ - topicName: String! + "Data associated with the update." + data: GenericKubernetesResourceActivityLogEntryData! } -""" -Application connection. -""" -type ApplicationConnection { +extend enum ActivityLogActivityType { """ - Pagination information. + An application was deleted. """ - pageInfo: PageInfo! + APPLICATION_DELETED """ - List of nodes. + An application was restarted. """ - nodes: [Application!]! + APPLICATION_RESTARTED """ - List of edges. + An application was scaled. """ - edges: [ApplicationEdge!]! + APPLICATION_SCALED +} +`, BuiltIn: false}, + {Name: "../schema/apply.graphqls", Input: `extend enum ActivityLogActivityType { + "A generic kubernetes resource was updated via apply." + GENERIC_KUBERNETES_RESOURCE_UPDATED + + "A generic kubernetes resource was created via apply." + GENERIC_KUBERNETES_RESOURCE_CREATED } """ -Application edge. +Additional data associated with a resource created or updated via apply. """ -type ApplicationEdge { - """ - Cursor for this edge that can be used for pagination. - """ - cursor: Cursor! +type GenericKubernetesResourceActivityLogEntryData { + "The apiVersion of the applied resource." + apiVersion: String! + "The kind of the applied resource." + kind: String! + "The fields that changed during the apply. Only populated for updates." + changedFields: [ResourceChangedField!]! + "GitHub Actions OIDC token claims at the time of the apply. Only present when the request was authenticated via a GitHub token." + gitHubClaims: GitHubActorClaims +} - """ - The application. - """ - node: Application! +""" +GitHub Actions OIDC token claims captured at the time of an apply operation. +""" +type GitHubActorClaims { + "The git ref that triggered the workflow, e.g. 'refs/heads/main'." + ref: String! + "The repository name that triggered the workflow, e.g. 'org/repo'." + repository: String! + "The immutable numeric GitHub repository ID." + repositoryID: String! + "The unique identifier of the Actions workflow run. Links to https://github.com//actions/runs/." + runID: String! + "The attempt number of the workflow run (1-indexed)." + runAttempt: String! + "The GitHub username that triggered the workflow." + actor: String! + "The path to the workflow file, e.g. '.github/workflows/deploy.yaml'." + workflow: String! + "The event that triggered the workflow, e.g. 'push' or 'workflow_dispatch'." + eventName: String! + "The GitHub deployment environment name, if the job targets one." + environment: String! + "The ref of the reusable workflow called by this job, if any. E.g. 'org/repo/.github/workflows/deploy.yaml@refs/heads/main'." + jobWorkflowRef: String! } """ -Ordering options when fetching applications. +A single field that changed. """ -input ApplicationOrder { - """ - The field to order items by. - """ - field: ApplicationOrderField! - - """ - The direction to order items by. - """ - direction: OrderDirection! +type ResourceChangedField { + "The dot-separated path to the changed field, e.g. 'spec.replicas'." + field: String! + "The value before the change. Null if the field was added." + oldValue: String + "The value after the change. Null if the field was removed." + newValue: String } """ -Fields to order applications by. +Activity log entry for a resource kind that is not modelled in the GraphQL API. +The resource type will be the uppercase Kubernetes kind, e.g. 'NAISJOB'. """ -enum ApplicationOrderField { - """ - Order applications by name. - """ - NAME +type GenericKubernetesResourceActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! - """ - Order applications by the name of the environment. - """ - ENVIRONMENT + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! - """ - Order applications by state. - """ - STATE -} + "Creation time of the entry." + createdAt: Time! -extend union SearchNode = Application + "Message that summarizes the entry." + message: String! -extend enum SearchType { - """ - Search for applications. - """ - APPLICATION -} + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! -input DeleteApplicationInput { - """ - Name of the application. - """ - name: String! + "Name of the resource that was affected by the action." + resourceName: String! - """ - Slug of the team that owns the application. - """ - teamSlug: Slug! + "The team slug that the entry belongs to." + teamSlug: Slug + + "The environment name that the entry belongs to." + environmentName: String + "Data associated with the apply operation." + data: GenericKubernetesResourceActivityLogEntryData! +} +`, BuiltIn: false}, + {Name: "../schema/authz.graphqls", Input: `type Role implements Node { """ - Name of the environment where the application runs. + The globally unique ID of the role. """ - environmentName: String! -} + id: ID! -type DeleteApplicationPayload { """ - The team that owned the deleted application. + Name of the role. """ - team: Team + name: String! """ - Whether or not the application was deleted. + Description of the role. """ - success: Boolean + description: String! } -input RestartApplicationInput { - """ - Name of the application. - """ - name: String! +extend type Query { + roles( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int - """ - Slug of the team that owns the application. - """ - teamSlug: Slug! + "Get items after this cursor." + after: Cursor - """ - Name of the environment where the application runs. - """ - environmentName: String! -} + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int -type RestartApplicationPayload { - """ - The application that was restarted. - """ - application: Application + "Get items before this cursor." + before: Cursor + ): RoleConnection! } -type Ingress { +type RoleConnection { """ - URL for the ingress. + A list of roles. """ - url: String! + nodes: [Role!]! """ - Type of ingress. + A list of role edges. """ - type: IngressType! + edges: [RoleEdge!]! """ - Metrics for the ingress. + Information to aid in pagination. """ - metrics: IngressMetrics! + pageInfo: PageInfo! } -type IngressMetrics { +type RoleEdge { """ - Number of requests to the ingress per second. + The role. """ - requestsPerSecond: Float! + node: Role! """ - Number of errors in the ingress per second. - """ - errorsPerSecond: Float! - """ - Ingress metrics between start and end with step size. + A cursor for use in pagination. """ - series(input: IngressMetricsInput!): [IngressMetricSample!]! + cursor: Cursor! } +`, BuiltIn: false}, + {Name: "../schema/bigquery.graphqls", Input: `extend type Team { + "BigQuery datasets owned by the team." + bigQueryDatasets( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int -input IngressMetricsInput { - """ - Fetch metrics from this timestamp. - """ - start: Time! + "Get items after this cursor." + after: Cursor - """ - Fetch metrics until this timestamp. - """ - end: Time! + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int - """ - Type of metric to fetch. - """ - type: IngressMetricsType! + "Get items before this cursor." + before: Cursor + + "Ordering options for items returned from the connection." + orderBy: BigQueryDatasetOrder + ): BigQueryDatasetConnection! } -""" -Type of ingress metrics to fetch. -""" -enum IngressMetricsType { - """ - Number of requests to the ingress per second. - """ - REQUESTS_PER_SECOND - """ - Number of errors in the ingress per second. - """ - ERRORS_PER_SECOND +extend type TeamEnvironment { + "BigQuery datasets in the team environment." + bigQueryDataset(name: String!): BigQueryDataset! } -""" -Ingress metric type. -""" -type IngressMetricSample { - "Timestamp of the value." - timestamp: Time! - "Value of the IngressMetricsType at the given timestamp." - value: Float! +extend interface Workload { + "BigQuery datasets referenced by the workload. This does not currently support pagination, but will return all available datasets." + bigQueryDatasets( + "Ordering options for items returned from the connection." + orderBy: BigQueryDatasetOrder + ): BigQueryDatasetConnection! } -enum IngressType { - UNKNOWN - EXTERNAL - INTERNAL - AUTHENTICATED +extend type Application { + "BigQuery datasets referenced by the application. This does not currently support pagination, but will return all available datasets." + bigQueryDatasets( + "Ordering options for items returned from the connection." + orderBy: BigQueryDatasetOrder + ): BigQueryDatasetConnection! } -type ApplicationInstance implements Node { +extend type Job { + "BigQuery datasets referenced by the job. This does not currently support pagination, but will return all available datasets." + bigQueryDatasets( + "Ordering options for items returned from the connection." + orderBy: BigQueryDatasetOrder + ): BigQueryDatasetConnection! +} + +extend type TeamInventoryCounts { + bigQueryDatasets: TeamInventoryCountBigQueryDatasets! +} + +type TeamInventoryCountBigQueryDatasets { + "Total number of BigQuery datasets." + total: Int! +} + +type BigQueryDataset implements Persistence & Node { id: ID! name: String! - image: ContainerImage! - restarts: Int! - created: Time! - status: ApplicationInstanceStatus! + team: Team! + environment: TeamEnvironment! @deprecated(reason: "Use the ` + "`" + `teamEnvironment` + "`" + ` field instead.") + teamEnvironment: TeamEnvironment! + cascadingDelete: Boolean! + description: String + access( + first: Int + after: Cursor + last: Int + before: Cursor + orderBy: BigQueryDatasetAccessOrder + ): BigQueryDatasetAccessConnection! + status: BigQueryDatasetStatus! + workload: Workload } -type ApplicationInstanceStatus { - state: ApplicationInstanceState! - message: String! +type BigQueryDatasetAccess { + role: String! + email: String! } -enum ApplicationInstanceState { - RUNNING - STARTING - FAILING - UNKNOWN +type BigQueryDatasetStatus { + creationTime: Time! + lastModifiedTime: Time } -type ApplicationInstanceConnection { - """ - Pagination information. - """ +type BigQueryDatasetAccessConnection { pageInfo: PageInfo! + nodes: [BigQueryDatasetAccess!]! + edges: [BigQueryDatasetAccessEdge!]! +} - """ - List of nodes. - """ - nodes: [ApplicationInstance!]! - - """ - List of edges. - """ - edges: [ApplicationInstanceEdge!]! +type BigQueryDatasetConnection { + pageInfo: PageInfo! + nodes: [BigQueryDataset!]! + edges: [BigQueryDatasetEdge!]! } -type ApplicationInstanceEdge { - """ - Cursor for this edge that can be used for pagination. - """ +type BigQueryDatasetAccessEdge { cursor: Cursor! - - """ - The instance. - """ - node: ApplicationInstance! + node: BigQueryDatasetAccess! } -extend enum ActivityLogEntryResourceType { - "All activity log entries related to applications will use this resource type." - APP +type BigQueryDatasetEdge { + cursor: Cursor! + node: BigQueryDataset! } -type ApplicationDeletedActivityLogEntry implements ActivityLogEntry & Node { - "ID of the entry." - id: ID! - - "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." - actor: String! - - "Creation time of the entry." - createdAt: Time! - - "Message that summarizes the entry." - message: String! - - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! - - "Name of the resource that was affected by the action." - resourceName: String! - - "The team slug that the entry belongs to." - teamSlug: Slug! - - "The environment name that the entry belongs to." - environmentName: String +input BigQueryDatasetAccessOrder { + field: BigQueryDatasetAccessOrderField! + direction: OrderDirection! } -type ApplicationRestartedActivityLogEntry implements ActivityLogEntry & Node { - "ID of the entry." - id: ID! - - "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." - actor: String! - - "Creation time of the entry." - createdAt: Time! - - "Message that summarizes the entry." - message: String! - - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! - - "Name of the resource that was affected by the action." - resourceName: String! +input BigQueryDatasetOrder { + field: BigQueryDatasetOrderField! + direction: OrderDirection! +} - "The team slug that the entry belongs to." - teamSlug: Slug! +enum BigQueryDatasetAccessOrderField { + ROLE + EMAIL +} - "The environment name that the entry belongs to." - environmentName: String +enum BigQueryDatasetOrderField { + NAME + ENVIRONMENT } -# This is managed directly by the activitylog package since it -# combines data within the database. -type ApplicationScaledActivityLogEntry implements ActivityLogEntry & Node { - "ID of the entry." - id: ID! +extend union SearchNode = BigQueryDataset - "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." - actor: String! +extend enum SearchType { + BIGQUERY_DATASET +} +`, BuiltIn: false}, + {Name: "../schema/bucket.graphqls", Input: `extend type Team { + "Google Cloud Storage buckets owned by the team." + buckets( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int - "Creation time of the entry." - createdAt: Time! + "Get items after this cursor." + after: Cursor - "Message that summarizes the entry." - message: String! + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! + "Get items before this cursor." + before: Cursor - "Name of the resource that was affected by the action." - resourceName: String! + "Ordering options for items returned from the connection." + orderBy: BucketOrder + ): BucketConnection! +} - "The team slug that the entry belongs to." - teamSlug: Slug! +extend type TeamEnvironment { + "Storage bucket in the team environment." + bucket(name: String!): Bucket! +} - "The environment name that the entry belongs to." - environmentName: String +extend interface Workload { + "Google Cloud Storage referenced by the workload. This does not currently support pagination, but will return all available buckets." + buckets( + "Ordering options for items returned from the connection." + orderBy: BucketOrder + ): BucketConnection! +} - "Data associated with the update." - data: ApplicationScaledActivityLogEntryData! +extend type Application { + "Google Cloud Storage referenced by the application. This does not currently support pagination, but will return all available buckets." + buckets( + "Ordering options for items returned from the connection." + orderBy: BucketOrder + ): BucketConnection! } -enum ScalingDirection { - """ - The scaling direction is up. - """ - UP +extend type Job { + "Google Cloud Storage referenced by the job. This does not currently support pagination, but will return all available buckets." + buckets( + "Ordering options for items returned from the connection." + orderBy: BucketOrder + ): BucketConnection! +} - """ - The scaling direction is down. - """ - DOWN +extend type TeamInventoryCounts { + buckets: TeamInventoryCountBuckets! } -type ApplicationScaledActivityLogEntryData { - newSize: Int! - direction: ScalingDirection! +type TeamInventoryCountBuckets { + "Total number of Google Cloud Storage buckets." + total: Int! } -type ApplicationCreatedActivityLogEntry implements ActivityLogEntry & Node { - "ID of the entry." +type Bucket implements Persistence & Node { id: ID! + name: String! + team: Team! + environment: TeamEnvironment! @deprecated(reason: "Use the ` + "`" + `teamEnvironment` + "`" + ` field instead.") + teamEnvironment: TeamEnvironment! + cascadingDelete: Boolean! + publicAccessPrevention: String! + uniformBucketLevelAccess: Boolean! + workload: Workload +} - "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." - actor: String! - - "Creation time of the entry." - createdAt: Time! +type BucketConnection { + pageInfo: PageInfo! + nodes: [Bucket!]! + edges: [BucketEdge!]! +} - "Message that summarizes the entry." - message: String! +type BucketEdge { + cursor: Cursor! + node: Bucket! +} - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! +input BucketOrder { + field: BucketOrderField! + direction: OrderDirection! +} - "Name of the resource that was affected by the action." - resourceName: String! +enum BucketOrderField { + NAME + ENVIRONMENT +} - "The team slug that the entry belongs to." - teamSlug: Slug! +extend union SearchNode = Bucket - "The environment name that the entry belongs to." - environmentName: String +extend enum SearchType { + BUCKET +} +`, BuiltIn: false}, + {Name: "../schema/cluster.graphqls", Input: `extend enum ActivityLogEntryResourceType { + "All activity log entries related to direct cluster changes." + CLUSTER_AUDIT +} - "Data associated with the creation." - data: GenericKubernetesResourceActivityLogEntryData! +extend enum ActivityLogActivityType { + "All activity log entries related to direct cluster changes." + CLUSTER_AUDIT } -type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { +type ClusterAuditActivityLogEntry implements ActivityLogEntry & Node { "ID of the entry." id: ID! @@ -17755,139 +18982,147 @@ type ApplicationUpdatedActivityLogEntry implements ActivityLogEntry & Node { "The environment name that the entry belongs to." environmentName: String - "Data associated with the update." - data: GenericKubernetesResourceActivityLogEntryData! + "Data associated with the entry." + data: ClusterAuditActivityLogEntryData! } -extend enum ActivityLogActivityType { - """ - An application was deleted. - """ - APPLICATION_DELETED - - """ - An application was restarted. - """ - APPLICATION_RESTARTED - - """ - An application was scaled. - """ - APPLICATION_SCALED +type ClusterAuditActivityLogEntryData { + "The action that was performed." + action: String! + "The kind of resource that was affected by the action." + resourceKind: String! } `, BuiltIn: false}, - {Name: "../schema/apply.graphqls", Input: `extend enum ActivityLogActivityType { - "A generic kubernetes resource was updated via apply." - GENERIC_KUBERNETES_RESOURCE_UPDATED + {Name: "../schema/configmap.graphqls", Input: `extend type Mutation { + "Create a new config." + createConfig(input: CreateConfigInput!): CreateConfigPayload! - "A generic kubernetes resource was created via apply." - GENERIC_KUBERNETES_RESOURCE_CREATED + "Add a value to a config." + addConfigValue(input: AddConfigValueInput!): AddConfigValuePayload! + + "Update a value within a config." + updateConfigValue(input: UpdateConfigValueInput!): UpdateConfigValuePayload! + + "Remove a value from a config." + removeConfigValue(input: RemoveConfigValueInput!): RemoveConfigValuePayload! + + "Delete a config, and the values it contains." + deleteConfig(input: DeleteConfigInput!): DeleteConfigPayload! } -""" -Additional data associated with a resource created or updated via apply. -""" -type GenericKubernetesResourceActivityLogEntryData { - "The apiVersion of the applied resource." - apiVersion: String! - "The kind of the applied resource." - kind: String! - "The fields that changed during the apply. Only populated for updates." - changedFields: [ResourceChangedField!]! - "GitHub Actions OIDC token claims at the time of the apply. Only present when the request was authenticated via a GitHub token." - gitHubClaims: GitHubActorClaims +extend type Team { + "Configs owned by the team." + configs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + + "Ordering options for items returned from the connection." + orderBy: ConfigOrder + + "Filtering options for items returned from the connection." + filter: ConfigFilter + ): ConfigConnection! } """ -GitHub Actions OIDC token claims captured at the time of an apply operation. +Input for filtering the configs of a team. """ -type GitHubActorClaims { - "The git ref that triggered the workflow, e.g. 'refs/heads/main'." - ref: String! - "The repository name that triggered the workflow, e.g. 'org/repo'." - repository: String! - "The immutable numeric GitHub repository ID." - repositoryID: String! - "The unique identifier of the Actions workflow run. Links to https://github.com//actions/runs/." - runID: String! - "The attempt number of the workflow run (1-indexed)." - runAttempt: String! - "The GitHub username that triggered the workflow." - actor: String! - "The path to the workflow file, e.g. '.github/workflows/deploy.yaml'." - workflow: String! - "The event that triggered the workflow, e.g. 'push' or 'workflow_dispatch'." - eventName: String! - "The GitHub deployment environment name, if the job targets one." - environment: String! - "The ref of the reusable workflow called by this job, if any. E.g. 'org/repo/.github/workflows/deploy.yaml@refs/heads/main'." - jobWorkflowRef: String! +input ConfigFilter { + """ + Filter by the name of the config. + """ + name: String + + """ + Filter by usage of the config. + """ + inUse: Boolean } -""" -A single field that changed. -""" -type ResourceChangedField { - "The dot-separated path to the changed field, e.g. 'spec.replicas'." - field: String! - "The value before the change. Null if the field was added." - oldValue: String - "The value after the change. Null if the field was removed." - newValue: String +extend type TeamEnvironment { + "Get a config by name." + config(name: String!): Config! } -""" -Activity log entry for a resource kind that is not modelled in the GraphQL API. -The resource type will be the uppercase Kubernetes kind, e.g. 'NAISJOB'. -""" -type GenericKubernetesResourceActivityLogEntry implements ActivityLogEntry & Node { - "ID of the entry." - id: ID! +extend interface Workload { + "Configs used by the workload." + configs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int - "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." - actor: String! + "Get items after this cursor." + after: Cursor - "Creation time of the entry." - createdAt: Time! + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int - "Message that summarizes the entry." - message: String! + "Get items before this cursor." + before: Cursor + ): ConfigConnection! +} - "Type of the resource that was affected by the action." - resourceType: ActivityLogEntryResourceType! +extend type Application { + "Configs used by the application." + configs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int - "Name of the resource that was affected by the action." - resourceName: String! + "Get items after this cursor." + after: Cursor - "The team slug that the entry belongs to." - teamSlug: Slug + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int - "The environment name that the entry belongs to." - environmentName: String + "Get items before this cursor." + before: Cursor + ): ConfigConnection! +} - "Data associated with the apply operation." - data: GenericKubernetesResourceActivityLogEntryData! +extend type Job { + "Configs used by the job." + configs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int + + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor + ): ConfigConnection! } -`, BuiltIn: false}, - {Name: "../schema/authz.graphqls", Input: `type Role implements Node { - """ - The globally unique ID of the role. - """ + +"A config is a collection of key-value pairs." +type Config implements Node & ActivityLogger { + "The globally unique ID of the config." id: ID! - """ - Name of the role. - """ + "The name of the config." name: String! - """ - Description of the role. - """ - description: String! -} + "The environment the config exists in." + teamEnvironment: TeamEnvironment! -extend type Query { - roles( + "The team that owns the config." + team: Team! + + "The values stored in the config." + values: [ConfigValue!]! + + "Applications that use the config." + applications( "Get the first n items in the connection. This can be used in combination with the after parameter." first: Int @@ -17899,41 +19134,25 @@ extend type Query { "Get items before this cursor." before: Cursor - ): RoleConnection! -} + ): ApplicationConnection! -type RoleConnection { - """ - A list of roles. - """ - nodes: [Role!]! + "Jobs that use the config." + jobs( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int - """ - A list of role edges. - """ - edges: [RoleEdge!]! + "Get items after this cursor." + after: Cursor - """ - Information to aid in pagination. - """ - pageInfo: PageInfo! -} + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int -type RoleEdge { - """ - The role. - """ - node: Role! + "Get items before this cursor." + before: Cursor + ): JobConnection! - """ - A cursor for use in pagination. - """ - cursor: Cursor! -} -`, BuiltIn: false}, - {Name: "../schema/bigquery.graphqls", Input: `extend type Team { - "BigQuery datasets owned by the team." - bigQueryDatasets( + "Workloads that use the config." + workloads( "Get the first n items in the connection. This can be used in combination with the after parameter." first: Int @@ -17945,235 +19164,225 @@ type RoleEdge { "Get items before this cursor." before: Cursor + ): WorkloadConnection! - "Ordering options for items returned from the connection." - orderBy: BigQueryDatasetOrder - ): BigQueryDatasetConnection! -} + "Last time the config was modified." + lastModifiedAt: Time -extend type TeamEnvironment { - "BigQuery datasets in the team environment." - bigQueryDataset(name: String!): BigQueryDataset! -} + "User who last modified the config." + lastModifiedBy: User -extend interface Workload { - "BigQuery datasets referenced by the workload. This does not currently support pagination, but will return all available datasets." - bigQueryDatasets( - "Ordering options for items returned from the connection." - orderBy: BigQueryDatasetOrder - ): BigQueryDatasetConnection! -} + "Activity log associated with the config." + activityLog( + "Get the first n items in the connection. This can be used in combination with the after parameter." + first: Int -extend type Application { - "BigQuery datasets referenced by the application. This does not currently support pagination, but will return all available datasets." - bigQueryDatasets( - "Ordering options for items returned from the connection." - orderBy: BigQueryDatasetOrder - ): BigQueryDatasetConnection! -} + "Get items after this cursor." + after: Cursor + + "Get the last n items in the connection. This can be used in combination with the before parameter." + last: Int + + "Get items before this cursor." + before: Cursor -extend type Job { - "BigQuery datasets referenced by the job. This does not currently support pagination, but will return all available datasets." - bigQueryDatasets( - "Ordering options for items returned from the connection." - orderBy: BigQueryDatasetOrder - ): BigQueryDatasetConnection! + "Filter items." + filter: ActivityLogFilter + ): ActivityLogEntryConnection! } extend type TeamInventoryCounts { - bigQueryDatasets: TeamInventoryCountBigQueryDatasets! + """ + Config inventory count for a team. + """ + configs: TeamInventoryCountConfigs! } -type TeamInventoryCountBigQueryDatasets { - "Total number of BigQuery datasets." +""" +Config inventory count for a team. +""" +type TeamInventoryCountConfigs { + """ + Total number of configs. + """ total: Int! } -type BigQueryDataset implements Persistence & Node { - id: ID! +input ConfigValueInput { + "The name of the config value." name: String! - team: Team! - environment: TeamEnvironment! @deprecated(reason: "Use the ` + "`" + `teamEnvironment` + "`" + ` field instead.") - teamEnvironment: TeamEnvironment! - cascadingDelete: Boolean! - description: String - access( - first: Int - after: Cursor - last: Int - before: Cursor - orderBy: BigQueryDatasetAccessOrder - ): BigQueryDatasetAccessConnection! - status: BigQueryDatasetStatus! - workload: Workload -} -type BigQueryDatasetAccess { - role: String! - email: String! + "The value to set." + value: String! } -type BigQueryDatasetStatus { - creationTime: Time! - lastModifiedTime: Time -} +input CreateConfigInput { + "The name of the config." + name: String! -type BigQueryDatasetAccessConnection { - pageInfo: PageInfo! - nodes: [BigQueryDatasetAccess!]! - edges: [BigQueryDatasetAccessEdge!]! -} + "The environment the config exists in." + environmentName: String! -type BigQueryDatasetConnection { - pageInfo: PageInfo! - nodes: [BigQueryDataset!]! - edges: [BigQueryDatasetEdge!]! + "The team that owns the config." + teamSlug: Slug! } -type BigQueryDatasetAccessEdge { - cursor: Cursor! - node: BigQueryDatasetAccess! -} +input AddConfigValueInput { + "The name of the config." + name: String! -type BigQueryDatasetEdge { - cursor: Cursor! - node: BigQueryDataset! -} + "The environment the config exists in." + environmentName: String! -input BigQueryDatasetAccessOrder { - field: BigQueryDatasetAccessOrderField! - direction: OrderDirection! -} + "The team that owns the config." + teamSlug: Slug! -input BigQueryDatasetOrder { - field: BigQueryDatasetOrderField! - direction: OrderDirection! + "The config value to add." + value: ConfigValueInput! } -enum BigQueryDatasetAccessOrderField { - ROLE - EMAIL -} +input UpdateConfigValueInput { + "The name of the config." + name: String! -enum BigQueryDatasetOrderField { - NAME - ENVIRONMENT -} + "The environment the config exists in." + environmentName: String! -extend union SearchNode = BigQueryDataset + "The team that owns the config." + teamSlug: Slug! -extend enum SearchType { - BIGQUERY_DATASET + "The config value to update." + value: ConfigValueInput! } -`, BuiltIn: false}, - {Name: "../schema/bucket.graphqls", Input: `extend type Team { - "Google Cloud Storage buckets owned by the team." - buckets( - "Get the first n items in the connection. This can be used in combination with the after parameter." - first: Int - "Get items after this cursor." - after: Cursor +input RemoveConfigValueInput { + "The name of the config." + configName: String! - "Get the last n items in the connection. This can be used in combination with the before parameter." - last: Int + "The environment the config exists in." + environmentName: String! - "Get items before this cursor." - before: Cursor + "The team that owns the config." + teamSlug: Slug! - "Ordering options for items returned from the connection." - orderBy: BucketOrder - ): BucketConnection! + "The config value to remove." + valueName: String! } -extend type TeamEnvironment { - "Storage bucket in the team environment." - bucket(name: String!): Bucket! +input DeleteConfigInput { + "The name of the config." + name: String! + + "The environment the config exists in." + environmentName: String! + + "The team that owns the config." + teamSlug: Slug! } -extend interface Workload { - "Google Cloud Storage referenced by the workload. This does not currently support pagination, but will return all available buckets." - buckets( - "Ordering options for items returned from the connection." - orderBy: BucketOrder - ): BucketConnection! +type CreateConfigPayload { + "The created config." + config: Config } -extend type Application { - "Google Cloud Storage referenced by the application. This does not currently support pagination, but will return all available buckets." - buckets( - "Ordering options for items returned from the connection." - orderBy: BucketOrder - ): BucketConnection! +input ConfigOrder { + "The field to order items by." + field: ConfigOrderField! + + "The direction to order items by." + direction: OrderDirection! } -extend type Job { - "Google Cloud Storage referenced by the job. This does not currently support pagination, but will return all available buckets." - buckets( - "Ordering options for items returned from the connection." - orderBy: BucketOrder - ): BucketConnection! +enum ConfigOrderField { + "Order configs by name." + NAME + + "Order configs by the name of the environment." + ENVIRONMENT + + "Order configs by the last time it was modified." + LAST_MODIFIED_AT } -extend type TeamInventoryCounts { - buckets: TeamInventoryCountBuckets! +type AddConfigValuePayload { + "The updated config." + config: Config } -type TeamInventoryCountBuckets { - "Total number of Google Cloud Storage buckets." - total: Int! +type UpdateConfigValuePayload { + "The updated config." + config: Config } -type Bucket implements Persistence & Node { - id: ID! - name: String! - team: Team! - environment: TeamEnvironment! @deprecated(reason: "Use the ` + "`" + `teamEnvironment` + "`" + ` field instead.") - teamEnvironment: TeamEnvironment! - cascadingDelete: Boolean! - publicAccessPrevention: String! - uniformBucketLevelAccess: Boolean! - workload: Workload +type RemoveConfigValuePayload { + "The updated config." + config: Config } -type BucketConnection { +type DeleteConfigPayload { + "The deleted config." + configDeleted: Boolean +} + +type ConfigConnection { + "Pagination information." pageInfo: PageInfo! - nodes: [Bucket!]! - edges: [BucketEdge!]! + + "List of nodes." + nodes: [Config!]! + + "List of edges." + edges: [ConfigEdge!]! } -type BucketEdge { +type ConfigEdge { + "Cursor for this edge that can be used for pagination." cursor: Cursor! - node: Bucket! + + "The Config." + node: Config! } -input BucketOrder { - field: BucketOrderField! - direction: OrderDirection! +type ConfigValue { + "The name of the config value." + name: String! + + "The config value itself." + value: String! } -enum BucketOrderField { - NAME - ENVIRONMENT +extend enum ActivityLogEntryResourceType { + "All activity log entries related to configs will use this resource type." + CONFIG } -extend union SearchNode = Bucket +type ConfigCreatedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! -extend enum SearchType { - BUCKET -} -`, BuiltIn: false}, - {Name: "../schema/cluster.graphqls", Input: `extend enum ActivityLogEntryResourceType { - "All activity log entries related to direct cluster changes." - CLUSTER_AUDIT -} + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! -extend enum ActivityLogActivityType { - "All activity log entries related to direct cluster changes." - CLUSTER_AUDIT + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String } -type ClusterAuditActivityLogEntry implements ActivityLogEntry & Node { +type ConfigUpdatedActivityLogEntry implements ActivityLogEntry & Node { "ID of the entry." id: ID! @@ -18199,14 +19408,58 @@ type ClusterAuditActivityLogEntry implements ActivityLogEntry & Node { environmentName: String "Data associated with the entry." - data: ClusterAuditActivityLogEntryData! + data: ConfigUpdatedActivityLogEntryData! } -type ClusterAuditActivityLogEntryData { - "The action that was performed." - action: String! - "The kind of resource that was affected by the action." - resourceKind: String! +type ConfigUpdatedActivityLogEntryDataUpdatedField { + "The name of the field that was updated." + field: String! + + "The old value of the field." + oldValue: String + + "The new value of the field." + newValue: String +} + +type ConfigUpdatedActivityLogEntryData { + "The fields that were updated." + updatedFields: [ConfigUpdatedActivityLogEntryDataUpdatedField!]! +} + +type ConfigDeletedActivityLogEntry implements ActivityLogEntry & Node { + "ID of the entry." + id: ID! + + "The identity of the actor who performed the action. The value is either the name of a service account, or the email address of a user." + actor: String! + + "Creation time of the entry." + createdAt: Time! + + "Message that summarizes the entry." + message: String! + + "Type of the resource that was affected by the action." + resourceType: ActivityLogEntryResourceType! + + "Name of the resource that was affected by the action." + resourceName: String! + + "The team slug that the entry belongs to." + teamSlug: Slug! + + "The environment name that the entry belongs to." + environmentName: String +} + +extend enum ActivityLogActivityType { + "Config was created." + CONFIG_CREATED + "Config was updated." + CONFIG_UPDATED + "Config was deleted." + CONFIG_DELETED } `, BuiltIn: false}, {Name: "../schema/cost.graphqls", Input: `extend type Team { From a1b2d92ccb0d7142be36d4c49c4f4d41cd52bd1d Mon Sep 17 00:00:00 2001 From: Vegar Sechmann Molvig Date: Wed, 18 Mar 2026 13:34:14 +0100 Subject: [PATCH 18/25] fix: use exported ActivityLogEntryResourceTypeJob constant --- internal/workload/job/queries.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/workload/job/queries.go b/internal/workload/job/queries.go index 1093c3e52..160cbe959 100644 --- a/internal/workload/job/queries.go +++ b/internal/workload/job/queries.go @@ -203,7 +203,7 @@ func DeleteRun(ctx context.Context, teamSlug slug.Slug, environmentName, runName if err := activitylog.Create(ctx, activitylog.CreateInput{ Action: activityLogEntryActionDeleteJobRun, Actor: authz.ActorFromContext(ctx).User, - ResourceType: activityLogEntryResourceTypeJob, + ResourceType: ActivityLogEntryResourceTypeJob, ResourceName: jobName, Data: &JobRunDeletedActivityLogEntryData{RunName: runName}, EnvironmentName: &environmentName, From 3705bba808074e7fedcd96b4b6b3795a80551868 Mon Sep 17 00:00:00 2001 From: Vegar Sechmann Molvig Date: Wed, 18 Mar 2026 13:49:11 +0100 Subject: [PATCH 19/25] fix: re-add and rename managementWatcherMgr --- internal/cmd/api/api.go | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/internal/cmd/api/api.go b/internal/cmd/api/api.go index 025b450d7..923a3d027 100644 --- a/internal/cmd/api/api.go +++ b/internal/cmd/api/api.go @@ -156,13 +156,13 @@ func run(ctx context.Context, cfg *Config, log logrus.FieldLogger) error { } defer watcherMgr.Stop() - mgmtWatcher, err := watcher.NewManager(scheme, kubernetes.ClusterConfigMap{"management": nil}, log.WithField("subsystem", "k8s_watcher"), mgmtWatcherOpts...) + mgmtWatcherMgr, err := watcher.NewManager(scheme, kubernetes.ClusterConfigMap{"management": nil}, log.WithField("subsystem", "k8s_watcher"), mgmtWatcherOpts...) if err != nil { return fmt.Errorf("create k8s watcher manager for management: %w", err) } - defer mgmtWatcher.Stop() + defer mgmtWatcherMgr.Stop() - watchers := watchers.SetupWatchers(ctx, watcherMgr, mgmtWatcher) + watchers := watchers.SetupWatchers(ctx, watcherMgr, mgmtWatcherMgr) pubsubClient, err := pubsub.NewClient(ctx, cfg.GoogleManagementProjectID) if err != nil { @@ -290,6 +290,7 @@ func run(ctx context.Context, cfg *Config, log logrus.FieldLogger) error { cfg.Fakes, watchers, watcherMgr, + mgmtWatcherMgr, pool, clusterConfig, serviceMaintenanceManager, @@ -331,7 +332,7 @@ func run(ctx context.Context, cfg *Config, log logrus.FieldLogger) error { ctx, cfg.InternalListenAddress, promReg, - []ReadinessChecker{watcherMgr, mgmtWatcher}, + []ReadinessChecker{watcherMgr, mgmtWatcherMgr}, log.WithField("subsystem", "internal_http"), ) }) From fb7c19912a00af1221abd2e0cf1c0cd27d24f885 Mon Sep 17 00:00:00 2001 From: Vegar Sechmann Molvig Date: Wed, 18 Mar 2026 14:04:48 +0100 Subject: [PATCH 20/25] refactor: simplify dynamic client override for apply --- internal/apply/apply.go | 17 +------- internal/cmd/api/api.go | 2 +- internal/integration/manager.go | 1 - internal/rest/rest.go | 75 +++++++++++++++------------------ 4 files changed, 36 insertions(+), 59 deletions(-) diff --git a/internal/apply/apply.go b/internal/apply/apply.go index 1cb5601c1..e6b192246 100644 --- a/internal/apply/apply.go +++ b/internal/apply/apply.go @@ -11,7 +11,6 @@ import ( "github.com/nais/api/internal/activitylog" "github.com/nais/api/internal/auth/authz" "github.com/nais/api/internal/auth/middleware" - "github.com/nais/api/internal/kubernetes" "github.com/nais/api/internal/slug" "github.com/sirupsen/logrus" "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" @@ -27,27 +26,15 @@ type Handler struct { type DynamicClientFactory func(environmentName string, teamSlug slug.Slug) (dynamic.Interface, error) -type HandlerOpt func(*Handler) - -func NewHandler(clusterConfigsMap kubernetes.ClusterConfigMap, log logrus.FieldLogger, opts ...HandlerOpt) *Handler { +func NewHandler(dynamicClientFn DynamicClientFactory, log logrus.FieldLogger) *Handler { h := &Handler{ log: log, - dynamicClientFn: clusterConfigsMap.TeamClient, - } - - for _, opt := range opts { - opt(h) + dynamicClientFn: dynamicClientFn, } return h } -func WithClientFactory(clientFactory DynamicClientFactory) HandlerOpt { - return func(h *Handler) { - h.dynamicClientFn = clientFactory - } -} - func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { ctx := r.Context() diff --git a/internal/cmd/api/api.go b/internal/cmd/api/api.go index 923a3d027..8ea480a46 100644 --- a/internal/cmd/api/api.go +++ b/internal/cmd/api/api.go @@ -342,7 +342,7 @@ func run(ctx context.Context, cfg *Config, log logrus.FieldLogger) error { ListenAddress: cfg.RestListenAddress, Pool: pool, PreSharedKey: cfg.RestPreSharedKey, - ClusterConfigs: clusterConfig, + DynamicClient: clusterConfig.TeamClient, ContextMiddleware: contextDependencies, JWTMiddleware: jwtMiddleware, AuthHandler: authHandler, diff --git a/internal/integration/manager.go b/internal/integration/manager.go index be2439a95..55101fa00 100644 --- a/internal/integration/manager.go +++ b/internal/integration/manager.go @@ -213,7 +213,6 @@ func newRestRunner(ctx context.Context, pool *pgxpool.Pool, clusterConfig kubern router := rest.MakeRouter(ctx, rest.Config{ Pool: pool, PreSharedKey: testPreSharedKey, - ClusterConfigs: clusterConfig, ContextMiddleware: contextDependencies, DynamicClient: func(cluster string, _ slug.Slug) (dynamic.Interface, error) { return k8sRunner.DynamicClient(cluster) diff --git a/internal/rest/rest.go b/internal/rest/rest.go index 104fa00d6..577b205d0 100644 --- a/internal/rest/rest.go +++ b/internal/rest/rest.go @@ -11,7 +11,6 @@ import ( "github.com/nais/api/internal/apply" "github.com/nais/api/internal/auth/authn" "github.com/nais/api/internal/auth/middleware" - "github.com/nais/api/internal/kubernetes" "github.com/nais/api/internal/rest/restteamsapi" "github.com/sirupsen/logrus" "golang.org/x/sync/errgroup" @@ -24,11 +23,10 @@ type Fakes struct { // Config holds all dependencies needed by the REST server. type Config struct { - ListenAddress string - Pool *pgxpool.Pool - PreSharedKey string - ClusterConfigs kubernetes.ClusterConfigMap - DynamicClient apply.DynamicClientFactory + ListenAddress string + Pool *pgxpool.Pool + PreSharedKey string + DynamicClient apply.DynamicClientFactory // ContextMiddleware sets up the request context with all loaders and // dependencies needed by the apply handler (authz, activitylog, etc.). // In production this is the middleware returned by ConfigureGraph. @@ -86,42 +84,35 @@ func MakeRouter(ctx context.Context, cfg Config) *chi.Mux { } // Apply route with user authentication. - if cfg.ClusterConfigs != nil { - router.Group(func(r chi.Router) { - if cfg.ContextMiddleware != nil { - r.Use(cfg.ContextMiddleware) - } - - if cfg.Fakes.WithInsecureUserHeader { - r.Use(middleware.InsecureUserHeader()) - } - - if cfg.JWTMiddleware != nil { - r.Use(cfg.JWTMiddleware) - } - - r.Use( - middleware.ApiKeyAuthentication(), - ) - - if cfg.AuthHandler != nil { - r.Use(middleware.Oauth2Authentication(cfg.AuthHandler)) - } - - r.Use( - middleware.GitHubOIDC(ctx, cfg.Log), - middleware.RequireAuthenticatedUser(), - ) - - opts := []apply.HandlerOpt{} - if cfg.DynamicClient != nil { - opts = append(opts, apply.WithClientFactory(cfg.DynamicClient)) - } - - handler := apply.NewHandler(cfg.ClusterConfigs, cfg.Log, opts...) - r.Post("/api/v1/teams/{teamSlug}/environments/{environment}/apply", handler.ServeHTTP) - }) - } + router.Group(func(r chi.Router) { + if cfg.ContextMiddleware != nil { + r.Use(cfg.ContextMiddleware) + } + + if cfg.Fakes.WithInsecureUserHeader { + r.Use(middleware.InsecureUserHeader()) + } + + if cfg.JWTMiddleware != nil { + r.Use(cfg.JWTMiddleware) + } + + r.Use( + middleware.ApiKeyAuthentication(), + ) + + if cfg.AuthHandler != nil { + r.Use(middleware.Oauth2Authentication(cfg.AuthHandler)) + } + + r.Use( + middleware.GitHubOIDC(ctx, cfg.Log), + middleware.RequireAuthenticatedUser(), + ) + + handler := apply.NewHandler(cfg.DynamicClient, cfg.Log) + r.Post("/api/v1/teams/{teamSlug}/environments/{environment}/apply", handler.ServeHTTP) + }) return router } From db7e4e728093041569620338fda5cd3b049cc444 Mon Sep 17 00:00:00 2001 From: Vegar Sechmann Molvig Date: Wed, 18 Mar 2026 14:19:25 +0100 Subject: [PATCH 21/25] fix: costupdater test use localhost --- internal/cost/costupdater/costupdater_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/cost/costupdater/costupdater_test.go b/internal/cost/costupdater/costupdater_test.go index d4bf52678..d68055278 100644 --- a/internal/cost/costupdater/costupdater_test.go +++ b/internal/cost/costupdater/costupdater_test.go @@ -19,7 +19,7 @@ import ( ) const ( - bigQueryHost = "0.0.0.0:9050" + bigQueryHost = "127.0.0.1:9050" bigQueryUrl = "http://" + bigQueryHost projectID = "nais-io" tenant = "test" From 78b1baff1a32b83dd5cd741d7809fc1d873580f0 Mon Sep 17 00:00:00 2001 From: Vegar Sechmann Molvig Date: Wed, 18 Mar 2026 14:41:14 +0100 Subject: [PATCH 22/25] refactor: make GitHub OIDC middleware injectable to avoid network calls in tests GitHubOIDC now accepts an issuer parameter, returns an error instead of silently degrading, and is passed as an optional field in rest.Config. Integration tests simply leave the field nil to skip the middleware. --- internal/auth/middleware/github_token.go | 23 +++++++++++++---------- internal/cmd/api/api.go | 21 ++++++++++++++------- internal/cmd/api/http.go | 10 +++++++++- internal/rest/rest.go | 16 ++++++++++------ 4 files changed, 46 insertions(+), 24 deletions(-) diff --git a/internal/auth/middleware/github_token.go b/internal/auth/middleware/github_token.go index 9b51b9afd..17c6b3e95 100644 --- a/internal/auth/middleware/github_token.go +++ b/internal/auth/middleware/github_token.go @@ -46,20 +46,23 @@ type GitHubActorClaims struct { JobWorkflowRef string `json:"jobWorkflowRef"` } -func GitHubOIDC(ctx context.Context, log logrus.FieldLogger) func(next http.Handler) http.Handler { +const ( + // GitHubOIDCIssuer is the OIDC issuer URL for GitHub Actions tokens. + GitHubOIDCIssuer = "https://token.actions.githubusercontent.com" + + // GitHubOIDCAudience is the expected audience claim in GitHub OIDC tokens. + GitHubOIDCAudience = "api.nais.io" +) + +func GitHubOIDC(ctx context.Context, issuer string, log logrus.FieldLogger) (func(next http.Handler) http.Handler, error) { log = log.WithField("subsystem", "github_oidc") - provider, err := oidc.NewProvider(ctx, "https://token.actions.githubusercontent.com") + provider, err := oidc.NewProvider(ctx, issuer) if err != nil { - log.WithError(err).Error("failed to initialize GitHub OIDC provider. Will not support GitHub OIDC authentication") - return func(sub http.Handler) http.Handler { - return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - sub.ServeHTTP(w, r) - }) - } + return nil, fmt.Errorf("initialize GitHub OIDC provider: %w", err) } verifier := provider.Verifier(&oidc.Config{ - ClientID: "api.nais.io", + ClientID: GitHubOIDCAudience, }) return func(next http.Handler) http.Handler { @@ -133,7 +136,7 @@ func GitHubOIDC(ctx context.Context, log logrus.FieldLogger) func(next http.Hand next.ServeHTTP(w, r.WithContext(authz.ContextWithActor(ctx, usr, roles))) } return http.HandlerFunc(fn) - } + }, nil } type GitHubRepoActor struct { diff --git a/internal/cmd/api/api.go b/internal/cmd/api/api.go index 8ea480a46..45de71af8 100644 --- a/internal/cmd/api/api.go +++ b/internal/cmd/api/api.go @@ -275,6 +275,11 @@ func run(ctx context.Context, cfg *Config, log logrus.FieldLogger) error { } } + githubOIDCMiddleware, err := middleware.GitHubOIDC(ctx, middleware.GitHubOIDCIssuer, log.WithField("subsystem", "github_oidc")) + if err != nil { + return fmt.Errorf("failed to create GitHub OIDC middleware: %w", err) + } + var lokiClientOpts []loki.OptionFunc if addr, ok := os.LookupEnv("LOGGING_LOKI_ADDRESS"); ok { lokiClientOpts = append(lokiClientOpts, loki.WithLocalLoki(addr)) @@ -321,6 +326,7 @@ func run(ctx context.Context, cfg *Config, log logrus.FieldLogger) error { cfg.ListenAddress, jwtMiddleware, + githubOIDCMiddleware, authHandler, graphHandler, contextDependencies, @@ -339,13 +345,14 @@ func run(ctx context.Context, cfg *Config, log logrus.FieldLogger) error { wg.Go(func() error { return restserver.Run(ctx, restserver.Config{ - ListenAddress: cfg.RestListenAddress, - Pool: pool, - PreSharedKey: cfg.RestPreSharedKey, - DynamicClient: clusterConfig.TeamClient, - ContextMiddleware: contextDependencies, - JWTMiddleware: jwtMiddleware, - AuthHandler: authHandler, + ListenAddress: cfg.RestListenAddress, + Pool: pool, + PreSharedKey: cfg.RestPreSharedKey, + DynamicClient: clusterConfig.TeamClient, + ContextMiddleware: contextDependencies, + JWTMiddleware: jwtMiddleware, + GitHubOIDCMiddleware: githubOIDCMiddleware, + AuthHandler: authHandler, Fakes: restserver.Fakes{ WithInsecureUserHeader: cfg.Fakes.WithInsecureUserHeader, }, diff --git a/internal/cmd/api/http.go b/internal/cmd/api/http.go index 3fa4e39d9..71211604e 100644 --- a/internal/cmd/api/http.go +++ b/internal/cmd/api/http.go @@ -78,6 +78,7 @@ func runHTTPServer( listenAddress string, jwtMiddleware func(http.Handler) http.Handler, + githubOIDCMiddleware func(http.Handler) http.Handler, authHandler authn.Handler, graphHandler *handler.Server, contextDependencies func(http.Handler) http.Handler, @@ -112,7 +113,14 @@ func runHTTPServer( middlewares, middleware.ApiKeyAuthentication(), middleware.Oauth2Authentication(authHandler), - middleware.GitHubOIDC(ctx, log), + ) + + if githubOIDCMiddleware != nil { + middlewares = append(middlewares, githubOIDCMiddleware) + } + + middlewares = append( + middlewares, middleware.RequireAuthenticatedUser(), otelhttp.NewMiddleware( "graphql", diff --git a/internal/rest/rest.go b/internal/rest/rest.go index 577b205d0..e86e7cef5 100644 --- a/internal/rest/rest.go +++ b/internal/rest/rest.go @@ -31,11 +31,12 @@ type Config struct { // dependencies needed by the apply handler (authz, activitylog, etc.). // In production this is the middleware returned by ConfigureGraph. // In tests a minimal equivalent can be provided. - ContextMiddleware func(http.Handler) http.Handler - JWTMiddleware func(http.Handler) http.Handler - AuthHandler authn.Handler - Fakes Fakes - Log logrus.FieldLogger + ContextMiddleware func(http.Handler) http.Handler + JWTMiddleware func(http.Handler) http.Handler + GitHubOIDCMiddleware func(http.Handler) http.Handler + AuthHandler authn.Handler + Fakes Fakes + Log logrus.FieldLogger } func Run(ctx context.Context, cfg Config) error { @@ -105,8 +106,11 @@ func MakeRouter(ctx context.Context, cfg Config) *chi.Mux { r.Use(middleware.Oauth2Authentication(cfg.AuthHandler)) } + if cfg.GitHubOIDCMiddleware != nil { + r.Use(cfg.GitHubOIDCMiddleware) + } + r.Use( - middleware.GitHubOIDC(ctx, cfg.Log), middleware.RequireAuthenticatedUser(), ) From 321b0522a9285f78c7b421542b1567381d5764b4 Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Thu, 19 Mar 2026 14:42:43 +0100 Subject: [PATCH 23/25] Add /api/v1/ path to ingress and support dynamic client factory in API server Co-authored-by: Vegar Sechmann Molvig --- charts/templates/ingress.yaml | 7 +++++++ internal/cmd/api/api.go | 19 ++++++++++++++++++- 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/charts/templates/ingress.yaml b/charts/templates/ingress.yaml index 89a95a301..a71a3721e 100644 --- a/charts/templates/ingress.yaml +++ b/charts/templates/ingress.yaml @@ -36,3 +36,10 @@ spec: name: rest path: /teams/ pathType: Prefix + - backend: + service: + name: "{{ .Release.Name }}" + port: + name: rest + path: /api/v1/ + pathType: Prefix diff --git a/internal/cmd/api/api.go b/internal/cmd/api/api.go index 45de71af8..8ed32defb 100644 --- a/internal/cmd/api/api.go +++ b/internal/cmd/api/api.go @@ -14,6 +14,7 @@ import ( aiven_service "github.com/aiven/go-client-codegen" "github.com/joho/godotenv" "github.com/nais/api/internal/activitylog" + "github.com/nais/api/internal/apply" "github.com/nais/api/internal/auth/authn" "github.com/nais/api/internal/auth/middleware" "github.com/nais/api/internal/database" @@ -35,6 +36,7 @@ import ( "github.com/nais/api/internal/persistence/sqlinstance" restserver "github.com/nais/api/internal/rest" "github.com/nais/api/internal/servicemaintenance" + "github.com/nais/api/internal/slug" "github.com/nais/api/internal/thirdparty/aiven" "github.com/nais/api/internal/thirdparty/hookd" fakehookd "github.com/nais/api/internal/thirdparty/hookd/fake" @@ -43,6 +45,7 @@ import ( "github.com/sethvargo/go-envconfig" "github.com/sirupsen/logrus" "golang.org/x/sync/errgroup" + "k8s.io/client-go/dynamic" k8s "k8s.io/client-go/kubernetes" k8sfake "k8s.io/client-go/kubernetes/fake" "k8s.io/client-go/rest" @@ -343,12 +346,26 @@ func run(ctx context.Context, cfg *Config, log logrus.FieldLogger) error { ) }) + var dynamicClientFactory apply.DynamicClientFactory + if cfg.Fakes.WithFakeKubernetes { + dynamicClients := watcherMgr.GetDynamicClients() + dynamicClientFactory = func(environmentName string, _ slug.Slug) (dynamic.Interface, error) { + client, ok := dynamicClients[environmentName] + if !ok { + return nil, fmt.Errorf("unknown environment: %q", environmentName) + } + return client, nil + } + } else { + dynamicClientFactory = clusterConfig.TeamClient + } + wg.Go(func() error { return restserver.Run(ctx, restserver.Config{ ListenAddress: cfg.RestListenAddress, Pool: pool, PreSharedKey: cfg.RestPreSharedKey, - DynamicClient: clusterConfig.TeamClient, + DynamicClient: dynamicClientFactory, ContextMiddleware: contextDependencies, JWTMiddleware: jwtMiddleware, GitHubOIDCMiddleware: githubOIDCMiddleware, From 90b6a644110f7e1ab19eca64664c71bab114ec43 Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Thu, 19 Mar 2026 14:47:04 +0100 Subject: [PATCH 24/25] Log enabled middlewares Custom error message for psk auth Co-authored-by: Vegar Sechmann Molvig --- internal/auth/middleware/presharedkey.go | 2 +- internal/rest/rest.go | 13 ++++++------- 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/internal/auth/middleware/presharedkey.go b/internal/auth/middleware/presharedkey.go index 85ee88838..bc04446d7 100644 --- a/internal/auth/middleware/presharedkey.go +++ b/internal/auth/middleware/presharedkey.go @@ -35,5 +35,5 @@ func PreSharedKeyAuthentication(preSharedKey string) func(next http.Handler) htt func handleError(w http.ResponseWriter) { w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusUnauthorized) - _, _ = fmt.Fprintln(w, `{"errors": [{"message": "Unauthorized"}]}`) + _, _ = fmt.Fprintln(w, `{"errors": [{"message": "No valid PSK provided"}]}`) } diff --git a/internal/rest/rest.go b/internal/rest/rest.go index e86e7cef5..3f75a558e 100644 --- a/internal/rest/rest.go +++ b/internal/rest/rest.go @@ -86,31 +86,30 @@ func MakeRouter(ctx context.Context, cfg Config) *chi.Mux { // Apply route with user authentication. router.Group(func(r chi.Router) { - if cfg.ContextMiddleware != nil { - r.Use(cfg.ContextMiddleware) - } + r.Use(cfg.ContextMiddleware) if cfg.Fakes.WithInsecureUserHeader { + cfg.Log.Info("#### Middleware enabled: InsecureUserHeader (for testing only) ####") r.Use(middleware.InsecureUserHeader()) } if cfg.JWTMiddleware != nil { + cfg.Log.Info("#### Middleware enabled: JWT Authentication ####") r.Use(cfg.JWTMiddleware) } - r.Use( - middleware.ApiKeyAuthentication(), - ) - if cfg.AuthHandler != nil { + cfg.Log.Info("#### Middleware enabled: OAuth2 Authentication ####") r.Use(middleware.Oauth2Authentication(cfg.AuthHandler)) } if cfg.GitHubOIDCMiddleware != nil { + cfg.Log.Info("#### Middleware enabled: GitHub OIDC Authentication ####") r.Use(cfg.GitHubOIDCMiddleware) } r.Use( + middleware.ApiKeyAuthentication(), middleware.RequireAuthenticatedUser(), ) From cc70248cd179b6683d78e65a4ca26c8139f5083b Mon Sep 17 00:00:00 2001 From: Thomas Krampl Date: Fri, 20 Mar 2026 08:49:01 +0100 Subject: [PATCH 25/25] Require team membership --- internal/auth/authz/queries.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/auth/authz/queries.go b/internal/auth/authz/queries.go index 0d1c529ac..3a24b048e 100644 --- a/internal/auth/authz/queries.go +++ b/internal/auth/authz/queries.go @@ -201,7 +201,7 @@ func CanUpdateJobs(ctx context.Context, teamSlug slug.Slug) error { } func CanApplyKubernetesResource(ctx context.Context, teamSlug slug.Slug) error { - return requireTeamAuthorization(ctx, teamSlug, "k8s_resources:apply") + return requireStrictTeamAuthorization(ctx, teamSlug, "k8s_resources:apply") } func CanCreateRepositories(ctx context.Context, teamSlug slug.Slug) error {