FileSystemDependencyGraphBuilder.java

package blue.contract.packager.graphbuilder;

import blue.contract.packager.model.DependencyGraph;
import blue.contract.packager.model.TypeDependency;
import blue.language.model.Node;

import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;

import static blue.contract.packager.BluePackageExporter.EXTENDS_FILE_NAME;
import static blue.language.utils.UncheckedObjectMapper.YAML_MAPPER;

public class FileSystemDependencyGraphBuilder implements DependencyGraphBuilder {
    private final Path rootPath;

    public FileSystemDependencyGraphBuilder(Path rootPath) {
        this.rootPath = rootPath;
    }

    @Override
    public DependencyGraph buildDependencyGraph(String rootDir) throws IOException {
        DependencyGraph graph = new DependencyGraph();
        Path fullPath = rootPath.resolve(rootDir);

        if (!Files.exists(fullPath)) {
            throw new IOException("Root directory not found: " + fullPath);
        }

        try (DirectoryStream<Path> typeStream = Files.newDirectoryStream(fullPath)) {
            for (Path typePath : typeStream) {
                if (Files.isDirectory(typePath)) {
                    String typeName = typePath.getFileName().toString();
                    processTypeDirectory(typePath, typeName, graph);
                }
            }
        }

        return graph;
    }

    private void processTypeDirectory(Path typePath, String typeName, DependencyGraph graph) throws IOException {
        try (DirectoryStream<Path> versionStream = Files.newDirectoryStream(typePath)) {
            for (Path versionPath : versionStream) {
                if (Files.isDirectory(versionPath)) {
                    String version = versionPath.getFileName().toString();
                    TypeDependency dependency = readDependency(versionPath.resolve(EXTENDS_FILE_NAME));
                    graph.addDirectory(typeName, version, dependency);
                    processFiles(versionPath, typeName, version, graph);
                }
            }
        }
    }

    private TypeDependency readDependency(Path path) throws IOException {
        if (!Files.exists(path)) {
            throw new IOException("Dependency file not found: " + path);
        }
        String content = Files.readString(path).trim();
        if (content.isEmpty() || content.lines().count() != 1) {
            throw new IOException("Invalid dependency file format. Expected one line in: " + path);
        }
        try {
            return TypeDependency.parse(content);
        } catch (IllegalArgumentException e) {
            throw new IOException("Invalid dependency format in file: " + path + ". " + e.getMessage());
        }
    }

    private void processFiles(Path versionPath, String typeName, String version, DependencyGraph graph) throws IOException {
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(versionPath, "*.blue")) {
            for (Path file : stream) {
                Node contract = YAML_MAPPER.readValue(Files.readString(file), Node.class);
                graph.addNode(typeName, version, contract);
            }
        }
    }
}