module GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader

# File lib/graphql/schema/member/has_arguments.rb, line 431
def authorize_application_object(argument, id, context, loaded_application_object)
  context.query.after_lazy(loaded_application_object) do |application_object|
    if application_object.nil?
      err = GraphQL::LoadApplicationObjectFailedError.new(context: context, argument: argument, id: id, object: application_object) #: GraphQL::RuntimeError
      application_object = load_application_object_failed(err)
    end
    # Double-check that the located object is actually of this type
    # (Don't want to allow arbitrary access to objects this way)
    if application_object.nil?
      nil
    else
      arg_loads_type = argument.loads
      maybe_lazy_resolve_type = context.schema.resolve_type(arg_loads_type, application_object, context)
      context.query.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
        if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
          application_object_type, application_object = resolve_type_result
        else
          application_object_type = resolve_type_result
          # application_object is already assigned
        end

        passes_possible_types_check = if context.types.loadable?(arg_loads_type, context)
          if arg_loads_type.kind.abstract?
            # This union/interface is used in `loads:` but not otherwise visible to this query
            context.types.loadable_possible_types(arg_loads_type, context).include?(application_object_type)
          else
            arg_loads_type == application_object_type
          end
        else
          context.types.possible_types(arg_loads_type).include?(application_object_type)
        end
        if !passes_possible_types_check
          err = GraphQL::LoadApplicationObjectFailedError.new(context: context, argument: argument, id: id, object: application_object)
          application_object = load_application_object_failed(err)
        end

        if application_object.nil?
          nil
        else
          # This object was loaded successfully
          # and resolved to the right type,
          # now apply the `.authorized?` class method if there is one
          context.query.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
            if authed
              application_object
            else
              err = GraphQL::UnauthorizedError.new(
                object: application_object,
                type: application_object_type,
                context: context,
              )
              if self.respond_to?(:unauthorized_object)
                err.set_backtrace(caller)
                loader = self #: untyped
                loader.unauthorized_object(err)
              else
                raise err
              end
            end
          end
        end
      end
    end
  end
end

# File lib/graphql/schema/member/has_arguments.rb, line 426
def load_and_authorize_application_object(argument, id, context)
  loaded_application_object = load_application_object(argument, id, context)
  authorize_application_object(argument, id, context, loaded_application_object)
end

# File lib/graphql/schema/member/has_arguments.rb, line 418
def load_application_object(argument, id, context)
  # See if any object can be found for this ID
  if id.nil?
    return nil
  end
  object_from_id(argument.loads, id, context)
end

# File lib/graphql/schema/member/has_arguments.rb, line 512
def load_application_object_failed(err)
  raise err
end

# File lib/graphql/schema/member/has_arguments.rb, line 414
def object_from_id(type, id, context)
  context.schema.object_from_id(id, context)
end