Add latest changes from gitlab-org/gitlab@15-0-stable-eev15.0.0-rc42

31 files changed, 147 insertions, 136 deletions

diff --git a/app/graphql/resolvers/alert_management/http_integrations_resolver.rb b/app/graphql/resolvers/alert_management/http_integrations_resolver.rb
index abc54614a59..225e20bab83 100644
--- a/app/graphql/resolvers/alert_management/http_integrations_resolver.rb
+++ b/app/graphql/resolvers/alert_management/http_integrations_resolver.rb
@@ -26,8 +26,7 @@ module Resolvers
       private
 
       def integrations_by(gid:)
-        id = Types::GlobalIDType[::AlertManagement::HttpIntegration].coerce_isolated_input(gid)
-        object = GitlabSchema.find_by_gid(id)
+        object = GitlabSchema.find_by_gid(gid)
 
         defer { object }.then do |integration|
           ret = integration if project == integration&.project
diff --git a/app/graphql/resolvers/base_issues_resolver.rb b/app/graphql/resolvers/base_issues_resolver.rb
index 4cae7866a49..a1fda976876 100644
--- a/app/graphql/resolvers/base_issues_resolver.rb
+++ b/app/graphql/resolvers/base_issues_resolver.rb
@@ -35,7 +35,7 @@ module Resolvers
 
     def prepare_params(args, parent)
       return unless [:escalation_status_asc, :escalation_status_desc].include?(args[:sort])
-      return if Feature.enabled?(:incident_escalations, parent, default_enabled: :yaml)
+      return if Feature.enabled?(:incident_escalations, parent)
 
       args[:sort] = :created_desc # default for sort argument
     end
diff --git a/app/graphql/resolvers/base_resolver.rb b/app/graphql/resolvers/base_resolver.rb
index dbded8f60a0..2b54a3fdd55 100644
--- a/app/graphql/resolvers/base_resolver.rb
+++ b/app/graphql/resolvers/base_resolver.rb
@@ -4,7 +4,6 @@ module Resolvers
   class BaseResolver < GraphQL::Schema::Resolver
     extend ::Gitlab::Utils::Override
     include ::Gitlab::Utils::StrongMemoize
-    include ::Gitlab::Graphql::GlobalIDCompatibility
 
     argument_class ::Types::BaseArgument
 
diff --git a/app/graphql/resolvers/boards_resolver.rb b/app/graphql/resolvers/boards_resolver.rb
index 679f2b4cceb..91cd15f615d 100644
--- a/app/graphql/resolvers/boards_resolver.rb
+++ b/app/graphql/resolvers/boards_resolver.rb
@@ -26,9 +26,6 @@ module Resolvers
     def extract_board_id(id)
       return unless id.present?
 
-      # TODO: remove this line when the compatibility layer is removed
-      # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-      id = Types::GlobalIDType[Board].coerce_isolated_input(id)
       id.model_id
     end
   end
diff --git a/app/graphql/resolvers/ci/config_resolver.rb b/app/graphql/resolvers/ci/config_resolver.rb
index f9d60650443..6f861012d83 100644
--- a/app/graphql/resolvers/ci/config_resolver.rb
+++ b/app/graphql/resolvers/ci/config_resolver.rb
@@ -37,7 +37,7 @@ module Resolvers
           .new(project: project, current_user: context[:current_user], sha: sha)
           .validate(content, dry_run: dry_run)
 
-        response(result).merge(merged_yaml: result.merged_yaml)
+        response(result)
       rescue GRPC::InvalidArgument => error
         Gitlab::ErrorTracking.track_and_raise_exception(error, sha: sha)
       end
@@ -45,20 +45,14 @@ module Resolvers
       private
 
       def response(result)
