Learn Spring GraphQL

Bootstrap a Spring Boot project in IntelliJ and bootstrap from start.spring.io, selecting web, GraphQL, Spring Data JPA, Docker Compose, Postgres, and Lombok, then configure Java and Maven settings per project.

Bootstrap a Spring project with Start.spring.io by choosing Java, a com.z package, and dependencies like GraphQL, web, Postgres, Lombok, and JPA, then download, extract, and set up the IDE.

Explain how Spring GraphQL dependencies such as Spring Data JPA, Hibernate, transactions, Spring Web, and WebFlux integrate with Postgres, Docker Compose, and Lombok to enable reactive GraphQL testing.

Explore the Dgs code generation plugin for spring graphql, which converts a .graphql script into Java code in the target folder and integrates with maven projects.

Coordinate the dgs plugin configuration and properties, set the package and codegen, adjust the graphql schema path, and enable jpa with sql display.

Explore GraphQL basic types, including id (string), string, int, float (double), and boolean, and observe how codegen outputs generated sources in the target folder within a Spring Maven workflow.

Learn to use GraphQL Java extended scalars for money, big decimal, long, currency, and date-time types, and wire them into Spring GraphQL via runtime wiring.

Explore how GraphQL handles reads through the query type, using input types, basic and extended scalars, and endpoints to fetch samples.

Explore query type in GraphQL, learn to pass multiple inputs with input types, and interpret square brackets as lists while returning mandatory sample objects for endpoints.

Master GraphQL subscriptions as a pub-sub model, where a publisher streams data and subscribers receive real-time updates via WebSocket, with arguments using inputs or scalar types.

Define the address detail as a GraphQL type, map departments, employees, and outsourced agents via an entity id foreign key, and prepare input types for each entity.

Explore creating GraphQL entity inputs for a Spring app, defining company, department, employee, outsourced inputs, and address inputs, while respecting input vs type rules and default fields.

Design a JPA company entity with uuid id, Lombok accessors, and table mappings for name, rc number, head office, country, business type, plus created and updated timestamps and unique indices.

Explore why we avoid heavy JPA entity relationships in Spring GraphQL by using explicit IDs and lazy loading; fetch addresses only when needed to reduce overhead and improve performance.

Learn to manage GitHub issues by closing an issue with a commit message that includes the issue id using close or closest, push to a staging branch, and review changes.

Develop JPA repositories and extend JPA specification executor to enable filtering with UUID entities. Implement find by name and find by company name across department, employee, outsourced, and address repositories.

Implement only the repository subset you need, using CrudRepository or JPA repository, and leverage paging and sorting with Pageable, find by, get by, and example by to keep builds lean.

Create a GraphQL endpoint and define queries and mutations for fetching and modifying company, departments, and employees, using a shared person interface and a base response with success and message.

Extend your learnings with an employee search by staff ID in the initial GraphQL query, returning a person and handling not-found exceptions.

Explore the setup of the initial GraphQL mutation, defining types like create company and create employee, using inputs and a creation response to return IDs and manage composition.

Implement one mutation controller in a spring graphQL project, ensure a single query and a single mutation entry point by renaming files, and validate compilation.

Implement a Spring GraphQL mutation by organizing endpoints in API package and creating a company controller. Map HTTP verbs (get, post, put, delete) to GraphQL query, mutation, and subscription mappings.

Learn how http verbs translate to GraphQL operations, using query mapping, mutation, and subscription mapping with aliases and schema mapping for consistent definitions.

Map a GraphQL mutation for creating a company in Spring GraphQL, using schema mapping or mutation mapping, with arguments and company inputs, and verify mappings via the GraphQL plugin.

Learn to implement a department controller in spring graphql, compare schema mapping with mutation mapping, align signatures with arguments and fields, and use constants for mutation like create department.

Map GraphQL mutations to a Spring employee controller using generated type name constants, ensure signatures match, use input arguments, and wire creation and update operations for robust mutation handling.

Create a mapper util that converts company inputs to an entity and a company dto, maps departments to department dtos (uuid, head office), and discusses when to use libraries.

Map address and employee data between DTOs and entities using a no-library approach, handling uuid, streets, city, state, zip code, and refactoring for reuse.