Find maven dependencies programatically

Hi,

One post mentioning the MavenFacade is this one: https://intellij-support.jetbrains.com/hc/en-us/community/posts/206781955-How-can-I-discover-the-maven-module-containing-a-file-

However, this post is from 2010 and I guess this class has been removed (?).

The problem with the nighly builds is the following:

Project B and Project C are build every night. This means, that Project A downloads the sources of Project B and Project C every day Project A is being built.
The sources are suffixed by the date, e.g. Project-C-20230810

When I programatically locate the dependencies of Project A, I receive the jar file of Project B.
In the same folder, where this jar file is located, are also the other nightly jar files of Project B, suffixed by different dates.

Since the .myType files of Project C are NOT included inside the jar of Project B, I need to find the exact jar-file name of the Project C jar, which is used in the jar file I received programatically.

I hope this does not sound too confusing. For a probably better understanding, here is a folder view of my local maven repo

Project-B
|- Project-B-20230810.jar (received programatically)
|- Project-B-20230810.pom (defines that e.g. Project-C-20230809.jar is used)
|- Project-B-20230811.jar
|- Project-B-20230811.pom

Project-C
|- Project-C-20230809.jar 
   |- project-c.myType    (I want to access this file)
|- Project-C-20230809.pom
|- Project-C-20230810.jar 
|- Project-C-20230810.pom
|- Project-C-20230811.jar
|- Project-C-20230811.pom

So in this case, I need to get the correct Project-C-xxx.jar.

Can I somehow create an org.jetbrains.idea.maven.project.MavenProject, or something similar from the Project-B-xxx.jar / Project-B-xxx.pom and access the dependencies this way?

Update: I think what expresses the problem better is the following:

When expanding the external libraries on the bottom left, there are multiple "same" libraries with different versions (these are jar files).
When opening a file of such an external library in the editor, how do I resolve the dependencies of the file's library?

Dobra101, would something along these lines be helpful to you?

This code communicates with a Maven server to determine the dependencies of a specified POM file. While it takes some shortcuts, it can serve as a starting point.

public List<String> getMavenProjectDependencyPaths(Project project, String pomFilePath) throws RemoteException {
  var pomFile = VirtualFileManager.getInstance().findFileByNioPath(Path.of(pomFilePath));
  var baseDir = MavenUtil.getVFileBaseDir(pomFile).getPath();
  var mavenServerManager = MavenServerManager.getInstance();
  var connector = mavenServerManager.getConnector(project, baseDir);
  var embedder = connector.createEmbedder(new MavenEmbedderSettings(new MavenServerSettings()));
  var taskId = UUID.randomUUID().toString();
  var request = new ProjectResolutionRequest(List.of(pomFile.toNioPath().toFile()), List.of(), List.of(), null, false);
  var resolutionResults = embedder.resolveProjects(taskId, request, MavenRemoteObjectWrapper.ourToken);
  var dependencyPaths = new ArrayList<String>();
  for (var resolutionResult : resolutionResults) {
    for (var dependency : resolutionResult.projectData.mavenModel.getDependencies()) {
      dependencyPaths.add(dependency.getPath());
    }
  }
  embedder.release(MavenRemoteObjectWrapper.ourToken);
  return dependencyPaths;
}

A higher-level code might look like this (but note that it adds the POM as a module to your project)

public List<String> addManagedFileAndGetDependencyPaths(Project project, String pomFilePath) {
  var pomFile = VirtualFileManager.getInstance().findFileByNioPath(Path.of(pomFilePath));
  var projectsManager = MavenProjectsManager.getInstance(project);
  projectsManager.addManagedFiles(List.of(pomFile));
  projectsManager.updateAllMavenProjectsSync(MavenImportSpec.EXPLICIT_IMPORT);
  var mavenProject = projectsManager.getProjectsTree().findProject(pomFile);
  var dependencyPaths = new ArrayList<String>();
  for (var dependency : mavenProject.getDependencies()) {
    dependencyPaths.add(dependency.getPath());
  }
  return dependencyPaths;
}

Thank you for the code snippets, I will give it a try.

However, my main problem is the following (maybe there is a much simpler solution I don't thought of yet):

Files of .myType are intermediate code files - the content is being rendered to a different language. That's why they are not included in the jar files.
However, references across these files are possible, such that inside a .myType file of Project A, parts of a .myType file of Project C can be referenced.
Where I now struggle is the reference resolve step. Resolving .myType references from Project A to Project B works as expected.
But when I open a .myType file in the editor, I can't resolve .myType references to Project C, as I probably have multiple versions of Project C in my external library, and I don't know which version is required for Project B.
That's why I somehow try to backward resolve the transitive dependencies of Maven.

As I said, there's probably a much simpler solution, but as of now I am clueless.

So the question is about resolving references in code in IDEA editor? 

Let's take the same example "Project A depends on Project B, Project B depends on Project C", but consider java language.

Project A pom.xml

<dependency>
    <groupId>org.example</groupId>
    <artifactId>ProjectB</artifactId>
    <version>20230810</version>
</dependency>

Project B pom.xml

<dependency>
    <groupId>org.example</groupId>
    <artifactId>ProjectC</artifactId>
    <version>20230810</version>
</dependency>

package org.example.a;

import org.example.b.ClassB;
import org.example.c.ClassC;

public class ClassA {
    public static void main(String[] args) {
        ClassB b;
        ClassC c;
    }
}

Hi, that cleared it a bit, thank you.

However, the problem is, that I have scenario 2.
I resolve a dependency inside ProjectA, and the file of ProjectB opens in the editor.
The reference resolve inside this ProjectB file was the part where I struggled.

For now I could solve it by searching the project library tables for the library which contains this file.
For this table entry I can receive the module it belongs to (I'm not on the PC at the moment, so I don't know what the method was called).
However, this module is called "coverage-aggregate". I don't know yet what that means, but now I can search the .myType files inside the module scope.

Thank you for your help!