-        if result.errors.empty?
-          {
-            status: :valid,
-            errors: [],
-            warnings: result.warnings,
-            stages: make_stages(result.jobs)
-          }
-        else
-          {
-            status: :invalid,
-            warnings: result.warnings,
-            errors: result.errors
-          }
-        end
+        {
+          status: result.status,
+          errors: result.errors,
+          warnings: result.warnings,
+          stages: make_stages(result),
+          merged_yaml: result.merged_yaml,
+          includes: result.includes
+        }
       end
 
       def make_jobs(config_jobs)
@@ -90,8 +84,10 @@ module Resolvers
         end
       end
 
-      def make_stages(jobs)
-        make_groups(jobs)
+      def make_stages(result)
+        return [] unless result.valid?
+
+        make_groups(result.jobs)
           .group_by { |group| group[:stage] }
           .map { |name, groups| { name: name, groups: groups } }
       end
diff --git a/app/graphql/resolvers/ci/runner_status_resolver.rb b/app/graphql/resolvers/ci/runner_status_resolver.rb
index d916a8a13f0..447ab306ba7 100644
--- a/app/graphql/resolvers/ci/runner_status_resolver.rb
+++ b/app/graphql/resolvers/ci/runner_status_resolver.rb
@@ -3,7 +3,8 @@
 module Resolvers
   module Ci
     # NOTE: This class was introduced to allow modifying the meaning of certain values in RunnerStatusEnum
-    # while preserving backward compatibility. It can be removed in 15.0 once the API has stabilized.
+    # while preserving backward compatibility. It can be removed in 17.0 after being deprecated
+    # and made a no-op in %16.0 (legacy_mode will be hard-coded to nil).
     class RunnerStatusResolver < BaseResolver
       type Types::Ci::RunnerStatusEnum, null: false
 
@@ -14,7 +15,11 @@ module Resolvers
                default_value: '14.5',
                required: false,
                description: 'Compatibility mode. A null value turns off compatibility mode.',
-               deprecated: { reason: 'Will be removed in 15.0. From that release onward, the field will behave as if legacyMode is null', milestone: '14.6' }
+               deprecated: {
+                 reason: 'Will be removed in 17.0. In GitLab 16.0 and later, ' \
+                         'the field will act as if `legacyMode` is null',
+                 milestone: '15.0'
+               }
 
       def resolve(legacy_mode:, **args)
         runner.status(legacy_mode)
diff --git a/app/graphql/resolvers/concerns/issue_resolver_arguments.rb b/app/graphql/resolvers/concerns/issue_resolver_arguments.rb
index 432d6f48607..de44dbb26d7 100644
--- a/app/graphql/resolvers/concerns/issue_resolver_arguments.rb
+++ b/app/graphql/resolvers/concerns/issue_resolver_arguments.rb
@@ -68,6 +68,12 @@ module IssueResolverArguments
              description: 'Negated arguments.',
              prepare: ->(negated_args, ctx) { negated_args.to_h },
              required: false
+    argument :crm_contact_id, GraphQL::Types::String,
+             required: false,
+             description: 'ID of a contact assigned to the issues.'
+    argument :crm_organization_id, GraphQL::Types::String,
+             required: false,
+             description: 'ID of an organization assigned to the issues.'
   end
 
   def resolve_with_lookahead(**args)
diff --git a/app/graphql/resolvers/concerns/resolves_ids.rb b/app/graphql/resolvers/concerns/resolves_ids.rb
index 8bf2a6b2ac9..3e248c40562 100644
--- a/app/graphql/resolvers/concerns/resolves_ids.rb
+++ b/app/graphql/resolvers/concerns/resolves_ids.rb
@@ -3,13 +3,10 @@
 module ResolvesIds
   extend ActiveSupport::Concern
 
-  def resolve_ids(ids, type)
+  def resolve_ids(ids)
     Array.wrap(ids).map do |id|
       next unless id.present?
 
-      # TODO: remove this line when the compatibility layer is removed
-      # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-      id = type.coerce_isolated_input(id)
       id.model_id
     end.compact
   end
