Разработка API GraphQL в Java

@Controller
public class BookController {
 
    @Autowired
    private BookService bookService;
 
    @QueryMapping
    public Book bookById(@Argument String id) {
        return bookService.getBookById(id);
    }
 
    @SchemaMapping(typeName = "Book", field = "author")
    public Author getAuthor(Book book) {
        return bookService.getAuthorForBook(book);
    }
}

@DgsComponent
public class BookDataFetcher {
 
    @DgsQuery
    public Book bookById(@InputArgument String id) {
        // Логика получения книги по ID
    }
 
    @DgsData(parentType = "Book", field = "author")
    public Author authorForBook(DgsDataFetchingEnvironment env) {
        Book book = env.getSource();
        // Логика получения автора для книги
    }
}

public class BookDataLoader {
    private BatchLoader<String, Book> bookBatchLoader = ids -> {
        return CompletableFuture.supplyAsync(() -> {
            // Здесь выполняется ОДИН запрос к БД для получения всех книг по списку id
            List<Book> books = bookRepository.findAllByIdIn(ids);
            return books;
        });
    };
 
    public DataLoader<String, Book> newDataLoader() {
        return DataLoader.newDataLoader(bookBatchLoader);
    }
}

@GraphQLType
public class Book {
    @GraphQLField
    private String id;
    
    @GraphQLField
    private String title;
    
    // Геттеры и сеттеры
}

@Entity
public class Project {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String description;
    private LocalDate startDate;
    private LocalDate endDate;
    
    @OneToMany(mappedBy = "project", cascade = CascadeType.ALL)
    private List<Task> tasks = new ArrayList<>();
    
    // Геттеры и сеттеры
}
 
@Entity
public class Task {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String description;
    
    @Enumerated(EnumType.STRING)
    private TaskStatus status = TaskStatus.TODO;
    private LocalDate dueDate;
    
    @ManyToOne(fetch = FetchType.LAZY)
    private Project project;
    
    @ManyToOne(fetch = FetchType.LAZY)
    private User assignee;
    
    // Геттеры и сеттеры
}
 
@Entity
@Table(name = "users") // Избегаем конфликта с системной таблицей
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String email;
    
    @OneToMany(mappedBy = "assignee")
    private List<Task> assignedTasks = new ArrayList<>();
    
    // Геттеры и сеттеры
}
 
public enum TaskStatus {
    TODO, IN_PROGRESS, REVIEW, DONE
}

public interface ProjectRepository extends JpaRepository<Project, Long> {
}
 
public interface TaskRepository extends JpaRepository<Task, Long> {
    List<Task> findByProjectId(Long projectId);
}
 
public interface UserRepository extends JpaRepository<User, Long> {
}

@Controller
public class ProjectGraphQLController {
    
    @Autowired
    private ProjectRepository projectRepository;
    
    @Autowired
    private TaskRepository taskRepository;
    
    @Autowired
    private UserRepository userRepository;
    
    @QueryMapping
    public Project projectById(@Argument Long id) {
        return projectRepository.findById(id).orElse(null);
    }
    
    @QueryMapping
    public List<Project> allProjects() {
        return projectRepository.findAll();
    }
    
    @QueryMapping
    public List<Task> tasksForProject(@Argument Long projectId) {
        return taskRepository.findByProjectId(projectId);
    }
    
    @MutationMapping
    public Project createProject(@Argument ProjectInput input) {
        Project project = new Project();
        project.setName(input.getName());
        project.setDescription(input.getDescription());
        // Преобразование строковых дат в LocalDate и т.д.
        return projectRepository.save(project);
    }
    
    // Другие методы для мутаций
    
    @SchemaMapping(typeName = "Project", field = "tasks")
    public List<Task> getTasks(Project project) {
        return taskRepository.findByProjectId(project.getId());
    }
    
    @SchemaMapping(typeName = "Task", field = "project")
    public Project getProject(Task task) {
        return task.getProject();
    }
    
    @SchemaMapping(typeName = "Task", field = "assignee")
    public User getAssignee(Task task) {
        return task.getAssignee();
    }
}

@MutationMapping
public Task updateTaskStatus(@Argument Long id, @Argument TaskStatus status) {
    Task task = taskRepository.findById(id)
        .orElseThrow(() -> new RuntimeException("Задача не найдена"));
    task.setStatus(status);
    return taskRepository.save(task);
}

public class TaskUpdateInput {
    private String title;
    private String description;
    private TaskStatus status;
    private String dueDate;
    private Long assigneeId;
    
    // Геттеры и сеттеры
}
 
@MutationMapping
public Task updateTask(@Argument Long id, @Argument TaskUpdateInput input) {
    Task task = taskRepository.findById(id)
        .orElseThrow(() -> new RuntimeException("Задача не найдена"));
    
    // Применяем только те поля, которые были переданы в запросе
    if (input.getTitle() != null) {
        task.setTitle(input.getTitle());
    }
    
    if (input.getDescription() != null) {
        task.setDescription(input.getDescription());
    }
    
    if (input.getStatus() != null) {
        task.setStatus(input.getStatus());
    }
    
    if (input.getDueDate() != null) {
        task.setDueDate(LocalDate.parse(input.getDueDate()));
    }
    
    if (input.getAssigneeId() != null) {
        User assignee = userRepository.findById(input.getAssigneeId())
            .orElseThrow(() -> new RuntimeException("Пользователь не найден"));
        task.setAssignee(assignee);
    }
    
    return taskRepository.save(task);
}