diff --git a/app/graphql/resolvers/concerns/resolves_snippets.rb b/app/graphql/resolvers/concerns/resolves_snippets.rb
index 46d78a6a8c8..8274b5cc49f 100644
--- a/app/graphql/resolvers/concerns/resolves_snippets.rb
+++ b/app/graphql/resolvers/concerns/resolves_snippets.rb
@@ -28,7 +28,7 @@ module ResolvesSnippets
 
   def snippet_finder_params(args)
     {
-      ids: resolve_ids(args[:ids], ::Types::GlobalIDType[::Snippet]),
+      ids: resolve_ids(args[:ids]),
       scope: args[:visibility]
     }.merge(options_by_type(args[:type]))
   end
diff --git a/app/graphql/resolvers/concerns/time_frame_arguments.rb b/app/graphql/resolvers/concerns/time_frame_arguments.rb
index 0ec3c642f29..87b7a96045c 100644
--- a/app/graphql/resolvers/concerns/time_frame_arguments.rb
+++ b/app/graphql/resolvers/concerns/time_frame_arguments.rb
@@ -24,10 +24,13 @@ module TimeFrameArguments
   # TODO: remove when the start_date and end_date arguments are removed
   def validate_timeframe_params!(args)
     return unless %i[start_date end_date timeframe].any? { |k| args[k].present? }
-    return if args[:timeframe] && %i[start_date end_date].all? { |k| args[k].nil? }
+
+    # the timeframe is passed in as a TimeframeInputType
+    timeframe = args[:timeframe].to_h if args[:timeframe]
+    return if timeframe && %i[start_date end_date].all? { |k| args[k].nil? }
 
     error_message =
-      if args[:timeframe].present?
+      if timeframe.present?
         "startDate and endDate are deprecated in favor of timeframe. Please use only timeframe."
       elsif args[:start_date].nil? || args[:end_date].nil?
         "Both startDate and endDate must be present."
@@ -42,7 +45,7 @@ module TimeFrameArguments
 
   def transform_timeframe_parameters(args)
     if args[:timeframe]
-      args[:timeframe].transform_keys { |k| :"#{k}_date" }
+      args[:timeframe].to_h.transform_keys { |k| :"#{k}_date" }
     else
       args.slice(:start_date, :end_date)
     end
diff --git a/app/graphql/resolvers/design_management/design_at_version_resolver.rb b/app/graphql/resolvers/design_management/design_at_version_resolver.rb
index c87670bc24c..5ba23b5d1ed 100644
--- a/app/graphql/resolvers/design_management/design_at_version_resolver.rb
+++ b/app/graphql/resolvers/design_management/design_at_version_resolver.rb
@@ -18,9 +18,6 @@ module Resolvers
       end
 
       def find_object(id:)
-        # TODO: remove this line when the compatibility layer is removed
-        # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-        id = ::Types::GlobalIDType[::DesignManagement::DesignAtVersion].coerce_isolated_input(id)
         dav = GitlabSchema.find_by_gid(id)
         return unless consistent?(dav)
 
diff --git a/app/graphql/resolvers/design_management/design_resolver.rb b/app/graphql/resolvers/design_management/design_resolver.rb
index d9e5203ef0e..eaa11d2fd9d 100644
--- a/app/graphql/resolvers/design_management/design_resolver.rb
+++ b/app/graphql/resolvers/design_management/design_resolver.rb
@@ -54,10 +54,6 @@ module Resolvers
       end
 
       def parse_gid(gid)
-        # TODO: remove this line when the compatibility layer is removed
-        # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-        gid = ::Types::GlobalIDType[::DesignManagement::Design].coerce_isolated_input(gid)
-
         gid.model_id
       end
     end
diff --git a/app/graphql/resolvers/design_management/designs_resolver.rb b/app/graphql/resolvers/design_management/designs_resolver.rb
index a62ef6d76e5..429bbba74a5 100644
--- a/app/graphql/resolvers/design_management/designs_resolver.rb
+++ b/app/graphql/resolvers/design_management/designs_resolver.rb
@@ -24,13 +24,17 @@ module Resolvers
       end
 
       def resolve(ids: nil, filenames: nil, at_version: nil)