@Component
public class GraphQLExceptionHandler implements DataFetcherExceptionHandler {
    @Override
    public GraphQLError onException(DataFetcherExceptionHandlerParameters parameters) {
        Throwable exception = parameters.getException();
        
        if (exception instanceof ResourceNotFoundException) {
            return GraphqlErrorBuilder.newError()
                .message(exception.getMessage())
                .errorType(ErrorType.NOT_FOUND)
                .path(parameters.getPath())
                .build();
        }
        
        // Другие типы исключений
        
        return GraphqlErrorBuilder.newError()
            .message("Внутренняя ошибка сервера")
            .errorType(ErrorType.INTERNAL_ERROR)
            .path(parameters.getPath())
            .build();
    }
}

@Component
public class UploadScalar extends GraphQLScalarType {
    public UploadScalar() {
        super("Upload", "Скаляр для загрузки файлов", new UploadCoercing());
    }
    
    private static class UploadCoercing implements Coercing<MultipartFile, MultipartFile> {
        // Реализация методов Coercing
    }
}

@MutationMapping
public Attachment uploadTaskAttachment(@Argument Long taskId, @Argument MultipartFile file) {
    Task task = taskRepository.findById(taskId)
        .orElseThrow(() -> new RuntimeException("Задача не найдена"));
    
    // Сохраняем файл
    String filename = file.getOriginalFilename();
    String filePath = "/uploads/" + UUID.randomUUID() + "_" + filename;
    
    try {
        Files.copy(file.getInputStream(), Paths.get(filePath));
    } catch (IOException e) {
        throw new RuntimeException("Ошибка при сохранении файла", e);
    }
    
    // Создаем вложение
    Attachment attachment = new Attachment();
    attachment.setFilename(filename);
    attachment.setMimeType(file.getContentType());
    attachment.setSize((int) file.getSize());
    attachment.setTaskId(taskId);
    
    return attachmentRepository.save(attachment);
}

private final DataLoader<Long, Project> projectDataLoader = 
    DataLoader.newDataLoader(projectIds -> {
        List<Project> projects = projectRepository.findAllById(projectIds);
        Map<Long, Project> projectMap = projects.stream()
            .collect(Collectors.toMap(Project::getId, Function.identity()));
        return CompletableFuture.supplyAsync(() -> 
            projectIds.stream()
                .map(id -> projectMap.get(id))
                .collect(Collectors.toList())
        );
    });
 
@SchemaMapping(typeName = "Task", field = "project")
public CompletableFuture<Project> project(Task task) {
    return projectDataLoader.load(task.getProjectId());
}

@Query("SELECT t FROM Task t LEFT JOIN FETCH t.project WHERE t.id IN :ids")
List<Task> findAllWithProjectByIdIn(@Param("ids") List<Long> ids);

@Entity
@Cacheable
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Project {
    // ...
}

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        cacheManager.setCaches(Arrays.asList(
            new ConcurrentMapCache("projects"),
            new ConcurrentMapCache("tasks")
        ));
        return cacheManager;
    }
}
 
@Service
public class ProjectService {
    @Cacheable("projects")
    public List<Project> findAll() {
        return projectRepository.findAll();
    }
}

@Repository
public interface TaskRepository extends JpaRepository<Task, Long> {
    @Query("SELECT t FROM Task t WHERE t.project.id IN :projectIds")
    List<Task> findByProjectIdIn(@Param("projectIds") List<Long> projectIds);
}

@QueryMapping
public TaskConnection tasks(@Argument Integer offset, @Argument Integer limit) {
    int actualOffset = offset != null ? offset : 0;
    int actualLimit = limit != null ? limit : 20;
    
    Page<Task> page = taskRepository.findAll(PageRequest.of(actualOffset / actualLimit, actualLimit));
    
    TaskConnection connection = new TaskConnection();
    connection.setItems(page.getContent());
    connection.setTotalCount((int)page.getTotalElements());
    
    return connection;
}

@QueryMapping
public TaskConnection tasks(@Argument Integer first, @Argument String after) {
    int limit = first != null ? first : 20;
    Long afterId = after != null ? decodeCursor(after) : null;
    
    List<Task> tasks;
    if (afterId == null) {
        tasks = taskRepository.findTop(limit);
    } else {
        tasks = taskRepository.findByIdGreaterThan(afterId, PageRequest.of(0, limit));
    }
    
    // Формирование ответа с курсорами и pageInfo
    // ...
}
 
private String encodeCursor(Long id) {
    return Base64.getEncoder().encodeToString(id.toString().getBytes());
}
 
private Long decodeCursor(String cursor) {
    String decoded = new String(Base64.getDecoder().decode(cursor));
    return Long.parseLong(decoded);
}

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/graphql").authenticated()
            .and()
            .addFilter(new JwtAuthenticationFilter(authenticationManager()));
    }
}