-        ::DesignManagement::DesignsFinder.new(
-          issue,
-          current_user,
-          ids: design_ids(ids),
-          filenames: filenames,
-          visible_at_version: version(at_version)
-        ).execute
+        context.scoped_set!(:at_version_argument, at_version) if at_version
+
+        ::Gitlab::Graphql::Lazy.with_value(version(at_version)) do |visible_at|
+          ::DesignManagement::DesignsFinder.new(
+            issue,
+            current_user,
+            ids: design_ids(ids),
+            filenames: filenames,
+            visible_at_version: visible_at
+          ).execute
+        end
       end
 
       private
@@ -38,19 +42,12 @@ module Resolvers
       def version(at_version)
         return unless at_version
 
-        # TODO: remove this line when the compatibility layer is removed
-        # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-        at_version = VersionID.coerce_isolated_input(at_version)
-        # TODO: when we get promises use this to make resolve lazy
-        Gitlab::Graphql::Lazy.force(GitlabSchema.find_by_gid(at_version))
+        GitlabSchema.find_by_gid(at_version)
       end
 
       def design_ids(gids)
         return if gids.nil?
 
-        # TODO: remove this line when the compatibility layer is removed
-        # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-        gids = gids.map { |id| DesignID.coerce_isolated_input(id) }
         gids.map(&:model_id)
       end
 
diff --git a/app/graphql/resolvers/design_management/version/design_at_version_resolver.rb b/app/graphql/resolvers/design_management/version/design_at_version_resolver.rb
index 76e365c40b1..30d2865ae85 100644
--- a/app/graphql/resolvers/design_management/version/design_at_version_resolver.rb
+++ b/app/graphql/resolvers/design_management/version/design_at_version_resolver.rb
@@ -34,11 +34,6 @@ module Resolvers
         def resolve(design_id: nil, filename: nil, design_at_version_id: nil)
           validate_arguments(design_id, filename, design_at_version_id)
 
-          # TODO: remove this when the compatibility layer is removed
-          # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-          design_id &&= DesignID.coerce_isolated_input(design_id)
-          design_at_version_id &&= DesignAtVersionID.coerce_isolated_input(design_at_version_id)
-
           return unless Ability.allowed?(current_user, :read_design, issue)
           return specific_design_at_version(design_at_version_id) if design_at_version_id
 
diff --git a/app/graphql/resolvers/design_management/version/designs_at_version_resolver.rb b/app/graphql/resolvers/design_management/version/designs_at_version_resolver.rb
index 97cc7554ba8..9f98762b519 100644
--- a/app/graphql/resolvers/design_management/version/designs_at_version_resolver.rb
+++ b/app/graphql/resolvers/design_management/version/designs_at_version_resolver.rb
@@ -41,9 +41,6 @@ module Resolvers
         def design_ids(gids)
           return if gids.nil?
 
-          # TODO: remove this line when the compatibility layer is removed
-          # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-          gids = gids.map { |id| DesignID.coerce_isolated_input(id) }
           gids.map(&:model_id)
         end
 
diff --git a/app/graphql/resolvers/design_management/version_in_collection_resolver.rb b/app/graphql/resolvers/design_management/version_in_collection_resolver.rb
index 2682ce6b3b1..f29cd30c36f 100644
--- a/app/graphql/resolvers/design_management/version_in_collection_resolver.rb
+++ b/app/graphql/resolvers/design_management/version_in_collection_resolver.rb
@@ -24,10 +24,6 @@ module Resolvers
                description: "SHA256 of a specific version."
 
       def resolve(version_id: nil, sha: nil)
-        # TODO: remove this line when the compatibility layer is removed
-        # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-        version_id &&= VersionID.coerce_isolated_input(version_id)
-
         check_args(version_id, sha)
 
         ::DesignManagement::VersionsFinder
diff --git a/app/graphql/resolvers/design_management/version_resolver.rb b/app/graphql/resolvers/design_management/version_resolver.rb
index a6403fbd69f..7895981d67c 100644
--- a/app/graphql/resolvers/design_management/version_resolver.rb
+++ b/app/graphql/resolvers/design_management/version_resolver.rb
@@ -18,10 +18,6 @@ module Resolvers
       end
 
       def find_object(id:)
-        # TODO: remove this line when the compatibility layer is removed
-        # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-        id = ::Types::GlobalIDType[::DesignManagement::Version].coerce_isolated_input(id)
-
         GitlabSchema.find_by_gid(id)
       end
     end
diff --git a/app/graphql/resolvers/design_management/versions_resolver.rb b/app/graphql/resolvers/design_management/versions_resolver.rb
index 23ba3c86d98..de636655087 100644
--- a/app/graphql/resolvers/design_management/versions_resolver.rb
+++ b/app/graphql/resolvers/design_management/versions_resolver.rb
@@ -9,8 +9,6 @@ module Resolvers
 
       VersionID = ::Types::GlobalIDType[::DesignManagement::Version]
 
-      extras [:parent]
-
       argument :earlier_or_equal_to_sha, GraphQL::Types::String,
                as: :sha,
                required: false,
@@ -26,11 +24,8 @@ module Resolvers
         ::Resolvers::DesignManagement::VersionInCollectionResolver
       end
 
-      def resolve(parent: nil, id: nil, sha: nil)
-        # TODO: remove this line when the compatibility layer is removed
-        # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-        id &&= VersionID.coerce_isolated_input(id)
-        version = cutoff(parent, id, sha)
+      def resolve(id: nil, sha: nil)
+        version = cutoff(id, sha)
 
         raise ::Gitlab::Graphql::Errors::ResourceNotAvailable, 'cutoff not found' unless version.present?
 
@@ -44,11 +39,11 @@ module Resolvers
       private
 
       # Find the most recent version that the client will accept
-      def cutoff(parent, id, sha)
+      def cutoff(id, sha)
         if sha.present? || id.present?
           specific_version(id, sha)
-        elsif at_version = at_version_arg(parent)
-          by_id(at_version)
+        elsif at_version = context[:at_version_argument]
+          by_id(at_version) # See: DesignsResolver
         else
           :unconstrained
         end
@@ -68,20 +63,6 @@ module Resolvers
       def by_id(gid)
         ::Gitlab::Graphql::Lazy.force(GitlabSchema.find_by_gid(gid))
       end
-
-      # Find an `at_version` argument passed to a parent node.
-      #
-      # If one is found, then a design collection further up the AST
-      # has been filtered to reflect designs at that version, and so
-      # for consistency we should only present versions up to the given
-      # version here.
-      def at_version_arg(parent)
-        # TODO: remove coercion when the compatibility layer is removed
-        # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-        version_id = ::Gitlab::Graphql::FindArgumentInParent.find(parent, :at_version, limit_depth: 4)
-        version_id &&= VersionID.coerce_isolated_input(version_id)
-        version_id
-      end
     end
   end
 end
diff --git a/app/graphql/resolvers/error_tracking/sentry_detailed_error_resolver.rb b/app/graphql/resolvers/error_tracking/sentry_detailed_error_resolver.rb
index 7032af46221..27bba6c8144 100644
--- a/app/graphql/resolvers/error_tracking/sentry_detailed_error_resolver.rb
+++ b/app/graphql/resolvers/error_tracking/sentry_detailed_error_resolver.rb
@@ -10,10 +10,6 @@ module Resolvers
                 description: 'ID of the Sentry issue.'
 
       def resolve(id:)
-        # TODO: remove this line when the compatibility layer is removed
-        # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-        id = ::Types::GlobalIDType[::Gitlab::ErrorTracking::DetailedError].coerce_isolated_input(id)
-
         # Get data from Sentry
         response = ::ErrorTracking::IssueDetailsService.new(
           project,
diff --git a/app/graphql/resolvers/error_tracking/sentry_error_stack_trace_resolver.rb b/app/graphql/resolvers/error_tracking/sentry_error_stack_trace_resolver.rb
index 8876f8badcd..3867634dd8b 100644
--- a/app/graphql/resolvers/error_tracking/sentry_error_stack_trace_resolver.rb
+++ b/app/graphql/resolvers/error_tracking/sentry_error_stack_trace_resolver.rb
@@ -10,10 +10,6 @@ module Resolvers
                 description: 'ID of the Sentry issue.'
 
       def resolve(id:)
-        # TODO: remove this line when the compatibility layer is removed
-        # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-        id = ::Types::GlobalIDType[::Gitlab::ErrorTracking::DetailedError].coerce_isolated_input(id)
-
         # Get data from Sentry
         response = ::ErrorTracking::IssueLatestEventService.new(
           project,
diff --git a/app/graphql/resolvers/group_members_resolver.rb b/app/graphql/resolvers/group_members_resolver.rb
index d3662b08cdf..f787f12e82a 100644
--- a/app/graphql/resolvers/group_members_resolver.rb
+++ b/app/graphql/resolvers/group_members_resolver.rb
@@ -11,6 +11,10 @@ module Resolvers
               required: false,
               default_value: GroupMembersFinder::DEFAULT_RELATIONS
 
+    argument :access_levels, [Types::AccessLevelEnum],
+              description: 'Filter members by the given access levels.',
+              required: false
+
     private
 
     def finder_class
diff --git a/app/graphql/resolvers/group_packages_resolver.rb b/app/graphql/resolvers/group_packages_resolver.rb
index d91fe84317d..b48e0b75190 100644
--- a/app/graphql/resolvers/group_packages_resolver.rb
+++ b/app/graphql/resolvers/group_packages_resolver.rb
@@ -26,7 +26,10 @@ module Resolvers
     def resolve(sort:, **filters)
       return unless packages_available?
 
-      ::Packages::GroupPackagesFinder.new(current_user, object, filters.merge(GROUP_SORT_TO_PARAMS_MAP.fetch(sort))).execute
+      params = filters.merge(GROUP_SORT_TO_PARAMS_MAP.fetch(sort))
+      params[:preload_pipelines] = false
+
+      ::Packages::GroupPackagesFinder.new(current_user, object, params).execute
     end
   end
 end
diff --git a/app/graphql/resolvers/incident_management/timeline_events_resolver.rb b/app/graphql/resolvers/incident_management/timeline_events_resolver.rb
new file mode 100644
index 00000000000..b9978259e6b
--- /dev/null
+++ b/app/graphql/resolvers/incident_management/timeline_events_resolver.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Resolvers
+  module IncidentManagement
+    class TimelineEventsResolver < BaseResolver
+      include LooksAhead
+
+      alias_method :project, :object
+
+      type ::Types::IncidentManagement::TimelineEventType.connection_type, null: true
+
+      argument :incident_id,
+               ::Types::GlobalIDType[::Issue],
+               required: true,
+               description: 'ID of the incident.'
+
+      when_single do
+        argument :id,
+                 ::Types::GlobalIDType[::IncidentManagement::TimelineEvent],
+                 required: true,
+                 description: 'ID of the timeline event.',
+                 prepare: ->(id, ctx) { id.model_id }
+      end
+
+      def resolve(**args)
+        incident = args[:incident_id].find
+
+        apply_lookahead(::IncidentManagement::TimelineEventsFinder.new(current_user, incident, args).execute)
+      end
+    end
+  end
+end
diff --git a/app/graphql/resolvers/package_details_resolver.rb b/app/graphql/resolvers/package_details_resolver.rb
index 42cb23e701d..705d3900cd2 100644
--- a/app/graphql/resolvers/package_details_resolver.rb
+++ b/app/graphql/resolvers/package_details_resolver.rb
@@ -17,9 +17,6 @@ module Resolvers
     end
 
     def resolve(id:)
-      # TODO: remove this line when the compatibility layer is removed
-      # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-      id = ::Types::GlobalIDType[::Packages::Package].coerce_isolated_input(id)
       GitlabSchema.find_by_gid(id)
     end
   end
diff --git a/app/graphql/resolvers/package_pipelines_resolver.rb b/app/graphql/resolvers/package_pipelines_resolver.rb
index 59a1cd173a4..9ff77f02547 100644
--- a/app/graphql/resolvers/package_pipelines_resolver.rb
+++ b/app/graphql/resolvers/package_pipelines_resolver.rb
@@ -12,21 +12,33 @@ module Resolvers
 
     alias_method :package, :object
 
-    def resolve(first: nil, last: nil, after: nil, before: nil, lookahead:)
-      finder = ::Packages::BuildInfosFinder.new(
-        package,
-        first: first,
-        last: last,
-        after: decode_cursor(after),
-        before: decode_cursor(before),
-        max_page_size: context.schema.default_max_page_size,
-        support_next_page: lookahead.selects?(:page_info)
-      )
+    # this resolver can be called for 100 packages max and we want to limit the
+    # number of build infos returned for _each_ package when using the new finder.
+    MAX_PAGE_SIZE = 20
 
-      build_infos = finder.execute
+    # This returns a promise for a connection of promises for pipelines:
+    # Lazy[Connection[Lazy[Pipeline]]] structure
+    def resolve(first: nil, last: nil, after: nil, before: nil, lookahead:)
+      default_value = default_value_for(first: first, last: last, after: after, before: before)
+      BatchLoader::GraphQL.for(package.id)
+                          .batch(default_value: default_value) do |package_ids, loader|
+        build_infos = ::Packages::BuildInfosFinder.new(
+          package_ids,
+          first: first,
+          last: last,
+          after: decode_cursor(after),
+          before: decode_cursor(before),
+          max_page_size: MAX_PAGE_SIZE,
+          support_next_page: lookahead.selects?(:page_info)
+        ).execute
 
-      # this .pluck_pipeline_ids can load max 101 pipelines ids
-      ::Ci::Pipeline.id_in(build_infos.pluck_pipeline_ids)
+        build_infos.each do |build_info|
+          loader.call(build_info.package_id) do |connection|
+            connection.items << lazy_load_pipeline(build_info.pipeline_id)
+            connection
+          end
+        end
+      end
     end
 
     # we manage the pagination manually, so opt out of the connection field extension
@@ -39,6 +51,22 @@ module Resolvers
 
     private
 
+    def lazy_load_pipeline(id)
+      ::Gitlab::Graphql::Loaders::BatchModelLoader.new(::Ci::Pipeline, id)
+        .find
+    end
+
+    def default_value_for(first:, last:, after:, before:)
+      Gitlab::Graphql::Pagination::ActiveRecordArrayConnection.new(
+        [],
+        first: first,
+        last: last,
+        after: after,
+        before: before,
+        max_page_size: MAX_PAGE_SIZE
+      )
+    end
+
     def decode_cursor(encoded)
       return unless encoded
 
diff --git a/app/graphql/resolvers/project_packages_resolver.rb b/app/graphql/resolvers/project_packages_resolver.rb
index 6d66c2fe460..284d3c594da 100644
--- a/app/graphql/resolvers/project_packages_resolver.rb
+++ b/app/graphql/resolvers/project_packages_resolver.rb
@@ -8,7 +8,10 @@ module Resolvers
     def resolve(sort:, **filters)
       return unless packages_available?
 
-      ::Packages::PackagesFinder.new(object, filters.merge(SORT_TO_PARAMS_MAP.fetch(sort))).execute
+      params = filters.merge(SORT_TO_PARAMS_MAP.fetch(sort))
+      params[:preload_pipelines] = false
+
+      ::Packages::PackagesFinder.new(object, params).execute
     end
   end
 end
diff --git a/app/graphql/resolvers/project_pipeline_resolver.rb b/app/graphql/resolvers/project_pipeline_resolver.rb
index ea733ab08ad..69327cd17b1 100644
--- a/app/graphql/resolvers/project_pipeline_resolver.rb
+++ b/app/graphql/resolvers/project_pipeline_resolver.rb
@@ -47,5 +47,10 @@ module Resolvers
         { statuses: [:needs] }
       ]
     end
+
+    def self.resolver_complexity(args, child_complexity:)
+      complexity = super
+      complexity - 10
+    end
   end
 end
diff --git a/app/graphql/resolvers/snippets_resolver.rb b/app/graphql/resolvers/snippets_resolver.rb
index 149bd8fa1ce..90f5f2cb534 100644
--- a/app/graphql/resolvers/snippets_resolver.rb
+++ b/app/graphql/resolvers/snippets_resolver.rb
@@ -38,11 +38,9 @@ module Resolvers
     private
 
     def snippet_finder_params(args)
-      # TODO: remove the type arguments when the compatibility layer is removed
-      # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
       super
-        .merge(author: resolve_ids(args[:author_id], ::Types::GlobalIDType[::User]),
-               project: resolve_ids(args[:project_id], ::Types::GlobalIDType[::Project]),
+        .merge(author: resolve_ids(args[:author_id]),
+               project: resolve_ids(args[:project_id]),
                explore: args[:explore])
     end
   end
diff --git a/app/graphql/resolvers/timelog_resolver.rb b/app/graphql/resolvers/timelog_resolver.rb
index 14831a29d90..52c4508003a 100644
--- a/app/graphql/resolvers/timelog_resolver.rb
+++ b/app/graphql/resolvers/timelog_resolver.rb
@@ -3,7 +3,6 @@
 module Resolvers
   class TimelogResolver < BaseResolver
     include LooksAhead
-    include ResolvesIds
 
     type ::Types::TimelogType.connection_type, null: false
 
@@ -100,14 +99,13 @@ module Resolvers
     def apply_project_filter(timelogs, args)
       return timelogs unless args[:project_id]
 
-      project = resolve_ids(args[:project_id], ::Types::GlobalIDType[::Project])
-      timelogs.in_project(project)
+      timelogs.in_project(args[:project_id].model_id)
     end
 
     def apply_group_filter(timelogs, args)
       return timelogs unless args[:group_id]
 
-      group = Group.find_by_id(resolve_ids(args[:group_id], ::Types::GlobalIDType[::Group]))
+      group = Group.find_by_id(args[:group_id].model_id)
       timelogs.in_group(group)
     end
 
diff --git a/app/graphql/resolvers/user_merge_requests_resolver_base.rb b/app/graphql/resolvers/user_merge_requests_resolver_base.rb
index e0201e45664..b2d85307c49 100644
--- a/app/graphql/resolvers/user_merge_requests_resolver_base.rb
+++ b/app/graphql/resolvers/user_merge_requests_resolver_base.rb
@@ -57,9 +57,6 @@ module Resolvers
     end
 
     def load_project(project_path, project_id)
-      # TODO: remove this line when the compatibility layer is removed
-      # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-      project_id &&= ::Types::GlobalIDType[::Project].coerce_isolated_input(project_id)
       @project = ::Gitlab::Graphql::Lazy.force(resolve_project(full_path: project_path, project_id: project_id))
     end
 
diff --git a/app/graphql/resolvers/work_item_resolver.rb b/app/graphql/resolvers/work_item_resolver.rb
index ad510849f31..9eb7d6bc693 100644
--- a/app/graphql/resolvers/work_item_resolver.rb
+++ b/app/graphql/resolvers/work_item_resolver.rb
@@ -20,9 +20,6 @@ module Resolvers
     private
 
     def find_object(id:)
-      # TODO: remove this line when the compatibility layer is removed
-      # See: https://gitlab.com/gitlab-org/gitlab/-/issues/257883
-      id = ::Types::GlobalIDType[::WorkItem].coerce_isolated_input(id)
       GitlabSchema.find_by_gid(id)
     end
   end