master 1b69c873421b cached
206 files
394.0 KB
94.8k tokens
879 symbols
1 requests
Download .txt
Showing preview only (460K chars total). Download the full file or copy to clipboard to get everything.
Repository: graphql-java-kickstart/graphql-java-servlet
Branch: master
Commit: 1b69c873421b
Files: 206
Total size: 394.0 KB

Directory structure:
gitextract_cv18k8ke/

├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   ├── config.yml
│   │   └── feature_request.md
│   ├── add-javax-suffix.sh
│   ├── release.sh
│   ├── replaceJakartaWithJavax.sh
│   ├── tag-release.sh
│   └── workflows/
│       ├── pull-request.yml
│       ├── release.yml
│       └── snapshot.yml
├── .gitignore
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── build.gradle
├── examples/
│   └── osgi/
│       ├── apache-karaf-feature/
│       │   ├── pom.xml
│       │   └── src/
│       │       └── main/
│       │           └── feature/
│       │               └── feature.xml
│       ├── apache-karaf-package/
│       │   └── pom.xml
│       ├── buildAndRun.sh
│       ├── pom.xml
│       └── providers/
│           ├── pom.xml
│           └── src/
│               └── main/
│                   └── java/
│                       └── graphql/
│                           └── servlet/
│                               └── examples/
│                                   └── osgi/
│                                       └── ExampleGraphQLProvider.java
├── gradle/
│   └── wrapper/
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradle.properties
├── gradlew
├── gradlew.bat
├── graphql-java-kickstart/
│   ├── bnd.bnd
│   ├── build.gradle
│   └── src/
│       └── main/
│           └── java/
│               └── graphql/
│                   └── kickstart/
│                       └── execution/
│                           ├── BatchedDataLoaderGraphQLBuilder.java
│                           ├── DecoratedExecutionResult.java
│                           ├── DefaultGraphQLRootObjectBuilder.java
│                           ├── ExtensionsDeserializer.java
│                           ├── FutureBatchedExecutionResult.java
│                           ├── FutureErrorExecutionResult.java
│                           ├── FutureExecutionResult.java
│                           ├── FutureSingleExecutionResult.java
│                           ├── GraphQLBatchedQueryResult.java
│                           ├── GraphQLErrorQueryResult.java
│                           ├── GraphQLInvoker.java
│                           ├── GraphQLInvokerProxy.java
│                           ├── GraphQLObjectMapper.java
│                           ├── GraphQLQueryInvoker.java
│                           ├── GraphQLQueryResult.java
│                           ├── GraphQLRequest.java
│                           ├── GraphQLRootObjectBuilder.java
│                           ├── GraphQLSingleQueryResult.java
│                           ├── ObjectMapDeserializationException.java
│                           ├── ObjectMapDeserializeHelper.java
│                           ├── OperationNameExtractor.java
│                           ├── StaticGraphQLRootObjectBuilder.java
│                           ├── StringUtils.java
│                           ├── VariablesDeserializer.java
│                           ├── config/
│                           │   ├── ConfiguringObjectMapperProvider.java
│                           │   ├── DefaultExecutionStrategyProvider.java
│                           │   ├── DefaultGraphQLSchemaProvider.java
│                           │   ├── ExecutionStrategyProvider.java
│                           │   ├── GraphQLBuilder.java
│                           │   ├── GraphQLBuilderConfigurer.java
│                           │   ├── GraphQLSchemaProvider.java
│                           │   ├── GraphQLServletObjectMapperConfigurer.java
│                           │   ├── InstrumentationProvider.java
│                           │   └── ObjectMapperProvider.java
│                           ├── context/
│                           │   ├── ContextSetting.java
│                           │   ├── ContextSettingNotConfiguredException.java
│                           │   ├── DefaultGraphQLContext.java
│                           │   ├── DefaultGraphQLContextBuilder.java
│                           │   ├── GraphQLContextBuilder.java
│                           │   └── GraphQLKickstartContext.java
│                           ├── error/
│                           │   ├── DefaultGraphQLErrorHandler.java
│                           │   ├── DefaultGraphQLServletObjectMapperConfigurer.java
│                           │   ├── GenericGraphQLError.java
│                           │   ├── GraphQLErrorHandler.java
│                           │   └── RenderableNonNullableFieldWasNullError.java
│                           ├── input/
│                           │   ├── GraphQLBatchedInvocationInput.java
│                           │   ├── GraphQLInvocationInput.java
│                           │   ├── GraphQLSingleInvocationInput.java
│                           │   ├── PerQueryBatchedInvocationInput.java
│                           │   └── PerRequestBatchedInvocationInput.java
│                           ├── instrumentation/
│                           │   ├── AbstractTrackingApproach.java
│                           │   ├── DataLoaderDispatcherInstrumentationState.java
│                           │   ├── FieldLevelTrackingApproach.java
│                           │   ├── NoOpInstrumentationProvider.java
│                           │   ├── RequestLevelTrackingApproach.java
│                           │   ├── RequestStack.java
│                           │   ├── TrackingApproach.java
│                           │   └── TrackingApproachException.java
│                           └── subscriptions/
│                               ├── AtomicSubscriptionSubscription.java
│                               ├── DefaultSubscriptionSession.java
│                               ├── GraphQLSubscriptionInvocationInputFactory.java
│                               ├── GraphQLSubscriptionMapper.java
│                               ├── SessionSubscriber.java
│                               ├── SessionSubscriptions.java
│                               ├── SubscriptionConnectionListener.java
│                               ├── SubscriptionException.java
│                               ├── SubscriptionProtocolFactory.java
│                               ├── SubscriptionSession.java
│                               └── apollo/
│                                   ├── ApolloCommandProvider.java
│                                   ├── ApolloSubscriptionConnectionListener.java
│                                   ├── ApolloSubscriptionConsumer.java
│                                   ├── ApolloSubscriptionKeepAliveRunner.java
│                                   ├── ApolloSubscriptionProtocolFactory.java
│                                   ├── ApolloSubscriptionSession.java
│                                   ├── KeepAliveSubscriptionConnectionListener.java
│                                   ├── OperationMessage.java
│                                   ├── SubscriptionCommand.java
│                                   ├── SubscriptionConnectionInitCommand.java
│                                   ├── SubscriptionConnectionTerminateCommand.java
│                                   ├── SubscriptionStartCommand.java
│                                   └── SubscriptionStopCommand.java
├── graphql-java-servlet/
│   ├── bnd.bnd
│   ├── build.gradle
│   └── src/
│       ├── main/
│       │   └── java/
│       │       └── graphql/
│       │           └── kickstart/
│       │               └── servlet/
│       │                   ├── AbstractGraphQLHttpServlet.java
│       │                   ├── AbstractGraphQLInvocationInputParser.java
│       │                   ├── AsyncTaskDecorator.java
│       │                   ├── AsyncTaskExecutor.java
│       │                   ├── AsyncTimeoutListener.java
│       │                   ├── BatchedQueryResponseWriter.java
│       │                   ├── ConfiguredGraphQLHttpServlet.java
│       │                   ├── ErrorQueryResponseWriter.java
│       │                   ├── ExecutionResultSubscriber.java
│       │                   ├── GraphQLConfiguration.java
│       │                   ├── GraphQLGetInvocationInputParser.java
│       │                   ├── GraphQLHttpServlet.java
│       │                   ├── GraphQLInvocationInputParser.java
│       │                   ├── GraphQLMultipartInvocationInputParser.java
│       │                   ├── GraphQLPostInvocationInputParser.java
│       │                   ├── GraphQLWebsocketServlet.java
│       │                   ├── HttpRequestHandler.java
│       │                   ├── HttpRequestHandlerImpl.java
│       │                   ├── HttpRequestInvoker.java
│       │                   ├── HttpRequestInvokerImpl.java
│       │                   ├── InvocationInputParseException.java
│       │                   ├── ListenerHandler.java
│       │                   ├── OsgiGraphQLHttpServlet.java
│       │                   ├── OsgiGraphQLHttpServletConfiguration.java
│       │                   ├── OsgiSchemaBuilder.java
│       │                   ├── PartIOException.java
│       │                   ├── QueryResponseWriter.java
│       │                   ├── QueryResponseWriterFactory.java
│       │                   ├── QueryResponseWriterFactoryImpl.java
│       │                   ├── SingleAsynchronousQueryResponseWriter.java
│       │                   ├── SingleQueryResponseWriter.java
│       │                   ├── StaticDataPublisher.java
│       │                   ├── SubscriptionAsyncListener.java
│       │                   ├── apollo/
│       │                   │   ├── ApolloScalars.java
│       │                   │   ├── ApolloWebSocketSubscriptionProtocolFactory.java
│       │                   │   └── ApolloWebSocketSubscriptionSession.java
│       │                   ├── cache/
│       │                   │   ├── BufferedHttpServletResponse.java
│       │                   │   ├── CacheReader.java
│       │                   │   ├── CachedResponse.java
│       │                   │   ├── CachingHttpRequestInvoker.java
│       │                   │   ├── CachingQueryResponseWriter.java
│       │                   │   ├── CachingQueryResponseWriterFactory.java
│       │                   │   └── GraphQLResponseCacheManager.java
│       │                   ├── config/
│       │                   │   ├── DefaultGraphQLSchemaServletProvider.java
│       │                   │   └── GraphQLSchemaServletProvider.java
│       │                   ├── context/
│       │                   │   ├── DefaultGraphQLServletContext.java
│       │                   │   ├── DefaultGraphQLServletContextBuilder.java
│       │                   │   ├── DefaultGraphQLWebSocketContext.java
│       │                   │   ├── GraphQLServletContext.java
│       │                   │   ├── GraphQLServletContextBuilder.java
│       │                   │   └── GraphQLWebSocketContext.java
│       │                   ├── core/
│       │                   │   ├── DefaultGraphQLRootObjectBuilder.java
│       │                   │   ├── GraphQLMBean.java
│       │                   │   ├── GraphQLServletListener.java
│       │                   │   ├── GraphQLServletRootObjectBuilder.java
│       │                   │   └── internal/
│       │                   │       ├── GraphQLThreadFactory.java
│       │                   │       ├── VariableMapException.java
│       │                   │       └── VariableMapper.java
│       │                   ├── input/
│       │                   │   ├── BatchInputPreProcessResult.java
│       │                   │   ├── BatchInputPreProcessor.java
│       │                   │   ├── GraphQLInvocationInputFactory.java
│       │                   │   └── NoOpBatchInputPreProcessor.java
│       │                   ├── osgi/
│       │                   │   ├── GraphQLCodeRegistryProvider.java
│       │                   │   ├── GraphQLDirectiveProvider.java
│       │                   │   ├── GraphQLFieldProvider.java
│       │                   │   ├── GraphQLMutationProvider.java
│       │                   │   ├── GraphQLProvider.java
│       │                   │   ├── GraphQLQueryProvider.java
│       │                   │   ├── GraphQLSubscriptionProvider.java
│       │                   │   └── GraphQLTypesProvider.java
│       │                   └── subscriptions/
│       │                       ├── FallbackSubscriptionConsumer.java
│       │                       ├── FallbackSubscriptionProtocolFactory.java
│       │                       ├── WebSocketSendSubscriber.java
│       │                       ├── WebSocketSubscriptionProtocolFactory.java
│       │                       └── WebSocketSubscriptionSession.java
│       └── test/
│           └── groovy/
│               └── graphql/
│                   └── kickstart/
│                       └── servlet/
│                           ├── AbstractGraphQLHttpServletSpec.groovy
│                           ├── BatchedQueryResponseWriterTest.groovy
│                           ├── DataLoaderDispatchingSpec.groovy
│                           ├── GraphQLServletListenerSpec.groovy
│                           ├── OsgiGraphQLHttpServletSpec.groovy
│                           ├── PartIOExceptionTest.groovy
│                           ├── RequestTester.groovy
│                           ├── SingleAsynchronousQueryResponseWriterTest.groovy
│                           ├── SingleQueryResponseWriterTest.groovy
│                           ├── TestBatchInputPreProcessor.java
│                           ├── TestException.groovy
│                           ├── TestGraphQLErrorException.groovy
│                           ├── TestMultipartPart.groovy
│                           ├── TestUtils.groovy
│                           └── cache/
│                               ├── CacheReaderTest.groovy
│                               └── CachingHttpRequestInvokerTest.groovy
├── lombok.config
├── renovate.json
└── settings.gradle

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: bug
assignees: ''

---

**Describe the bug**
A clear and concise description of what the bug is.

**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

**Expected behavior**
A clear and concise description of what you expected to happen.

**Screenshots**
If applicable, add screenshots to help explain your problem.

**Desktop (please complete the following information):**
 - OS: [e.g. iOS]
 - Browser [e.g. chrome, safari]
 - Version [e.g. 22]

**Additional context**
Add any other context about the problem here.


================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
blank_issues_enabled: false
contact_links:
  - name: Question
    url: https://github.com/graphql-java-kickstart/graphql-java-servlet/discussions
    about: Anything you are not sure about? Ask the community in Discussions!


================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: enhancement
assignees: ''

---

**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

**Describe the solution you'd like**
A clear and concise description of what you want to happen.

**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.

**Additional context**
Add any other context or screenshots about the feature request here.


================================================
FILE: .github/add-javax-suffix.sh
================================================
#!/bin/bash

addSuffix() {
  local result
  result=$(grep include settings.gradle | awk '{print $2}' | tr -d "'" | tr -d ':')
  readarray -t <<<"$result"
  modules=("${MAPFILE[@]}")

  updateLocalDependencies
}

updateLocalDependencies() {
  for module in "${modules[@]}"; do
    cp -rf "$module" "$module"-javax
    rm -rf "$module"

    for dependency in "${modules[@]}"; do
      sed -i -E "s/project\(('|\"):${dependency}('|\")\)/project\(':${dependency}-javax'\)/" "$module"-"javax"/build.gradle
    done
  done

  updateGradleSettings
}

updateGradleSettings() {
  for module in "${modules[@]}"; do
    echo "Replace ${module} with ${module}-javax in settings.gradle"
    sed -i -E "s/('|\"):${module}('|\")/':${module}-javax'/" settings.gradle
  done

  cat settings.gradle
}

echo "Add suffix -javax to modules"
addSuffix

ls -lh

================================================
FILE: .github/release.sh
================================================
#!/bin/bash
set -ev

FLAVOUR="${1}"

removeSnapshots() {
  sed -i 's/-SNAPSHOT//' gradle.properties
}

echo "Publishing release to Maven Central"
removeSnapshots

if [ "${FLAVOUR}" == 'javax' ]; then
  .github/add-javax-suffix.sh
fi

./gradlew clean build publishToSonatype closeAndReleaseSonatypeStagingRepository


================================================
FILE: .github/replaceJakartaWithJavax.sh
================================================
#!/bin/bash

# Set jdk11 as source and target
sed -i 's/SOURCE_COMPATIBILITY=.*/SOURCE_COMPATIBILITY=11/' gradle.properties
sed -i 's/TARGET_COMPATIBILITY=.*/TARGET_COMPATIBILITY=11/' gradle.properties

# Replace jakarta imports and dependencies with javax
grep -rl 'import jakarta' ./graphql-java-servlet | xargs sed -i 's/import jakarta/import javax/g'
sed -i 's/.*jakarta.websocket:jakarta.websocket-client-api.*//' graphql-java-servlet/build.gradle
sed -i \
  's/jakarta.servlet:jakarta.servlet-api.*/javax.servlet:javax.servlet-api:$LIB_JAVAX_SERVLET"/' \
  graphql-java-servlet/build.gradle
sed -i \
  's/jakarta.websocket.*/javax.websocket:javax.websocket-api:$LIB_JAVAX_WEBSOCKET"/' \
  graphql-java-servlet/build.gradle

# Final check if there are something else to replace
grep -rl 'jakarta' ./graphql-java-servlet | xargs sed -i 's/jakarta/javax/g'

# Set the version 5 for spring framework
sed -i \
  's/org.springframework:spring-test.*/org.springframework:spring-test:$LIB_SPRINGFRAMEWORK_5"/' \
  graphql-java-servlet/build.gradle
sed -i \
  's/org.springframework:spring-web.*/org.springframework:spring-web:$LIB_SPRINGFRAMEWORK_5"/' \
  graphql-java-servlet/build.gradle

echo "Replaced jakarta occurrences with javax"

================================================
FILE: .github/tag-release.sh
================================================
#!/bin/bash
set -ev

getVersion() {
  ./gradlew properties -q | grep -E "^version" | awk '{print $2}' | tr -d '[:space:]'
}

removeSnapshots() {
  sed -i 's/-SNAPSHOT//' gradle.properties
}

commitRelease() {
  local APP_VERSION
  APP_VERSION=$(getVersion)
  git commit -a -m "Update version for release"
  git tag -a "v${APP_VERSION}" -m "Tag release version"
}

bumpVersion() {
  echo "Bump version number"
  local APP_VERSION
  APP_VERSION=$(getVersion | xargs)
  local SEMANTIC_REGEX='^([0-9]+)\.([0-9]+)(\.([0-9]+))?$'
  if [[ ${APP_VERSION} =~ ${SEMANTIC_REGEX} ]]; then
    if [[ ${BASH_REMATCH[4]} ]]; then
      nextVersion=$((BASH_REMATCH[4] + 1))
      nextVersion="${BASH_REMATCH[1]}.${BASH_REMATCH[2]}.${nextVersion}-SNAPSHOT"
    else
      nextVersion=$((BASH_REMATCH[2] + 1))
      nextVersion="${BASH_REMATCH[1]}.${nextVersion}-SNAPSHOT"
    fi

    echo "Next version: ${nextVersion}"
    sed -i -E "s/^version(\s)?=.*/version=${nextVersion}/" gradle.properties
    git commit -a -m "Bumped version for next release"
  else
    echo "No semantic version and therefore cannot publish to maven repository: '${APP_VERSION}'"
  fi
}

git config --global user.email "actions@github.com"
git config --global user.name "GitHub Actions"

echo "Deploying release to Maven Central"
removeSnapshots
commitRelease
bumpVersion
git push --follow-tags

================================================
FILE: .github/workflows/pull-request.yml
================================================
name: "Pull request"
on:
  pull_request:
    types: [ opened, synchronize, reopened ]

jobs:
  validation:
    name: Gradle Wrapper Validation
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: gradle/wrapper-validation-action@v3

  test:
    name: Test run
    strategy:
      fail-fast: false
      matrix:
        os: [ ubuntu-latest, macos-latest, windows-latest ]
        java: [ 17, 19 ]
    needs: validation
    runs-on: ${{ matrix.os }}
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: ${{ matrix.java }}
      - name: Cache Gradle
        uses: actions/cache@v4
        env:
          java-version: ${{ matrix.java }}
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-${{ env.java-version }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: ${{ runner.os }}-${{ env.java-version }}-gradle-
      - name: Make gradlew executable (non-Windows only)
        if: matrix.os != 'windows-latest'
        run: chmod +x ./gradlew
      - name: Gradle Check (non-Windows)
        if: matrix.os != 'windows-latest'
        run: ./gradlew --info check
      - name: Gradle Check (Windows)
        if: matrix.os == 'windows-latest'
        shell: cmd
        run: gradlew --info check

  build:
    name: Sonar analysis
    needs: validation
    runs-on: ubuntu-latest
    env:
      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
    steps:
      - uses: actions/checkout@v4
        if: env.SONAR_TOKEN != null
        with:
          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
      - name: Set up JDK 17
        if: env.SONAR_TOKEN != null
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: 17
      - name: Cache SonarCloud packages
        if: env.SONAR_TOKEN != null
        uses: actions/cache@v4
        with:
          path: ~/.sonar/cache
          key: ${{ runner.os }}-sonar
          restore-keys: ${{ runner.os }}-sonar
      - name: Cache Gradle packages
        if: env.SONAR_TOKEN != null
        uses: actions/cache@v4
        with:
          path: ~/.gradle/caches
          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
          restore-keys: ${{ runner.os }}-gradle
      - name: Build and analyze
        if: env.SONAR_TOKEN != null
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
        run: ./gradlew build jacocoTestReport sonarqube --info


================================================
FILE: .github/workflows/release.yml
================================================
name: "Publish release"
on: [ workflow_dispatch ]

jobs:
  validation:
    name: Gradle Wrapper Validation
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: gradle/wrapper-validation-action@v3

  test-jakarta:
    name: Test run jakarta
    needs: validation
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: 17
      - name: Cache Gradle
        uses: actions/cache@v4
        env:
          java-version: 17
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-${{ env.java-version }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: |
            ${{ runner.os }}-${{ env.java-version }}-gradle-
      - name: Make gradlew executable
        run: chmod +x ./gradlew
      - name: Gradle Check
        run: ./gradlew --info check

  build-jakarta:
    name: Publish release jakarta
    needs: test-jakarta
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: 17
      - name: Cache Gradle
        uses: actions/cache@v4
        env:
          java-version: 17
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-${{ env.java-version }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: |
            ${{ runner.os }}-${{ env.java-version }}-gradle-
      - name: Prepare environment
        env:
          GPG_KEY_CONTENTS: ${{ secrets.GPG_KEY_CONTENTS }}
          SIGNING_SECRET_KEY_RING_FILE: ${{ secrets.GPG_SIGNING_SECRET_KEY_RING_FILE }}
        run: sudo bash -c "echo '$GPG_KEY_CONTENTS' | base64 -d > '$SIGNING_SECRET_KEY_RING_FILE'"
      - name: Publish release
        env:
          SIGNING_KEY_ID: ${{ secrets.GPG_SIGNING_KEY_ID }}
          SIGNING_PASSWORD: ${{ secrets.GPG_SIGNING_PASSWORD }}
          SIGNING_SECRET_KEY_RING_FILE: ${{ secrets.GPG_SIGNING_SECRET_KEY_RING_FILE }}
          OSS_USER_TOKEN_KEY: ${{ secrets.OSS_USER_TOKEN_KEY }}
          OSS_USER_TOKEN_PASS: ${{ secrets.OSS_USER_TOKEN_PASS }}
        run: .github/release.sh

  test-javax:
    name: Test run javax
    needs: validation
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: 11
      - name: Cache Gradle
        uses: actions/cache@v4
        env:
          java-version: 11
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-${{ env.java-version }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: |
            ${{ runner.os }}-${{ env.java-version }}-gradle-
      - name: Make gradlew executable
        run: chmod +x ./gradlew
      - name: Replace jakarta with javax
        run: .github/replaceJakartaWithJavax.sh
      - name: Gradle Check
        run: ./gradlew --info check

  build-javax:
    name: Publish release javax
    needs: test-javax
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: 11

      - name: Cache Gradle
        uses: actions/cache@v4
        env:
          java-version: 11
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-${{ env.java-version }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: |
            ${{ runner.os }}-${{ env.java-version }}-gradle-
      - name: Prepare environment
        env:
          GPG_KEY_CONTENTS: ${{ secrets.GPG_KEY_CONTENTS }}
          SIGNING_SECRET_KEY_RING_FILE: ${{ secrets.GPG_SIGNING_SECRET_KEY_RING_FILE }}
        run: sudo bash -c "echo '$GPG_KEY_CONTENTS' | base64 -d > '$SIGNING_SECRET_KEY_RING_FILE'"
      - name: Replace jakarta with javax
        run: .github/replaceJakartaWithJavax.sh
      - name: Publish release
        env:
          SIGNING_KEY_ID: ${{ secrets.GPG_SIGNING_KEY_ID }}
          SIGNING_PASSWORD: ${{ secrets.GPG_SIGNING_PASSWORD }}
          SIGNING_SECRET_KEY_RING_FILE: ${{ secrets.GPG_SIGNING_SECRET_KEY_RING_FILE }}
          OSS_USER_TOKEN_KEY: ${{ secrets.OSS_USER_TOKEN_KEY }}
          OSS_USER_TOKEN_PASS: ${{ secrets.OSS_USER_TOKEN_PASS }}
        run: .github/release.sh javax
  tag:
    name: Tag release
    needs: [ build-jakarta, build-javax ]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: 17
      - name: Cache Gradle
        uses: actions/cache@v4
        env:
          java-version: 17
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-${{ env.java-version }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: |
            ${{ runner.os }}-${{ env.java-version }}-gradle-
      - name: Tag release
        run: .github/tag-release.sh


================================================
FILE: .github/workflows/snapshot.yml
================================================
name: "Publish snapshot"
on:
  push:
    branches:
      - master

jobs:
  validation:
    name: Gradle Wrapper Validation
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: gradle/wrapper-validation-action@v3

  test-jakarta:
    name: Test run jakarta
    needs: validation
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: 17
      - name: Cache Gradle
        uses: actions/cache@v4
        env:
          java-version: 17
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-${{ env.java-version }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: |
            ${{ runner.os }}-${{ env.java-version }}-gradle-
      - name: Make gradlew executable
        run: chmod +x ./gradlew
      - name: Gradle Check
        run: ./gradlew --info check

  build-jakarta:
    name: Publish snapshot jakarta
    needs: test-jakarta
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: 17
      - name: Cache Gradle
        uses: actions/cache@v4
        env:
          java-version: 17
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-${{ env.java-version }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: |
            ${{ runner.os }}-${{ env.java-version }}-gradle-
      - name: Make gradlew executable
        run: chmod +x ./gradlew
      - name: Gradle Publish Snapshot
        if: env.OSS_USER_TOKEN_KEY != null
        env:
          OSS_USER_TOKEN_KEY: ${{ secrets.OSS_USER_TOKEN_KEY }}
          OSS_USER_TOKEN_PASS: ${{ secrets.OSS_USER_TOKEN_PASS }}
        run: ./gradlew clean build publish -x test

  test-javax:
    name: Test run javax
    needs: validation
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: 11
      - name: Cache Gradle
        uses: actions/cache@v4
        env:
          java-version: 11
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-${{ env.java-version }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: |
            ${{ runner.os }}-${{ env.java-version }}-gradle-
      - name: Make gradlew executable
        run: chmod +x ./gradlew
      - name: Replace jakarta with javax
        run: .github/replaceJakartaWithJavax.sh
      - name: Gradle Check
        run: ./gradlew --info check

  build-javax:
    name: Publish snapshot javax
    needs: test-javax
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: 11
      - name: Cache Gradle
        uses: actions/cache@v4
        env:
          java-version: 11
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-${{ env.java-version }}-gradle-${{ hashFiles('**/*.gradle*') }}
          restore-keys: |
            ${{ runner.os }}-${{ env.java-version }}-gradle-
      - name: Make gradlew executable
        run: chmod +x ./gradlew
      - name: Replace jakarta with javax
        run: .github/replaceJakartaWithJavax.sh
      - name: Add suffix to modules
        run: .github/add-javax-suffix.sh
      - name: Gradle Publish Snapshot
        if: env.OSS_USER_TOKEN_KEY != null
        env:
          OSS_USER_TOKEN_KEY: ${{ secrets.OSS_USER_TOKEN_KEY }}
          OSS_USER_TOKEN_PASS: ${{ secrets.OSS_USER_TOKEN_PASS }}
        run: ./gradlew clean build publish -x test

  sonar:
    name: Sonar analysis
    needs: validation
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'
          java-version: 17
      - name: Cache SonarCloud packages
        uses: actions/cache@v4
        with:
          path: ~/.sonar/cache
          key: ${{ runner.os }}-sonar
          restore-keys: ${{ runner.os }}-sonar
      - name: Cache Gradle packages
        uses: actions/cache@v4
        with:
          path: ~/.gradle/caches
          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle') }}
          restore-keys: ${{ runner.os }}-gradle
      - name: Build and analyze
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
        if: env.SONAR_TOKEN != null
        run: ./gradlew build jacocoTestReport sonarqube --info


================================================
FILE: .gitignore
================================================
.gradle/
build/
*.iml
*.ipr
*.iws
.idea/*
!.idea/codeStyles/
target/
/out/
.classpath
.project
.settings
bin
.DS_Store
/**/out/
/projectFilesBackup/.idea/workspace.xml


================================================
FILE: CONTRIBUTING.md
================================================
# How to contribute

We're really glad you're reading this, because we need more volunteer developers
to help with this project!

We can use all the help we can get on all our [GraphQL Java Kickstart](https://github.com/graphql-java-kickstart)
projects. This work ranges from adding new features, fixing bugs, and answering questions to writing documentation. 

## Answering questions and writing documentation

A lot of the questions asked on Spectrum or Github are caused by a lack of documentation.
We should strive from now on to answer questions by adding content to 
our [documentation](https://github.com/graphql-java-kickstart/documentation) and referring
them to the newly created content.

Continuous integration will make sure that the changes are automatically deployed to 
https://www.graphql-java-kickstart.com.

## Submitting changes

Please send a Pull Request with a clear list of what you've done using the
[Github flow](https://guides.github.com/introduction/flow/). We can always use more
test coverage, so we'd love to see that in the pull requests too. And make sure to
follow our coding conventions (below) and make sure all your commits are atomic 
(one feature per commit).

## Coding conventions

We use Google Style guides for our projects. See the 
[Java Style Guide](https://google.github.io/styleguide/javaguide.html) for a detailed
description. You can download the 
[IntelliJ Java Google Style](https://github.com/google/styleguide/blob/gh-pages/intellij-java-google-style.xml)
to import in these settings in IntelliJ.

These conventions are checked during the build phase. If the build fails because
the code is not using the correct style you can fix this easily by running a gradle task
```bash
./gradlew googleJavaFormat
```

### SonarLint

It would also be very helpful to install the SonarLint plugin in your IDE and fix any
relevant SonarLint issues before pushing a PR. We're aware that the current state
of the code raises a lot of SonarLint issues out of the box, but any help in reducing
that is appreciated. More importantly we don't increase that technical debt.


================================================
FILE: LICENSE
================================================
Copyright 2016 Yurii Rashkovskii and Contributors

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and


================================================
FILE: README.md
================================================
# GraphQL Java Servlet
[![Maven Central](https://img.shields.io/maven-central/v/com.graphql-java-kickstart/graphql-java-servlet.svg)](https://maven-badges.herokuapp.com/maven-central/com.graphql-java-kickstart/graphql-java-servlet)
[![Build Status](https://github.com/graphql-java-kickstart/graphql-java-servlet/workflows/Publish%20snapshot/badge.svg)](https://github.com/graphql-java-kickstart/graphql-java-servlet/actions?query=workflow%3A%22Publish+snapshot%22)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=graphql-java-kickstart_graphql-java-servlet&metric=alert_status)](https://sonarcloud.io/dashboard?id=graphql-java-kickstart_graphql-java-servlet)
[![GitHub contributors](https://img.shields.io/github/contributors/graphql-java-kickstart/graphql-java-servlet)](https://github.com/graphql-java-kickstart/graphql-java-servlet/graphs/contributors)
[![Discuss on GitHub](https://img.shields.io/badge/GitHub-discuss-orange)](https://github.com/graphql-java-kickstart/graphql-java-servlet/discussions)


## We are looking for contributors!
Are you interested in improving our documentation, working on the codebase, reviewing PRs?

[Reach out to us on Discussions](https://github.com/graphql-java-kickstart/graphql-java-servlet/discussions) and join the team!

We hope you'll get involved! Read our [Contributors' Guide](CONTRIBUTING.md) for more details.

## Overview
Implementation of GraphQL Java Servlet including support for Relay.js, Apollo and OSGi out of the box.
This project wraps the Java implementation of GraphQL provided by [GraphQL Java](https://www.graphql-java.com).
See [GraphQL Java documentation](https://www.graphql-java.com/documentation/latest/) for more in depth details
regarding GraphQL Java itself. 

We try to stay up to date with GraphQL Java as much as possible maintaining the retro-compatibility
with javax and Springframework 5.

On each release we publish three flavours of this project:
 - [latest jakarta](#jakarta-and-springframework-6)
 - [jakarta5](#jakarta5)
 - [javax](#javax-and-springframework-5)
 
All of them also supports legacy projects that can compile with older JDK versions: the minimum JDK
version supported is the `11`.

## Jakarta and Springframework 6.*
This is the main flavour using the latest version of `Jakarta` (currently the `6.*`) and the latest
version of `Springframework` (currently the `6.*`). All the codebase can be found in the branch: 
`master`

```xml
<dependency>
    <groupId>com.graphql-java-kickstart</groupId>
    <artifactId>graphql-java-servlet</artifactId>
    <version>${graphql-java-servlet.version}</version>
</dependency>
```

## Jakarta5
This flavour use the `jakarta` version `5.*` and it is meant to be used for all the projects that 
are already migrated to jakarta, but they are waiting that `jakarta6` will become more broadly used.
All the codebase can be found in the branch: `jakarta5`

```xml
<dependency>
    <groupId>com.graphql-java-kickstart</groupId>
    <artifactId>graphql-java-servlet-jakarta5</artifactId>
    <version>${graphql-java-servlet-jakarta5.version}</version>
</dependency>
```

## Javax and Springframework 5.*
This is the legacy flavour using the `javax` dependency and the version `5.*` of `Springframework` 
(since it is still broadly used by a lot of projects). All the codebase can be found in the branch: 
`master` 

```xml
<dependency>
    <groupId>com.graphql-java-kickstart</groupId>
    <artifactId>graphql-java-servlet-javax</artifactId>
    <version>${graphql-java-servlet.version}</version>
</dependency>
```


## Installation and getting started

See [Getting started](https://graphql-java-kickstart.github.io/servlet/getting-started/) for more
detailed instructions.


================================================
FILE: build.gradle
================================================
/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2016 oEmbedler Inc. and Contributors
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 *  documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
 *  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
 *  persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
        maven { url "https://plugins.gradle.org/m2/" }
        maven { url 'https://repo.spring.io/plugins-release' }
    }
}

plugins {
    id "biz.aQute.bnd.builder" version "6.4.0" apply false
    id "org.sonarqube" version "5.1.0.4882"
    id "jacoco"
    id "io.github.gradle-nexus.publish-plugin" version '2.0.0'
}

sonarqube {
    properties {
        property "sonar.projectKey", "graphql-java-kickstart_graphql-java-servlet"
        property "sonar.organization", "graphql-java-kickstart"
        property "sonar.host.url", "https://sonarcloud.io"
    }
}

subprojects {
    apply plugin: 'idea'
    apply plugin: 'jacoco'
    apply plugin: 'org.sonarqube'
    apply plugin: 'java'
    apply plugin: 'maven-publish'
    apply plugin: 'signing'

    repositories {
        mavenLocal()
        mavenCentral()
        maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
        maven { url "https://repo.spring.io/libs-milestone" }
    }

    dependencies {
        compileOnly "org.projectlombok:lombok:$LIB_LOMBOK_VER"
        annotationProcessor "org.projectlombok:lombok:$LIB_LOMBOK_VER"

        testCompileOnly "org.projectlombok:lombok:$LIB_LOMBOK_VER"
        testAnnotationProcessor "org.projectlombok:lombok:$LIB_LOMBOK_VER"
    }

    idea {
        module {
            downloadJavadoc = true
            downloadSources = true
        }
    }

    compileJava {
        sourceCompatibility = SOURCE_COMPATIBILITY
        targetCompatibility = TARGET_COMPATIBILITY
    }

    compileTestJava {
        sourceCompatibility = SOURCE_COMPATIBILITY_TEST
        targetCompatibility = TARGET_COMPATIBILITY_TEST
    }

    compileJava.dependsOn(processResources)

    test {
        useJUnitPlatform()

        afterSuite { desc, result ->
            if (!desc.parent) {
                if (result.testCount == 0) {
                    throw new IllegalStateException("No tests were found. Failing the build")
                }
            }
        }
    }

    jacocoTestReport {
        reports {
            xml.required = true
            html.required = false
            csv.required = false
        }
    }

    if (!it.name.startsWith('example')) {
        jar {
            from "LICENSE.md"
        }

        java {
            withSourcesJar()
            withJavadocJar()
        }

        if (!version.toString().endsWith('-SNAPSHOT')) {
            ext["signing.keyId"] = System.env.SIGNING_KEY_ID
            ext["signing.password"] = System.env.SIGNING_PASSWORD
            ext["signing.secretKeyRingFile"] = System.env.SIGNING_SECRET_KEY_RING_FILE

            signing {
                sign publishing.publications
            }
        }

        publishing {
            publications {
                mavenJava(MavenPublication) {
                    version version
                    from components.java

                    versionMapping {
                        usage('java-api') {
                            fromResolutionOf('runtimeClasspath')
                        }
                        usage('java-runtime') {
                            fromResolutionResult()
                        }
                    }

                    pom {
                        name = PROJECT_NAME
                        description = 'relay.js-compatible GraphQL servlet'
                        url = 'https://github.com/graphql-java-kickstart/graphql-java-servlet'
                        inceptionYear = '2016'

                        scm {
                            url = 'https://github.com/graphql-java-kickstart/graphql-java-servlet'
                            connection = 'scm:https://github.com/graphql-java-kickstart/graphql-java-servlet.git'
                            developerConnection = 'scm:git://github.com/graphql-java-kickstart/graphql-java-servlet.git'
                        }

                        licenses {
                            license {
                                name = 'The Apache Software License, Version 2.0'
                                url = 'https://www.apache.org/licenses/LICENSE-2.0.txt'
                                distribution = 'repo'
                            }
                        }

                        developers {
                            developer {
                                id = 'oliemansm'
                                name = 'Michiel Oliemans'
                            }
                            developer {
                                id = 'yrashk'
                                name = 'Yurii Rashkovskii'
                                email = 'yrashk@gmail.com'
                            }
                            developer {
                                id = 'apottere'
                                name = 'Andrew Potter'
                                email = 'apottere@gmail.com'
                            }
                        }
                    }
                }
            }
        }
    }
}

nexusPublishing {
    repositories {
        sonatype {
            username = System.env.OSS_USER_TOKEN_KEY ?: project.findProperty('OSS_USER_TOKEN_KEY') ?: ''
            password = System.env.OSS_USER_TOKEN_PASS ?: project.findProperty('OSS_USER_TOKEN_PASS') ?: ''
        }
    }
}

wrapper {
    distributionType = Wrapper.DistributionType.ALL
}


================================================
FILE: examples/osgi/apache-karaf-feature/pom.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://maven.apache.org/POM/4.0.0"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <artifactId>graphql-java-servlet-osgi-examples-karaf-feature</artifactId>
  <build>
    <plugins>
      <plugin>
        <artifactId>karaf-maven-plugin</artifactId>
        <configuration>
          <addTransitiveFeatures>true</addTransitiveFeatures>
          <includeTransitiveDependency>true</includeTransitiveDependency>
          <startLevel>80</startLevel>
        </configuration>
        <extensions>true</extensions>
        <groupId>org.apache.karaf.tooling</groupId>
        <version>4.2.10</version>
      </plugin>

      <plugin>
        <artifactId>maven-install-plugin</artifactId>
        <groupId>org.apache.maven.plugins</groupId>
        <version>2.5.2</version>
      </plugin>
      <plugin>
        <artifactId>maven-deploy-plugin</artifactId>
        <groupId>org.apache.maven.plugins</groupId>
        <version>2.8.2</version>
      </plugin>
    </plugins>

  </build>

  <dependencies>
    <dependency>
      <artifactId>jackson-core</artifactId>
      <groupId>com.fasterxml.jackson.core</groupId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <artifactId>jackson-annotations</artifactId>
      <groupId>com.fasterxml.jackson.core</groupId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <artifactId>jackson-databind</artifactId>
      <groupId>com.fasterxml.jackson.core</groupId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <artifactId>jackson-datatype-jdk8</artifactId>
      <groupId>com.fasterxml.jackson.datatype</groupId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <artifactId>guava</artifactId>
      <groupId>com.google.guava</groupId>
      <version>[24.1.1,)</version>
    </dependency>
    <dependency>
      <artifactId>commons-fileupload</artifactId>
      <groupId>commons-fileupload</groupId>
      <version>[1.3.3,)</version>
    </dependency>
    <dependency>
      <artifactId>antlr4-runtime</artifactId>
      <groupId>org.antlr</groupId>
      <version>4.7.1</version>
    </dependency>

    <dependency>
      <artifactId>graphql-java-servlet</artifactId>
      <groupId>com.graphql-java-kickstart</groupId>
      <version>${graphql.java.servlet.version}</version>
    </dependency>
    <dependency>
      <artifactId>graphql-java</artifactId>
      <groupId>com.graphql-java</groupId>
      <version>${graphql.java.version}</version>
    </dependency>
    <dependency>
      <artifactId>graphql-java-annotations</artifactId>
      <groupId>com.graphql-java</groupId>
      <version>0.13.1</version>
    </dependency>

    <dependency>
      <artifactId>graphql-java-servlet-osgi-examples-providers</artifactId>
      <groupId>com.graphql-java-kickstart</groupId>
      <version>${project.version}</version>
    </dependency>
    <dependency>
      <artifactId>slf4j-api</artifactId>
      <groupId>org.slf4j</groupId>
      <version>1.7.25</version>
    </dependency>
    <dependency>
      <artifactId>slf4j-log4j12</artifactId>
      <groupId>org.slf4j</groupId>
      <version>1.7.25</version>
    </dependency>
  </dependencies>
  <modelVersion>4.0.0</modelVersion>

  <packaging>feature</packaging>


  <parent>
    <artifactId>graphql-java-servlet-osgi-examples</artifactId>
    <groupId>com.graphql-java-kickstart</groupId>
    <version>10.1.0</version>
  </parent>

  <properties>
    <jackson.version>2.13.4.2</jackson.version>
  </properties>

</project>


================================================
FILE: examples/osgi/apache-karaf-feature/src/main/feature/feature.xml
================================================
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<features name="graphql-java-servlet-osgi-examples-karaf-feature"
  xmlns="http://karaf.apache.org/xmlns/features/v1.4.0">
  <feature description="graphql-java-servlet-osgi-examples-karaf-feature"
    name="graphql-java-servlet-osgi-examples-karaf-feature">
    <feature dependency="false" prerequisite="true">scr</feature>
    <feature dependency="false" prerequisite="true">war</feature>
    <feature dependency="false" prerequisite="true">http</feature>
  </feature>
</features>


================================================
FILE: examples/osgi/apache-karaf-package/pom.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://maven.apache.org/POM/4.0.0"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <artifactId>graphql-java-servlet-osgi-examples-apache-karaf-package</artifactId>
  <build>
    <!-- if you want to include resources in the distribution -->
    <plugins>
      <!-- if you want to include resources in the distribution -->
      <plugin>
        <artifactId>maven-resources-plugin</artifactId>
        <executions>
          <execution>
            <goals>
              <goal>resources</goal>
            </goals>
            <id>process-resources</id>
          </execution>
        </executions>
        <groupId>org.apache.maven.plugins</groupId>
        <version>2.6</version>
      </plugin>
      <plugin>
        <artifactId>karaf-maven-plugin</artifactId>
        <configuration>
          <!-- no startupFeatures -->
          <bootFeatures>
            <feature>minimal</feature>
            <feature>wrapper</feature>
            <feature>graphql-java-servlet-osgi-examples-karaf-feature</feature>
          </bootFeatures>
          <installedFeatures>
          </installedFeatures>
        </configuration>
        <extensions>true</extensions>
        <groupId>org.apache.karaf.tooling</groupId>
        <version>${karaf.version}</version>
      </plugin>

      <plugin>
        <artifactId>maven-install-plugin</artifactId>
        <groupId>org.apache.maven.plugins</groupId>
        <version>2.5.2</version>
      </plugin>
      <plugin>
        <artifactId>maven-deploy-plugin</artifactId>
        <groupId>org.apache.maven.plugins</groupId>
        <version>2.8.2</version>
      </plugin>
    </plugins>

    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <filtering>false</filtering>
        <includes>
          <include>**/*</include>
        </includes>
      </resource>
      <resource>
        <directory>src/main/filtered-resources</directory>
        <filtering>true</filtering>
        <includes>
          <include>**/*</include>
        </includes>
      </resource>
    </resources>
  </build>

  <dependencies>
    <dependency>
      <!-- scope is compile so all features (there is only one) are installed into startup.properties and the feature repo itself is not added in etc/org.apache.karaf.features.cfg file -->
      <artifactId>framework</artifactId>
      <groupId>org.apache.karaf.features</groupId>
      <type>kar</type>
      <version>${karaf.version}</version>
    </dependency>
    <dependency>
      <!-- scope is runtime so the feature repo is listed in etc/org.apache.karaf.features.cfg file, and features will installed into the system directory if specify in the plugin configuration -->
      <artifactId>standard</artifactId>
      <classifier>features</classifier>
      <groupId>org.apache.karaf.features</groupId>
      <scope>runtime</scope>
      <type>xml</type>
      <version>${karaf.version}</version>
    </dependency>
    <dependency>
      <!-- scope is runtime so the feature repo is listed in etc/org.apache.karaf.features.cfg file, and features will installed into the system directory if specify in the plugin configuration -->
      <artifactId>enterprise</artifactId>
      <classifier>features</classifier>
      <groupId>org.apache.karaf.features</groupId>
      <scope>runtime</scope>
      <type>xml</type>
      <version>${karaf.version}</version>
    </dependency>

    <dependency>
      <artifactId>graphql-java-servlet-osgi-examples-karaf-feature</artifactId>
      <classifier>features</classifier>
      <groupId>com.graphql-java-kickstart</groupId>
      <scope>runtime</scope>
      <type>xml</type>
      <version>${project.version}</version>
    </dependency>
  </dependencies>
  <modelVersion>4.0.0</modelVersion>

  <packaging>karaf-assembly</packaging>

  <parent>
    <artifactId>graphql-java-servlet-osgi-examples</artifactId>
    <groupId>com.graphql-java-kickstart</groupId>
    <version>10.1.0</version>
  </parent>
</project>


================================================
FILE: examples/osgi/buildAndRun.sh
================================================
#!/usr/bin/env bash
mvn clean install
pushd apache-karaf-package/target || exit 1
tar zxvf graphql-java-servlet-osgi-examples-apache-karaf-package-10.1.0.tar.gz
cd graphql-java-servlet-osgi-examples-apache-karaf-package-10.1.0/bin || exit 1
./karaf debug
popd || exit 1


================================================
FILE: examples/osgi/pom.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://maven.apache.org/POM/4.0.0"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <artifactId>graphql-java-servlet-osgi-examples</artifactId>

  <groupId>com.graphql-java-kickstart</groupId>
  <modelVersion>4.0.0</modelVersion>
  <modules>
    <module>providers</module>
    <module>apache-karaf-feature</module>
    <module>apache-karaf-package</module>
  </modules>
  <packaging>pom</packaging>

  <properties>
    <graphql.java.servlet.version>11.0.0-SNAPSHOT</graphql.java.servlet.version>
    <graphql.java.version>16.1</graphql.java.version>
    <karaf.version>4.2.10</karaf.version>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
  </properties>

  <version>10.1.0</version>

</project>


================================================
FILE: examples/osgi/providers/pom.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://maven.apache.org/POM/4.0.0"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <artifactId>graphql-java-servlet-osgi-examples-providers</artifactId>
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-bundle-plugin</artifactId>
        <configuration>
        </configuration>
        <extensions>true</extensions>
        <groupId>org.apache.felix</groupId>
        <version>3.3.0</version>
      </plugin>
    </plugins>
  </build>

  <dependencies>
    <dependency>
      <artifactId>graphql-java-servlet</artifactId>
      <groupId>com.graphql-java-kickstart</groupId>
      <scope>provided</scope>
      <version>${graphql.java.servlet.version}</version>
    </dependency>
    <dependency>
      <artifactId>graphql-java</artifactId>
      <groupId>com.graphql-java</groupId>
      <scope>provided</scope>
      <version>${graphql.java.version}</version>
    </dependency>
    <dependency>
      <artifactId>osgi.enterprise</artifactId>
      <groupId>org.osgi</groupId>
      <scope>provided</scope>
      <version>6.0.0</version>
    </dependency>
    <dependency>
      <artifactId>org.apache.felix.scr.ds-annotations</artifactId>
      <groupId>org.apache.felix</groupId>
      <scope>provided</scope>
      <version>1.2.4</version>
    </dependency>
  </dependencies>
  <modelVersion>4.0.0</modelVersion>

  <packaging>bundle</packaging>

  <parent>
    <artifactId>graphql-java-servlet-osgi-examples</artifactId>
    <groupId>com.graphql-java-kickstart</groupId>
    <version>10.1.0</version>
  </parent>

</project>


================================================
FILE: examples/osgi/providers/src/main/java/graphql/servlet/examples/osgi/ExampleGraphQLProvider.java
================================================
package graphql.servlet.examples.osgi;

import graphql.schema.GraphQLFieldDefinition;
import graphql.schema.GraphQLType;
import graphql.kickstart.servlet.osgi.GraphQLMutationProvider;
import graphql.kickstart.servlet.osgi.GraphQLQueryProvider;
import graphql.kickstart.servlet.osgi.GraphQLTypesProvider;
import org.osgi.service.component.annotations.Component;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import static graphql.Scalars.GraphQLString;
import static graphql.schema.GraphQLFieldDefinition.*;

@Component(
    name = "ExampleGraphQLProvider",
    immediate = true
)
public class ExampleGraphQLProvider implements GraphQLQueryProvider, GraphQLMutationProvider,
    GraphQLTypesProvider {

  public Collection<GraphQLFieldDefinition> getQueries() {
    List<GraphQLFieldDefinition> fieldDefinitions = new ArrayList<GraphQLFieldDefinition>();
    fieldDefinitions.add(newFieldDefinition()
        .type(GraphQLString)
        .name("hello")
        .description(
            "Basic example of a GraphQL Java Servlet provider using the Apache Karaf OSGi Runtime")
        .staticValue("world")
        .build());
    return fieldDefinitions;
  }

  public Collection<GraphQLFieldDefinition> getMutations() {
    return new ArrayList<GraphQLFieldDefinition>();
  }

  public Collection<GraphQLType> getTypes() {
    return new ArrayList<GraphQLType>();
  }
}


================================================
FILE: gradle/wrapper/gradle-wrapper.properties
================================================
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-all.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists


================================================
FILE: gradle.properties
================================================
version=16.0.0
group=com.graphql-java-kickstart
PROJECT_NAME=graphql-java-servlet
PROJECT_DESC=GraphQL Java Kickstart
PROJECT_GIT_REPO_URL=https://github.com/graphql-java-kickstart/graphql-java-servlet
PROJECT_LICENSE=MIT
PROJECT_LICENSE_URL=https://github.com/graphql-java-kickstart/spring-java-servlet/blob/master/LICENSE.md
PROJECT_DEV_ID=oliemansm
PROJECT_DEV_NAME=Michiel Oliemans
LIB_GRAPHQL_JAVA_VER=22.3
LIB_JACKSON_VER=2.17.2
LIB_SLF4J_VER=2.0.16
LIB_LOMBOK_VER=1.18.34
# These constants are necessary to the automatic release of javax flavour
LIB_JAVAX_SERVLET=4.0.1
LIB_JAVAX_WEBSOCKET=1.1
LIB_SPRINGFRAMEWORK_5=5.3.25
SOURCE_COMPATIBILITY=11
TARGET_COMPATIBILITY=11
SOURCE_COMPATIBILITY_TEST=17
TARGET_COMPATIBILITY_TEST=17


================================================
FILE: gradlew
================================================
#!/bin/sh

#
# Copyright © 2015-2021 the original authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0
#

##############################################################################
#
#   Gradle start up script for POSIX generated by Gradle.
#
#   Important for running:
#
#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
#       noncompliant, but you have some other compliant shell such as ksh or
#       bash, then to run this script, type that shell name before the whole
#       command line, like:
#
#           ksh Gradle
#
#       Busybox and similar reduced shells will NOT work, because this script
#       requires all of these POSIX shell features:
#         * functions;
#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
#         * compound commands having a testable exit status, especially «case»;
#         * various built-in commands including «command», «set», and «ulimit».
#
#   Important for patching:
#
#   (2) This script targets any POSIX shell, so it avoids extensions provided
#       by Bash, Ksh, etc; in particular arrays are avoided.
#
#       The "traditional" practice of packing multiple parameters into a
#       space-separated string is a well documented source of bugs and security
#       problems, so this is (mostly) avoided, by progressively accumulating
#       options in "$@", and eventually passing that to Java.
#
#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
#       see the in-line comments for details.
#
#       There are tweaks for specific operating systems such as AIX, CygWin,
#       Darwin, MinGW, and NonStop.
#
#   (3) This script is generated from the Groovy template
#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
#       within the Gradle project.
#
#       You can find Gradle at https://github.com/gradle/gradle/.
#
##############################################################################

# Attempt to set APP_HOME

# Resolve links: $0 may be a link
app_path=$0

# Need this for daisy-chained symlinks.
while
    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
    [ -h "$app_path" ]
do
    ls=$( ls -ld "$app_path" )
    link=${ls#*' -> '}
    case $link in             #(
      /*)   app_path=$link ;; #(
      *)    app_path=$APP_HOME$link ;;
    esac
done

# This is normally unused
# shellcheck disable=SC2034
APP_BASE_NAME=${0##*/}
# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
' "$PWD" ) || exit

# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum

warn () {
    echo "$*"
} >&2

die () {
    echo
    echo "$*"
    echo
    exit 1
} >&2

# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "$( uname )" in                #(
  CYGWIN* )         cygwin=true  ;; #(
  Darwin* )         darwin=true  ;; #(
  MSYS* | MINGW* )  msys=true    ;; #(
  NONSTOP* )        nonstop=true ;;
esac

CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar


# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
        # IBM's JDK on AIX uses strange locations for the executables
        JAVACMD=$JAVA_HOME/jre/sh/java
    else
        JAVACMD=$JAVA_HOME/bin/java
    fi
    if [ ! -x "$JAVACMD" ] ; then
        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME

Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
    fi
else
    JAVACMD=java
    if ! command -v java >/dev/null 2>&1
    then
        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.

Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
    fi
fi

# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
    case $MAX_FD in #(
      max*)
        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
        # shellcheck disable=SC2039,SC3045
        MAX_FD=$( ulimit -H -n ) ||
            warn "Could not query maximum file descriptor limit"
    esac
    case $MAX_FD in  #(
      '' | soft) :;; #(
      *)
        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
        # shellcheck disable=SC2039,SC3045
        ulimit -n "$MAX_FD" ||
            warn "Could not set maximum file descriptor limit to $MAX_FD"
    esac
fi

# Collect all arguments for the java command, stacking in reverse order:
#   * args from the command line
#   * the main class name
#   * -classpath
#   * -D...appname settings
#   * --module-path (only if needed)
#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.

# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )

    JAVACMD=$( cygpath --unix "$JAVACMD" )

    # Now convert the arguments - kludge to limit ourselves to /bin/sh
    for arg do
        if
            case $arg in                                #(
              -*)   false ;;                            # don't mess with options #(
              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
                    [ -e "$t" ] ;;                      #(
              *)    false ;;
            esac
        then
            arg=$( cygpath --path --ignore --mixed "$arg" )
        fi
        # Roll the args list around exactly as many times as the number of
        # args, so each arg winds up back in the position where it started, but
        # possibly modified.
        #
        # NB: a `for` loop captures its iteration list before it begins, so
        # changing the positional parameters here affects neither the number of
        # iterations, nor the values presented in `arg`.
        shift                   # remove old arg
        set -- "$@" "$arg"      # push replacement arg
    done
fi


# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'

# Collect all arguments for the java command:
#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
#     and any embedded shellness will be escaped.
#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
#     treated as '${Hostname}' itself on the command line.

set -- \
        "-Dorg.gradle.appname=$APP_BASE_NAME" \
        -classpath "$CLASSPATH" \
        org.gradle.wrapper.GradleWrapperMain \
        "$@"

# Stop when "xargs" is not available.
if ! command -v xargs >/dev/null 2>&1
then
    die "xargs is not available"
fi

# Use "xargs" to parse quoted args.
#
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
#
# In Bash we could simply go:
#
#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
#   set -- "${ARGS[@]}" "$@"
#
# but POSIX shell has neither arrays nor command substitution, so instead we
# post-process each arg (as a line of input to sed) to backslash-escape any
# character that might be a shell metacharacter, then use eval to reverse
# that process (while maintaining the separation between arguments), and wrap
# the whole thing up as a single "set" statement.
#
# This will of course break if any of these variables contains a newline or
# an unmatched quote.
#

eval "set -- $(
        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
        xargs -n1 |
        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
        tr '\n' ' '
    )" '"$@"'

exec "$JAVACMD" "$@"


================================================
FILE: gradlew.bat
================================================
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem      https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@rem SPDX-License-Identifier: Apache-2.0
@rem

@if "%DEBUG%"=="" @echo off
@rem ##########################################################################
@rem
@rem  Gradle startup script for Windows
@rem
@rem ##########################################################################

@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal

set DIRNAME=%~dp0
if "%DIRNAME%"=="" set DIRNAME=.
@rem This is normally unused
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%

@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi

@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"

@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome

set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if %ERRORLEVEL% equ 0 goto execute

echo. 1>&2
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2

goto fail

:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe

if exist "%JAVA_EXE%" goto execute

echo. 1>&2
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
echo. 1>&2
echo Please set the JAVA_HOME variable in your environment to match the 1>&2
echo location of your Java installation. 1>&2

goto fail

:execute
@rem Setup the command line

set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar


@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*

:end
@rem End local scope for the variables with windows NT shell
if %ERRORLEVEL% equ 0 goto mainEnd

:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
set EXIT_CODE=%ERRORLEVEL%
if %EXIT_CODE% equ 0 set EXIT_CODE=1
if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
exit /b %EXIT_CODE%

:mainEnd
if "%OS%"=="Windows_NT" endlocal

:omega


================================================
FILE: graphql-java-kickstart/bnd.bnd
================================================
Export-Package: graphql.kickstart.*
Import-Package: !lombok,*


================================================
FILE: graphql-java-kickstart/build.gradle
================================================
apply plugin: 'biz.aQute.bnd.builder'

jar {
    bndfile = 'bnd.bnd'
}

apply plugin: 'java-library-distribution'

dependencies {
    // GraphQL
    api "com.graphql-java:graphql-java:$LIB_GRAPHQL_JAVA_VER"
    implementation "org.slf4j:slf4j-api:$LIB_SLF4J_VER"

    // JSON
    api "com.fasterxml.jackson.core:jackson-core:$LIB_JACKSON_VER"
    api "com.fasterxml.jackson.core:jackson-annotations:$LIB_JACKSON_VER"
    api "com.fasterxml.jackson.core:jackson-databind:2.17.2"
    api "com.fasterxml.jackson.datatype:jackson-datatype-jdk8:$LIB_JACKSON_VER"
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/BatchedDataLoaderGraphQLBuilder.java
================================================
package graphql.kickstart.execution;

import graphql.GraphQL;
import graphql.kickstart.execution.config.GraphQLBuilder;
import graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;
import graphql.kickstart.execution.input.GraphQLSingleInvocationInput;

public class BatchedDataLoaderGraphQLBuilder {

  GraphQL newGraphQL(GraphQLBatchedInvocationInput invocationInput, GraphQLBuilder graphQLBuilder) {
    return invocationInput.getInvocationInputs().stream()
        .findFirst()
        .map(GraphQLSingleInvocationInput::getSchema)
        .map(schema -> graphQLBuilder.build(schema, graphQLBuilder.getInstrumentationSupplier()))
        .orElseThrow(
            () ->
                new IllegalArgumentException(
                    "Batched invocation input must contain at least one query"));
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/DecoratedExecutionResult.java
================================================
package graphql.kickstart.execution;

import graphql.ExecutionResult;
import graphql.GraphQLError;
import java.util.List;
import java.util.Map;
import lombok.RequiredArgsConstructor;
import org.reactivestreams.Publisher;

@RequiredArgsConstructor
class DecoratedExecutionResult implements ExecutionResult {

  private final ExecutionResult result;

  boolean isAsynchronous() {
    return result.getData() instanceof Publisher;
  }

  @Override
  public List<GraphQLError> getErrors() {
    return result.getErrors();
  }

  @Override
  public <T> T getData() {
    return result.getData();
  }

  @Override
  public boolean isDataPresent() {
    return result.isDataPresent();
  }

  @Override
  public Map<Object, Object> getExtensions() {
    return result.getExtensions();
  }

  @Override
  public Map<String, Object> toSpecification() {
    return result.toSpecification();
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/DefaultGraphQLRootObjectBuilder.java
================================================
package graphql.kickstart.execution;

public class DefaultGraphQLRootObjectBuilder extends StaticGraphQLRootObjectBuilder {

  public DefaultGraphQLRootObjectBuilder() {
    super(new Object());
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/ExtensionsDeserializer.java
================================================
package graphql.kickstart.execution;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.ObjectCodec;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import java.io.IOException;
import java.util.Map;

public class ExtensionsDeserializer extends JsonDeserializer<Map<String, Object>> {

  public static Map<String, Object> deserializeExtensionsObject(
      Object extensions, ObjectCodec codec) {
    return ObjectMapDeserializeHelper.deserializeObjectMapObject(extensions, codec, "extensions");
  }

  @Override
  public Map<String, Object> deserialize(JsonParser p, DeserializationContext ctxt)
      throws IOException {
    return ExtensionsDeserializer.deserializeExtensionsObject(
        p.readValueAs(Object.class), p.getCodec());
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/FutureBatchedExecutionResult.java
================================================
package graphql.kickstart.execution;

import graphql.ExecutionResult;
import graphql.kickstart.execution.input.GraphQLInvocationInput;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import lombok.Getter;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
class FutureBatchedExecutionResult implements FutureExecutionResult {

  @Getter
  private final GraphQLInvocationInput invocationInput;
  private final CompletableFuture<List<ExecutionResult>> batched;

  @Override
  public CompletableFuture<GraphQLQueryResult> thenApplyQueryResult() {
    return batched.thenApply(GraphQLQueryResult::create);
  }

  @Override
  public void cancel() {
    batched.cancel(true);
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/FutureErrorExecutionResult.java
================================================
package graphql.kickstart.execution;

import graphql.kickstart.execution.input.GraphQLInvocationInput;
import java.util.concurrent.CompletableFuture;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
class FutureErrorExecutionResult implements FutureExecutionResult {

  private final GraphQLErrorQueryResult errorQueryResult;

  @Override
  public CompletableFuture<GraphQLQueryResult> thenApplyQueryResult() {
    return CompletableFuture.completedFuture(errorQueryResult);
  }

  @Override
  public GraphQLInvocationInput getInvocationInput() {
    return null;
  }

  @Override
  public void cancel() {
    // nothing to do
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/FutureExecutionResult.java
================================================
package graphql.kickstart.execution;

import graphql.ExecutionResult;
import graphql.kickstart.execution.input.GraphQLInvocationInput;
import java.util.List;
import java.util.concurrent.CompletableFuture;

public interface FutureExecutionResult {

  static FutureExecutionResult single(
      GraphQLInvocationInput invocationInput, CompletableFuture<ExecutionResult> single) {
    return new FutureSingleExecutionResult(invocationInput, single);
  }

  static FutureExecutionResult batched(
      GraphQLInvocationInput invocationInput, CompletableFuture<List<ExecutionResult>> batched) {
    return new FutureBatchedExecutionResult(invocationInput, batched);
  }

  static FutureExecutionResult error(GraphQLErrorQueryResult result) {
    return new FutureErrorExecutionResult(result);
  }

  CompletableFuture<GraphQLQueryResult> thenApplyQueryResult();

  GraphQLInvocationInput getInvocationInput();

  void cancel();
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/FutureSingleExecutionResult.java
================================================
package graphql.kickstart.execution;

import graphql.ExecutionResult;
import graphql.kickstart.execution.input.GraphQLInvocationInput;
import java.util.concurrent.CompletableFuture;
import lombok.Getter;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
class FutureSingleExecutionResult implements FutureExecutionResult {

  @Getter
  private final GraphQLInvocationInput invocationInput;
  private final CompletableFuture<ExecutionResult> single;

  @Override
  public CompletableFuture<GraphQLQueryResult> thenApplyQueryResult() {
    return single.thenApply(GraphQLQueryResult::create);
  }

  @Override
  public void cancel() {
    single.cancel(true);
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLBatchedQueryResult.java
================================================
package graphql.kickstart.execution;

import graphql.ExecutionResult;
import java.util.List;
import lombok.Getter;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
class GraphQLBatchedQueryResult implements GraphQLQueryResult {

  @Getter private final List<ExecutionResult> results;

  @Override
  public boolean isBatched() {
    return true;
  }

  @Override
  public boolean isAsynchronous() {
    return false;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLErrorQueryResult.java
================================================
package graphql.kickstart.execution;

import lombok.Getter;
import lombok.RequiredArgsConstructor;

@Getter
@RequiredArgsConstructor
class GraphQLErrorQueryResult implements GraphQLQueryResult {

  private final int statusCode;
  private final String message;

  @Override
  public boolean isBatched() {
    return false;
  }

  @Override
  public boolean isAsynchronous() {
    return false;
  }

  @Override
  public boolean isError() {
    return true;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLInvoker.java
================================================
package graphql.kickstart.execution;

import static java.util.stream.Collectors.toList;

import graphql.ExecutionResult;
import graphql.GraphQL;
import graphql.kickstart.execution.config.GraphQLBuilder;
import graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;
import graphql.kickstart.execution.input.GraphQLInvocationInput;
import graphql.kickstart.execution.input.GraphQLSingleInvocationInput;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@RequiredArgsConstructor
public class GraphQLInvoker {

  private final GraphQLBuilder graphQLBuilder;
  private final BatchedDataLoaderGraphQLBuilder batchedDataLoaderGraphQLBuilder;
  private final GraphQLInvokerProxy proxy = GraphQL::executeAsync;

  public FutureExecutionResult execute(GraphQLInvocationInput invocationInput) {
    if (invocationInput instanceof GraphQLSingleInvocationInput) {
      return FutureExecutionResult.single(
          invocationInput, executeAsync((GraphQLSingleInvocationInput) invocationInput));
    }
    return FutureExecutionResult.batched(
        invocationInput, executeAsync((GraphQLBatchedInvocationInput) invocationInput));
  }

  public CompletableFuture<ExecutionResult> executeAsync(
      GraphQLSingleInvocationInput invocationInput) {
    GraphQL graphQL = graphQLBuilder.build(invocationInput.getSchema());
    return proxy.executeAsync(graphQL, invocationInput.getExecutionInput());
  }

  public GraphQLQueryResult query(GraphQLInvocationInput invocationInput) {
    return queryAsync(invocationInput).join();
  }

  public CompletableFuture<GraphQLQueryResult> queryAsync(GraphQLInvocationInput invocationInput) {
    if (invocationInput instanceof GraphQLSingleInvocationInput) {
      return executeAsync((GraphQLSingleInvocationInput) invocationInput)
          .thenApply(GraphQLQueryResult::create);
    }
    GraphQLBatchedInvocationInput batchedInvocationInput =
        (GraphQLBatchedInvocationInput) invocationInput;
    return executeAsync(batchedInvocationInput).thenApply(GraphQLQueryResult::create);
  }

  private CompletableFuture<List<ExecutionResult>> executeAsync(
      GraphQLBatchedInvocationInput batchedInvocationInput) {
    GraphQL graphQL =
        batchedDataLoaderGraphQLBuilder.newGraphQL(batchedInvocationInput, graphQLBuilder);
    return sequence(
        batchedInvocationInput.getExecutionInputs().stream()
            .map(executionInput -> proxy.executeAsync(graphQL, executionInput))
            .collect(toList()));
  }

  @SuppressWarnings({"unchecked", "rawtypes"})
  private <T> CompletableFuture<List<T>> sequence(List<CompletableFuture<T>> futures) {
    CompletableFuture[] futuresArray = futures.toArray(new CompletableFuture[0]);
    return CompletableFuture.allOf(futuresArray)
        .thenApply(
            aVoid -> {
              List<T> result = new ArrayList<>(futures.size());
              for (CompletableFuture future : futuresArray) {
                assert future.isDone(); // per the API contract of allOf()
                result.add((T) future.join());
              }
              return result;
            });
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLInvokerProxy.java
================================================
package graphql.kickstart.execution;

import graphql.ExecutionInput;
import graphql.ExecutionResult;
import graphql.GraphQL;
import java.util.concurrent.CompletableFuture;

public interface GraphQLInvokerProxy {

  CompletableFuture<ExecutionResult> executeAsync(GraphQL graphQL, ExecutionInput executionInput);
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLObjectMapper.java
================================================
package graphql.kickstart.execution;

import static java.util.stream.Collectors.toList;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.MappingIterator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectReader;
import graphql.ExecutionResult;
import graphql.ExecutionResultImpl;
import graphql.GraphQLError;
import graphql.kickstart.execution.config.ConfiguringObjectMapperProvider;
import graphql.kickstart.execution.config.GraphQLServletObjectMapperConfigurer;
import graphql.kickstart.execution.config.ObjectMapperProvider;
import graphql.kickstart.execution.error.DefaultGraphQLErrorHandler;
import graphql.kickstart.execution.error.GraphQLErrorHandler;
import java.io.IOException;
import java.io.InputStream;
import java.io.Writer;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;
import lombok.SneakyThrows;

/** @author Andrew Potter */
public class GraphQLObjectMapper {

  private static final TypeReference<Map<String, List<String>>> MULTIPART_MAP_TYPE_REFERENCE =
      new TypeReference<Map<String, List<String>>>() {};
  private final ObjectMapperProvider objectMapperProvider;
  private final Supplier<GraphQLErrorHandler> graphQLErrorHandlerSupplier;

  private ObjectMapper mapper;

  protected GraphQLObjectMapper(
      ObjectMapperProvider objectMapperProvider,
      Supplier<GraphQLErrorHandler> graphQLErrorHandlerSupplier) {
    this.objectMapperProvider = objectMapperProvider;
    this.graphQLErrorHandlerSupplier = graphQLErrorHandlerSupplier;
  }

  public static Builder newBuilder() {
    return new Builder();
  }

  // Double-check idiom for lazy initialization of instance fields.
  public ObjectMapper getJacksonMapper() {
    ObjectMapper result = mapper;
    if (result == null) { // First check (no locking)
      synchronized (this) {
        result = mapper;
        if (result == null) { // Second check (with locking)
          mapper = result = objectMapperProvider.provide();
        }
      }
    }

    return result;
  }

  /** @return an {@link ObjectReader} for deserializing {@link GraphQLRequest} */
  public ObjectReader getGraphQLRequestMapper() {
    return getJacksonMapper().reader().forType(GraphQLRequest.class);
  }

  public GraphQLRequest readGraphQLRequest(InputStream inputStream) throws IOException {
    return getGraphQLRequestMapper().readValue(inputStream);
  }

  public GraphQLRequest readGraphQLRequest(String text) throws IOException {
    return getGraphQLRequestMapper().readValue(text);
  }

  public List<GraphQLRequest> readBatchedGraphQLRequest(InputStream inputStream)
      throws IOException {
    MappingIterator<GraphQLRequest> iterator = getGraphQLRequestMapper().readValues(inputStream);
    List<GraphQLRequest> requests = new ArrayList<>();

    while (iterator.hasNext()) {
      requests.add(iterator.next());
    }

    return requests;
  }

  public List<GraphQLRequest> readBatchedGraphQLRequest(String query) throws IOException {
    MappingIterator<GraphQLRequest> iterator = getGraphQLRequestMapper().readValues(query);
    List<GraphQLRequest> requests = new ArrayList<>();

    while (iterator.hasNext()) {
      requests.add(iterator.next());
    }

    return requests;
  }

  @SneakyThrows
  public String serializeResultAsJson(ExecutionResult executionResult) {
    return getJacksonMapper().writeValueAsString(createResultFromExecutionResult(executionResult));
  }

  public void serializeResultAsJson(Writer writer, ExecutionResult executionResult)
      throws IOException {
    getJacksonMapper().writeValue(writer, createResultFromExecutionResult(executionResult));
  }

  /**
   * Serializes result as bytes in UTF-8 encoding instead of string.
   *
   * @param executionResult query execution result to serialize.
   * @return result serialized into Json representation in UTF-8 encoding, converted into {@code
   *     byte[]}.
   */
  @SneakyThrows
  public byte[] serializeResultAsBytes(ExecutionResult executionResult) {
    return getJacksonMapper().writeValueAsBytes(createResultFromExecutionResult(executionResult));
  }

  public boolean areErrorsPresent(ExecutionResult executionResult) {
    return graphQLErrorHandlerSupplier.get().errorsPresent(executionResult.getErrors());
  }

  public ExecutionResult sanitizeErrors(ExecutionResult executionResult) {
    Object data = executionResult.getData();
    Map<Object, Object> extensions = executionResult.getExtensions();
    List<GraphQLError> errors = executionResult.getErrors();

    GraphQLErrorHandler errorHandler = graphQLErrorHandlerSupplier.get();
    if (errorHandler.errorsPresent(errors)) {
      errors = errorHandler.processErrors(errors);
    } else {
      errors = null;
    }
    return new ExecutionResultImpl(data, errors, extensions);
  }

  public Map<String, Object> createResultFromExecutionResult(ExecutionResult executionResult) {
    ExecutionResult sanitizedExecutionResult = sanitizeErrors(executionResult);
    return convertSanitizedExecutionResult(sanitizedExecutionResult);
  }

  public Map<String, Object> convertSanitizedExecutionResult(ExecutionResult executionResult) {
    return convertSanitizedExecutionResult(executionResult, true);
  }

  public Map<String, Object> convertSanitizedExecutionResult(
      ExecutionResult executionResult, boolean includeData) {
    final Map<String, Object> result = new LinkedHashMap<>();

    if (areErrorsPresent(executionResult)) {
      result.put(
          "errors",
          executionResult.getErrors().stream()
              .map(GraphQLError::toSpecification)
              .collect(toList()));
    }

    if (executionResult.getExtensions() != null && !executionResult.getExtensions().isEmpty()) {
      result.put("extensions", executionResult.getExtensions());
    }

    if (includeData) {
      result.put("data", executionResult.getData());
    }

    return result;
  }

  @SneakyThrows
  public Map<String, Object> deserializeVariables(String variables) {
    return VariablesDeserializer.deserializeVariablesObject(
        getJacksonMapper().readValue(variables, Object.class), getJacksonMapper());
  }

  @SneakyThrows
  public Map<String, Object> deserializeExtensions(String extensions) {
    return ExtensionsDeserializer.deserializeExtensionsObject(
        getJacksonMapper().readValue(extensions, Object.class), getJacksonMapper());
  }

  @SneakyThrows
  public Map<String, List<String>> deserializeMultipartMap(InputStream inputStream) {
    return getJacksonMapper().readValue(inputStream, MULTIPART_MAP_TYPE_REFERENCE);
  }

  public static class Builder {

    private ObjectMapperProvider objectMapperProvider = new ConfiguringObjectMapperProvider();
    private Supplier<GraphQLErrorHandler> graphQLErrorHandler = DefaultGraphQLErrorHandler::new;

    public Builder withObjectMapperConfigurer(
        GraphQLServletObjectMapperConfigurer objectMapperConfigurer) {
      return withObjectMapperConfigurer(() -> objectMapperConfigurer);
    }

    public Builder withObjectMapperConfigurer(
        Supplier<GraphQLServletObjectMapperConfigurer> objectMapperConfigurer) {
      this.objectMapperProvider = new ConfiguringObjectMapperProvider(objectMapperConfigurer.get());
      return this;
    }

    public Builder withObjectMapperProvider(ObjectMapperProvider objectMapperProvider) {
      this.objectMapperProvider = objectMapperProvider;
      return this;
    }

    public Builder withGraphQLErrorHandler(GraphQLErrorHandler graphQLErrorHandler) {
      return withGraphQLErrorHandler(() -> graphQLErrorHandler);
    }

    public Builder withGraphQLErrorHandler(Supplier<GraphQLErrorHandler> graphQLErrorHandler) {
      this.graphQLErrorHandler = graphQLErrorHandler;
      return this;
    }

    public GraphQLObjectMapper build() {
      return new GraphQLObjectMapper(objectMapperProvider, graphQLErrorHandler);
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLQueryInvoker.java
================================================
package graphql.kickstart.execution;

import graphql.execution.instrumentation.ChainedInstrumentation;
import graphql.execution.instrumentation.Instrumentation;
import graphql.execution.instrumentation.SimplePerformantInstrumentation;
import graphql.execution.preparsed.NoOpPreparsedDocumentProvider;
import graphql.execution.preparsed.PreparsedDocumentProvider;
import graphql.kickstart.execution.config.DefaultExecutionStrategyProvider;
import graphql.kickstart.execution.config.ExecutionStrategyProvider;
import graphql.kickstart.execution.config.GraphQLBuilder;
import java.util.List;
import java.util.function.Supplier;

/**
 * @author Andrew Potter
 */
public class GraphQLQueryInvoker {

  private final Supplier<ExecutionStrategyProvider> getExecutionStrategyProvider;
  private final Supplier<Instrumentation> getInstrumentation;
  private final Supplier<PreparsedDocumentProvider> getPreparsedDocumentProvider;

  protected GraphQLQueryInvoker(
      Supplier<ExecutionStrategyProvider> getExecutionStrategyProvider,
      Supplier<Instrumentation> getInstrumentation,
      Supplier<PreparsedDocumentProvider> getPreparsedDocumentProvider) {
    this.getExecutionStrategyProvider = getExecutionStrategyProvider;
    this.getInstrumentation = getInstrumentation;
    this.getPreparsedDocumentProvider = getPreparsedDocumentProvider;
  }

  public static Builder newBuilder() {
    return new Builder();
  }

  public GraphQLInvoker toGraphQLInvoker() {
    GraphQLBuilder graphQLBuilder =
        new GraphQLBuilder()
            .executionStrategyProvider(getExecutionStrategyProvider)
            .instrumentation(getInstrumentation)
            .preparsedDocumentProvider(getPreparsedDocumentProvider);
    return new GraphQLInvoker(graphQLBuilder, new BatchedDataLoaderGraphQLBuilder());
  }

  public static class Builder {

    private Supplier<ExecutionStrategyProvider> getExecutionStrategyProvider =
        DefaultExecutionStrategyProvider::new;
    private Supplier<Instrumentation> getInstrumentation =
        () -> SimplePerformantInstrumentation.INSTANCE;
    private Supplier<PreparsedDocumentProvider> getPreparsedDocumentProvider =
        () -> NoOpPreparsedDocumentProvider.INSTANCE;

    public Builder withExecutionStrategyProvider(ExecutionStrategyProvider provider) {
      return withExecutionStrategyProvider(() -> provider);
    }

    public Builder withExecutionStrategyProvider(Supplier<ExecutionStrategyProvider> supplier) {
      this.getExecutionStrategyProvider = supplier;
      return this;
    }

    public Builder withInstrumentation(Instrumentation instrumentation) {
      return withInstrumentation(() -> instrumentation);
    }

    public Builder withInstrumentation(Supplier<Instrumentation> supplier) {
      this.getInstrumentation = supplier;
      return this;
    }

    public Builder with(List<Instrumentation> instrumentations) {
      if (instrumentations.isEmpty()) {
        return this;
      }
      if (instrumentations.size() == 1) {
        withInstrumentation(instrumentations.get(0));
      } else {
        withInstrumentation(new ChainedInstrumentation(instrumentations));
      }
      return this;
    }

    public Builder withPreparsedDocumentProvider(PreparsedDocumentProvider provider) {
      return withPreparsedDocumentProvider(() -> provider);
    }

    public Builder withPreparsedDocumentProvider(Supplier<PreparsedDocumentProvider> supplier) {
      this.getPreparsedDocumentProvider = supplier;
      return this;
    }

    public GraphQLQueryInvoker build() {
      return new GraphQLQueryInvoker(
          getExecutionStrategyProvider,
          getInstrumentation,
          getPreparsedDocumentProvider);
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLQueryResult.java
================================================
package graphql.kickstart.execution;

import static java.util.Collections.emptyList;

import graphql.ExecutionResult;
import java.util.List;

public interface GraphQLQueryResult {

  static GraphQLSingleQueryResult create(ExecutionResult result) {
    return new GraphQLSingleQueryResult(new DecoratedExecutionResult(result));
  }

  static GraphQLBatchedQueryResult create(List<ExecutionResult> results) {
    return new GraphQLBatchedQueryResult(results);
  }

  static GraphQLErrorQueryResult createError(int statusCode, String message) {
    return new GraphQLErrorQueryResult(statusCode, message);
  }

  boolean isBatched();

  boolean isAsynchronous();

  default DecoratedExecutionResult getResult() {
    return null;
  }

  default List<ExecutionResult> getResults() {
    return emptyList();
  }

  default boolean isError() {
    return false;
  }

  default int getStatusCode() {
    return 200;
  }

  default String getMessage() {
    return null;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLRequest.java
================================================
package graphql.kickstart.execution;

import static graphql.kickstart.execution.OperationNameExtractor.extractOperationName;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import graphql.introspection.IntrospectionQuery;
import java.util.HashMap;
import java.util.Map;

/** @author Andrew Potter */
@JsonIgnoreProperties(ignoreUnknown = true)
public class GraphQLRequest {

  private String query;

  @JsonDeserialize(using = VariablesDeserializer.class)
  private Map<String, Object> variables = new HashMap<>();

  @JsonDeserialize(using = ExtensionsDeserializer.class)
  private Map<String, Object> extensions = new HashMap<>();

  private String operationName;

  public GraphQLRequest() {}

  public GraphQLRequest(
      String query,
      Map<String, Object> variables,
      Map<String, Object> extensions,
      String operationName) {
    this.query = query;
    this.operationName = operationName;
    if (extensions != null) {
      this.extensions = extensions;
    }
    if (variables != null) {
      this.variables = variables;
    }
  }

  public static GraphQLRequest createIntrospectionRequest() {
    return new GraphQLRequest(
        IntrospectionQuery.INTROSPECTION_QUERY,
        new HashMap<>(),
        new HashMap<>(),
        "IntrospectionQuery");
  }

  public static GraphQLRequest createQueryOnlyRequest(String query) {
    return new GraphQLRequest(query, new HashMap<>(), new HashMap<>(), null);
  }

  public String getQuery() {
    return query;
  }

  public void setQuery(String query) {
    this.query = query;
  }

  public Map<String, Object> getVariables() {
    return variables;
  }

  public void setVariables(Map<String, Object> variables) {
    if (variables != null) {
      this.variables = variables;
    }
  }

  public Map<String, Object> getExtensions() {
    return extensions;
  }

  public void setExtensions(Map<String, Object> extensions) {
    if (extensions != null) {
      this.extensions = extensions;
    }
  }

  public String getOperationName() {
    return extractOperationName(query, operationName, null);
  }

  public void setOperationName(String operationName) {
    this.operationName = operationName;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLRootObjectBuilder.java
================================================
package graphql.kickstart.execution;

public interface GraphQLRootObjectBuilder {

  /** @return the graphql root object */
  Object build();
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLSingleQueryResult.java
================================================
package graphql.kickstart.execution;

import lombok.Getter;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
class GraphQLSingleQueryResult implements GraphQLQueryResult {

  @Getter private final DecoratedExecutionResult result;

  @Override
  public boolean isBatched() {
    return false;
  }

  @Override
  public boolean isAsynchronous() {
    return result.isAsynchronous();
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/ObjectMapDeserializationException.java
================================================
package graphql.kickstart.execution;

public class ObjectMapDeserializationException extends RuntimeException {

  ObjectMapDeserializationException(String message) {
    super(message);
  }

  ObjectMapDeserializationException(String message, Throwable cause) {
    super(message, cause);
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/ObjectMapDeserializeHelper.java
================================================
package graphql.kickstart.execution;

import com.fasterxml.jackson.core.ObjectCodec;
import com.fasterxml.jackson.core.type.TypeReference;
import java.io.IOException;
import java.util.Map;

public class ObjectMapDeserializeHelper {

  public static Map<String, Object> deserializeObjectMapObject(
      Object object, ObjectCodec codec, String fieldName) {
    if (object instanceof Map) {
      @SuppressWarnings("unchecked")
      Map<String, Object> genericObjectMap = (Map<String, Object>) object;
      return genericObjectMap;
    } else if (object instanceof String) {
      try {
        return codec.readValue(
            codec.getFactory().createParser((String) object),
            new TypeReference<Map<String, Object>>() {});
      } catch (IOException e) {
        throw new ObjectMapDeserializationException(
            String.format("Cannot deserialize field '%s'", fieldName), e);
      }
    } else {
      throw new ObjectMapDeserializationException(
          String.format("Field '%s' should be either an object or a string", fieldName));
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/OperationNameExtractor.java
================================================
package graphql.kickstart.execution;

import static graphql.kickstart.execution.StringUtils.isNotEmpty;

import graphql.language.Document;
import graphql.language.OperationDefinition;
import graphql.parser.InvalidSyntaxException;
import graphql.parser.Parser;
import java.util.List;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;

@NoArgsConstructor(access = AccessLevel.PRIVATE)
class OperationNameExtractor {

  static String extractOperationName(
      String gqlQuery, String requestedOperationName, String defaultIfNotFound) {
    if (isNotEmpty(requestedOperationName)) {
      return requestedOperationName;
    }
    if (isNotEmpty(gqlQuery)) {
      return parseForOperationName(gqlQuery, defaultIfNotFound);
    }
    return defaultIfNotFound;
  }

  private static String parseForOperationName(String gqlQuery, String defaultIfNotFound) {
    try {
      Document document = new Parser().parseDocument(gqlQuery);
      List<OperationDefinition> operations =
          document.getDefinitionsOfType(OperationDefinition.class);
      if (operations.size() == 1) {
        String name = operations.get(0).getName();
        if (isNotEmpty(name)) {
          return name;
        }
      }
    } catch (InvalidSyntaxException ignored) {
      // ignored
    }
    return defaultIfNotFound;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/StaticGraphQLRootObjectBuilder.java
================================================
package graphql.kickstart.execution;

public class StaticGraphQLRootObjectBuilder implements GraphQLRootObjectBuilder {

  private final Object rootObject;

  public StaticGraphQLRootObjectBuilder(Object rootObject) {
    this.rootObject = rootObject;
  }

  @Override
  public Object build() {
    return rootObject;
  }

  protected Object getRootObject() {
    return rootObject;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/StringUtils.java
================================================
package graphql.kickstart.execution;

import lombok.AccessLevel;
import lombok.NoArgsConstructor;

@NoArgsConstructor(access = AccessLevel.PRIVATE)
class StringUtils {

  static boolean isNotEmpty(CharSequence cs) {
    return !isEmpty(cs);
  }

  static boolean isEmpty(final CharSequence cs) {
    return cs == null || cs.length() == 0;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/VariablesDeserializer.java
================================================
package graphql.kickstart.execution;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.ObjectCodec;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import java.io.IOException;
import java.util.Map;

/** @author Andrew Potter */
public class VariablesDeserializer extends JsonDeserializer<Map<String, Object>> {

  public static Map<String, Object> deserializeVariablesObject(
      Object variables, ObjectCodec codec) {
    return ObjectMapDeserializeHelper.deserializeObjectMapObject(variables, codec, "variables");
  }

  @Override
  public Map<String, Object> deserialize(JsonParser p, DeserializationContext ctxt)
      throws IOException {
    return deserializeVariablesObject(p.readValueAs(Object.class), p.getCodec());
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/ConfiguringObjectMapperProvider.java
================================================
package graphql.kickstart.execution.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import graphql.kickstart.execution.error.DefaultGraphQLServletObjectMapperConfigurer;

public class ConfiguringObjectMapperProvider implements ObjectMapperProvider {

  private final ObjectMapper objectMapperTemplate;

  private final GraphQLServletObjectMapperConfigurer objectMapperConfigurer;

  public ConfiguringObjectMapperProvider(
      ObjectMapper objectMapperTemplate,
      GraphQLServletObjectMapperConfigurer objectMapperConfigurer) {
    this.objectMapperTemplate =
        objectMapperTemplate == null ? new ObjectMapper() : objectMapperTemplate;
    this.objectMapperConfigurer =
        objectMapperConfigurer == null
            ? new DefaultGraphQLServletObjectMapperConfigurer()
            : objectMapperConfigurer;
  }

  public ConfiguringObjectMapperProvider(ObjectMapper objectMapperTemplate) {
    this(objectMapperTemplate, null);
  }

  public ConfiguringObjectMapperProvider(
      GraphQLServletObjectMapperConfigurer objectMapperConfigurer) {
    this(null, objectMapperConfigurer);
  }

  public ConfiguringObjectMapperProvider() {
    this(null, null);
  }

  @Override
  public ObjectMapper provide() {
    ObjectMapper mapper = this.objectMapperTemplate.copy();
    this.objectMapperConfigurer.configure(mapper);
    return mapper;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/DefaultExecutionStrategyProvider.java
================================================
package graphql.kickstart.execution.config;

import graphql.execution.ExecutionStrategy;

/** @author Andrew Potter */
public class DefaultExecutionStrategyProvider implements ExecutionStrategyProvider {

  private final ExecutionStrategy queryExecutionStrategy;
  private final ExecutionStrategy mutationExecutionStrategy;
  private final ExecutionStrategy subscriptionExecutionStrategy;

  public DefaultExecutionStrategyProvider() {
    this(null);
  }

  public DefaultExecutionStrategyProvider(ExecutionStrategy executionStrategy) {
    this(executionStrategy, executionStrategy, null);
  }

  public DefaultExecutionStrategyProvider(
      ExecutionStrategy queryExecutionStrategy,
      ExecutionStrategy mutationExecutionStrategy,
      ExecutionStrategy subscriptionExecutionStrategy) {
    this.queryExecutionStrategy = queryExecutionStrategy;
    this.mutationExecutionStrategy = mutationExecutionStrategy;
    this.subscriptionExecutionStrategy = subscriptionExecutionStrategy;
  }

  @Override
  public ExecutionStrategy getQueryExecutionStrategy() {
    return queryExecutionStrategy;
  }

  @Override
  public ExecutionStrategy getMutationExecutionStrategy() {
    return mutationExecutionStrategy;
  }

  @Override
  public ExecutionStrategy getSubscriptionExecutionStrategy() {
    return subscriptionExecutionStrategy;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/DefaultGraphQLSchemaProvider.java
================================================
package graphql.kickstart.execution.config;

import graphql.schema.GraphQLSchema;

/** @author Andrew Potter */
public class DefaultGraphQLSchemaProvider implements GraphQLSchemaProvider {

  private final GraphQLSchema schema;
  private final GraphQLSchema readOnlySchema;

  public DefaultGraphQLSchemaProvider(GraphQLSchema schema) {
    this(schema, GraphQLSchemaProvider.copyReadOnly(schema));
  }

  public DefaultGraphQLSchemaProvider(GraphQLSchema schema, GraphQLSchema readOnlySchema) {
    this.schema = schema;
    this.readOnlySchema = readOnlySchema;
  }

  @Override
  public GraphQLSchema getSchema() {
    return schema;
  }

  @Override
  public GraphQLSchema getReadOnlySchema() {
    return readOnlySchema;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/ExecutionStrategyProvider.java
================================================
package graphql.kickstart.execution.config;

import graphql.execution.ExecutionStrategy;

public interface ExecutionStrategyProvider {

  ExecutionStrategy getQueryExecutionStrategy();

  ExecutionStrategy getMutationExecutionStrategy();

  ExecutionStrategy getSubscriptionExecutionStrategy();
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLBuilder.java
================================================
package graphql.kickstart.execution.config;

import graphql.GraphQL;
import graphql.execution.ExecutionStrategy;
import graphql.execution.instrumentation.Instrumentation;
import graphql.execution.instrumentation.SimplePerformantInstrumentation;
import graphql.execution.preparsed.NoOpPreparsedDocumentProvider;
import graphql.execution.preparsed.PreparsedDocumentProvider;
import graphql.schema.GraphQLSchema;
import java.util.function.Supplier;
import lombok.Getter;

public class GraphQLBuilder {

  private Supplier<ExecutionStrategyProvider> executionStrategyProviderSupplier =
      DefaultExecutionStrategyProvider::new;
  private Supplier<PreparsedDocumentProvider> preparsedDocumentProviderSupplier =
      () -> NoOpPreparsedDocumentProvider.INSTANCE;

  @Getter
  private Supplier<Instrumentation> instrumentationSupplier =
      () -> SimplePerformantInstrumentation.INSTANCE;

  private Supplier<GraphQLBuilderConfigurer> graphQLBuilderConfigurerSupplier = () -> builder -> {};

  public GraphQLBuilder executionStrategyProvider(Supplier<ExecutionStrategyProvider> supplier) {
    if (supplier != null) {
      executionStrategyProviderSupplier = supplier;
    }
    return this;
  }

  public GraphQLBuilder preparsedDocumentProvider(Supplier<PreparsedDocumentProvider> supplier) {
    if (supplier != null) {
      preparsedDocumentProviderSupplier = supplier;
    }
    return this;
  }

  public GraphQLBuilder instrumentation(Supplier<Instrumentation> supplier) {
    if (supplier != null) {
      instrumentationSupplier = supplier;
    }
    return this;
  }

  public GraphQLBuilder graphQLBuilderConfigurer(Supplier<GraphQLBuilderConfigurer> supplier) {
    if (supplier != null) {
      graphQLBuilderConfigurerSupplier = supplier;
    }
    return this;
  }

  public GraphQL build(GraphQLSchemaProvider schemaProvider) {
    return build(schemaProvider.getSchema());
  }

  public GraphQL build(GraphQLSchema schema) {
    return build(schema, instrumentationSupplier);
  }

  public GraphQL build(
      GraphQLSchema schema, Supplier<Instrumentation> configuredInstrumentationSupplier) {
    ExecutionStrategyProvider executionStrategyProvider = executionStrategyProviderSupplier.get();
    ExecutionStrategy queryExecutionStrategy =
        executionStrategyProvider.getQueryExecutionStrategy();
    ExecutionStrategy mutationExecutionStrategy =
        executionStrategyProvider.getMutationExecutionStrategy();
    ExecutionStrategy subscriptionExecutionStrategy =
        executionStrategyProvider.getSubscriptionExecutionStrategy();

    GraphQL.Builder builder =
        GraphQL.newGraphQL(schema)
            .preparsedDocumentProvider(preparsedDocumentProviderSupplier.get());

    if (queryExecutionStrategy != null) {
      builder.queryExecutionStrategy(queryExecutionStrategy);
    }

    if (mutationExecutionStrategy != null) {
      builder.mutationExecutionStrategy(mutationExecutionStrategy);
    }

    if (subscriptionExecutionStrategy != null) {
      builder.subscriptionExecutionStrategy(subscriptionExecutionStrategy);
    }

    Instrumentation instrumentation = configuredInstrumentationSupplier.get();
    builder.instrumentation(instrumentation);
    graphQLBuilderConfigurerSupplier.get().configure(builder);
    return builder.build();
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLBuilderConfigurer.java
================================================
package graphql.kickstart.execution.config;

import graphql.GraphQL;

public interface GraphQLBuilderConfigurer {

  void configure(GraphQL.Builder builder);
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLSchemaProvider.java
================================================
package graphql.kickstart.execution.config;

import graphql.schema.GraphQLObjectType;
import graphql.schema.GraphQLSchema;

public interface GraphQLSchemaProvider {

  static GraphQLSchema copyReadOnly(GraphQLSchema schema) {
    return GraphQLSchema.newSchema(schema).mutation((GraphQLObjectType) null).build();
  }

  /** @return a schema for handling mbean calls. */
  GraphQLSchema getSchema();

  GraphQLSchema getReadOnlySchema();
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLServletObjectMapperConfigurer.java
================================================
package graphql.kickstart.execution.config;

import com.fasterxml.jackson.databind.ObjectMapper;

/** @author Andrew Potter */
public interface GraphQLServletObjectMapperConfigurer {

  void configure(ObjectMapper mapper);
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/InstrumentationProvider.java
================================================
package graphql.kickstart.execution.config;

import graphql.execution.instrumentation.Instrumentation;

public interface InstrumentationProvider {

  Instrumentation getInstrumentation();
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/ObjectMapperProvider.java
================================================
package graphql.kickstart.execution.config;

import com.fasterxml.jackson.databind.ObjectMapper;

public interface ObjectMapperProvider {

  ObjectMapper provide();
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/ContextSetting.java
================================================
package graphql.kickstart.execution.context;

import graphql.kickstart.execution.GraphQLRequest;
import graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;
import graphql.kickstart.execution.input.PerQueryBatchedInvocationInput;
import graphql.kickstart.execution.input.PerRequestBatchedInvocationInput;
import graphql.schema.GraphQLSchema;
import java.util.List;
import java.util.function.Supplier;

/**
 * An enum representing possible context settings. These are modeled after Apollo's link settings.
 */
public enum ContextSetting {

  /**
   * A context object, and therefor dataloader registry and subject, should be shared between all
   * GraphQL executions in a http request.
   */
  PER_REQUEST,
  /** Each GraphQL execution should always have its own context. */
  PER_QUERY;

  /**
   * Creates a set of inputs with the correct context based on the setting.
   *
   * @param requests the GraphQL requests to execute.
   * @param schema the GraphQL schema to execute the requests against.
   * @param contextSupplier method that returns the context to use for each execution or for the
   *     request as a whole.
   * @param root the root object to use for each execution.
   * @return a configured batch input.
   */
  public GraphQLBatchedInvocationInput getBatch(
      List<GraphQLRequest> requests,
      GraphQLSchema schema,
      Supplier<GraphQLKickstartContext> contextSupplier,
      Object root) {
    switch (this) {
      case PER_QUERY:
        return new PerQueryBatchedInvocationInput(requests, schema, contextSupplier, root, this);
      case PER_REQUEST:
        return new PerRequestBatchedInvocationInput(requests, schema, contextSupplier, root, this);
      default:
        throw new ContextSettingNotConfiguredException();
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/ContextSettingNotConfiguredException.java
================================================
package graphql.kickstart.execution.context;

public class ContextSettingNotConfiguredException extends RuntimeException {

  ContextSettingNotConfiguredException() {
    super("Unconfigured context setting type");
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/DefaultGraphQLContext.java
================================================
package graphql.kickstart.execution.context;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import org.dataloader.DataLoaderRegistry;

/**
 * An object for the DefaultGraphQLContextBuilder to return. Can be extended to include more
 * context.
 */
public class DefaultGraphQLContext implements GraphQLKickstartContext {

  private final DataLoaderRegistry dataLoaderRegistry;
  private final Map<Object, Object> map;

  public DefaultGraphQLContext(DataLoaderRegistry dataLoaderRegistry, Map<Object, Object> map) {
    this.dataLoaderRegistry =
        Objects.requireNonNull(dataLoaderRegistry, "dataLoaderRegistry is required");
    this.map = Objects.requireNonNull(map, "map is required");
  }

  public DefaultGraphQLContext(Map<Object, Object> map) {
    this(new DataLoaderRegistry(), map);
  }

  public DefaultGraphQLContext(DataLoaderRegistry dataLoaderRegistry) {
    this(dataLoaderRegistry, new HashMap<>());
  }

  public DefaultGraphQLContext() {
    this(new DataLoaderRegistry());
  }

  public void put(Object key, Object value) {
    map.put(key, value);
  }

  @Override
  public DataLoaderRegistry getDataLoaderRegistry() {
    return dataLoaderRegistry;
  }

  @Override
  public Map<Object, Object> getMapOfContext() {
    return map;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/DefaultGraphQLContextBuilder.java
================================================
package graphql.kickstart.execution.context;

/** Returns an empty context. */
public class DefaultGraphQLContextBuilder implements GraphQLContextBuilder {

  @Override
  public GraphQLKickstartContext build() {
    return new DefaultGraphQLContext();
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/GraphQLContextBuilder.java
================================================
package graphql.kickstart.execution.context;

public interface GraphQLContextBuilder {

  /** @return the graphql context */
  GraphQLKickstartContext build();
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/GraphQLKickstartContext.java
================================================
package graphql.kickstart.execution.context;

import java.util.Map;
import lombok.NonNull;
import org.dataloader.DataLoaderRegistry;

/** Represents the context required by the servlet to execute a GraphQL request. */
public interface GraphQLKickstartContext {

  static GraphQLKickstartContext of(Map<Object, Object> map) {
    return new DefaultGraphQLContext(map);
  }

  static GraphQLKickstartContext of(DataLoaderRegistry dataLoaderRegistry) {
    return new DefaultGraphQLContext(dataLoaderRegistry);
  }

  static GraphQLKickstartContext of(
      DataLoaderRegistry dataLoaderRegistry, Map<Object, Object> map) {
    return new DefaultGraphQLContext(dataLoaderRegistry, map);
  }

  /** @return the Dataloader registry to use for the execution. Must not return <code>null</code> */
  @NonNull
  DataLoaderRegistry getDataLoaderRegistry();

  Map<Object, Object> getMapOfContext();
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/DefaultGraphQLErrorHandler.java
================================================
package graphql.kickstart.execution.error;

import graphql.ExceptionWhileDataFetching;
import graphql.GraphQLError;
import graphql.execution.NonNullableFieldWasNullError;
import java.util.List;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;

/** @author Andrew Potter */
@Slf4j
public class DefaultGraphQLErrorHandler implements GraphQLErrorHandler {

  @Override
  public List<GraphQLError> processErrors(List<GraphQLError> errors) {
    final List<GraphQLError> clientErrors = filterGraphQLErrors(errors);
    if (clientErrors.size() < errors.size()) {

      // Some errors were filtered out to hide implementation - put a generic error in place.
      clientErrors.add(new GenericGraphQLError("Internal Server Error(s) while executing query"));

      errors.stream().filter(error -> !isClientError(error)).forEach(this::logError);
    }

    return clientErrors;
  }

  protected void logError(GraphQLError error) {
    if (error instanceof Throwable) {
      log.error("Error executing query!", (Throwable) error);
    } else if (error instanceof ExceptionWhileDataFetching) {
      log.error(
          "Error executing query {}",
          error.getMessage(),
          ((ExceptionWhileDataFetching) error).getException());
    } else {
      log.error(
          "Error executing query ({}): {}", error.getClass().getSimpleName(), error.getMessage());
    }
  }

  protected List<GraphQLError> filterGraphQLErrors(List<GraphQLError> errors) {
    return errors.stream()
        .filter(this::isClientError)
        .map(this::replaceNonNullableFieldWasNullError)
        .collect(Collectors.toList());
  }

  protected boolean isClientError(GraphQLError error) {
    if (error instanceof ExceptionWhileDataFetching) {
      return ((ExceptionWhileDataFetching) error).getException() instanceof GraphQLError;
    }
    return true;
  }

  private GraphQLError replaceNonNullableFieldWasNullError(GraphQLError error) {
    if (error instanceof NonNullableFieldWasNullError) {
      return new RenderableNonNullableFieldWasNullError((NonNullableFieldWasNullError) error);
    } else {
      return error;
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/DefaultGraphQLServletObjectMapperConfigurer.java
================================================
package graphql.kickstart.execution.error;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import graphql.kickstart.execution.config.GraphQLServletObjectMapperConfigurer;

/** @author Andrew Potter */
public class DefaultGraphQLServletObjectMapperConfigurer
    implements GraphQLServletObjectMapperConfigurer {

  @Override
  public void configure(ObjectMapper mapper) {
    mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    mapper.setDefaultPropertyInclusion(JsonInclude.Include.ALWAYS);
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/GenericGraphQLError.java
================================================
package graphql.kickstart.execution.error;

import static java.util.Collections.emptyList;

import com.fasterxml.jackson.annotation.JsonIgnore;
import graphql.ErrorType;
import graphql.GraphQLError;
import graphql.language.SourceLocation;
import java.util.List;

/** @author Andrew Potter */
public class GenericGraphQLError implements GraphQLError {

  private final String message;

  public GenericGraphQLError(String message) {
    this.message = message;
  }

  @Override
  public String getMessage() {
    return message;
  }

  @Override
  @JsonIgnore
  public List<SourceLocation> getLocations() {
    return emptyList();
  }

  @Override
  @JsonIgnore
  public ErrorType getErrorType() {
    return null;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/GraphQLErrorHandler.java
================================================
package graphql.kickstart.execution.error;

import graphql.GraphQLError;
import java.util.List;

/** @author Andrew Potter */
public interface GraphQLErrorHandler {

  default boolean errorsPresent(List<GraphQLError> errors) {
    return errors != null && !errors.isEmpty();
  }

  List<GraphQLError> processErrors(List<GraphQLError> errors);
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/RenderableNonNullableFieldWasNullError.java
================================================
package graphql.kickstart.execution.error;

import com.fasterxml.jackson.annotation.JsonInclude;
import graphql.ErrorType;
import graphql.GraphQLError;
import graphql.execution.NonNullableFieldWasNullError;
import graphql.language.SourceLocation;
import java.util.List;
import java.util.Map;

class RenderableNonNullableFieldWasNullError implements GraphQLError {

  private final NonNullableFieldWasNullError delegate;

  public RenderableNonNullableFieldWasNullError(
      NonNullableFieldWasNullError nonNullableFieldWasNullError) {
    this.delegate = nonNullableFieldWasNullError;
  }

  @Override
  public String getMessage() {
    return delegate.getMessage();
  }

  @Override
  @JsonInclude(JsonInclude.Include.NON_NULL)
  public List<SourceLocation> getLocations() {
    return delegate.getLocations();
  }

  @Override
  public ErrorType getErrorType() {
    return delegate.getErrorType();
  }

  @Override
  public List<Object> getPath() {
    return delegate.getPath();
  }

  @Override
  public Map<String, Object> toSpecification() {
    return delegate.toSpecification();
  }

  @Override
  @JsonInclude(JsonInclude.Include.NON_NULL)
  public Map<String, Object> getExtensions() {
    return delegate.getExtensions();
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/GraphQLBatchedInvocationInput.java
================================================
package graphql.kickstart.execution.input;

import static java.util.stream.Collectors.toList;

import graphql.ExecutionInput;
import graphql.kickstart.execution.context.ContextSetting;
import java.util.List;

/** Interface representing a batched input. */
public interface GraphQLBatchedInvocationInput extends GraphQLInvocationInput {

  /** @return each individual input in the batch, configured with a context. */
  List<GraphQLSingleInvocationInput> getInvocationInputs();

  default List<ExecutionInput> getExecutionInputs() {
    return getInvocationInputs().stream()
        .map(GraphQLSingleInvocationInput::getExecutionInput)
        .collect(toList());
  }

  ContextSetting getContextSetting();

}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/GraphQLInvocationInput.java
================================================
package graphql.kickstart.execution.input;

import java.util.List;

public interface GraphQLInvocationInput {
  List<String> getQueries();
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/GraphQLSingleInvocationInput.java
================================================
package graphql.kickstart.execution.input;

import static java.util.Collections.singletonList;

import graphql.ExecutionInput;
import graphql.execution.ExecutionId;
import graphql.kickstart.execution.GraphQLRequest;
import graphql.kickstart.execution.context.GraphQLKickstartContext;
import graphql.schema.GraphQLSchema;
import java.util.List;

/** Represents a single GraphQL execution. */
public class GraphQLSingleInvocationInput implements GraphQLInvocationInput {

  private final GraphQLSchema schema;

  private final ExecutionInput executionInput;

  public GraphQLSingleInvocationInput(
      GraphQLRequest request, GraphQLSchema schema, GraphQLKickstartContext context, Object root) {
    this.schema = schema;
    this.executionInput = createExecutionInput(request, context, root);
  }

  /** @return the schema to use to execute this query. */
  public GraphQLSchema getSchema() {
    return schema;
  }

  private ExecutionInput createExecutionInput(
      GraphQLRequest graphQLRequest, GraphQLKickstartContext context, Object root) {
    return ExecutionInput.newExecutionInput()
        .query(graphQLRequest.getQuery())
        .operationName(graphQLRequest.getOperationName())
        .context(context)
        .graphQLContext(context.getMapOfContext())
        .root(root)
        .variables(graphQLRequest.getVariables())
        .extensions(graphQLRequest.getExtensions())
        .dataLoaderRegistry(context.getDataLoaderRegistry())
        .executionId(ExecutionId.generate())
        .build();
  }

  public ExecutionInput getExecutionInput() {
    return executionInput;
  }

  @Override
  public List<String> getQueries() {
    return singletonList(executionInput.getQuery());
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/PerQueryBatchedInvocationInput.java
================================================
package graphql.kickstart.execution.input;

import static java.util.stream.Collectors.toList;

import graphql.kickstart.execution.GraphQLRequest;
import graphql.kickstart.execution.context.ContextSetting;
import graphql.kickstart.execution.context.GraphQLKickstartContext;
import graphql.schema.GraphQLSchema;
import java.util.List;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import lombok.Getter;

/** A Collection of GraphQLSingleInvocationInput that each have a unique context object. */
@Getter
public class PerQueryBatchedInvocationInput implements GraphQLBatchedInvocationInput {

  private final List<GraphQLSingleInvocationInput> invocationInputs;
  private final ContextSetting contextSetting;

  public PerQueryBatchedInvocationInput(
      List<GraphQLRequest> requests,
      GraphQLSchema schema,
      Supplier<GraphQLKickstartContext> contextSupplier,
      Object root,
      ContextSetting contextSetting) {
    invocationInputs =
        requests.stream()
            .map(
                request ->
                    new GraphQLSingleInvocationInput(request, schema, contextSupplier.get(), root))
            .collect(Collectors.toList());
    this.contextSetting = contextSetting;
  }

  @Override
  public List<String> getQueries() {
    return invocationInputs.stream()
        .map(GraphQLSingleInvocationInput::getQueries)
        .flatMap(List::stream)
        .collect(toList());
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/PerRequestBatchedInvocationInput.java
================================================
package graphql.kickstart.execution.input;

import static java.util.stream.Collectors.toList;

import graphql.kickstart.execution.GraphQLRequest;
import graphql.kickstart.execution.context.ContextSetting;
import graphql.kickstart.execution.context.GraphQLKickstartContext;
import graphql.schema.GraphQLSchema;
import java.util.List;
import java.util.function.Supplier;
import lombok.Getter;

/** A collection of GraphQLSingleInvocationInputs that share a context object. */
@Getter
public class PerRequestBatchedInvocationInput implements GraphQLBatchedInvocationInput {

  private final List<GraphQLSingleInvocationInput> invocationInputs;
  private final ContextSetting contextSetting;

  public PerRequestBatchedInvocationInput(
      List<GraphQLRequest> requests,
      GraphQLSchema schema,
      Supplier<GraphQLKickstartContext> contextSupplier,
      Object root,
      ContextSetting contextSetting) {
    GraphQLKickstartContext context = contextSupplier.get();
    invocationInputs =
        requests.stream()
            .map(request -> new GraphQLSingleInvocationInput(request, schema, context, root))
            .collect(toList());
    this.contextSetting = contextSetting;
  }

  @Override
  public List<String> getQueries() {
    return invocationInputs.stream()
        .map(GraphQLSingleInvocationInput::getQueries)
        .flatMap(List::stream)
        .collect(toList());
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/AbstractTrackingApproach.java
================================================
package graphql.kickstart.execution.instrumentation;

import graphql.ExecutionResult;
import graphql.execution.ExecutionId;
import graphql.execution.FieldValueInfo;
import graphql.execution.ResultPath;
import graphql.execution.instrumentation.ExecutionStrategyInstrumentationContext;
import graphql.execution.instrumentation.InstrumentationContext;
import graphql.execution.instrumentation.parameters.InstrumentationExecutionStrategyParameters;
import graphql.execution.instrumentation.parameters.InstrumentationFieldFetchParameters;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import lombok.extern.slf4j.Slf4j;
import org.dataloader.DataLoaderRegistry;

/** Handles logic common to tracking approaches. */
@Slf4j
public abstract class AbstractTrackingApproach implements TrackingApproach {

  private final DataLoaderRegistry dataLoaderRegistry;

  private final RequestStack stack = new RequestStack();

  protected AbstractTrackingApproach(DataLoaderRegistry dataLoaderRegistry) {
    this.dataLoaderRegistry = dataLoaderRegistry;
  }

  /** @return allows extending classes to modify the stack. */
  protected RequestStack getStack() {
    return stack;
  }

  @Override
  public ExecutionStrategyInstrumentationContext beginExecutionStrategy(
      InstrumentationExecutionStrategyParameters parameters) {
    ExecutionId executionId = parameters.getExecutionContext().getExecutionId();
    ResultPath path = parameters.getExecutionStrategyParameters().getPath();
    int parentLevel = path.getLevel();
    int curLevel = parentLevel + 1;
    int fieldCount = parameters.getExecutionStrategyParameters().getFields().size();
    synchronized (stack) {
      stack.increaseExpectedFetchCount(executionId, curLevel, fieldCount);
      stack.increaseHappenedStrategyCalls(executionId, curLevel);
    }

    return new ExecutionStrategyInstrumentationContext() {
      @Override
      public void onDispatched() {
        // default empty implementation
      }

      @Override
      public void onCompleted(ExecutionResult result, Throwable t) {
        // default empty implementation
      }

      @Override
      public void onFieldValuesInfo(List<FieldValueInfo> fieldValueInfoList) {
        synchronized (stack) {
          stack.setStatus(
              executionId,
              handleOnFieldValuesInfo(fieldValueInfoList, stack, executionId, curLevel));
          if (stack.allReady()) {
            dispatchWithoutLocking();
          }
        }
      }
    };
  }

  //
  // thread safety : called with synchronised(stack)
  //
  private boolean handleOnFieldValuesInfo(
      List<FieldValueInfo> fieldValueInfoList,
      RequestStack stack,
      ExecutionId executionId,
      int curLevel) {
    stack.increaseHappenedOnFieldValueCalls(executionId, curLevel);
    int expectedStrategyCalls = 0;
    for (FieldValueInfo fieldValueInfo : fieldValueInfoList) {
      if (fieldValueInfo.getCompleteValueType() == FieldValueInfo.CompleteValueType.OBJECT) {
        expectedStrategyCalls++;
      } else if (fieldValueInfo.getCompleteValueType() == FieldValueInfo.CompleteValueType.LIST) {
        expectedStrategyCalls += getCountForList(fieldValueInfo);
      }
    }
    stack.increaseExpectedStrategyCalls(executionId, curLevel + 1, expectedStrategyCalls);
    return dispatchIfNeeded(stack, executionId, curLevel + 1);
  }

  private int getCountForList(FieldValueInfo fieldValueInfo) {
    int result = 0;
    for (FieldValueInfo cvi : fieldValueInfo.getFieldValueInfos()) {
      if (cvi.getCompleteValueType() == FieldValueInfo.CompleteValueType.OBJECT) {
        result++;
      } else if (cvi.getCompleteValueType() == FieldValueInfo.CompleteValueType.LIST) {
        result += getCountForList(cvi);
      }
    }
    return result;
  }

  @Override
  public InstrumentationContext<Object> beginFieldFetch(
      InstrumentationFieldFetchParameters parameters) {
    ExecutionId executionId = parameters.getExecutionContext().getExecutionId();
    ResultPath path = parameters.getEnvironment().getExecutionStepInfo().getPath();
    int level = path.getLevel();
    return new InstrumentationContext<Object>() {

      @Override
      public void onDispatched() {
        synchronized (stack) {
          stack.increaseFetchCount(executionId, level);
          stack.setStatus(executionId, dispatchIfNeeded(stack, executionId, level));

          if (stack.allReady()) {
            dispatchWithoutLocking();
          }
        }
      }

      @Override
      public void onCompleted(Object result, Throwable t) {
        // default empty implementation
      }
    };
  }

  @Override
  public void removeTracking(ExecutionId executionId) {
    synchronized (stack) {
      stack.removeExecution(executionId);
      if (stack.allReady()) {
        dispatchWithoutLocking();
      }
    }
  }

  //
  // thread safety : called with synchronised(stack)
  //
  private boolean dispatchIfNeeded(RequestStack stack, ExecutionId executionId, int level) {
    if (levelReady(stack, executionId, level)) {
      return stack.dispatchIfNotDispatchedBefore(executionId, level);
    }
    return false;
  }

  //
  // thread safety : called with synchronised(stack)
  //
  private boolean levelReady(RequestStack stack, ExecutionId executionId, int level) {
    if (level == 1) {
      // level 1 is special: there is only one strategy call and that's it
      return stack.allFetchesHappened(executionId, 1);
    }
    return (levelReady(stack, executionId, level - 1)
        && stack.allOnFieldCallsHappened(executionId, level - 1)
        && stack.allStrategyCallsHappened(executionId, level)
        && stack.allFetchesHappened(executionId, level));
  }

  @Override
  public void dispatch() {
    synchronized (stack) {
      dispatchWithoutLocking();
    }
  }

  private void dispatchWithoutLocking() {
    log.debug("Dispatching data loaders ({})", dataLoaderRegistry.getKeys());
    dataLoaderRegistry.dispatchAll();
    stack.allReset();
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/DataLoaderDispatcherInstrumentationState.java
================================================
package graphql.kickstart.execution.instrumentation;

import graphql.execution.ExecutionId;
import graphql.execution.instrumentation.InstrumentationState;
import org.dataloader.DataLoaderRegistry;

/** A base class that keeps track of whether aggressive batching can be used */
public class DataLoaderDispatcherInstrumentationState implements InstrumentationState {

  private final TrackingApproach approach;
  private final DataLoaderRegistry dataLoaderRegistry;
  private final boolean hasNoDataLoaders;
  private boolean aggressivelyBatching = true;

  public DataLoaderDispatcherInstrumentationState(
      DataLoaderRegistry dataLoaderRegistry, TrackingApproach approach, ExecutionId executionId) {

    this.dataLoaderRegistry = dataLoaderRegistry;
    this.approach = approach;
    approach.createState(executionId);
    hasNoDataLoaders = dataLoaderRegistry.getKeys().isEmpty();
  }

  boolean isAggressivelyBatching() {
    return aggressivelyBatching;
  }

  void setAggressivelyBatching(boolean aggressivelyBatching) {
    this.aggressivelyBatching = aggressivelyBatching;
  }

  TrackingApproach getApproach() {
    return approach;
  }

  DataLoaderRegistry getDataLoaderRegistry() {
    return dataLoaderRegistry;
  }

  boolean hasNoDataLoaders() {
    return hasNoDataLoaders;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/FieldLevelTrackingApproach.java
================================================
package graphql.kickstart.execution.instrumentation;

import graphql.Internal;
import graphql.execution.ExecutionId;
import graphql.execution.instrumentation.InstrumentationState;
import org.dataloader.DataLoaderRegistry;

/**
 * This approach uses field level tracking to achieve its aims of making the data loader more
 * efficient. Can handle new/concurrent executions using the same sets of dataloaders, attempting to
 * batch load calls together.
 */
@Internal
public class FieldLevelTrackingApproach extends AbstractTrackingApproach {

  public FieldLevelTrackingApproach(DataLoaderRegistry dataLoaderRegistry) {
    super(dataLoaderRegistry);
  }

  public InstrumentationState createState(ExecutionId executionId) {
    synchronized (getStack()) {
      if (getStack().contains(executionId)) {
        throw new TrackingApproachException(
            String.format("Execution id %s already in active execution", executionId));
      }
      getStack().addExecution(executionId);
      return null;
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/NoOpInstrumentationProvider.java
================================================
package graphql.kickstart.execution.instrumentation;

import graphql.execution.instrumentation.Instrumentation;
import graphql.execution.instrumentation.SimplePerformantInstrumentation;
import graphql.kickstart.execution.config.InstrumentationProvider;

public class NoOpInstrumentationProvider implements InstrumentationProvider {

  @Override
  public Instrumentation getInstrumentation() {
    return SimplePerformantInstrumentation.INSTANCE;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/RequestLevelTrackingApproach.java
================================================
package graphql.kickstart.execution.instrumentation;

import graphql.execution.ExecutionId;
import graphql.execution.instrumentation.InstrumentationState;
import java.util.List;
import org.dataloader.DataLoaderRegistry;

/** Dispatching approach that expects to know about all executions before execution starts. */
public class RequestLevelTrackingApproach extends AbstractTrackingApproach {

  public RequestLevelTrackingApproach(
      List<ExecutionId> executionIds, DataLoaderRegistry dataLoaderRegistry) {
    super(dataLoaderRegistry);
    RequestStack requestStack = getStack();
    executionIds.forEach(requestStack::addExecution);
  }

  @Override
  public InstrumentationState createState(ExecutionId executionId) {
    if (!getStack().contains(executionId)) {
      throw new TrackingApproachException(
          String.format("Request tracking not set up with execution id %s", executionId));
    }
    return null;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/RequestStack.java
================================================
package graphql.kickstart.execution.instrumentation;

import graphql.Assert;
import graphql.execution.ExecutionId;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/** Manages sets of call stack state for ongoing executions. */
public class RequestStack {

  private final Map<ExecutionId, CallStack> activeRequests = new LinkedHashMap<>();

  private final Map<ExecutionId, Boolean> status = new LinkedHashMap<>();

  /**
   * Sets the status indicating if a specific execution is ready for dispatching.
   *
   * @param executionId must be an active execution
   * @param toState if ready to dispatch
   */
  public void setStatus(ExecutionId executionId, boolean toState) {
    if (!activeRequests.containsKey(executionId)) {
      throw new IllegalStateException(
          String.format(
              "Can not set status for execution %s, it is not managed by this request stack",
              executionId));
    }
    if (toState) {
      status.put(executionId, true);
    }
  }

  /** @return if all managed executions are ready to be dispatched. */
  public boolean allReady() {
    return status.values().stream().noneMatch(Boolean.FALSE::equals)
        && activeRequests.values().stream().map(CallStack::getDispatchedLevels).distinct().count()
            <= 1;
  }

  /** Removes all dispatch status. Should be used after a call to dispatch. */
  public void allReset() {
    status.keySet().forEach(key -> status.put(key, false));
  }

  /**
   * Returns if this RequestStack is managing an execution for the supplied id.
   *
   * @param executionId no restrictions
   * @return if an active execution
   */
  public boolean contains(ExecutionId executionId) {
    return activeRequests.containsKey(executionId);
  }

  /**
   * Removes any state associated with an id.
   *
   * @param executionId no restrictions
   */
  public void removeExecution(ExecutionId executionId) {
    activeRequests.remove(executionId);
    status.remove(executionId);
  }

  /**
   * Creates a call stack for an associated id.
   *
   * @param executionId can not already be managed by this RequestStack
   */
  public void addExecution(ExecutionId executionId) {
    if (activeRequests.containsKey(executionId)) {
      throw new IllegalStateException(
          String.format("An execution already exists for %s, can not create one", executionId));
    }
    CallStack callStack = new CallStack();
    status.put(executionId, false);
    activeRequests.put(executionId, callStack);
  }

  /**
   * Increases the expected fetch count for an execution.
   *
   * @param executionId must be managed by this RequestStack
   * @param curLevel the level to increase the expected count
   * @param fieldCount the amount to increase the expected amount
   */
  public void increaseExpectedFetchCount(ExecutionId executionId, int curLevel, int fieldCount) {
    if (!activeRequests.containsKey(executionId)) {
      throw new IllegalStateException(
          String.format(
              "Execution %s not managed by this RequestStack, can not increase expected fetch count",
              executionId));
    }
    activeRequests.get(executionId).increaseExpectedFetchCount(curLevel, fieldCount);
  }

  /**
   * Increments happened strategy calls for an execution at specified level.
   *
   * @param executionId must be managed by this RequestStack
   * @param curLevel level to increment
   */
  public void increaseHappenedStrategyCalls(ExecutionId executionId, int curLevel) {
    if (!activeRequests.containsKey(executionId)) {
      throw new IllegalStateException(
          String.format(
              "Execution %s not managed by this RequestStack, can not increase happened happened strategy calls",
              executionId));
    }
    activeRequests.get(executionId).increaseHappenedStrategyCalls(curLevel);
  }

  /**
   * Increments happened on field value calls for an execution at a specified level.
   *
   * @param executionId must be managed by this RequestStack
   * @param curLevel level to increment
   */
  public void increaseHappenedOnFieldValueCalls(ExecutionId executionId, int curLevel) {
    if (!activeRequests.containsKey(executionId)) {
      throw new IllegalStateException(
          String.format(
              "Execution %s not managed by this RequestStack, can not increase happened on field calls",
              executionId));
    }
    activeRequests.get(executionId).increaseHappenedOnFieldValueCalls(curLevel);
  }

  /**
   * Increases expected strategy calls for an execution at a specified level.
   *
   * @param executionId must be managed by this RequestStack
   * @param curLevel level to increase
   * @param expectedStrategyCalls number to increment by
   */
  public void increaseExpectedStrategyCalls(
      ExecutionId executionId, int curLevel, int expectedStrategyCalls) {
    if (!activeRequests.containsKey(executionId)) {
      throw new IllegalStateException(
          String.format(
              "Execution %s not managed by this RequestStack, can not increase expected strategy calls",
              executionId));
    }
    activeRequests.get(executionId).increaseExpectedStrategyCalls(curLevel, expectedStrategyCalls);
  }

  /**
   * Get the all fetches happened value for an execution at a specific level.
   *
   * @param executionId must be managed by this RequestStack
   * @param level the level to get the value of
   * @return allFetchesHappened
   */
  public boolean allFetchesHappened(ExecutionId executionId, int level) {
    if (!activeRequests.containsKey(executionId)) {
      throw new IllegalStateException(
          String.format(
              "Execution %s not managed by this RequestStack, can not get all fetches happened value",
              executionId));
    }
    return activeRequests.get(executionId).allFetchesHappened(level);
  }

  /**
   * Get the all on field calls happened for an exectuion at a specific level.
   *
   * @param executionId must be managed by this RequestStack
   * @param level the level to get the value of
   * @return allOnFieldCallsHappened
   */
  public boolean allOnFieldCallsHappened(ExecutionId executionId, int level) {
    if (!activeRequests.containsKey(executionId)) {
      throw new IllegalStateException(
          String.format(
              "Execution %s not managed by this RequestStack, can not get all on field calls happened value",
              executionId));
    }
    return activeRequests.get(executionId).allOnFieldCallsHappened(level);
  }

  /**
   * Get the all strategy calls happened value for an exectuion at a specific level.
   *
   * @param executionId must be managed by this RequestStack
   * @param level the level to get the value of
   * @return allStrategyCallsHappened
   */
  public boolean allStrategyCallsHappened(ExecutionId executionId, int level) {
    if (!activeRequests.containsKey(executionId)) {
      throw new IllegalStateException(
          String.format(
              "Execution %s not managed by this RequestStack, can not get all strategy calls happened value",
              executionId));
    }
    return activeRequests.get(executionId).allStrategyCallsHappened(level);
  }

  /**
   * Get the dispatch if not dispatched before value of a specific level.
   *
   * @param executionId must be managed by this RequestStack
   * @param level the level to get the value of
   * @return dispatchIfNotDispattchedBefore
   */
  public boolean dispatchIfNotDispatchedBefore(ExecutionId executionId, int level) {
    if (!activeRequests.containsKey(executionId)) {
      throw new IllegalStateException(
          String.format(
              "Execution %s not managed by this RequestStack, can not get dispatch if not dispatched before value",
              executionId));
    }
    return activeRequests.get(executionId).dispatchIfNotDispatchedBefore(level);
  }

  /**
   * Increment the fetch count for an execution at a specific level.
   *
   * @param executionId must be managed by this RequestStack
   * @param level the level to increment
   */
  public void increaseFetchCount(ExecutionId executionId, int level) {
    if (!activeRequests.containsKey(executionId)) {
      throw new IllegalStateException(
          String.format(
              "Execution %s not managed by this RequestStack, can not increase fetch count",
              executionId));
    }
    activeRequests.get(executionId).increaseFetchCount(level);
  }

  /**
   * Clear and mark current level as ready for an execution.
   *
   * @param executionId must be managed by this RequestStack
   * @param level the level to clear and mark
   */
  public void clearAndMarkCurrentLevelAsReady(ExecutionId executionId, int level) {
    if (!activeRequests.containsKey(executionId)) {
      throw new IllegalStateException(
          String.format(
              "Execution %s not managed by this RequestStack, can not clea and mark current level as ready",
              executionId));
    }
    activeRequests.get(executionId).clearAndMarkCurrentLevelAsReady(level);
  }

  private static class CallStack {

    private final Map<Integer, Integer> expectedFetchCountPerLevel = new LinkedHashMap<>();
    private final Map<Integer, Integer> fetchCountPerLevel = new LinkedHashMap<>();
    private final Map<Integer, Integer> expectedStrategyCallsPerLevel = new LinkedHashMap<>();
    private final Map<Integer, Integer> happenedStrategyCallsPerLevel = new LinkedHashMap<>();
    private final Map<Integer, Integer> happenedOnFieldValueCallsPerLevel = new LinkedHashMap<>();

    private final List<Integer> dispatchedLevels = new ArrayList<>();

    private CallStack() {
      expectedStrategyCallsPerLevel.put(1, 1);
    }

    private void increaseExpectedFetchCount(int level, int count) {
      expectedFetchCountPerLevel.put(
          level, expectedFetchCountPerLevel.getOrDefault(level, 0) + count);
    }

    private void increaseFetchCount(int level) {
      fetchCountPerLevel.put(level, fetchCountPerLevel.getOrDefault(level, 0) + 1);
    }

    private void increaseExpectedStrategyCalls(int level, int count) {
      expectedStrategyCallsPerLevel.put(
          level, expectedStrategyCallsPerLevel.getOrDefault(level, 0) + count);
    }

    private void increaseHappenedStrategyCalls(int level) {
      happenedStrategyCallsPerLevel.put(
          level, happenedStrategyCallsPerLevel.getOrDefault(level, 0) + 1);
    }

    private void increaseHappenedOnFieldValueCalls(int level) {
      happenedOnFieldValueCallsPerLevel.put(
          level, happenedOnFieldValueCallsPerLevel.getOrDefault(level, 0) + 1);
    }

    private boolean allStrategyCallsHappened(int level) {
      return Objects.equals(
          happenedStrategyCallsPerLevel.get(level), expectedStrategyCallsPerLevel.get(level));
    }

    private boolean allOnFieldCallsHappened(int level) {
      return Objects.equals(
          happenedOnFieldValueCallsPerLevel.get(level), expectedStrategyCallsPerLevel.get(level));
    }

    private boolean allFetchesHappened(int level) {
      return Objects.equals(fetchCountPerLevel.get(level), expectedFetchCountPerLevel.get(level));
    }

    private List<Integer> getDispatchedLevels() {
      return dispatchedLevels;
    }

    @Override
    public String toString() {
      return "CallStack{"
          + "expectedFetchCountPerLevel="
          + expectedFetchCountPerLevel
          + ", fetchCountPerLevel="
          + fetchCountPerLevel
          + ", expectedStrategyCallsPerLevel="
          + expectedStrategyCallsPerLevel
          + ", happenedStrategyCallsPerLevel="
          + happenedStrategyCallsPerLevel
          + ", happenedOnFieldValueCallsPerLevel="
          + happenedOnFieldValueCallsPerLevel
          + ", dispatchedLevels"
          + dispatchedLevels
          + '}';
    }

    private boolean dispatchIfNotDispatchedBefore(int level) {
      if (dispatchedLevels.contains(level)) {
        Assert.assertShouldNeverHappen("level " + level + " already dispatched");
        return false;
      }
      dispatchedLevels.add(level);
      return true;
    }

    private void clearAndMarkCurrentLevelAsReady(int level) {
      expectedFetchCountPerLevel.clear();
      fetchCountPerLevel.clear();
      expectedStrategyCallsPerLevel.clear();
      happenedStrategyCallsPerLevel.clear();
      happenedOnFieldValueCallsPerLevel.clear();
      dispatchedLevels.clear();

      // make sure the level is ready
      expectedFetchCountPerLevel.put(level, 1);
      expectedStrategyCallsPerLevel.put(level, 1);
      happenedStrategyCallsPerLevel.put(level, 1);
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/TrackingApproach.java
================================================
package graphql.kickstart.execution.instrumentation;

import graphql.execution.ExecutionId;
import graphql.execution.instrumentation.ExecutionStrategyInstrumentationContext;
import graphql.execution.instrumentation.InstrumentationContext;
import graphql.execution.instrumentation.InstrumentationState;
import graphql.execution.instrumentation.parameters.InstrumentationExecutionStrategyParameters;
import graphql.execution.instrumentation.parameters.InstrumentationFieldFetchParameters;

public interface TrackingApproach extends InstrumentationState {

  /**
   * Handles creating any state for DataLoaderDispatcherInstrumentation
   *
   * @param executionId the execution to create state for.
   * @return individual state, if any for the execution.
   */
  InstrumentationState createState(ExecutionId executionId);

  /** Dispatch dataloaders and clean up state. */
  void dispatch();

  /**
   * Handles approach specific logic for DataLoaderDispatcherInstrumentation.
   *
   * @param parameters parameters supplied to DataLoaderDispatcherInstrumentation
   * @return the instrumented context
   */
  ExecutionStrategyInstrumentationContext beginExecutionStrategy(
      InstrumentationExecutionStrategyParameters parameters);

  /**
   * Handles approach specific logic for DataLoaderDispatcherInstrumentation.
   *
   * @param parameters parameters supplied to DataLoaderDispatcherInstrumentation
   * @return the instrumented context
   */
  InstrumentationContext<Object> beginFieldFetch(InstrumentationFieldFetchParameters parameters);

  /**
   * Removes tracking state for an execution.
   *
   * @param executionId the execution to remove state for
   */
  void removeTracking(ExecutionId executionId);
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/TrackingApproachException.java
================================================
package graphql.kickstart.execution.instrumentation;

public class TrackingApproachException extends RuntimeException {

  TrackingApproachException(String message) {
    super(message);
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/AtomicSubscriptionSubscription.java
================================================
package graphql.kickstart.execution.subscriptions;

import java.util.concurrent.atomic.AtomicReference;
import org.reactivestreams.Subscription;

public class AtomicSubscriptionSubscription {

  private final AtomicReference<Subscription> reference = new AtomicReference<>(null);

  public void set(Subscription subscription) {
    if (reference.get() != null) {
      throw new IllegalStateException("Cannot overwrite subscription!");
    }

    reference.set(subscription);
  }

  public Subscription get() {
    Subscription subscription = reference.get();
    if (subscription == null) {
      throw new IllegalStateException("Subscription has not been initialized yet!");
    }

    return subscription;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/DefaultSubscriptionSession.java
================================================
package graphql.kickstart.execution.subscriptions;

import graphql.ExecutionResult;
import graphql.execution.reactive.SingleSubscriberPublisher;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscription;

@Slf4j
@RequiredArgsConstructor
public class DefaultSubscriptionSession implements SubscriptionSession {

  @Getter private final GraphQLSubscriptionMapper mapper;
  private SingleSubscriberPublisher<String> publisher = new SingleSubscriberPublisher<>();
  private SessionSubscriptions subscriptions = new SessionSubscriptions();

  @Override
  public void send(String message) {
    Objects.requireNonNull(message, "message is required");
    publisher.offer(message);
  }

  @Override
  public void sendMessage(Object payload) {
    Objects.requireNonNull(payload, "payload is required");
    send(mapper.serialize(payload));
  }

  @Override
  public void subscribe(String id, Publisher<ExecutionResult> dataPublisher) {
    dataPublisher.subscribe(new SessionSubscriber(this, id));
  }

  @Override
  public void add(String id, Subscription subscription) {
    subscriptions.add(id, subscription);
  }

  @Override
  public void unsubscribe(String id) {
    subscriptions.cancel(id);
  }

  @Override
  public void sendDataMessage(String id, Object payload) {
    send(mapper.serialize(payload));
  }

  @Override
  public void sendErrorMessage(String id, Object payload) {
    send(mapper.serialize(payload));
  }

  @Override
  public void sendCompleteMessage(String id) {
    // default empty implementation
  }

  @Override
  public void close(String reason) {
    log.debug("Closing subscription session {}", getId());
    subscriptions.close();
    publisher.noMoreData();
  }

  @Override
  public Map<String, Object> getUserProperties() {
    return new HashMap<>();
  }

  @Override
  public boolean isOpen() {
    return true;
  }

  @Override
  public String getId() {
    return null;
  }

  @Override
  public SessionSubscriptions getSubscriptions() {
    return subscriptions;
  }

  @Override
  public Object unwrap() {
    throw new UnsupportedOperationException();
  }

  @Override
  public Publisher<String> getPublisher() {
    return publisher;
  }

  @Override
  public String toString() {
    return getId();
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/GraphQLSubscriptionInvocationInputFactory.java
================================================
package graphql.kickstart.execution.subscriptions;

import graphql.kickstart.execution.GraphQLRequest;
import graphql.kickstart.execution.input.GraphQLSingleInvocationInput;

public interface GraphQLSubscriptionInvocationInputFactory {

  GraphQLSingleInvocationInput create(GraphQLRequest graphQLRequest, SubscriptionSession session);
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/GraphQLSubscriptionMapper.java
================================================
package graphql.kickstart.execution.subscriptions;

import com.fasterxml.jackson.core.JsonProcessingException;
import graphql.ExecutionResult;
import graphql.GraphQLException;
import graphql.kickstart.execution.GraphQLObjectMapper;
import graphql.kickstart.execution.GraphQLRequest;
import java.util.Map;
import java.util.Objects;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
public class GraphQLSubscriptionMapper {

  private final GraphQLObjectMapper graphQLObjectMapper;

  public GraphQLRequest readGraphQLRequest(String payload) {
    Objects.requireNonNull(payload, "Payload is required");
    try {
      return graphQLObjectMapper.getJacksonMapper().readValue(payload, GraphQLRequest.class);
    } catch (JsonProcessingException e) {
      throw new GraphQLException("Cannot read GraphQL request from payload '" + payload + "'", e);
    }
  }

  public GraphQLRequest convertGraphQLRequest(Object payload) {
    Objects.requireNonNull(payload, "Payload is required");
    return graphQLObjectMapper.getJacksonMapper().convertValue(payload, GraphQLRequest.class);
  }

  public ExecutionResult sanitizeErrors(ExecutionResult executionResult) {
    return graphQLObjectMapper.sanitizeErrors(executionResult);
  }

  public boolean hasNoErrors(ExecutionResult executionResult) {
    return !graphQLObjectMapper.areErrorsPresent(executionResult);
  }

  public Map<String, Object> convertSanitizedExecutionResult(ExecutionResult executionResult) {
    return graphQLObjectMapper.convertSanitizedExecutionResult(executionResult, false);
  }

  public String serialize(Object payload) {
    try {
      return graphQLObjectMapper.getJacksonMapper().writeValueAsString(payload);
    } catch (JsonProcessingException e) {
      return e.getMessage();
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SessionSubscriber.java
================================================
package graphql.kickstart.execution.subscriptions;

import static java.util.Collections.singletonList;

import graphql.ExecutionResult;
import graphql.GraphqlErrorBuilder;
import graphql.execution.NonNullableFieldWasNullException;
import graphql.kickstart.execution.error.GenericGraphQLError;
import java.util.HashMap;
import java.util.Map;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;

@Slf4j
@RequiredArgsConstructor
class SessionSubscriber implements Subscriber<ExecutionResult> {

  private final SubscriptionSession session;
  private final String id;
  private AtomicSubscriptionSubscription subscriptionReference =
      new AtomicSubscriptionSubscription();

  @Override
  public void onSubscribe(Subscription subscription) {
    log.debug("Subscribe to execution result: {}", subscription);
    subscriptionReference.set(subscription);
    subscriptionReference.get().request(1);

    session.add(id, subscriptionReference.get());
  }

  @Override
  public void onNext(ExecutionResult executionResult) {
    Map<String, Object> result = new HashMap<>();
    result.put("data", executionResult.getData());

    session.sendDataMessage(id, result);
    subscriptionReference.get().request(1);
  }

  @Override
  public void onError(Throwable throwable) {
    log.error("Subscription error", throwable);
    Map<String, Object> payload = new HashMap<>();
    if (throwable.getCause() instanceof NonNullableFieldWasNullException) {
      NonNullableFieldWasNullException e = (NonNullableFieldWasNullException) throwable.getCause();
      payload.put(
          "errors",
          singletonList(
              GraphqlErrorBuilder.newError().message(e.getMessage()).path(e.getPath()).build()));
    } else {
      payload.put("errors", singletonList(new GenericGraphQLError(throwable.getMessage())));
    }

    session.unsubscribe(id);
    session.sendErrorMessage(id, payload);
  }

  @Override
  public void onComplete() {
    session.unsubscribe(id);
    session.sendCompleteMessage(id);
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SessionSubscriptions.java
================================================
package graphql.kickstart.execution.subscriptions;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.reactivestreams.Subscription;

/** @author Andrew Potter */
public class SessionSubscriptions {

  private final Object lock = new Object();

  private boolean closed = false;
  private Map<String, Subscription> subscriptions = new ConcurrentHashMap<>();

  public void add(Subscription subscription) {
    add(getImplicitId(subscription), subscription);
  }

  public void add(String id, Subscription subscription) {
    synchronized (lock) {
      if (closed) {
        throw new IllegalStateException("Websocket was already closed!");
      }
      subscriptions.put(id, subscription);
    }
  }

  public void cancel(Subscription subscription) {
    cancel(getImplicitId(subscription));
  }

  public void cancel(String id) {
    Subscription subscription = subscriptions.remove(id);
    if (subscription != null) {
      subscription.cancel();
    }
  }

  public void close() {
    synchronized (lock) {
      closed = true;
      subscriptions.forEach((k, v) -> v.cancel());
      subscriptions.clear();
    }
  }

  private String getImplicitId(Subscription subscription) {
    return String.valueOf(subscription.hashCode());
  }

  public int getSubscriptionCount() {
    return subscriptions.size();
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SubscriptionConnectionListener.java
================================================
package graphql.kickstart.execution.subscriptions;

/** Marker interface */
public interface SubscriptionConnectionListener {}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SubscriptionException.java
================================================
package graphql.kickstart.execution.subscriptions;

public class SubscriptionException extends Exception {

  private final transient Object payload;

  public SubscriptionException() {
    this(null);
  }

  public SubscriptionException(Object payload) {
    this.payload = payload;
  }

  public Object getPayload() {
    return payload;
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SubscriptionProtocolFactory.java
================================================
package graphql.kickstart.execution.subscriptions;

import java.util.function.Consumer;

/** @author Andrew Potter */
public abstract class SubscriptionProtocolFactory {

  private final String protocol;

  protected SubscriptionProtocolFactory(String protocol) {
    this.protocol = protocol;
  }

  public String getProtocol() {
    return protocol;
  }

  public abstract Consumer<String> createConsumer(SubscriptionSession session);

  public void shutdown() {
    // do nothing
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SubscriptionSession.java
================================================
package graphql.kickstart.execution.subscriptions;

import graphql.ExecutionResult;
import java.util.Map;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscription;

public interface SubscriptionSession {

  void subscribe(String id, Publisher<ExecutionResult> data);

  void add(String id, Subscription subscription);

  void unsubscribe(String id);

  void send(String message);

  void sendMessage(Object payload);

  void sendDataMessage(String id, Object payload);

  void sendErrorMessage(String id, Object payload);

  void sendCompleteMessage(String id);

  void close(String reason);

  /**
   * While the session is open, this method returns a Map that the developer may use to store
   * application specific information relating to this session instance. The developer may retrieve
   * information from this Map at any time between the opening of the session and during the
   * onClose() method. But outside that time, any information stored using this Map may no longer be
   * kept by the container. Web socket applications running on distributed implementations of the
   * web container should make any application specific objects stored here java.io.Serializable, or
   * the object may not be recreated after a failover.
   *
   * @return an editable Map of application data.
   */
  Map<String, Object> getUserProperties();

  boolean isOpen();

  String getId();

  SessionSubscriptions getSubscriptions();

  Object unwrap();

  Publisher<String> getPublisher();
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloCommandProvider.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import graphql.kickstart.execution.GraphQLInvoker;
import graphql.kickstart.execution.subscriptions.GraphQLSubscriptionInvocationInputFactory;
import graphql.kickstart.execution.subscriptions.GraphQLSubscriptionMapper;
import graphql.kickstart.execution.subscriptions.apollo.OperationMessage.Type;
import java.util.Collection;
import java.util.EnumMap;

public class ApolloCommandProvider {

  private final EnumMap<Type, SubscriptionCommand> commands = new EnumMap<>(Type.class);

  public ApolloCommandProvider(
      GraphQLSubscriptionMapper mapper,
      GraphQLSubscriptionInvocationInputFactory invocationInputFactory,
      GraphQLInvoker graphQLInvoker,
      Collection<ApolloSubscriptionConnectionListener> connectionListeners) {
    commands.put(
        Type.GQL_CONNECTION_INIT, new SubscriptionConnectionInitCommand(connectionListeners));
    commands.put(
        Type.GQL_START,
        new SubscriptionStartCommand(
            mapper, invocationInputFactory, graphQLInvoker, connectionListeners));
    commands.put(Type.GQL_STOP, new SubscriptionStopCommand(connectionListeners));
    commands.put(
        Type.GQL_CONNECTION_TERMINATE,
        new SubscriptionConnectionTerminateCommand(connectionListeners));
  }

  public SubscriptionCommand getByType(Type type) {
    if (commands.containsKey(type)) {
      return commands.get(type);
    }
    throw new IllegalStateException("No command found for type " + type);
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionConnectionListener.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import graphql.kickstart.execution.subscriptions.SubscriptionConnectionListener;
import graphql.kickstart.execution.subscriptions.SubscriptionSession;

public interface ApolloSubscriptionConnectionListener extends SubscriptionConnectionListener {

  default void onConnect(SubscriptionSession session, OperationMessage message) {
    // do nothing
  }

  default void onStart(SubscriptionSession session, OperationMessage message) {
    // do nothing
  }

  default void onStop(SubscriptionSession session, OperationMessage message) {
    // do nothing
  }

  default void onTerminate(SubscriptionSession session, OperationMessage message) {
    // do nothing
  }

  default void shutdown() {
    // do nothing
  }
}

================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionConsumer.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import com.fasterxml.jackson.core.JsonProcessingException;
import graphql.kickstart.execution.GraphQLObjectMapper;
import graphql.kickstart.execution.subscriptions.SubscriptionSession;
import graphql.kickstart.execution.subscriptions.apollo.OperationMessage.Type;
import java.util.function.Consumer;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@RequiredArgsConstructor
public class ApolloSubscriptionConsumer implements Consumer<String> {

  private final SubscriptionSession session;
  private final GraphQLObjectMapper objectMapper;
  private final ApolloCommandProvider commandProvider;

  @Override
  public void accept(String request) {
    try {
      OperationMessage message =
          objectMapper.getJacksonMapper().readValue(request, OperationMessage.class);
      SubscriptionCommand command = commandProvider.getByType(message.getType());
      command.apply(session, message);
    } catch (JsonProcessingException e) {
      log.error("Cannot read subscription command '{}'", request, e);
      session.sendMessage(new OperationMessage(Type.GQL_CONNECTION_ERROR, null, e.getMessage()));
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionKeepAliveRunner.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import graphql.kickstart.execution.subscriptions.SubscriptionSession;
import java.time.Duration;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import lombok.extern.slf4j.Slf4j;

@Slf4j
class ApolloSubscriptionKeepAliveRunner {

  private static final int EXECUTOR_POOL_SIZE = 10;

  private final ScheduledExecutorService executor;
  private final OperationMessage keepAliveMessage;
  private final Map<SubscriptionSession, Future<?>> futures;
  private final long keepAliveIntervalSeconds;

  ApolloSubscriptionKeepAliveRunner(Duration keepAliveInterval) {
    this.keepAliveMessage = OperationMessage.newKeepAliveMessage();
    this.executor = Executors.newScheduledThreadPool(EXECUTOR_POOL_SIZE);
    this.futures = new ConcurrentHashMap<>();
    this.keepAliveIntervalSeconds = keepAliveInterval.getSeconds();
  }

  void keepAlive(SubscriptionSession session) {
    futures.computeIfAbsent(session, this::startKeepAlive);
  }

  private ScheduledFuture<?> startKeepAlive(SubscriptionSession session) {
    return executor.scheduleAtFixedRate(
        () -> {
          try {
            if (session.isOpen()) {
              session.sendMessage(keepAliveMessage);
            } else {
              log.debug("Session {} appears to be closed. Aborting keep alive", session.getId());
              abort(session);
            }
          } catch (Exception t) {
            log.error(
                "Cannot send keep alive message to session {}. Aborting keep alive",
                session.getId(),
                t);
            abort(session);
          }
        },
        0,
        keepAliveIntervalSeconds,
        TimeUnit.SECONDS);
  }

  void abort(SubscriptionSession session) {
    Future<?> future = futures.remove(session);
    if (future != null) {
      future.cancel(true);
    }
  }

  void shutdown() {
    this.executor.shutdown();
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionProtocolFactory.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import graphql.kickstart.execution.GraphQLInvoker;
import graphql.kickstart.execution.GraphQLObjectMapper;
import graphql.kickstart.execution.subscriptions.GraphQLSubscriptionInvocationInputFactory;
import graphql.kickstart.execution.subscriptions.GraphQLSubscriptionMapper;
import graphql.kickstart.execution.subscriptions.SubscriptionProtocolFactory;
import graphql.kickstart.execution.subscriptions.SubscriptionSession;
import java.time.Duration;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.function.Consumer;
import lombok.Getter;

/** @author Andrew Potter */
public class ApolloSubscriptionProtocolFactory extends SubscriptionProtocolFactory {

  public static final int KEEP_ALIVE_INTERVAL = 15;
  @Getter private final GraphQLObjectMapper objectMapper;
  private final ApolloCommandProvider commandProvider;
  private KeepAliveSubscriptionConnectionListener keepAlive;

  public ApolloSubscriptionProtocolFactory(
      GraphQLObjectMapper objectMapper,
      GraphQLSubscriptionInvocationInputFactory invocationInputFactory,
      GraphQLInvoker graphQLInvoker) {
    this(
        objectMapper,
        invocationInputFactory,
        graphQLInvoker,
        Duration.ofSeconds(KEEP_ALIVE_INTERVAL));
  }

  public ApolloSubscriptionProtocolFactory(
      GraphQLObjectMapper objectMapper,
      GraphQLSubscriptionInvocationInputFactory invocationInputFactory,
      GraphQLInvoker graphQLInvoker,
      Duration keepAliveInterval) {
    this(objectMapper, invocationInputFactory, graphQLInvoker, null, keepAliveInterval);
  }

  public ApolloSubscriptionProtocolFactory(
      GraphQLObjectMapper objectMapper,
      GraphQLSubscriptionInvocationInputFactory invocationInputFactory,
      GraphQLInvoker graphQLInvoker,
      Collection<ApolloSubscriptionConnectionListener> connectionListeners) {
    this(
        objectMapper,
        invocationInputFactory,
        graphQLInvoker,
        connectionListeners,
        Duration.ofSeconds(KEEP_ALIVE_INTERVAL));
  }

  public ApolloSubscriptionProtocolFactory(
      GraphQLObjectMapper objectMapper,
      GraphQLSubscriptionInvocationInputFactory invocationInputFactory,
      GraphQLInvoker graphQLInvoker,
      Collection<ApolloSubscriptionConnectionListener> connectionListeners,
      Duration keepAliveInterval) {
    super("graphql-ws");
    this.objectMapper = objectMapper;
    Set<ApolloSubscriptionConnectionListener> listeners = new HashSet<>();
    if (connectionListeners != null) {
      listeners.addAll(connectionListeners);
    }
    if (keepAliveInterval != null
        && listeners.stream()
            .noneMatch(KeepAliveSubscriptionConnectionListener.class::isInstance)) {
      keepAlive = new KeepAliveSubscriptionConnectionListener(keepAliveInterval);
      listeners.add(keepAlive);
    }
    commandProvider =
        new ApolloCommandProvider(
            new GraphQLSubscriptionMapper(objectMapper),
            invocationInputFactory,
            graphQLInvoker,
            listeners);
  }

  @Override
  public Consumer<String> createConsumer(SubscriptionSession session) {
    return new ApolloSubscriptionConsumer(session, objectMapper, commandProvider);
  }

  @Override
  public void shutdown() {
    if (keepAlive != null) {
      keepAlive.shutdown();
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionSession.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import graphql.kickstart.execution.subscriptions.DefaultSubscriptionSession;
import graphql.kickstart.execution.subscriptions.GraphQLSubscriptionMapper;
import graphql.kickstart.execution.subscriptions.apollo.OperationMessage.Type;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ApolloSubscriptionSession extends DefaultSubscriptionSession {

  public ApolloSubscriptionSession(GraphQLSubscriptionMapper mapper) {
    super(mapper);
  }

  @Override
  public void sendDataMessage(String id, Object payload) {
    sendMessage(new OperationMessage(Type.GQL_DATA, id, payload));
  }

  @Override
  public void sendErrorMessage(String id, Object payload) {
    sendMessage(new OperationMessage(Type.GQL_ERROR, id, payload));
  }

  @Override
  public void sendCompleteMessage(String id) {
    sendMessage(new OperationMessage(Type.GQL_COMPLETE, id, null));
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/KeepAliveSubscriptionConnectionListener.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import graphql.kickstart.execution.subscriptions.SubscriptionSession;
import java.time.Duration;

public class KeepAliveSubscriptionConnectionListener
    implements ApolloSubscriptionConnectionListener {

  protected final ApolloSubscriptionKeepAliveRunner keepAliveRunner;

  public KeepAliveSubscriptionConnectionListener() {
    this(Duration.ofSeconds(15));
  }

  public KeepAliveSubscriptionConnectionListener(Duration keepAliveInterval) {
    keepAliveRunner = new ApolloSubscriptionKeepAliveRunner(keepAliveInterval);
  }

  @Override
  public void onConnect(SubscriptionSession session, OperationMessage message) {
    keepAliveRunner.keepAlive(session);
  }

  @Override
  public void onStart(SubscriptionSession session, OperationMessage message) {
    // do nothing
  }

  @Override
  public void onStop(SubscriptionSession session, OperationMessage message) {
    // do nothing
  }

  @Override
  public void onTerminate(SubscriptionSession session, OperationMessage message) {
    keepAliveRunner.abort(session);
  }

  @Override
  public void shutdown() {
    keepAliveRunner.shutdown();
  }

}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/OperationMessage.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonValue;
import java.util.HashMap;
import java.util.Map;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;

@NoArgsConstructor
@AllArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class OperationMessage {

  private Type type;
  private String id;
  private Object payload;

  public static OperationMessage newKeepAliveMessage() {
    return new OperationMessage(Type.GQL_CONNECTION_KEEP_ALIVE, null, null);
  }

  public Type getType() {
    return type;
  }

  public String getId() {
    return id;
  }

  public Object getPayload() {
    return payload;
  }

  public enum Type {

    // Server Messages
    GQL_CONNECTION_ACK("connection_ack"),
    GQL_CONNECTION_ERROR("connection_error"),
    GQL_CONNECTION_KEEP_ALIVE("ka"),
    GQL_DATA("data"),
    GQL_ERROR("error"),
    GQL_COMPLETE("complete"),

    // Client Messages
    GQL_CONNECTION_INIT("connection_init"),
    GQL_CONNECTION_TERMINATE("connection_terminate"),
    GQL_START("start"),
    GQL_STOP("stop");

    private static final Map<String, Type> reverseLookup = new HashMap<>();

    static {
      for (Type type : Type.values()) {
        reverseLookup.put(type.getValue(), type);
      }
    }

    private final String value;

    Type(String value) {
      this.value = value;
    }

    @JsonCreator
    public static Type findType(String value) {
      return reverseLookup.get(value);
    }

    @JsonValue
    public String getValue() {
      return value;
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionCommand.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import graphql.kickstart.execution.subscriptions.SubscriptionSession;

interface SubscriptionCommand {

  void apply(SubscriptionSession session, OperationMessage message);
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionConnectionInitCommand.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import graphql.kickstart.execution.subscriptions.SubscriptionSession;
import graphql.kickstart.execution.subscriptions.apollo.OperationMessage.Type;
import java.util.Collection;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@RequiredArgsConstructor
class SubscriptionConnectionInitCommand implements SubscriptionCommand {

  private final Collection<ApolloSubscriptionConnectionListener> connectionListeners;

  @Override
  public void apply(SubscriptionSession session, OperationMessage message) {
    log.debug("Apollo subscription connection init: {}", session);
    try {
      connectionListeners.forEach(it -> it.onConnect(session, message));
      session.sendMessage(new OperationMessage(Type.GQL_CONNECTION_ACK, message.getId(), null));
    } catch (Exception t) {
      log.error("Cannot initialize subscription command '{}'", message, t);
      session.sendMessage(
          new OperationMessage(Type.GQL_CONNECTION_ERROR, message.getId(), t.getMessage()));
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionConnectionTerminateCommand.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import static graphql.kickstart.execution.subscriptions.apollo.OperationMessage.Type.GQL_CONNECTION_TERMINATE;

import graphql.kickstart.execution.subscriptions.SubscriptionSession;
import java.util.Collection;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@RequiredArgsConstructor
class SubscriptionConnectionTerminateCommand implements SubscriptionCommand {

  private final Collection<ApolloSubscriptionConnectionListener> connectionListeners;

  @Override
  public void apply(SubscriptionSession session, OperationMessage message) {
    connectionListeners.forEach(it -> it.onTerminate(session, message));
    session.close("client requested " + GQL_CONNECTION_TERMINATE.getValue());
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionStartCommand.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import static graphql.kickstart.execution.subscriptions.apollo.OperationMessage.Type.GQL_ERROR;

import graphql.ExecutionResult;
import graphql.kickstart.execution.GraphQLInvoker;
import graphql.kickstart.execution.GraphQLRequest;
import graphql.kickstart.execution.input.GraphQLSingleInvocationInput;
import graphql.kickstart.execution.subscriptions.GraphQLSubscriptionInvocationInputFactory;
import graphql.kickstart.execution.subscriptions.GraphQLSubscriptionMapper;
import graphql.kickstart.execution.subscriptions.SubscriptionSession;
import java.util.Collection;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@RequiredArgsConstructor
class SubscriptionStartCommand implements SubscriptionCommand {

  private final GraphQLSubscriptionMapper mapper;
  private final GraphQLSubscriptionInvocationInputFactory invocationInputFactory;
  private final GraphQLInvoker graphQLInvoker;
  private final Collection<ApolloSubscriptionConnectionListener> connectionListeners;

  @Override
  public void apply(SubscriptionSession session, OperationMessage message) {
    log.debug("Apollo subscription start: {} --> {}", session, message.getPayload());
    connectionListeners.forEach(it -> it.onStart(session, message));
    CompletableFuture<ExecutionResult> executionResult =
        executeAsync(message.getPayload(), session);
    executionResult.thenAccept(result -> handleSubscriptionStart(session, message.getId(), result));
  }

  private CompletableFuture<ExecutionResult> executeAsync(
      Object payload, SubscriptionSession session) {
    Objects.requireNonNull(payload, "Payload is required");
    GraphQLRequest graphQLRequest = mapper.convertGraphQLRequest(payload);

    GraphQLSingleInvocationInput invocationInput =
        invocationInputFactory.create(graphQLRequest, session);
    return graphQLInvoker.executeAsync(invocationInput);
  }

  private void handleSubscriptionStart(
      SubscriptionSession session, String id, ExecutionResult executionResult) {
    ExecutionResult sanitizedExecutionResult = mapper.sanitizeErrors(executionResult);
    if (mapper.hasNoErrors(sanitizedExecutionResult)) {
      session.subscribe(id, sanitizedExecutionResult.getData());
    } else {
      Object payload = mapper.convertSanitizedExecutionResult(sanitizedExecutionResult);
      session.sendMessage(new OperationMessage(GQL_ERROR, id, payload));
    }
  }
}


================================================
FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionStopCommand.java
================================================
package graphql.kickstart.execution.subscriptions.apollo;

import graphql.kickstart.execution.subscriptions.SubscriptionSession;
import java.util.Collection;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
class SubscriptionStopCommand implements SubscriptionCommand {

  private final Collection<ApolloSubscriptionConnectionListener> connectionListeners;

  @Override
  public void apply(SubscriptionSession session, OperationMessage message) {
    connectionListeners.forEach(it -> it.onStop(session, message));
    session.unsubscribe(message.getId());
  }
}


================================================
FILE: graphql-java-servlet/bnd.bnd
================================================
Export-Package: graphql.kickstart.servlet.*
Import-Package: !lombok,*
Require-Capability: osgi.extender;
  filter:="(&(osgi.extender=osgi.component)(version>=1.3)(!(version>=2.0)))"


================================================
FILE: graphql-java-servlet/build.gradle
================================================
buildscript {
    repositories {
        mavenCentral()
    }
}

apply plugin: 'groovy'
apply plugin: 'java-library-distribution'
apply plugin: 'biz.aQute.bnd.builder'

jar {
    bndfile = 'bnd.bnd'
}

dependencies {
    api(project(':graphql-java-kickstart'))

    // Servlet
    compileOnly "jakarta.servlet:jakarta.servlet-api:6.1.0"
    compileOnly "jakarta.websocket:jakarta.websocket-api:2.2.0"
    compileOnly "jakarta.websocket:jakarta.websocket-client-api:2.2.0"
    implementation "org.slf4j:slf4j-api:$LIB_SLF4J_VER"

    // OSGi
    compileOnly 'org.osgi:org.osgi.core:6.0.0'
    compileOnly 'org.osgi:org.osgi.service.cm:1.6.1'
    compileOnly 'org.osgi:org.osgi.service.component:1.5.1'
    compileOnly 'org.osgi:org.osgi.service.component.annotations:1.5.1'
    compileOnly 'org.osgi:org.osgi.service.metatype.annotations:1.4.1'
    compileOnly 'org.osgi:org.osgi.annotation:6.0.0'

    testImplementation 'io.github.graphql-java:graphql-java-annotations:9.1'

    // Unit testing
    testImplementation "org.apache.groovy:groovy-all:4.0.23"
    testImplementation "org.spockframework:spock-core:2.3-groovy-4.0"
    testRuntimeOnly "net.bytebuddy:byte-buddy:1.15.2"
    testRuntimeOnly "org.objenesis:objenesis:3.4"
    testImplementation "org.slf4j:slf4j-simple:$LIB_SLF4J_VER"
    testImplementation "org.springframework:spring-test:6.1.13"
    testRuntimeOnly "org.springframework:spring-web:6.1.13"
    testImplementation 'com.google.guava:guava:33.3.1-jre'
    testImplementation "jakarta.servlet:jakarta.servlet-api:6.1.0"
    testImplementation "jakarta.websocket:jakarta.websocket-api:2.2.0"
    testImplementation "jakarta.websocket:jakarta.websocket-client-api:2.2.0"
}


================================================
FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AbstractGraphQLHttpServlet.java
================================================
package graphql.kickstart.servlet;

import static graphql.kickstart.execution.GraphQLRequest.createQueryOnlyRequest;

import graphql.ExecutionResult;
import graphql.kickstart.execution.GraphQLRequest;
import graphql.kickstart.execution.input.GraphQLSingleInvocationInput;
import graphql.kickstart.servlet.core.GraphQLMBean;
import graphql.kickstart.servlet.core.GraphQLServletListener;
import graphql.schema.GraphQLFieldDefinition;
import jakarta.servlet.Servlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;

/** @author Andrew Potter */
@Slf4j
public abstract class AbstractGraphQLHttpServlet extends HttpServlet
    implements Servlet, GraphQLMBean {

  protected abstract GraphQLConfiguration getConfiguration();

  public void addListener(GraphQLServletListener servletListener) {
    getConfiguration().add(servletListener);
  }

  public void removeListener(GraphQLServletListener servletListener) {
    getConfiguration().remove(servletListener);
  }

  @Override
  public String[] getQueries() {
    return getConfiguration()
        .getInvocationInputFactory()
        .getSchemaProvider()
        .getSchema()
        .getQueryType()
        .getFieldDefinitions()
        .stream()
        .map(GraphQLFieldDefinition::getName)
        .toArray(String[]::new);
  }

  @Override
  public String[] getMutations() {
    return getConfiguration()
        .getInvocationInputFactory()
        .getSchemaProvider()
        .getSchema()
        .getMutationType()
        .getFieldDefinitions()
        .stream()
        .map(GraphQLFieldDefinition::getName)
        .toArray(String[]::new);
  }

  @Override
  public String executeQuery(String query) {
    try {
      GraphQLRequest graphQLRequest = createQueryOnlyRequest(query);
      GraphQLSingleInvocationInput invocationInput =
          getConfiguration().getInvocationInputFactory().create(graphQLRequest);
      ExecutionResult result =
          getConfiguration().getGraphQLInvoker().query(invocationInput).getResult();
      return getConfiguration().getObjectMapper().serializeResultAsJson(result);
    } catch (Exception e) {
      return e.getMessage();
    }
  }

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
    doRequest(req, resp);
  }

  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
    doRequest(req, resp);
  }

  private void doRequest(HttpServletRequest request, HttpServletResponse response) {
    try {
      getConfiguration().getHttpRequestHandler().handle(request, response);
    } catch (Exception t) {
      log.error("Error executing GraphQL request!", t);
    }
  }
}


================================================
FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AbstractGraphQLInvocationInputParser.java
================================================
package graphql.kickstart.servlet;

import graphql.kickstart.execution.GraphQLObjectMapper;
import graphql.kickstart.execution.context.ContextSetting;
import graphql.kickstart.servlet.input.GraphQLInvocationInputFactory;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
abstract class AbstractGraphQLInvocationInputParser implements GraphQLInvocationInputParser {

  final GraphQLInvocationInputFactory invocationInputFactory;
  final GraphQLObjectMapper graphQLObjectMapper;
  final ContextSetting contextSetting;

  boolean isSingleQuery(String query) {
    return query != null && !query.trim().isEmpty() && !query.trim().startsWith("[");
  }

  boolean isBatchedQuery(String query) {
    return query != null && query.trim().startsWith("[");
  }
}


================================================
FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AsyncTaskDecorator.java
================================================
package graphql.kickstart.servlet;

public interface AsyncTaskDecorator {

  Runnable decorate(Runnable runnable);

}


================================================
FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AsyncTaskExecutor.java
================================================
package graphql.kickstart.servlet;

import java.util.concurrent.Executor;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
class AsyncTaskExecutor implements Executor {

  private final Executor executor;
  private final AsyncTaskDecorator taskDecorator;

  @Override
  public void execute(@NonNull Runnable command) {
    if (taskDecorator != null) {
      Runnable decorated = taskDecorator.decorate(command);
      executor.execute(decorated);
    } else {
      executor.execute(command);
    }
  }
}


================================================
FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AsyncTimeoutListener.java
================================================
package graphql.kickstart.servlet;

import java.io.IOException;
import jakarta.servlet.AsyncEvent;
import jakarta.servlet.AsyncListener;

interface AsyncTimeoutListener extends AsyncListener {

  default void onComplete(AsyncEvent event) throws IOException {}

  default void onError(AsyncEvent event) throws IOException {}

  default void onStartAsync(AsyncEvent event) throws IOException {}
}


================================================
FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/BatchedQueryResponseWriter.java
================================================
package graphql.kickstart.servlet;

import graphql.ExecutionResult;
import graphql.kickstart.execution.GraphQLObjectMapper;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@RequiredArgsConstructor
class BatchedQueryResponseWriter implements QueryResponseWriter {
  private final List<ExecutionResult> results;
  private final GraphQLObjectMapper graphQLObjectMapper;

  @Override
  public void write(HttpServletRequest request, HttpServletResponse response) throws IOException {
    response.setCharacterEncoding(StandardCharsets.UTF_8.name());
    response.setContentType(HttpRequestHandler.APPLICATION_JSON_UTF8);
    response.setStatus(HttpRequestHandler.STATUS_OK);

    // Use direct serialization to byte arrays and avoid any string concatenation to save multiple
    // GiB of memory allocation during large response processing.
    List<byte[]> serializedResults = new ArrayList<>(2 * results.size() + 1);

    if (!results.isEmpty()) {
      serializedResults.add("[".getBytes(StandardCharsets.UTF_8));
    } else {
      serializedResults.add("[]".getBytes(StandardCharsets.UTF_8));
    }
    long totalLength = serializedResults.get(0).length;

    // '[', ',' and ']' are all 1 byte in UTF-8.
    for (int i = 0; i < results.size(); i++) {
      byte[] currentResult = graphQLObjectMapper.serializeResultAsBytes(results.get(i));
      serializedResults.add(currentResult);

      if (i != results.size() - 1) {
        serializedResults.add(",".getBytes(StandardCharsets.UTF_8));
      } else {
        serializedResults.add("]".getBytes(StandardCharsets.UTF_8));
      }
      totalLength += currentResult.length + 1; // result.length + ',' or ']'
    }

    if (totalLength > Integer.MAX_VALUE) {
      throw new IllegalStateException(
          "Response size exceed 2GiB. Query will fail. Seen size: " + totalLength);
    }
    response.setContentLength((int) totalLength);

    for (byte[] result : serializedResults) {
      response.getOutputStream().write(result);
    }
  }
}


================================================
FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ConfiguredGraphQLHttpServlet.java
================================================
package graphql.kickstart.servlet;

import java.util.Objects;

class ConfiguredGraphQLHttpServlet extends GraphQLHttpServlet {

  private final GraphQLConfiguration configuration;

  ConfiguredGraphQLHttpServlet(GraphQLConfiguration configuration) {
    this.configuration = Objects.requireNonNull(configuration, "configuration is required");
  }

  @Override
  protected GraphQLConfiguration getConfiguration() {
    return configuration;
  }
}


================================================
FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ErrorQueryResponseWriter.java
================================================
package graphql.kickstart.servlet;

import java.io.IOException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
class ErrorQueryResponseWriter implements QueryResponseWriter {

  private final int statusCode;
  private final String message;

  @Override
  public void write(HttpServletRequest request, HttpServletResponse response) throws IOException {
    response.sendError(statusCode, message);
  }
}


================================================
FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ExecutionResultSubscriber.java
================================================
package graphql.kickstart.servlet;

import graphql.ExecutionResult;
import graphql.kickstart.execution.GraphQLObjectMapper;
import java.io.IOException;
import java.io.Writer;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicReference;
import jakarta.servlet.AsyncContext;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;

class ExecutionResultSubscriber implements Subscriber<ExecutionResult> {

  private final AtomicReference<Subscription> subscriptionRef;
  private final AsyncContext asyncContext;
  private final GraphQLObjectMapper graphQLObjectMapper;
  private final CountDownLatch completedLatch = new CountDownLatch(1);

  ExecutionResultSubscriber(
      AtomicReference<Subscription> subscriptionRef,
      AsyncContext asyncContext,
      GraphQLObjectMapper graphQLObjectMapper) {
    this.subscriptionRef = subscriptionRef;
    this.asyncContext = asyncContext;
    this.graphQLObjectMapper = graphQLObjectMapper;
  }

  @Override
  public void onSubscribe(Subscription subscription) {
    subscriptionRef.set(subscription);
    subscriptionRef.get().request(1);
  }

  @Override
  public void onNext(ExecutionResult executionResult) {
    try {
      Writer writer = asyncContext.getResponse().getWriter();
      writer.write("data: ");
      writer.write(graphQLObjectMapper.serializeResultAsJson(executionResult));
      writer.write("\n\n");
      writer.flush();
      subscriptionRef.get().request(1);
    } catch (IOException ignored) {
      // ignore
    }
  }

  @Override
  public void onError(Throwable t) {
    asyncContext.complete();
    completedLatch.countDown();
  }

  @Override
  public void onComplete() {
    asyncContext.complete();
    completedLatch.countDown();
  }

  void await() throws InterruptedException {
    completedLatch.await();
  }
}


================================================
FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLConfiguration.java
================================================
package graphql.kickstart.servlet;

import graphql.kickstart.execution.GraphQLInvoker;
import graphql.kickstart.execution.GraphQLObjectMapper;
import graphql.kickstart.execution.GraphQLQueryInvoker;
import graphql.kickstart.execution.context.ContextSetting;
import graphql.kickstart.servlet.cache.CachingHttpRequestInvoker;
import graphql.kickstart.servlet.cache.GraphQLResponseCacheManager;
import graphql.kickstart.servlet.config.DefaultGraphQLSchemaServletProvider;
import graphql.kickstart.servlet.config.GraphQLSchemaServletProvider;
import graphql.kickstart.servlet.context.GraphQLServletContextBuilder;
import graphql.kickstart.servlet.core.GraphQLServletListener;
impor
Download .txt
gitextract_cv18k8ke/

├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   ├── config.yml
│   │   └── feature_request.md
│   ├── add-javax-suffix.sh
│   ├── release.sh
│   ├── replaceJakartaWithJavax.sh
│   ├── tag-release.sh
│   └── workflows/
│       ├── pull-request.yml
│       ├── release.yml
│       └── snapshot.yml
├── .gitignore
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── build.gradle
├── examples/
│   └── osgi/
│       ├── apache-karaf-feature/
│       │   ├── pom.xml
│       │   └── src/
│       │       └── main/
│       │           └── feature/
│       │               └── feature.xml
│       ├── apache-karaf-package/
│       │   └── pom.xml
│       ├── buildAndRun.sh
│       ├── pom.xml
│       └── providers/
│           ├── pom.xml
│           └── src/
│               └── main/
│                   └── java/
│                       └── graphql/
│                           └── servlet/
│                               └── examples/
│                                   └── osgi/
│                                       └── ExampleGraphQLProvider.java
├── gradle/
│   └── wrapper/
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradle.properties
├── gradlew
├── gradlew.bat
├── graphql-java-kickstart/
│   ├── bnd.bnd
│   ├── build.gradle
│   └── src/
│       └── main/
│           └── java/
│               └── graphql/
│                   └── kickstart/
│                       └── execution/
│                           ├── BatchedDataLoaderGraphQLBuilder.java
│                           ├── DecoratedExecutionResult.java
│                           ├── DefaultGraphQLRootObjectBuilder.java
│                           ├── ExtensionsDeserializer.java
│                           ├── FutureBatchedExecutionResult.java
│                           ├── FutureErrorExecutionResult.java
│                           ├── FutureExecutionResult.java
│                           ├── FutureSingleExecutionResult.java
│                           ├── GraphQLBatchedQueryResult.java
│                           ├── GraphQLErrorQueryResult.java
│                           ├── GraphQLInvoker.java
│                           ├── GraphQLInvokerProxy.java
│                           ├── GraphQLObjectMapper.java
│                           ├── GraphQLQueryInvoker.java
│                           ├── GraphQLQueryResult.java
│                           ├── GraphQLRequest.java
│                           ├── GraphQLRootObjectBuilder.java
│                           ├── GraphQLSingleQueryResult.java
│                           ├── ObjectMapDeserializationException.java
│                           ├── ObjectMapDeserializeHelper.java
│                           ├── OperationNameExtractor.java
│                           ├── StaticGraphQLRootObjectBuilder.java
│                           ├── StringUtils.java
│                           ├── VariablesDeserializer.java
│                           ├── config/
│                           │   ├── ConfiguringObjectMapperProvider.java
│                           │   ├── DefaultExecutionStrategyProvider.java
│                           │   ├── DefaultGraphQLSchemaProvider.java
│                           │   ├── ExecutionStrategyProvider.java
│                           │   ├── GraphQLBuilder.java
│                           │   ├── GraphQLBuilderConfigurer.java
│                           │   ├── GraphQLSchemaProvider.java
│                           │   ├── GraphQLServletObjectMapperConfigurer.java
│                           │   ├── InstrumentationProvider.java
│                           │   └── ObjectMapperProvider.java
│                           ├── context/
│                           │   ├── ContextSetting.java
│                           │   ├── ContextSettingNotConfiguredException.java
│                           │   ├── DefaultGraphQLContext.java
│                           │   ├── DefaultGraphQLContextBuilder.java
│                           │   ├── GraphQLContextBuilder.java
│                           │   └── GraphQLKickstartContext.java
│                           ├── error/
│                           │   ├── DefaultGraphQLErrorHandler.java
│                           │   ├── DefaultGraphQLServletObjectMapperConfigurer.java
│                           │   ├── GenericGraphQLError.java
│                           │   ├── GraphQLErrorHandler.java
│                           │   └── RenderableNonNullableFieldWasNullError.java
│                           ├── input/
│                           │   ├── GraphQLBatchedInvocationInput.java
│                           │   ├── GraphQLInvocationInput.java
│                           │   ├── GraphQLSingleInvocationInput.java
│                           │   ├── PerQueryBatchedInvocationInput.java
│                           │   └── PerRequestBatchedInvocationInput.java
│                           ├── instrumentation/
│                           │   ├── AbstractTrackingApproach.java
│                           │   ├── DataLoaderDispatcherInstrumentationState.java
│                           │   ├── FieldLevelTrackingApproach.java
│                           │   ├── NoOpInstrumentationProvider.java
│                           │   ├── RequestLevelTrackingApproach.java
│                           │   ├── RequestStack.java
│                           │   ├── TrackingApproach.java
│                           │   └── TrackingApproachException.java
│                           └── subscriptions/
│                               ├── AtomicSubscriptionSubscription.java
│                               ├── DefaultSubscriptionSession.java
│                               ├── GraphQLSubscriptionInvocationInputFactory.java
│                               ├── GraphQLSubscriptionMapper.java
│                               ├── SessionSubscriber.java
│                               ├── SessionSubscriptions.java
│                               ├── SubscriptionConnectionListener.java
│                               ├── SubscriptionException.java
│                               ├── SubscriptionProtocolFactory.java
│                               ├── SubscriptionSession.java
│                               └── apollo/
│                                   ├── ApolloCommandProvider.java
│                                   ├── ApolloSubscriptionConnectionListener.java
│                                   ├── ApolloSubscriptionConsumer.java
│                                   ├── ApolloSubscriptionKeepAliveRunner.java
│                                   ├── ApolloSubscriptionProtocolFactory.java
│                                   ├── ApolloSubscriptionSession.java
│                                   ├── KeepAliveSubscriptionConnectionListener.java
│                                   ├── OperationMessage.java
│                                   ├── SubscriptionCommand.java
│                                   ├── SubscriptionConnectionInitCommand.java
│                                   ├── SubscriptionConnectionTerminateCommand.java
│                                   ├── SubscriptionStartCommand.java
│                                   └── SubscriptionStopCommand.java
├── graphql-java-servlet/
│   ├── bnd.bnd
│   ├── build.gradle
│   └── src/
│       ├── main/
│       │   └── java/
│       │       └── graphql/
│       │           └── kickstart/
│       │               └── servlet/
│       │                   ├── AbstractGraphQLHttpServlet.java
│       │                   ├── AbstractGraphQLInvocationInputParser.java
│       │                   ├── AsyncTaskDecorator.java
│       │                   ├── AsyncTaskExecutor.java
│       │                   ├── AsyncTimeoutListener.java
│       │                   ├── BatchedQueryResponseWriter.java
│       │                   ├── ConfiguredGraphQLHttpServlet.java
│       │                   ├── ErrorQueryResponseWriter.java
│       │                   ├── ExecutionResultSubscriber.java
│       │                   ├── GraphQLConfiguration.java
│       │                   ├── GraphQLGetInvocationInputParser.java
│       │                   ├── GraphQLHttpServlet.java
│       │                   ├── GraphQLInvocationInputParser.java
│       │                   ├── GraphQLMultipartInvocationInputParser.java
│       │                   ├── GraphQLPostInvocationInputParser.java
│       │                   ├── GraphQLWebsocketServlet.java
│       │                   ├── HttpRequestHandler.java
│       │                   ├── HttpRequestHandlerImpl.java
│       │                   ├── HttpRequestInvoker.java
│       │                   ├── HttpRequestInvokerImpl.java
│       │                   ├── InvocationInputParseException.java
│       │                   ├── ListenerHandler.java
│       │                   ├── OsgiGraphQLHttpServlet.java
│       │                   ├── OsgiGraphQLHttpServletConfiguration.java
│       │                   ├── OsgiSchemaBuilder.java
│       │                   ├── PartIOException.java
│       │                   ├── QueryResponseWriter.java
│       │                   ├── QueryResponseWriterFactory.java
│       │                   ├── QueryResponseWriterFactoryImpl.java
│       │                   ├── SingleAsynchronousQueryResponseWriter.java
│       │                   ├── SingleQueryResponseWriter.java
│       │                   ├── StaticDataPublisher.java
│       │                   ├── SubscriptionAsyncListener.java
│       │                   ├── apollo/
│       │                   │   ├── ApolloScalars.java
│       │                   │   ├── ApolloWebSocketSubscriptionProtocolFactory.java
│       │                   │   └── ApolloWebSocketSubscriptionSession.java
│       │                   ├── cache/
│       │                   │   ├── BufferedHttpServletResponse.java
│       │                   │   ├── CacheReader.java
│       │                   │   ├── CachedResponse.java
│       │                   │   ├── CachingHttpRequestInvoker.java
│       │                   │   ├── CachingQueryResponseWriter.java
│       │                   │   ├── CachingQueryResponseWriterFactory.java
│       │                   │   └── GraphQLResponseCacheManager.java
│       │                   ├── config/
│       │                   │   ├── DefaultGraphQLSchemaServletProvider.java
│       │                   │   └── GraphQLSchemaServletProvider.java
│       │                   ├── context/
│       │                   │   ├── DefaultGraphQLServletContext.java
│       │                   │   ├── DefaultGraphQLServletContextBuilder.java
│       │                   │   ├── DefaultGraphQLWebSocketContext.java
│       │                   │   ├── GraphQLServletContext.java
│       │                   │   ├── GraphQLServletContextBuilder.java
│       │                   │   └── GraphQLWebSocketContext.java
│       │                   ├── core/
│       │                   │   ├── DefaultGraphQLRootObjectBuilder.java
│       │                   │   ├── GraphQLMBean.java
│       │                   │   ├── GraphQLServletListener.java
│       │                   │   ├── GraphQLServletRootObjectBuilder.java
│       │                   │   └── internal/
│       │                   │       ├── GraphQLThreadFactory.java
│       │                   │       ├── VariableMapException.java
│       │                   │       └── VariableMapper.java
│       │                   ├── input/
│       │                   │   ├── BatchInputPreProcessResult.java
│       │                   │   ├── BatchInputPreProcessor.java
│       │                   │   ├── GraphQLInvocationInputFactory.java
│       │                   │   └── NoOpBatchInputPreProcessor.java
│       │                   ├── osgi/
│       │                   │   ├── GraphQLCodeRegistryProvider.java
│       │                   │   ├── GraphQLDirectiveProvider.java
│       │                   │   ├── GraphQLFieldProvider.java
│       │                   │   ├── GraphQLMutationProvider.java
│       │                   │   ├── GraphQLProvider.java
│       │                   │   ├── GraphQLQueryProvider.java
│       │                   │   ├── GraphQLSubscriptionProvider.java
│       │                   │   └── GraphQLTypesProvider.java
│       │                   └── subscriptions/
│       │                       ├── FallbackSubscriptionConsumer.java
│       │                       ├── FallbackSubscriptionProtocolFactory.java
│       │                       ├── WebSocketSendSubscriber.java
│       │                       ├── WebSocketSubscriptionProtocolFactory.java
│       │                       └── WebSocketSubscriptionSession.java
│       └── test/
│           └── groovy/
│               └── graphql/
│                   └── kickstart/
│                       └── servlet/
│                           ├── AbstractGraphQLHttpServletSpec.groovy
│                           ├── BatchedQueryResponseWriterTest.groovy
│                           ├── DataLoaderDispatchingSpec.groovy
│                           ├── GraphQLServletListenerSpec.groovy
│                           ├── OsgiGraphQLHttpServletSpec.groovy
│                           ├── PartIOExceptionTest.groovy
│                           ├── RequestTester.groovy
│                           ├── SingleAsynchronousQueryResponseWriterTest.groovy
│                           ├── SingleQueryResponseWriterTest.groovy
│                           ├── TestBatchInputPreProcessor.java
│                           ├── TestException.groovy
│                           ├── TestGraphQLErrorException.groovy
│                           ├── TestMultipartPart.groovy
│                           ├── TestUtils.groovy
│                           └── cache/
│                               ├── CacheReaderTest.groovy
│                               └── CachingHttpRequestInvokerTest.groovy
├── lombok.config
├── renovate.json
└── settings.gradle
Download .txt
SYMBOL INDEX (879 symbols across 157 files)

FILE: examples/osgi/providers/src/main/java/graphql/servlet/examples/osgi/ExampleGraphQLProvider.java
  class ExampleGraphQLProvider (line 17) | @Component(
    method getQueries (line 24) | public Collection<GraphQLFieldDefinition> getQueries() {
    method getMutations (line 36) | public Collection<GraphQLFieldDefinition> getMutations() {
    method getTypes (line 40) | public Collection<GraphQLType> getTypes() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/BatchedDataLoaderGraphQLBuilder.java
  class BatchedDataLoaderGraphQLBuilder (line 8) | public class BatchedDataLoaderGraphQLBuilder {
    method newGraphQL (line 10) | GraphQL newGraphQL(GraphQLBatchedInvocationInput invocationInput, Grap...

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/DecoratedExecutionResult.java
  class DecoratedExecutionResult (line 10) | @RequiredArgsConstructor
    method isAsynchronous (line 15) | boolean isAsynchronous() {
    method getErrors (line 19) | @Override
    method getData (line 24) | @Override
    method isDataPresent (line 29) | @Override
    method getExtensions (line 34) | @Override
    method toSpecification (line 39) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/DefaultGraphQLRootObjectBuilder.java
  class DefaultGraphQLRootObjectBuilder (line 3) | public class DefaultGraphQLRootObjectBuilder extends StaticGraphQLRootOb...
    method DefaultGraphQLRootObjectBuilder (line 5) | public DefaultGraphQLRootObjectBuilder() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/ExtensionsDeserializer.java
  class ExtensionsDeserializer (line 10) | public class ExtensionsDeserializer extends JsonDeserializer<Map<String,...
    method deserializeExtensionsObject (line 12) | public static Map<String, Object> deserializeExtensionsObject(
    method deserialize (line 17) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/FutureBatchedExecutionResult.java
  class FutureBatchedExecutionResult (line 10) | @RequiredArgsConstructor
    method thenApplyQueryResult (line 17) | @Override
    method cancel (line 22) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/FutureErrorExecutionResult.java
  class FutureErrorExecutionResult (line 7) | @RequiredArgsConstructor
    method thenApplyQueryResult (line 12) | @Override
    method getInvocationInput (line 17) | @Override
    method cancel (line 22) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/FutureExecutionResult.java
  type FutureExecutionResult (line 8) | public interface FutureExecutionResult {
    method single (line 10) | static FutureExecutionResult single(
    method batched (line 15) | static FutureExecutionResult batched(
    method error (line 20) | static FutureExecutionResult error(GraphQLErrorQueryResult result) {
    method thenApplyQueryResult (line 24) | CompletableFuture<GraphQLQueryResult> thenApplyQueryResult();
    method getInvocationInput (line 26) | GraphQLInvocationInput getInvocationInput();
    method cancel (line 28) | void cancel();

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/FutureSingleExecutionResult.java
  class FutureSingleExecutionResult (line 9) | @RequiredArgsConstructor
    method thenApplyQueryResult (line 16) | @Override
    method cancel (line 21) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLBatchedQueryResult.java
  class GraphQLBatchedQueryResult (line 8) | @RequiredArgsConstructor
    method isBatched (line 13) | @Override
    method isAsynchronous (line 18) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLErrorQueryResult.java
  class GraphQLErrorQueryResult (line 6) | @Getter
    method isBatched (line 13) | @Override
    method isAsynchronous (line 18) | @Override
    method isError (line 23) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLInvoker.java
  class GraphQLInvoker (line 17) | @Slf4j
    method execute (line 25) | public FutureExecutionResult execute(GraphQLInvocationInput invocation...
    method executeAsync (line 34) | public CompletableFuture<ExecutionResult> executeAsync(
    method query (line 40) | public GraphQLQueryResult query(GraphQLInvocationInput invocationInput) {
    method queryAsync (line 44) | public CompletableFuture<GraphQLQueryResult> queryAsync(GraphQLInvocat...
    method executeAsync (line 54) | private CompletableFuture<List<ExecutionResult>> executeAsync(
    method sequence (line 64) | @SuppressWarnings({"unchecked", "rawtypes"})

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLInvokerProxy.java
  type GraphQLInvokerProxy (line 8) | public interface GraphQLInvokerProxy {
    method executeAsync (line 10) | CompletableFuture<ExecutionResult> executeAsync(GraphQL graphQL, Execu...

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLObjectMapper.java
  class GraphQLObjectMapper (line 28) | public class GraphQLObjectMapper {
    method GraphQLObjectMapper (line 37) | protected GraphQLObjectMapper(
    method newBuilder (line 44) | public static Builder newBuilder() {
    method getJacksonMapper (line 49) | public ObjectMapper getJacksonMapper() {
    method getGraphQLRequestMapper (line 64) | public ObjectReader getGraphQLRequestMapper() {
    method readGraphQLRequest (line 68) | public GraphQLRequest readGraphQLRequest(InputStream inputStream) thro...
    method readGraphQLRequest (line 72) | public GraphQLRequest readGraphQLRequest(String text) throws IOExcepti...
    method readBatchedGraphQLRequest (line 76) | public List<GraphQLRequest> readBatchedGraphQLRequest(InputStream inpu...
    method readBatchedGraphQLRequest (line 88) | public List<GraphQLRequest> readBatchedGraphQLRequest(String query) th...
    method serializeResultAsJson (line 99) | @SneakyThrows
    method serializeResultAsJson (line 104) | public void serializeResultAsJson(Writer writer, ExecutionResult execu...
    method serializeResultAsBytes (line 116) | @SneakyThrows
    method areErrorsPresent (line 121) | public boolean areErrorsPresent(ExecutionResult executionResult) {
    method sanitizeErrors (line 125) | public ExecutionResult sanitizeErrors(ExecutionResult executionResult) {
    method createResultFromExecutionResult (line 139) | public Map<String, Object> createResultFromExecutionResult(ExecutionRe...
    method convertSanitizedExecutionResult (line 144) | public Map<String, Object> convertSanitizedExecutionResult(ExecutionRe...
    method convertSanitizedExecutionResult (line 148) | public Map<String, Object> convertSanitizedExecutionResult(
    method deserializeVariables (line 171) | @SneakyThrows
    method deserializeExtensions (line 177) | @SneakyThrows
    method deserializeMultipartMap (line 183) | @SneakyThrows
    class Builder (line 188) | public static class Builder {
      method withObjectMapperConfigurer (line 193) | public Builder withObjectMapperConfigurer(
      method withObjectMapperConfigurer (line 198) | public Builder withObjectMapperConfigurer(
      method withObjectMapperProvider (line 204) | public Builder withObjectMapperProvider(ObjectMapperProvider objectM...
      method withGraphQLErrorHandler (line 209) | public Builder withGraphQLErrorHandler(GraphQLErrorHandler graphQLEr...
      method withGraphQLErrorHandler (line 213) | public Builder withGraphQLErrorHandler(Supplier<GraphQLErrorHandler>...
      method build (line 218) | public GraphQLObjectMapper build() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLQueryInvoker.java
  class GraphQLQueryInvoker (line 17) | public class GraphQLQueryInvoker {
    method GraphQLQueryInvoker (line 23) | protected GraphQLQueryInvoker(
    method newBuilder (line 32) | public static Builder newBuilder() {
    method toGraphQLInvoker (line 36) | public GraphQLInvoker toGraphQLInvoker() {
    class Builder (line 45) | public static class Builder {
      method withExecutionStrategyProvider (line 54) | public Builder withExecutionStrategyProvider(ExecutionStrategyProvid...
      method withExecutionStrategyProvider (line 58) | public Builder withExecutionStrategyProvider(Supplier<ExecutionStrat...
      method withInstrumentation (line 63) | public Builder withInstrumentation(Instrumentation instrumentation) {
      method withInstrumentation (line 67) | public Builder withInstrumentation(Supplier<Instrumentation> supplie...
      method with (line 72) | public Builder with(List<Instrumentation> instrumentations) {
      method withPreparsedDocumentProvider (line 84) | public Builder withPreparsedDocumentProvider(PreparsedDocumentProvid...
      method withPreparsedDocumentProvider (line 88) | public Builder withPreparsedDocumentProvider(Supplier<PreparsedDocum...
      method build (line 93) | public GraphQLQueryInvoker build() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLQueryResult.java
  type GraphQLQueryResult (line 8) | public interface GraphQLQueryResult {
    method create (line 10) | static GraphQLSingleQueryResult create(ExecutionResult result) {
    method create (line 14) | static GraphQLBatchedQueryResult create(List<ExecutionResult> results) {
    method createError (line 18) | static GraphQLErrorQueryResult createError(int statusCode, String mess...
    method isBatched (line 22) | boolean isBatched();
    method isAsynchronous (line 24) | boolean isAsynchronous();
    method getResult (line 26) | default DecoratedExecutionResult getResult() {
    method getResults (line 30) | default List<ExecutionResult> getResults() {
    method isError (line 34) | default boolean isError() {
    method getStatusCode (line 38) | default int getStatusCode() {
    method getMessage (line 42) | default String getMessage() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLRequest.java
  class GraphQLRequest (line 12) | @JsonIgnoreProperties(ignoreUnknown = true)
    method GraphQLRequest (line 25) | public GraphQLRequest() {}
    method GraphQLRequest (line 27) | public GraphQLRequest(
    method createIntrospectionRequest (line 42) | public static GraphQLRequest createIntrospectionRequest() {
    method createQueryOnlyRequest (line 50) | public static GraphQLRequest createQueryOnlyRequest(String query) {
    method getQuery (line 54) | public String getQuery() {
    method setQuery (line 58) | public void setQuery(String query) {
    method getVariables (line 62) | public Map<String, Object> getVariables() {
    method setVariables (line 66) | public void setVariables(Map<String, Object> variables) {
    method getExtensions (line 72) | public Map<String, Object> getExtensions() {
    method setExtensions (line 76) | public void setExtensions(Map<String, Object> extensions) {
    method getOperationName (line 82) | public String getOperationName() {
    method setOperationName (line 86) | public void setOperationName(String operationName) {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLRootObjectBuilder.java
  type GraphQLRootObjectBuilder (line 3) | public interface GraphQLRootObjectBuilder {
    method build (line 6) | Object build();

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLSingleQueryResult.java
  class GraphQLSingleQueryResult (line 6) | @RequiredArgsConstructor
    method isBatched (line 11) | @Override
    method isAsynchronous (line 16) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/ObjectMapDeserializationException.java
  class ObjectMapDeserializationException (line 3) | public class ObjectMapDeserializationException extends RuntimeException {
    method ObjectMapDeserializationException (line 5) | ObjectMapDeserializationException(String message) {
    method ObjectMapDeserializationException (line 9) | ObjectMapDeserializationException(String message, Throwable cause) {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/ObjectMapDeserializeHelper.java
  class ObjectMapDeserializeHelper (line 8) | public class ObjectMapDeserializeHelper {
    method deserializeObjectMapObject (line 10) | public static Map<String, Object> deserializeObjectMapObject(

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/OperationNameExtractor.java
  class OperationNameExtractor (line 13) | @NoArgsConstructor(access = AccessLevel.PRIVATE)
    method extractOperationName (line 16) | static String extractOperationName(
    method parseForOperationName (line 27) | private static String parseForOperationName(String gqlQuery, String de...

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/StaticGraphQLRootObjectBuilder.java
  class StaticGraphQLRootObjectBuilder (line 3) | public class StaticGraphQLRootObjectBuilder implements GraphQLRootObject...
    method StaticGraphQLRootObjectBuilder (line 7) | public StaticGraphQLRootObjectBuilder(Object rootObject) {
    method build (line 11) | @Override
    method getRootObject (line 16) | protected Object getRootObject() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/StringUtils.java
  class StringUtils (line 6) | @NoArgsConstructor(access = AccessLevel.PRIVATE)
    method isNotEmpty (line 9) | static boolean isNotEmpty(CharSequence cs) {
    method isEmpty (line 13) | static boolean isEmpty(final CharSequence cs) {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/VariablesDeserializer.java
  class VariablesDeserializer (line 11) | public class VariablesDeserializer extends JsonDeserializer<Map<String, ...
    method deserializeVariablesObject (line 13) | public static Map<String, Object> deserializeVariablesObject(
    method deserialize (line 18) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/ConfiguringObjectMapperProvider.java
  class ConfiguringObjectMapperProvider (line 6) | public class ConfiguringObjectMapperProvider implements ObjectMapperProv...
    method ConfiguringObjectMapperProvider (line 12) | public ConfiguringObjectMapperProvider(
    method ConfiguringObjectMapperProvider (line 23) | public ConfiguringObjectMapperProvider(ObjectMapper objectMapperTempla...
    method ConfiguringObjectMapperProvider (line 27) | public ConfiguringObjectMapperProvider(
    method ConfiguringObjectMapperProvider (line 32) | public ConfiguringObjectMapperProvider() {
    method provide (line 36) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/DefaultExecutionStrategyProvider.java
  class DefaultExecutionStrategyProvider (line 6) | public class DefaultExecutionStrategyProvider implements ExecutionStrate...
    method DefaultExecutionStrategyProvider (line 12) | public DefaultExecutionStrategyProvider() {
    method DefaultExecutionStrategyProvider (line 16) | public DefaultExecutionStrategyProvider(ExecutionStrategy executionStr...
    method DefaultExecutionStrategyProvider (line 20) | public DefaultExecutionStrategyProvider(
    method getQueryExecutionStrategy (line 29) | @Override
    method getMutationExecutionStrategy (line 34) | @Override
    method getSubscriptionExecutionStrategy (line 39) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/DefaultGraphQLSchemaProvider.java
  class DefaultGraphQLSchemaProvider (line 6) | public class DefaultGraphQLSchemaProvider implements GraphQLSchemaProvid...
    method DefaultGraphQLSchemaProvider (line 11) | public DefaultGraphQLSchemaProvider(GraphQLSchema schema) {
    method DefaultGraphQLSchemaProvider (line 15) | public DefaultGraphQLSchemaProvider(GraphQLSchema schema, GraphQLSchem...
    method getSchema (line 20) | @Override
    method getReadOnlySchema (line 25) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/ExecutionStrategyProvider.java
  type ExecutionStrategyProvider (line 5) | public interface ExecutionStrategyProvider {
    method getQueryExecutionStrategy (line 7) | ExecutionStrategy getQueryExecutionStrategy();
    method getMutationExecutionStrategy (line 9) | ExecutionStrategy getMutationExecutionStrategy();
    method getSubscriptionExecutionStrategy (line 11) | ExecutionStrategy getSubscriptionExecutionStrategy();

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLBuilder.java
  class GraphQLBuilder (line 13) | public class GraphQLBuilder {
    method executionStrategyProvider (line 26) | public GraphQLBuilder executionStrategyProvider(Supplier<ExecutionStra...
    method preparsedDocumentProvider (line 33) | public GraphQLBuilder preparsedDocumentProvider(Supplier<PreparsedDocu...
    method instrumentation (line 40) | public GraphQLBuilder instrumentation(Supplier<Instrumentation> suppli...
    method graphQLBuilderConfigurer (line 47) | public GraphQLBuilder graphQLBuilderConfigurer(Supplier<GraphQLBuilder...
    method build (line 54) | public GraphQL build(GraphQLSchemaProvider schemaProvider) {
    method build (line 58) | public GraphQL build(GraphQLSchema schema) {
    method build (line 62) | public GraphQL build(

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLBuilderConfigurer.java
  type GraphQLBuilderConfigurer (line 5) | public interface GraphQLBuilderConfigurer {
    method configure (line 7) | void configure(GraphQL.Builder builder);

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLSchemaProvider.java
  type GraphQLSchemaProvider (line 6) | public interface GraphQLSchemaProvider {
    method copyReadOnly (line 8) | static GraphQLSchema copyReadOnly(GraphQLSchema schema) {
    method getSchema (line 13) | GraphQLSchema getSchema();
    method getReadOnlySchema (line 15) | GraphQLSchema getReadOnlySchema();

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLServletObjectMapperConfigurer.java
  type GraphQLServletObjectMapperConfigurer (line 6) | public interface GraphQLServletObjectMapperConfigurer {
    method configure (line 8) | void configure(ObjectMapper mapper);

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/InstrumentationProvider.java
  type InstrumentationProvider (line 5) | public interface InstrumentationProvider {
    method getInstrumentation (line 7) | Instrumentation getInstrumentation();

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/ObjectMapperProvider.java
  type ObjectMapperProvider (line 5) | public interface ObjectMapperProvider {
    method provide (line 7) | ObjectMapper provide();

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/ContextSetting.java
  type ContextSetting (line 14) | public enum ContextSetting {
    method getBatch (line 34) | public GraphQLBatchedInvocationInput getBatch(

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/ContextSettingNotConfiguredException.java
  class ContextSettingNotConfiguredException (line 3) | public class ContextSettingNotConfiguredException extends RuntimeExcepti...
    method ContextSettingNotConfiguredException (line 5) | ContextSettingNotConfiguredException() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/DefaultGraphQLContext.java
  class DefaultGraphQLContext (line 12) | public class DefaultGraphQLContext implements GraphQLKickstartContext {
    method DefaultGraphQLContext (line 17) | public DefaultGraphQLContext(DataLoaderRegistry dataLoaderRegistry, Ma...
    method DefaultGraphQLContext (line 23) | public DefaultGraphQLContext(Map<Object, Object> map) {
    method DefaultGraphQLContext (line 27) | public DefaultGraphQLContext(DataLoaderRegistry dataLoaderRegistry) {
    method DefaultGraphQLContext (line 31) | public DefaultGraphQLContext() {
    method put (line 35) | public void put(Object key, Object value) {
    method getDataLoaderRegistry (line 39) | @Override
    method getMapOfContext (line 44) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/DefaultGraphQLContextBuilder.java
  class DefaultGraphQLContextBuilder (line 4) | public class DefaultGraphQLContextBuilder implements GraphQLContextBuild...
    method build (line 6) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/GraphQLContextBuilder.java
  type GraphQLContextBuilder (line 3) | public interface GraphQLContextBuilder {
    method build (line 6) | GraphQLKickstartContext build();

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/GraphQLKickstartContext.java
  type GraphQLKickstartContext (line 8) | public interface GraphQLKickstartContext {
    method of (line 10) | static GraphQLKickstartContext of(Map<Object, Object> map) {
    method of (line 14) | static GraphQLKickstartContext of(DataLoaderRegistry dataLoaderRegistr...
    method of (line 18) | static GraphQLKickstartContext of(
    method getDataLoaderRegistry (line 24) | @NonNull
    method getMapOfContext (line 27) | Map<Object, Object> getMapOfContext();

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/DefaultGraphQLErrorHandler.java
  class DefaultGraphQLErrorHandler (line 11) | @Slf4j
    method processErrors (line 14) | @Override
    method logError (line 28) | protected void logError(GraphQLError error) {
    method filterGraphQLErrors (line 42) | protected List<GraphQLError> filterGraphQLErrors(List<GraphQLError> er...
    method isClientError (line 49) | protected boolean isClientError(GraphQLError error) {
    method replaceNonNullableFieldWasNullError (line 56) | private GraphQLError replaceNonNullableFieldWasNullError(GraphQLError ...

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/DefaultGraphQLServletObjectMapperConfigurer.java
  class DefaultGraphQLServletObjectMapperConfigurer (line 9) | public class DefaultGraphQLServletObjectMapperConfigurer
    method configure (line 12) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/GenericGraphQLError.java
  class GenericGraphQLError (line 12) | public class GenericGraphQLError implements GraphQLError {
    method GenericGraphQLError (line 16) | public GenericGraphQLError(String message) {
    method getMessage (line 20) | @Override
    method getLocations (line 25) | @Override
    method getErrorType (line 31) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/GraphQLErrorHandler.java
  type GraphQLErrorHandler (line 7) | public interface GraphQLErrorHandler {
    method errorsPresent (line 9) | default boolean errorsPresent(List<GraphQLError> errors) {
    method processErrors (line 13) | List<GraphQLError> processErrors(List<GraphQLError> errors);

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/RenderableNonNullableFieldWasNullError.java
  class RenderableNonNullableFieldWasNullError (line 11) | class RenderableNonNullableFieldWasNullError implements GraphQLError {
    method RenderableNonNullableFieldWasNullError (line 15) | public RenderableNonNullableFieldWasNullError(
    method getMessage (line 20) | @Override
    method getLocations (line 25) | @Override
    method getErrorType (line 31) | @Override
    method getPath (line 36) | @Override
    method toSpecification (line 41) | @Override
    method getExtensions (line 46) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/GraphQLBatchedInvocationInput.java
  type GraphQLBatchedInvocationInput (line 10) | public interface GraphQLBatchedInvocationInput extends GraphQLInvocation...
    method getInvocationInputs (line 13) | List<GraphQLSingleInvocationInput> getInvocationInputs();
    method getExecutionInputs (line 15) | default List<ExecutionInput> getExecutionInputs() {
    method getContextSetting (line 21) | ContextSetting getContextSetting();

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/GraphQLInvocationInput.java
  type GraphQLInvocationInput (line 5) | public interface GraphQLInvocationInput {
    method getQueries (line 6) | List<String> getQueries();

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/GraphQLSingleInvocationInput.java
  class GraphQLSingleInvocationInput (line 13) | public class GraphQLSingleInvocationInput implements GraphQLInvocationIn...
    method GraphQLSingleInvocationInput (line 19) | public GraphQLSingleInvocationInput(
    method getSchema (line 26) | public GraphQLSchema getSchema() {
    method createExecutionInput (line 30) | private ExecutionInput createExecutionInput(
    method getExecutionInput (line 45) | public ExecutionInput getExecutionInput() {
    method getQueries (line 49) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/PerQueryBatchedInvocationInput.java
  class PerQueryBatchedInvocationInput (line 15) | @Getter
    method PerQueryBatchedInvocationInput (line 21) | public PerQueryBatchedInvocationInput(
    method getQueries (line 36) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/PerRequestBatchedInvocationInput.java
  class PerRequestBatchedInvocationInput (line 14) | @Getter
    method PerRequestBatchedInvocationInput (line 20) | public PerRequestBatchedInvocationInput(
    method getQueries (line 34) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/AbstractTrackingApproach.java
  class AbstractTrackingApproach (line 17) | @Slf4j
    method AbstractTrackingApproach (line 24) | protected AbstractTrackingApproach(DataLoaderRegistry dataLoaderRegist...
    method getStack (line 29) | protected RequestStack getStack() {
    method beginExecutionStrategy (line 33) | @Override
    method handleOnFieldValuesInfo (line 74) | private boolean handleOnFieldValuesInfo(
    method getCountForList (line 92) | private int getCountForList(FieldValueInfo fieldValueInfo) {
    method beginFieldFetch (line 104) | @Override
    method removeTracking (line 131) | @Override
    method dispatchIfNeeded (line 144) | private boolean dispatchIfNeeded(RequestStack stack, ExecutionId execu...
    method levelReady (line 154) | private boolean levelReady(RequestStack stack, ExecutionId executionId...
    method dispatch (line 165) | @Override
    method dispatchWithoutLocking (line 172) | private void dispatchWithoutLocking() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/DataLoaderDispatcherInstrumentationState.java
  class DataLoaderDispatcherInstrumentationState (line 8) | public class DataLoaderDispatcherInstrumentationState implements Instrum...
    method DataLoaderDispatcherInstrumentationState (line 15) | public DataLoaderDispatcherInstrumentationState(
    method isAggressivelyBatching (line 24) | boolean isAggressivelyBatching() {
    method setAggressivelyBatching (line 28) | void setAggressivelyBatching(boolean aggressivelyBatching) {
    method getApproach (line 32) | TrackingApproach getApproach() {
    method getDataLoaderRegistry (line 36) | DataLoaderRegistry getDataLoaderRegistry() {
    method hasNoDataLoaders (line 40) | boolean hasNoDataLoaders() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/FieldLevelTrackingApproach.java
  class FieldLevelTrackingApproach (line 13) | @Internal
    method FieldLevelTrackingApproach (line 16) | public FieldLevelTrackingApproach(DataLoaderRegistry dataLoaderRegistr...
    method createState (line 20) | public InstrumentationState createState(ExecutionId executionId) {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/NoOpInstrumentationProvider.java
  class NoOpInstrumentationProvider (line 7) | public class NoOpInstrumentationProvider implements InstrumentationProvi...
    method getInstrumentation (line 9) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/RequestLevelTrackingApproach.java
  class RequestLevelTrackingApproach (line 9) | public class RequestLevelTrackingApproach extends AbstractTrackingApproa...
    method RequestLevelTrackingApproach (line 11) | public RequestLevelTrackingApproach(
    method createState (line 18) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/RequestStack.java
  class RequestStack (line 12) | public class RequestStack {
    method setStatus (line 24) | public void setStatus(ExecutionId executionId, boolean toState) {
    method allReady (line 37) | public boolean allReady() {
    method allReset (line 44) | public void allReset() {
    method contains (line 54) | public boolean contains(ExecutionId executionId) {
    method removeExecution (line 63) | public void removeExecution(ExecutionId executionId) {
    method addExecution (line 73) | public void addExecution(ExecutionId executionId) {
    method increaseExpectedFetchCount (line 90) | public void increaseExpectedFetchCount(ExecutionId executionId, int cu...
    method increaseHappenedStrategyCalls (line 106) | public void increaseHappenedStrategyCalls(ExecutionId executionId, int...
    method increaseHappenedOnFieldValueCalls (line 122) | public void increaseHappenedOnFieldValueCalls(ExecutionId executionId,...
    method increaseExpectedStrategyCalls (line 139) | public void increaseExpectedStrategyCalls(
    method allFetchesHappened (line 157) | public boolean allFetchesHappened(ExecutionId executionId, int level) {
    method allOnFieldCallsHappened (line 174) | public boolean allOnFieldCallsHappened(ExecutionId executionId, int le...
    method allStrategyCallsHappened (line 191) | public boolean allStrategyCallsHappened(ExecutionId executionId, int l...
    method dispatchIfNotDispatchedBefore (line 208) | public boolean dispatchIfNotDispatchedBefore(ExecutionId executionId, ...
    method increaseFetchCount (line 224) | public void increaseFetchCount(ExecutionId executionId, int level) {
    method clearAndMarkCurrentLevelAsReady (line 240) | public void clearAndMarkCurrentLevelAsReady(ExecutionId executionId, i...
    class CallStack (line 250) | private static class CallStack {
      method CallStack (line 260) | private CallStack() {
      method increaseExpectedFetchCount (line 264) | private void increaseExpectedFetchCount(int level, int count) {
      method increaseFetchCount (line 269) | private void increaseFetchCount(int level) {
      method increaseExpectedStrategyCalls (line 273) | private void increaseExpectedStrategyCalls(int level, int count) {
      method increaseHappenedStrategyCalls (line 278) | private void increaseHappenedStrategyCalls(int level) {
      method increaseHappenedOnFieldValueCalls (line 283) | private void increaseHappenedOnFieldValueCalls(int level) {
      method allStrategyCallsHappened (line 288) | private boolean allStrategyCallsHappened(int level) {
      method allOnFieldCallsHappened (line 293) | private boolean allOnFieldCallsHappened(int level) {
      method allFetchesHappened (line 298) | private boolean allFetchesHappened(int level) {
      method getDispatchedLevels (line 302) | private List<Integer> getDispatchedLevels() {
      method toString (line 306) | @Override
      method dispatchIfNotDispatchedBefore (line 324) | private boolean dispatchIfNotDispatchedBefore(int level) {
      method clearAndMarkCurrentLevelAsReady (line 333) | private void clearAndMarkCurrentLevelAsReady(int level) {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/TrackingApproach.java
  type TrackingApproach (line 10) | public interface TrackingApproach extends InstrumentationState {
    method createState (line 18) | InstrumentationState createState(ExecutionId executionId);
    method dispatch (line 21) | void dispatch();
    method beginExecutionStrategy (line 29) | ExecutionStrategyInstrumentationContext beginExecutionStrategy(
    method beginFieldFetch (line 38) | InstrumentationContext<Object> beginFieldFetch(InstrumentationFieldFet...
    method removeTracking (line 45) | void removeTracking(ExecutionId executionId);

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/TrackingApproachException.java
  class TrackingApproachException (line 3) | public class TrackingApproachException extends RuntimeException {
    method TrackingApproachException (line 5) | TrackingApproachException(String message) {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/AtomicSubscriptionSubscription.java
  class AtomicSubscriptionSubscription (line 6) | public class AtomicSubscriptionSubscription {
    method set (line 10) | public void set(Subscription subscription) {
    method get (line 18) | public Subscription get() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/DefaultSubscriptionSession.java
  class DefaultSubscriptionSession (line 14) | @Slf4j
    method send (line 22) | @Override
    method sendMessage (line 28) | @Override
    method subscribe (line 34) | @Override
    method add (line 39) | @Override
    method unsubscribe (line 44) | @Override
    method sendDataMessage (line 49) | @Override
    method sendErrorMessage (line 54) | @Override
    method sendCompleteMessage (line 59) | @Override
    method close (line 64) | @Override
    method getUserProperties (line 71) | @Override
    method isOpen (line 76) | @Override
    method getId (line 81) | @Override
    method getSubscriptions (line 86) | @Override
    method unwrap (line 91) | @Override
    method getPublisher (line 96) | @Override
    method toString (line 101) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/GraphQLSubscriptionInvocationInputFactory.java
  type GraphQLSubscriptionInvocationInputFactory (line 6) | public interface GraphQLSubscriptionInvocationInputFactory {
    method create (line 8) | GraphQLSingleInvocationInput create(GraphQLRequest graphQLRequest, Sub...

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/GraphQLSubscriptionMapper.java
  class GraphQLSubscriptionMapper (line 12) | @RequiredArgsConstructor
    method readGraphQLRequest (line 17) | public GraphQLRequest readGraphQLRequest(String payload) {
    method convertGraphQLRequest (line 26) | public GraphQLRequest convertGraphQLRequest(Object payload) {
    method sanitizeErrors (line 31) | public ExecutionResult sanitizeErrors(ExecutionResult executionResult) {
    method hasNoErrors (line 35) | public boolean hasNoErrors(ExecutionResult executionResult) {
    method convertSanitizedExecutionResult (line 39) | public Map<String, Object> convertSanitizedExecutionResult(ExecutionRe...
    method serialize (line 43) | public String serialize(Object payload) {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SessionSubscriber.java
  class SessionSubscriber (line 16) | @Slf4j
    method onSubscribe (line 25) | @Override
    method onNext (line 34) | @Override
    method onError (line 43) | @Override
    method onComplete (line 61) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SessionSubscriptions.java
  class SessionSubscriptions (line 8) | public class SessionSubscriptions {
    method add (line 15) | public void add(Subscription subscription) {
    method add (line 19) | public void add(String id, Subscription subscription) {
    method cancel (line 28) | public void cancel(Subscription subscription) {
    method cancel (line 32) | public void cancel(String id) {
    method close (line 39) | public void close() {
    method getImplicitId (line 47) | private String getImplicitId(Subscription subscription) {
    method getSubscriptionCount (line 51) | public int getSubscriptionCount() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SubscriptionConnectionListener.java
  type SubscriptionConnectionListener (line 4) | public interface SubscriptionConnectionListener {}

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SubscriptionException.java
  class SubscriptionException (line 3) | public class SubscriptionException extends Exception {
    method SubscriptionException (line 7) | public SubscriptionException() {
    method SubscriptionException (line 11) | public SubscriptionException(Object payload) {
    method getPayload (line 15) | public Object getPayload() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SubscriptionProtocolFactory.java
  class SubscriptionProtocolFactory (line 6) | public abstract class SubscriptionProtocolFactory {
    method SubscriptionProtocolFactory (line 10) | protected SubscriptionProtocolFactory(String protocol) {
    method getProtocol (line 14) | public String getProtocol() {
    method createConsumer (line 18) | public abstract Consumer<String> createConsumer(SubscriptionSession se...
    method shutdown (line 20) | public void shutdown() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SubscriptionSession.java
  type SubscriptionSession (line 8) | public interface SubscriptionSession {
    method subscribe (line 10) | void subscribe(String id, Publisher<ExecutionResult> data);
    method add (line 12) | void add(String id, Subscription subscription);
    method unsubscribe (line 14) | void unsubscribe(String id);
    method send (line 16) | void send(String message);
    method sendMessage (line 18) | void sendMessage(Object payload);
    method sendDataMessage (line 20) | void sendDataMessage(String id, Object payload);
    method sendErrorMessage (line 22) | void sendErrorMessage(String id, Object payload);
    method sendCompleteMessage (line 24) | void sendCompleteMessage(String id);
    method close (line 26) | void close(String reason);
    method getUserProperties (line 39) | Map<String, Object> getUserProperties();
    method isOpen (line 41) | boolean isOpen();
    method getId (line 43) | String getId();
    method getSubscriptions (line 45) | SessionSubscriptions getSubscriptions();
    method unwrap (line 47) | Object unwrap();
    method getPublisher (line 49) | Publisher<String> getPublisher();

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloCommandProvider.java
  class ApolloCommandProvider (line 10) | public class ApolloCommandProvider {
    method ApolloCommandProvider (line 14) | public ApolloCommandProvider(
    method getByType (line 31) | public SubscriptionCommand getByType(Type type) {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionConnectionListener.java
  type ApolloSubscriptionConnectionListener (line 6) | public interface ApolloSubscriptionConnectionListener extends Subscripti...
    method onConnect (line 8) | default void onConnect(SubscriptionSession session, OperationMessage m...
    method onStart (line 12) | default void onStart(SubscriptionSession session, OperationMessage mes...
    method onStop (line 16) | default void onStop(SubscriptionSession session, OperationMessage mess...
    method onTerminate (line 20) | default void onTerminate(SubscriptionSession session, OperationMessage...
    method shutdown (line 24) | default void shutdown() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionConsumer.java
  class ApolloSubscriptionConsumer (line 11) | @Slf4j
    method accept (line 19) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionKeepAliveRunner.java
  class ApolloSubscriptionKeepAliveRunner (line 14) | @Slf4j
    method ApolloSubscriptionKeepAliveRunner (line 24) | ApolloSubscriptionKeepAliveRunner(Duration keepAliveInterval) {
    method keepAlive (line 31) | void keepAlive(SubscriptionSession session) {
    method startKeepAlive (line 35) | private ScheduledFuture<?> startKeepAlive(SubscriptionSession session) {
    method abort (line 58) | void abort(SubscriptionSession session) {
    method shutdown (line 65) | void shutdown() {

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionProtocolFactory.java
  class ApolloSubscriptionProtocolFactory (line 17) | public class ApolloSubscriptionProtocolFactory extends SubscriptionProto...
    method ApolloSubscriptionProtocolFactory (line 24) | public ApolloSubscriptionProtocolFactory(
    method ApolloSubscriptionProtocolFactory (line 35) | public ApolloSubscriptionProtocolFactory(
    method ApolloSubscriptionProtocolFactory (line 43) | public ApolloSubscriptionProtocolFactory(
    method ApolloSubscriptionProtocolFactory (line 56) | public ApolloSubscriptionProtocolFactory(
    method createConsumer (line 82) | @Override
    method shutdown (line 87) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionSession.java
  class ApolloSubscriptionSession (line 8) | @Slf4j
    method ApolloSubscriptionSession (line 11) | public ApolloSubscriptionSession(GraphQLSubscriptionMapper mapper) {
    method sendDataMessage (line 15) | @Override
    method sendErrorMessage (line 20) | @Override
    method sendCompleteMessage (line 25) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/KeepAliveSubscriptionConnectionListener.java
  class KeepAliveSubscriptionConnectionListener (line 6) | public class KeepAliveSubscriptionConnectionListener
    method KeepAliveSubscriptionConnectionListener (line 11) | public KeepAliveSubscriptionConnectionListener() {
    method KeepAliveSubscriptionConnectionListener (line 15) | public KeepAliveSubscriptionConnectionListener(Duration keepAliveInter...
    method onConnect (line 19) | @Override
    method onStart (line 24) | @Override
    method onStop (line 29) | @Override
    method onTerminate (line 34) | @Override
    method shutdown (line 39) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/OperationMessage.java
  class OperationMessage (line 11) | @NoArgsConstructor
    method newKeepAliveMessage (line 20) | public static OperationMessage newKeepAliveMessage() {
    method getType (line 24) | public Type getType() {
    method getId (line 28) | public String getId() {
    method getPayload (line 32) | public Object getPayload() {
    type Type (line 36) | public enum Type {
      method Type (line 62) | Type(String value) {
      method findType (line 66) | @JsonCreator
      method getValue (line 71) | @JsonValue

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionCommand.java
  type SubscriptionCommand (line 5) | interface SubscriptionCommand {
    method apply (line 7) | void apply(SubscriptionSession session, OperationMessage message);

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionConnectionInitCommand.java
  class SubscriptionConnectionInitCommand (line 9) | @Slf4j
    method apply (line 15) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionConnectionTerminateCommand.java
  class SubscriptionConnectionTerminateCommand (line 10) | @Slf4j
    method apply (line 16) | @Override

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionStartCommand.java
  class SubscriptionStartCommand (line 18) | @Slf4j
    method apply (line 27) | @Override
    method executeAsync (line 36) | private CompletableFuture<ExecutionResult> executeAsync(
    method handleSubscriptionStart (line 46) | private void handleSubscriptionStart(

FILE: graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionStopCommand.java
  class SubscriptionStopCommand (line 7) | @RequiredArgsConstructor
    method apply (line 12) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AbstractGraphQLHttpServlet.java
  class AbstractGraphQLHttpServlet (line 18) | @Slf4j
    method getConfiguration (line 22) | protected abstract GraphQLConfiguration getConfiguration();
    method addListener (line 24) | public void addListener(GraphQLServletListener servletListener) {
    method removeListener (line 28) | public void removeListener(GraphQLServletListener servletListener) {
    method getQueries (line 32) | @Override
    method getMutations (line 45) | @Override
    method executeQuery (line 58) | @Override
    method doGet (line 72) | @Override
    method doPost (line 77) | @Override
    method doRequest (line 82) | private void doRequest(HttpServletRequest request, HttpServletResponse...

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AbstractGraphQLInvocationInputParser.java
  class AbstractGraphQLInvocationInputParser (line 8) | @RequiredArgsConstructor
    method isSingleQuery (line 15) | boolean isSingleQuery(String query) {
    method isBatchedQuery (line 19) | boolean isBatchedQuery(String query) {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AsyncTaskDecorator.java
  type AsyncTaskDecorator (line 3) | public interface AsyncTaskDecorator {
    method decorate (line 5) | Runnable decorate(Runnable runnable);

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AsyncTaskExecutor.java
  class AsyncTaskExecutor (line 7) | @RequiredArgsConstructor
    method execute (line 13) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AsyncTimeoutListener.java
  type AsyncTimeoutListener (line 7) | interface AsyncTimeoutListener extends AsyncListener {
    method onComplete (line 9) | default void onComplete(AsyncEvent event) throws IOException {}
    method onError (line 11) | default void onError(AsyncEvent event) throws IOException {}
    method onStartAsync (line 13) | default void onStartAsync(AsyncEvent event) throws IOException {}

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/BatchedQueryResponseWriter.java
  class BatchedQueryResponseWriter (line 14) | @Slf4j
    method write (line 20) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ConfiguredGraphQLHttpServlet.java
  class ConfiguredGraphQLHttpServlet (line 5) | class ConfiguredGraphQLHttpServlet extends GraphQLHttpServlet {
    method ConfiguredGraphQLHttpServlet (line 9) | ConfiguredGraphQLHttpServlet(GraphQLConfiguration configuration) {
    method getConfiguration (line 13) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ErrorQueryResponseWriter.java
  class ErrorQueryResponseWriter (line 8) | @RequiredArgsConstructor
    method write (line 14) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ExecutionResultSubscriber.java
  class ExecutionResultSubscriber (line 13) | class ExecutionResultSubscriber implements Subscriber<ExecutionResult> {
    method ExecutionResultSubscriber (line 20) | ExecutionResultSubscriber(
    method onSubscribe (line 29) | @Override
    method onNext (line 35) | @Override
    method onError (line 49) | @Override
    method onComplete (line 55) | @Override
    method await (line 61) | void await() throws InterruptedException {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLConfiguration.java
  class GraphQLConfiguration (line 27) | public class GraphQLConfiguration {
    method GraphQLConfiguration (line 41) | private GraphQLConfiguration(
    method with (line 65) | public static GraphQLConfiguration.Builder with(GraphQLSchema schema) {
    method with (line 69) | public static GraphQLConfiguration.Builder with(GraphQLSchemaServletPr...
    method with (line 73) | public static GraphQLConfiguration.Builder with(
    method getInvocationInputFactory (line 78) | public GraphQLInvocationInputFactory getInvocationInputFactory() {
    method getGraphQLInvoker (line 82) | public GraphQLInvoker getGraphQLInvoker() {
    method getObjectMapper (line 86) | public GraphQLObjectMapper getObjectMapper() {
    method getListeners (line 90) | public List<GraphQLServletListener> getListeners() {
    method add (line 94) | public void add(GraphQLServletListener listener) {
    method remove (line 98) | public boolean remove(GraphQLServletListener listener) {
    method getSubscriptionTimeout (line 102) | public long getSubscriptionTimeout() {
    method getContextSetting (line 106) | public ContextSetting getContextSetting() {
    method getBatchInputPreProcessor (line 110) | public BatchInputPreProcessor getBatchInputPreProcessor() {
    method getResponseCacheManager (line 114) | public GraphQLResponseCacheManager getResponseCacheManager() {
    method getHttpRequestHandler (line 118) | public HttpRequestHandler getHttpRequestHandler() {
    method createHttpRequestHandler (line 125) | private HttpRequestHandler createHttpRequestHandler() {
    class Builder (line 133) | public static class Builder {
      method Builder (line 152) | private Builder(GraphQLInvocationInputFactory.Builder invocationInpu...
      method Builder (line 156) | private Builder(GraphQLInvocationInputFactory invocationInputFactory) {
      method with (line 160) | public Builder with(GraphQLInvoker graphQLInvoker) {
      method with (line 165) | public Builder with(GraphQLQueryInvoker queryInvoker) {
      method with (line 172) | public Builder with(GraphQLObjectMapper objectMapper) {
      method with (line 179) | public Builder with(List<GraphQLServletListener> listeners) {
      method with (line 186) | public Builder with(GraphQLServletContextBuilder contextBuilder) {
      method with (line 191) | public Builder with(GraphQLServletRootObjectBuilder rootObjectBuilde...
      method with (line 196) | public Builder with(long subscriptionTimeout) {
      method asyncTimeout (line 201) | public Builder asyncTimeout(long asyncTimeout) {
      method with (line 206) | public Builder with(Executor asyncExecutor) {
      method asyncCorePoolSize (line 211) | public Builder asyncCorePoolSize(int asyncCorePoolSize) {
      method asyncMaxPoolSize (line 216) | public Builder asyncMaxPoolSize(int asyncMaxPoolSize) {
      method with (line 221) | public Builder with(ContextSetting contextSetting) {
      method with (line 228) | public Builder with(BatchInputPreProcessor batchInputPreProcessor) {
      method with (line 235) | public Builder with(Supplier<BatchInputPreProcessor> batchInputPrePr...
      method with (line 242) | public Builder with(GraphQLResponseCacheManager responseCache) {
      method with (line 247) | public Builder with(AsyncTaskDecorator asyncTaskDecorator) {
      method getAsyncExecutor (line 252) | private Executor getAsyncExecutor() {
      method getAsyncTaskExecutor (line 264) | private Executor getAsyncTaskExecutor() {
      method build (line 268) | public GraphQLConfiguration build() {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLGetInvocationInputParser.java
  class GraphQLGetInvocationInputParser (line 18) | @Slf4j
    method GraphQLGetInvocationInputParser (line 21) | GraphQLGetInvocationInputParser(
    method getGraphQLInvocationInput (line 28) | public GraphQLInvocationInput getGraphQLInvocationInput(
    method isIntrospectionQuery (line 54) | private boolean isIntrospectionQuery(HttpServletRequest request) {
    method getVariables (line 60) | private Map<String, Object> getVariables(HttpServletRequest request) {
    method getExtensions (line 67) | private Map<String, Object> getExtensions(HttpServletRequest request) {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLHttpServlet.java
  class GraphQLHttpServlet (line 6) | public abstract class GraphQLHttpServlet extends AbstractGraphQLHttpServ...
    method with (line 8) | public static GraphQLHttpServlet with(GraphQLSchema schema) {
    method with (line 12) | public static GraphQLHttpServlet with(GraphQLConfiguration configurati...
    method getConfiguration (line 16) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLInvocationInputParser.java
  type GraphQLInvocationInputParser (line 12) | interface GraphQLInvocationInputParser {
    method create (line 14) | static GraphQLInvocationInputParser create(
    method getGraphQLInvocationInput (line 41) | GraphQLInvocationInput getGraphQLInvocationInput(

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLMultipartInvocationInputParser.java
  class GraphQLMultipartInvocationInputParser (line 27) | @Slf4j
    method GraphQLMultipartInvocationInputParser (line 32) | GraphQLMultipartInvocationInputParser(
    method getGraphQLInvocationInput (line 39) | @Override
    method getGraphQLInvocationInput (line 70) | private GraphQLInvocationInput getGraphQLInvocationInput(
    method findPart (line 108) | private Optional<Part> findPart(Map<String, List<Part>> parts) {
    method getPart (line 117) | private Optional<Part> getPart(Map<String, List<Part>> parts, String n...
    method mapMultipartVariables (line 123) | private void mapMultipartVariables(
    method buildRequestFromQuery (line 145) | private GraphQLRequest buildRequestFromQuery(
    method read (line 176) | private String read(InputStream inputStream, String charset) throws IO...

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLPostInvocationInputParser.java
  class GraphQLPostInvocationInputParser (line 16) | class GraphQLPostInvocationInputParser extends AbstractGraphQLInvocation...
    method GraphQLPostInvocationInputParser (line 20) | GraphQLPostInvocationInputParser(
    method getGraphQLInvocationInput (line 27) | public GraphQLInvocationInput getGraphQLInvocationInput(

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLWebsocketServlet.java
  class GraphQLWebsocketServlet (line 48) | @Slf4j
    method GraphQLWebsocketServlet (line 69) | public GraphQLWebsocketServlet(GraphQLConfiguration configuration) {
    method GraphQLWebsocketServlet (line 73) | public GraphQLWebsocketServlet(
    method GraphQLWebsocketServlet (line 83) | public GraphQLWebsocketServlet(
    method GraphQLWebsocketServlet (line 90) | public GraphQLWebsocketServlet(
    method GraphQLWebsocketServlet (line 119) | public GraphQLWebsocketServlet(
    method onOpen (line 134) | @Override
    method onClose (line 169) | @Override
    method onError (line 181) | @Override
    method closeUnexpectedly (line 194) | private void closeUnexpectedly(Session session, Throwable t) {
    method modifyHandshake (line 202) | public void modifyHandshake(
    method beginShutDown (line 229) | public void beginShutDown() {
    method isShutDown (line 264) | public boolean isShutDown() {
    method getSubscriptionProtocolFactory (line 268) | private SubscriptionProtocolFactory getSubscriptionProtocolFactory(Lis...
    method getSessionCount (line 281) | public int getSessionCount() {
    method getSubscriptionCount (line 285) | public int getSubscriptionCount() {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/HttpRequestHandler.java
  type HttpRequestHandler (line 7) | public interface HttpRequestHandler {
    method handle (line 16) | void handle(HttpServletRequest request, HttpServletResponse response) ...

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/HttpRequestHandlerImpl.java
  class HttpRequestHandlerImpl (line 11) | @Slf4j
    method HttpRequestHandlerImpl (line 17) | HttpRequestHandlerImpl(GraphQLConfiguration configuration) {
    method HttpRequestHandlerImpl (line 26) | HttpRequestHandlerImpl(
    method handle (line 32) | @Override
    method parseInvocationInput (line 60) | private GraphQLInvocationInput parseInvocationInput(

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/HttpRequestInvoker.java
  type HttpRequestInvoker (line 7) | public interface HttpRequestInvoker {
    method execute (line 9) | void execute(

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/HttpRequestInvokerImpl.java
  class HttpRequestInvokerImpl (line 31) | @Slf4j
    method execute (line 39) | @Override
    method invokeAndHandleAsync (line 52) | private void invokeAndHandleAsync(
    method handle (line 102) | private void handle(
    method handleInternal (line 125) | private CompletableFuture<Void> handleInternal(
    method writeResultResponse (line 145) | private void writeResultResponse(
    method writeErrorResponse (line 158) | private Void writeErrorResponse(
    method getCause (line 176) | private Throwable getCause(Throwable t) {
    method toErrorResult (line 180) | private ExecutionResult toErrorResult(Throwable t) {
    method createWriter (line 193) | protected QueryResponseWriter createWriter(
    method invoke (line 198) | private FutureExecutionResult invoke(
    method invokeBatched (line 208) | private FutureExecutionResult invokeBatched(

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/InvocationInputParseException.java
  class InvocationInputParseException (line 3) | public class InvocationInputParseException extends RuntimeException {
    method InvocationInputParseException (line 5) | public InvocationInputParseException(Throwable t) {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ListenerHandler.java
  class ListenerHandler (line 17) | @Slf4j
    method start (line 25) | static ListenerHandler start(
    method runListeners (line 36) | private static <R> List<R> runListeners(
    method runCallbacks (line 52) | void runCallbacks(Consumer<RequestCallback> action) {
    method onParseError (line 63) | void onParseError(Throwable throwable) {
    method beforeFlush (line 67) | void beforeFlush() {
    method onSuccess (line 71) | void onSuccess() {
    method onError (line 75) | void onError(Throwable throwable) {
    method onFinally (line 79) | void onFinally() {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/OsgiGraphQLHttpServlet.java
  class OsgiGraphQLHttpServlet (line 34) | @Component(
    method OsgiGraphQLHttpServlet (line 42) | public OsgiGraphQLHttpServlet() {
    method activate (line 46) | @Activate
    method deactivate (line 51) | @Deactivate
    method getConfiguration (line 56) | @Override
    method updateSchema (line 61) | protected void updateSchema() {
    method bindProvider (line 65) | @Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = Refer...
    method unbindProvider (line 88) | public void unbindProvider(GraphQLProvider provider) {
    method bindQueryProvider (line 110) | @Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = Refer...
    method unbindQueryProvider (line 116) | public void unbindQueryProvider(GraphQLQueryProvider queryProvider) {
    method bindMutationProvider (line 121) | @Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = Refer...
    method unbindMutationProvider (line 127) | public void unbindMutationProvider(GraphQLMutationProvider mutationPro...
    method bindSubscriptionProvider (line 132) | @Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = Refer...
    method unbindSubscriptionProvider (line 138) | public void unbindSubscriptionProvider(GraphQLSubscriptionProvider sub...
    method bindTypesProvider (line 143) | @Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = Refer...
    method unbindTypesProvider (line 149) | public void unbindTypesProvider(GraphQLTypesProvider typesProvider) {
    method bindDirectivesProvider (line 154) | @Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = Refer...
    method unbindDirectivesProvider (line 160) | public void unbindDirectivesProvider(GraphQLDirectiveProvider directiv...
    method bindServletListener (line 165) | @Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = Refer...
    method unbindServletListener (line 170) | public void unbindServletListener(GraphQLServletListener listener) {
    method setContextBuilder (line 174) | @Reference(cardinality = ReferenceCardinality.OPTIONAL, policy = Refer...
    method unsetContextBuilder (line 179) | public void unsetContextBuilder(GraphQLServletContextBuilder contextBu...
    method setRootObjectBuilder (line 183) | @Reference(cardinality = ReferenceCardinality.OPTIONAL, policy = Refer...
    method unsetRootObjectBuilder (line 188) | public void unsetRootObjectBuilder(GraphQLRootObjectBuilder rootObject...
    method setExecutionStrategyProvider (line 192) | @Reference(
    method unsetExecutionStrategyProvider (line 200) | public void unsetExecutionStrategyProvider(ExecutionStrategyProvider p...
    method setInstrumentationProvider (line 204) | @Reference(
    method unsetInstrumentationProvider (line 212) | public void unsetInstrumentationProvider(InstrumentationProvider provi...
    method setErrorHandler (line 216) | @Reference(
    method unsetErrorHandler (line 224) | public void unsetErrorHandler(GraphQLErrorHandler errorHandler) {
    method setPreparsedDocumentProvider (line 228) | @Reference(
    method unsetPreparsedDocumentProvider (line 236) | public void unsetPreparsedDocumentProvider(PreparsedDocumentProvider p...
    method bindCodeRegistryProvider (line 240) | @Reference(
    method unbindCodeRegistryProvider (line 249) | public void unbindCodeRegistryProvider(GraphQLCodeRegistryProvider gra...

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/OsgiSchemaBuilder.java
  class OsgiSchemaBuilder (line 48) | @Setter
    method activate (line 75) | void activate(int schemaUpdateDelay) {
    method deactivate (line 82) | void deactivate() {
    method updateSchema (line 88) | void updateSchema() {
    method doUpdateSchema (line 101) | private void doUpdateSchema() {
    method buildQueryType (line 114) | private GraphQLObjectType buildQueryType() {
    method buildTypes (line 135) | private Set<GraphQLType> buildTypes() {
    method buildMutationType (line 142) | private GraphQLObjectType buildMutationType() {
    method buildSubscriptionType (line 146) | private GraphQLObjectType buildSubscriptionType() {
    method buildObjectType (line 150) | private GraphQLObjectType buildObjectType(String name, List<GraphQLFie...
    method buildDirectives (line 166) | private Set<GraphQLDirective> buildDirectives() {
    method add (line 173) | void add(GraphQLQueryProvider provider) {
    method add (line 177) | void add(GraphQLMutationProvider provider) {
    method add (line 181) | void add(GraphQLSubscriptionProvider provider) {
    method add (line 185) | void add(GraphQLTypesProvider provider) {
    method add (line 189) | void add(GraphQLDirectiveProvider provider) {
    method remove (line 193) | void remove(GraphQLQueryProvider provider) {
    method remove (line 197) | void remove(GraphQLMutationProvider provider) {
    method remove (line 201) | void remove(GraphQLSubscriptionProvider provider) {
    method remove (line 205) | void remove(GraphQLTypesProvider provider) {
    method remove (line 209) | void remove(GraphQLDirectiveProvider provider) {
    method getSchemaProvider (line 213) | GraphQLSchemaServletProvider getSchemaProvider() {
    method buildConfiguration (line 217) | GraphQLConfiguration buildConfiguration() {
    method buildInvocationInputFactory (line 225) | private GraphQLInvocationInputFactory buildInvocationInputFactory() {
    method buildQueryInvoker (line 232) | private GraphQLQueryInvoker buildQueryInvoker() {
    method buildObjectMapper (line 240) | private GraphQLObjectMapper buildObjectMapper() {
    method add (line 244) | void add(GraphQLServletListener listener) {
    method remove (line 248) | void remove(GraphQLServletListener listener) {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/PartIOException.java
  class PartIOException (line 3) | public class PartIOException extends RuntimeException {
    method PartIOException (line 5) | public PartIOException(String message, Throwable cause) {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/QueryResponseWriter.java
  type QueryResponseWriter (line 7) | public interface QueryResponseWriter {
    method write (line 9) | void write(HttpServletRequest request, HttpServletResponse response) t...

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/QueryResponseWriterFactory.java
  type QueryResponseWriterFactory (line 6) | public interface QueryResponseWriterFactory {
    method createWriter (line 8) | QueryResponseWriter createWriter(

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/QueryResponseWriterFactoryImpl.java
  class QueryResponseWriterFactoryImpl (line 7) | public class QueryResponseWriterFactoryImpl implements QueryResponseWrit...
    method createWriter (line 9) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/SingleAsynchronousQueryResponseWriter.java
  class SingleAsynchronousQueryResponseWriter (line 17) | @RequiredArgsConstructor
    method write (line 24) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/SingleQueryResponseWriter.java
  class SingleQueryResponseWriter (line 11) | @RequiredArgsConstructor
    method write (line 17) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/StaticDataPublisher.java
  class StaticDataPublisher (line 6) | class StaticDataPublisher<T> extends SingleSubscriberPublisher<T> implem...
    method StaticDataPublisher (line 8) | StaticDataPublisher(T data) {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/SubscriptionAsyncListener.java
  class SubscriptionAsyncListener (line 9) | @RequiredArgsConstructor
    method onComplete (line 14) | @Override
    method onTimeout (line 19) | @Override
    method onError (line 24) | @Override
    method onStartAsync (line 29) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/apollo/ApolloScalars.java
  class ApolloScalars (line 12) | @NoArgsConstructor(access = AccessLevel.PRIVATE)
    method serialize (line 21) | @Override
    method parseValue (line 26) | @Override
    method parseLiteral (line 41) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/apollo/ApolloWebSocketSubscriptionProtocolFactory.java
  class ApolloWebSocketSubscriptionProtocolFactory (line 15) | public class ApolloWebSocketSubscriptionProtocolFactory extends ApolloSu...
    method ApolloWebSocketSubscriptionProtocolFactory (line 18) | public ApolloWebSocketSubscriptionProtocolFactory(
    method ApolloWebSocketSubscriptionProtocolFactory (line 25) | public ApolloWebSocketSubscriptionProtocolFactory(
    method ApolloWebSocketSubscriptionProtocolFactory (line 33) | public ApolloWebSocketSubscriptionProtocolFactory(
    method ApolloWebSocketSubscriptionProtocolFactory (line 41) | public ApolloWebSocketSubscriptionProtocolFactory(
    method createSession (line 55) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/apollo/ApolloWebSocketSubscriptionSession.java
  class ApolloWebSocketSubscriptionSession (line 9) | public class ApolloWebSocketSubscriptionSession extends ApolloSubscripti...
    method ApolloWebSocketSubscriptionSession (line 13) | public ApolloWebSocketSubscriptionSession(GraphQLSubscriptionMapper ma...
    method isOpen (line 18) | @Override
    method getUserProperties (line 23) | @Override
    method getId (line 28) | @Override
    method unwrap (line 33) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/BufferedHttpServletResponse.java
  class BufferedHttpServletResponse (line 14) | @Slf4j
    method BufferedHttpServletResponse (line 22) | public BufferedHttpServletResponse(HttpServletResponse response) {
    method sendError (line 26) | @Override
    method sendError (line 32) | @Override
    method getOutputStream (line 37) | @Override
    method getWriter (line 51) | @Override
    method flushBuffer (line 68) | @Override
    method isCommitted (line 77) | @Override
    method close (line 82) | public void close() throws IOException {
    method getErrorMessage (line 90) | public String getErrorMessage() {
    method getContentAsByteArray (line 94) | public byte[] getContentAsByteArray() {
    class BufferedOutputStream (line 102) | private static final class BufferedOutputStream extends ServletOutputS...
      method BufferedOutputStream (line 107) | public BufferedOutputStream(OutputStream delegate) {
      method write (line 111) | public void write(int b) throws IOException {
      method flush (line 116) | @Override
      method close (line 122) | @Override
      method isReady (line 128) | @Override
      method setWriteListener (line 133) | @Override
      method toByteArray (line 138) | public byte[] toByteArray() {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/CacheReader.java
  class CacheReader (line 11) | @Slf4j
    method responseFromCache (line 21) | public boolean responseFromCache(
    method write (line 40) | private void write(HttpServletResponse response, CachedResponse cached...

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/CachedResponse.java
  class CachedResponse (line 6) | public class CachedResponse implements Serializable {
    method CachedResponse (line 16) | private CachedResponse(
    method ofContent (line 29) | public static CachedResponse ofContent(byte[] contentBytes) {
    method ofError (line 41) | public static CachedResponse ofError(int errorStatusCode, String error...
    method isError (line 46) | public boolean isError() {
    method getContentBytes (line 54) | public byte[] getContentBytes() {
    method getErrorStatusCode (line 59) | public Integer getErrorStatusCode() {
    method getErrorMessage (line 64) | public String getErrorMessage() {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/CachingHttpRequestInvoker.java
  class CachingHttpRequestInvoker (line 17) | @Slf4j
    method CachingHttpRequestInvoker (line 25) | public CachingHttpRequestInvoker(GraphQLConfiguration configuration) {
    method execute (line 36) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/CachingQueryResponseWriter.java
  class CachingQueryResponseWriter (line 10) | @Slf4j
    method CachingQueryResponseWriter (line 18) | public CachingQueryResponseWriter(
    method write (line 29) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/CachingQueryResponseWriterFactory.java
  class CachingQueryResponseWriterFactory (line 10) | public class CachingQueryResponseWriterFactory implements QueryResponseW...
    method createWriter (line 15) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/GraphQLResponseCacheManager.java
  type GraphQLResponseCacheManager (line 7) | public interface GraphQLResponseCacheManager {
    method get (line 17) | CachedResponse get(HttpServletRequest request, GraphQLInvocationInput ...
    method isCacheable (line 25) | boolean isCacheable(HttpServletRequest request, GraphQLInvocationInput...
    method put (line 34) | void put(

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/config/DefaultGraphQLSchemaServletProvider.java
  class DefaultGraphQLSchemaServletProvider (line 9) | public class DefaultGraphQLSchemaServletProvider extends DefaultGraphQLS...
    method DefaultGraphQLSchemaServletProvider (line 12) | public DefaultGraphQLSchemaServletProvider(GraphQLSchema schema) {
    method getSchema (line 16) | @Override
    method getSchema (line 21) | @Override
    method getReadOnlySchema (line 26) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/config/GraphQLSchemaServletProvider.java
  type GraphQLSchemaServletProvider (line 8) | public interface GraphQLSchemaServletProvider extends GraphQLSchemaProvi...
    method getSchema (line 14) | GraphQLSchema getSchema(HttpServletRequest request);
    method getSchema (line 20) | GraphQLSchema getSchema(HandshakeRequest request);
    method getReadOnlySchema (line 28) | GraphQLSchema getReadOnlySchema(HttpServletRequest request);

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/context/DefaultGraphQLServletContext.java
  class DefaultGraphQLServletContext (line 14) | public class DefaultGraphQLServletContext extends DefaultGraphQLContext
    method DefaultGraphQLServletContext (line 17) | protected DefaultGraphQLServletContext(
    method createServletContext (line 26) | public static Builder createServletContext(DataLoaderRegistry registry) {
    method createServletContext (line 30) | public static Builder createServletContext() {
    method getHttpServletRequest (line 39) | @Override
    method getHttpServletResponse (line 50) | @Override
    method getFileParts (line 61) | @Override
    method getParts (line 75) | @Override
    class Builder (line 83) | public static class Builder {
      method Builder (line 89) | private Builder(DataLoaderRegistry dataLoaderRegistry) {
      method build (line 93) | public DefaultGraphQLServletContext build() {
      method with (line 98) | public Builder with(HttpServletRequest httpServletRequest) {
      method with (line 103) | public Builder with(DataLoaderRegistry dataLoaderRegistry) {
      method with (line 108) | public Builder with(HttpServletResponse httpServletResponse) {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/context/DefaultGraphQLServletContextBuilder.java
  class DefaultGraphQLServletContextBuilder (line 13) | public class DefaultGraphQLServletContextBuilder extends DefaultGraphQLC...
    method build (line 16) | @Override
    method build (line 24) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/context/DefaultGraphQLWebSocketContext.java
  class DefaultGraphQLWebSocketContext (line 9) | @Deprecated
    method DefaultGraphQLWebSocketContext (line 13) | private DefaultGraphQLWebSocketContext(
    method createWebSocketContext (line 20) | public static Builder createWebSocketContext(DataLoaderRegistry regist...
    method createWebSocketContext (line 24) | public static Builder createWebSocketContext() {
    method getSession (line 32) | @Override
    method getHandshakeRequest (line 42) | @Override
    class Builder (line 48) | public static class Builder {
      method Builder (line 54) | private Builder(DataLoaderRegistry dataLoaderRegistry) {
      method build (line 58) | public DefaultGraphQLWebSocketContext build() {
      method with (line 62) | public Builder with(Session session) {
      method with (line 67) | public Builder with(HandshakeRequest handshakeRequest) {
      method with (line 72) | public Builder with(DataLoaderRegistry dataLoaderRegistry) {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/context/GraphQLServletContext.java
  type GraphQLServletContext (line 11) | public interface GraphQLServletContext extends GraphQLKickstartContext {
    method getFileParts (line 13) | List<Part> getFileParts();
    method getParts (line 15) | Map<String, List<Part>> getParts();
    method getHttpServletRequest (line 17) | HttpServletRequest getHttpServletRequest();
    method getHttpServletResponse (line 19) | HttpServletResponse getHttpServletResponse();

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/context/GraphQLServletContextBuilder.java
  type GraphQLServletContextBuilder (line 10) | public interface GraphQLServletContextBuilder extends GraphQLContextBuil...
    method build (line 12) | GraphQLKickstartContext build(
    method build (line 15) | GraphQLKickstartContext build(Session session, HandshakeRequest handsh...

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/context/GraphQLWebSocketContext.java
  type GraphQLWebSocketContext (line 8) | public interface GraphQLWebSocketContext extends GraphQLKickstartContext {
    method getSession (line 10) | Session getSession();
    method getHandshakeRequest (line 12) | HandshakeRequest getHandshakeRequest();

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/DefaultGraphQLRootObjectBuilder.java
  class DefaultGraphQLRootObjectBuilder (line 7) | public class DefaultGraphQLRootObjectBuilder extends StaticGraphQLRootOb...
    method DefaultGraphQLRootObjectBuilder (line 10) | public DefaultGraphQLRootObjectBuilder() {
    method build (line 14) | @Override
    method build (line 19) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/GraphQLMBean.java
  type GraphQLMBean (line 3) | public interface GraphQLMBean {
    method getQueries (line 5) | String[] getQueries();
    method getMutations (line 7) | String[] getMutations();
    method executeQuery (line 9) | String executeQuery(String query);

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/GraphQLServletListener.java
  type GraphQLServletListener (line 7) | public interface GraphQLServletListener {
    method onRequest (line 15) | default RequestCallback onRequest(HttpServletRequest request, HttpServ...
    type RequestCallback (line 22) | interface RequestCallback {
      method onParseError (line 29) | default void onParseError(
      method beforeFlush (line 38) | default void beforeFlush(HttpServletRequest request, HttpServletResp...
      method onSuccess (line 45) | default void onSuccess(HttpServletRequest request, HttpServletRespon...
      method onError (line 52) | default void onError(
      method onFinally (line 61) | default void onFinally(HttpServletRequest request, HttpServletRespon...

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/GraphQLServletRootObjectBuilder.java
  type GraphQLServletRootObjectBuilder (line 7) | public interface GraphQLServletRootObjectBuilder extends GraphQLRootObje...
    method build (line 9) | Object build(HttpServletRequest req);
    method build (line 11) | Object build(HandshakeRequest req);

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/internal/GraphQLThreadFactory.java
  class GraphQLThreadFactory (line 12) | public class GraphQLThreadFactory implements ThreadFactory {
    method newThread (line 17) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/internal/VariableMapException.java
  class VariableMapException (line 3) | public class VariableMapException extends RuntimeException {
    method VariableMapException (line 5) | VariableMapException(String message) {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/internal/VariableMapper.java
  class VariableMapper (line 8) | public class VariableMapper {
    method set (line 14) | @Override
    method recurse (line 19) | @Override
    method set (line 26) | @Override
    method recurse (line 31) | @Override
    method mapVariable (line 37) | @SuppressWarnings({"unchecked", "rawtypes"})
    method determineMapper (line 66) | private static Mapper<?> determineMapper(
    type Mapper (line 78) | interface Mapper<T> {
      method set (line 80) | Object set(T location, String target, Part value);
      method recurse (line 82) | Object recurse(T location, String target);

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/input/BatchInputPreProcessResult.java
  class BatchInputPreProcessResult (line 9) | public class BatchInputPreProcessResult {
    method BatchInputPreProcessResult (line 19) | public BatchInputPreProcessResult(GraphQLBatchedInvocationInput graphQ...
    method BatchInputPreProcessResult (line 26) | public BatchInputPreProcessResult(int statusCode, String messsage) {
    method isExecutable (line 34) | public boolean isExecutable() {
    method getBatchedInvocationInput (line 39) | public GraphQLBatchedInvocationInput getBatchedInvocationInput() {
    method getStatusMessage (line 44) | public String getStatusMessage() {
    method getStatusCode (line 49) | public int getStatusCode() {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/input/BatchInputPreProcessor.java
  type BatchInputPreProcessor (line 7) | public interface BatchInputPreProcessor {
    method preProcessBatch (line 18) | BatchInputPreProcessResult preProcessBatch(

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/input/GraphQLInvocationInputFactory.java
  class GraphQLInvocationInputFactory (line 25) | public class GraphQLInvocationInputFactory implements GraphQLSubscriptio...
    method GraphQLInvocationInputFactory (line 31) | protected GraphQLInvocationInputFactory(
    method newBuilder (line 40) | public static Builder newBuilder(GraphQLSchema schema) {
    method newBuilder (line 44) | public static Builder newBuilder(GraphQLSchemaServletProvider schemaPr...
    method newBuilder (line 48) | public static Builder newBuilder(Supplier<GraphQLSchemaServletProvider...
    method getSchemaProvider (line 52) | public GraphQLSchemaProvider getSchemaProvider() {
    method create (line 56) | public GraphQLSingleInvocationInput create(
    method create (line 61) | public GraphQLBatchedInvocationInput create(
    method createReadOnly (line 69) | public GraphQLSingleInvocationInput createReadOnly(
    method createReadOnly (line 74) | public GraphQLBatchedInvocationInput createReadOnly(
    method create (line 82) | public GraphQLSingleInvocationInput create(GraphQLRequest graphQLReque...
    method create (line 90) | private GraphQLSingleInvocationInput create(
    method create (line 104) | private GraphQLBatchedInvocationInput create(
    method create (line 119) | @Override
    method create (line 131) | public GraphQLBatchedInvocationInput create(
    class Builder (line 142) | public static class Builder {
      method Builder (line 150) | public Builder(GraphQLSchemaServletProvider schemaProvider) {
      method Builder (line 154) | public Builder(Supplier<GraphQLSchemaServletProvider> schemaProvider...
      method withGraphQLContextBuilder (line 158) | public Builder withGraphQLContextBuilder(GraphQLServletContextBuilde...
      method withGraphQLContextBuilder (line 162) | public Builder withGraphQLContextBuilder(
      method withGraphQLRootObjectBuilder (line 168) | public Builder withGraphQLRootObjectBuilder(GraphQLServletRootObject...
      method withGraphQLRootObjectBuilder (line 172) | public Builder withGraphQLRootObjectBuilder(
      method build (line 178) | public GraphQLInvocationInputFactory build() {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/input/NoOpBatchInputPreProcessor.java
  class NoOpBatchInputPreProcessor (line 8) | public class NoOpBatchInputPreProcessor implements BatchInputPreProcessor {
    method preProcessBatch (line 10) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLCodeRegistryProvider.java
  type GraphQLCodeRegistryProvider (line 5) | public interface GraphQLCodeRegistryProvider extends GraphQLProvider {
    method getCodeRegistry (line 7) | GraphQLCodeRegistry getCodeRegistry();

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLDirectiveProvider.java
  type GraphQLDirectiveProvider (line 7) | public interface GraphQLDirectiveProvider extends GraphQLProvider {
    method getDirectives (line 10) | Collection<GraphQLDirective> getDirectives();

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLFieldProvider.java
  type GraphQLFieldProvider (line 6) | public interface GraphQLFieldProvider extends GraphQLProvider {
    method getFields (line 8) | Collection<GraphQLFieldDefinition> getFields();

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLMutationProvider.java
  type GraphQLMutationProvider (line 6) | public interface GraphQLMutationProvider extends GraphQLFieldProvider {
    method getMutations (line 8) | Collection<GraphQLFieldDefinition> getMutations();
    method getFields (line 10) | default Collection<GraphQLFieldDefinition> getFields() {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLProvider.java
  type GraphQLProvider (line 3) | public interface GraphQLProvider {}

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLQueryProvider.java
  type GraphQLQueryProvider (line 7) | public interface GraphQLQueryProvider extends GraphQLProvider {
    method getQueries (line 10) | Collection<GraphQLFieldDefinition> getQueries();

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLSubscriptionProvider.java
  type GraphQLSubscriptionProvider (line 6) | public interface GraphQLSubscriptionProvider extends GraphQLFieldProvider {
    method getSubscriptions (line 8) | Collection<GraphQLFieldDefinition> getSubscriptions();
    method getFields (line 10) | default Collection<GraphQLFieldDefinition> getFields() {

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLTypesProvider.java
  type GraphQLTypesProvider (line 6) | public interface GraphQLTypesProvider extends GraphQLProvider {
    method getTypes (line 8) | Collection<GraphQLType> getTypes();

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/subscriptions/FallbackSubscriptionConsumer.java
  class FallbackSubscriptionConsumer (line 17) | @RequiredArgsConstructor
    method accept (line 25) | @Override
    method executeAsync (line 32) | private CompletableFuture<ExecutionResult> executeAsync(
    method handleSubscriptionStart (line 42) | private void handleSubscriptionStart(

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/subscriptions/FallbackSubscriptionProtocolFactory.java
  class FallbackSubscriptionProtocolFactory (line 12) | public class FallbackSubscriptionProtocolFactory extends SubscriptionPro...
    method FallbackSubscriptionProtocolFactory (line 19) | public FallbackSubscriptionProtocolFactory(
    method createConsumer (line 29) | @Override
    method createSession (line 35) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/subscriptions/WebSocketSendSubscriber.java
  class WebSocketSendSubscriber (line 11) | @Slf4j
    method onSubscribe (line 18) | @Override
    method onNext (line 24) | @Override
    method onError (line 36) | @Override
    method onComplete (line 41) | @Override

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/subscriptions/WebSocketSubscriptionProtocolFactory.java
  type WebSocketSubscriptionProtocolFactory (line 7) | public interface WebSocketSubscriptionProtocolFactory {
    method createConsumer (line 9) | Consumer<String> createConsumer(SubscriptionSession session);
    method createSession (line 11) | SubscriptionSession createSession(Session session);

FILE: graphql-java-servlet/src/main/java/graphql/kickstart/servlet/subscriptions/WebSocketSubscriptionSession.java
  class WebSocketSubscriptionSession (line 8) | public class WebSocketSubscriptionSession extends DefaultSubscriptionSes...
    method WebSocketSubscriptionSession (line 12) | public WebSocketSubscriptionSession(GraphQLSubscriptionMapper mapper, ...
    method isOpen (line 17) | @Override
    method getUserProperties (line 22) | @Override
    method getId (line 27) | @Override
    method unwrap (line 32) | @Override

FILE: graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestBatchInputPreProcessor.java
  class TestBatchInputPreProcessor (line 9) | public class TestBatchInputPreProcessor implements BatchInputPreProcessor {
    method preProcessBatch (line 13) | @Override
Condensed preview — 206 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (442K chars).
[
  {
    "path": ".github/ISSUE_TEMPLATE/bug_report.md",
    "chars": 666,
    "preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: bug\nassignees: ''\n\n---\n\n**Describe the "
  },
  {
    "path": ".github/ISSUE_TEMPLATE/config.yml",
    "chars": 224,
    "preview": "blank_issues_enabled: false\ncontact_links:\n  - name: Question\n    url: https://github.com/graphql-java-kickstart/graphql"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature_request.md",
    "chars": 604,
    "preview": "---\nname: Feature request\nabout: Suggest an idea for this project\ntitle: ''\nlabels: enhancement\nassignees: ''\n\n---\n\n**Is"
  },
  {
    "path": ".github/add-javax-suffix.sh",
    "chars": 837,
    "preview": "#!/bin/bash\n\naddSuffix() {\n  local result\n  result=$(grep include settings.gradle | awk '{print $2}' | tr -d \"'\" | tr -d"
  },
  {
    "path": ".github/release.sh",
    "chars": 315,
    "preview": "#!/bin/bash\nset -ev\n\nFLAVOUR=\"${1}\"\n\nremoveSnapshots() {\n  sed -i 's/-SNAPSHOT//' gradle.properties\n}\n\necho \"Publishing "
  },
  {
    "path": ".github/replaceJakartaWithJavax.sh",
    "chars": 1235,
    "preview": "#!/bin/bash\n\n# Set jdk11 as source and target\nsed -i 's/SOURCE_COMPATIBILITY=.*/SOURCE_COMPATIBILITY=11/' gradle.propert"
  },
  {
    "path": ".github/tag-release.sh",
    "chars": 1354,
    "preview": "#!/bin/bash\nset -ev\n\ngetVersion() {\n  ./gradlew properties -q | grep -E \"^version\" | awk '{print $2}' | tr -d '[:space:]"
  },
  {
    "path": ".github/workflows/pull-request.yml",
    "chars": 2749,
    "preview": "name: \"Pull request\"\non:\n  pull_request:\n    types: [ opened, synchronize, reopened ]\n\njobs:\n  validation:\n    name: Gra"
  },
  {
    "path": ".github/workflows/release.yml",
    "chars": 5509,
    "preview": "name: \"Publish release\"\non: [ workflow_dispatch ]\n\njobs:\n  validation:\n    name: Gradle Wrapper Validation\n    runs-on: "
  },
  {
    "path": ".github/workflows/snapshot.yml",
    "chars": 5228,
    "preview": "name: \"Publish snapshot\"\non:\n  push:\n    branches:\n      - master\n\njobs:\n  validation:\n    name: Gradle Wrapper Validati"
  },
  {
    "path": ".gitignore",
    "chars": 168,
    "preview": ".gradle/\nbuild/\n*.iml\n*.ipr\n*.iws\n.idea/*\n!.idea/codeStyles/\ntarget/\n/out/\n.classpath\n.project\n.settings\nbin\n.DS_Store\n/"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 2108,
    "preview": "# How to contribute\n\nWe're really glad you're reading this, because we need more volunteer developers\nto help with this "
  },
  {
    "path": "LICENSE",
    "chars": 544,
    "preview": "Copyright 2016 Yurii Rashkovskii and Contributors\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou m"
  },
  {
    "path": "README.md",
    "chars": 3734,
    "preview": "# GraphQL Java Servlet\n[![Maven Central](https://img.shields.io/maven-central/v/com.graphql-java-kickstart/graphql-java-"
  },
  {
    "path": "build.gradle",
    "chars": 6583,
    "preview": "/*\n * The MIT License (MIT)\n *\n * Copyright (c) 2016 oEmbedler Inc. and Contributors\n *\n * Permission is hereby granted,"
  },
  {
    "path": "examples/osgi/apache-karaf-feature/pom.xml",
    "chars": 3726,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n  xmlns=\"http://ma"
  },
  {
    "path": "examples/osgi/apache-karaf-feature/src/main/feature/feature.xml",
    "chars": 538,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<features name=\"graphql-java-servlet-osgi-examples-karaf-feature"
  },
  {
    "path": "examples/osgi/apache-karaf-package/pom.xml",
    "chars": 4132,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n  xmlns=\"http://ma"
  },
  {
    "path": "examples/osgi/buildAndRun.sh",
    "chars": 270,
    "preview": "#!/usr/bin/env bash\nmvn clean install\npushd apache-karaf-package/target || exit 1\ntar zxvf graphql-java-servlet-osgi-exa"
  },
  {
    "path": "examples/osgi/pom.xml",
    "chars": 923,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n  xmlns=\"http://ma"
  },
  {
    "path": "examples/osgi/providers/pom.xml",
    "chars": 1712,
    "preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n  xmlns=\"http://ma"
  },
  {
    "path": "examples/osgi/providers/src/main/java/graphql/servlet/examples/osgi/ExampleGraphQLProvider.java",
    "chars": 1404,
    "preview": "package graphql.servlet.examples.osgi;\n\nimport graphql.schema.GraphQLFieldDefinition;\nimport graphql.schema.GraphQLType;"
  },
  {
    "path": "gradle/wrapper/gradle-wrapper.properties",
    "chars": 253,
    "preview": "distributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributi"
  },
  {
    "path": "gradle.properties",
    "chars": 736,
    "preview": "version=16.0.0\ngroup=com.graphql-java-kickstart\nPROJECT_NAME=graphql-java-servlet\nPROJECT_DESC=GraphQL Java Kickstart\nPR"
  },
  {
    "path": "gradlew",
    "chars": 8739,
    "preview": "#!/bin/sh\n\n#\n# Copyright © 2015-2021 the original authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "gradlew.bat",
    "chars": 2966,
    "preview": "@rem\r\n@rem Copyright 2015 the original author or authors.\r\n@rem\r\n@rem Licensed under the Apache License, Version 2.0 (th"
  },
  {
    "path": "graphql-java-kickstart/bnd.bnd",
    "chars": 62,
    "preview": "Export-Package: graphql.kickstart.*\nImport-Package: !lombok,*\n"
  },
  {
    "path": "graphql-java-kickstart/build.gradle",
    "chars": 560,
    "preview": "apply plugin: 'biz.aQute.bnd.builder'\n\njar {\n    bndfile = 'bnd.bnd'\n}\n\napply plugin: 'java-library-distribution'\n\ndepen"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/BatchedDataLoaderGraphQLBuilder.java",
    "chars": 818,
    "preview": "package graphql.kickstart.execution;\n\nimport graphql.GraphQL;\nimport graphql.kickstart.execution.config.GraphQLBuilder;\n"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/DecoratedExecutionResult.java",
    "chars": 886,
    "preview": "package graphql.kickstart.execution;\n\nimport graphql.ExecutionResult;\nimport graphql.GraphQLError;\nimport java.util.List"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/DefaultGraphQLRootObjectBuilder.java",
    "chars": 201,
    "preview": "package graphql.kickstart.execution;\n\npublic class DefaultGraphQLRootObjectBuilder extends StaticGraphQLRootObjectBuilde"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/ExtensionsDeserializer.java",
    "chars": 844,
    "preview": "package graphql.kickstart.execution;\n\nimport com.fasterxml.jackson.core.JsonParser;\nimport com.fasterxml.jackson.core.Ob"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/FutureBatchedExecutionResult.java",
    "chars": 712,
    "preview": "package graphql.kickstart.execution;\n\nimport graphql.ExecutionResult;\nimport graphql.kickstart.execution.input.GraphQLIn"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/FutureErrorExecutionResult.java",
    "chars": 649,
    "preview": "package graphql.kickstart.execution;\n\nimport graphql.kickstart.execution.input.GraphQLInvocationInput;\nimport java.util."
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/FutureExecutionResult.java",
    "chars": 925,
    "preview": "package graphql.kickstart.execution;\n\nimport graphql.ExecutionResult;\nimport graphql.kickstart.execution.input.GraphQLIn"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/FutureSingleExecutionResult.java",
    "chars": 679,
    "preview": "package graphql.kickstart.execution;\n\nimport graphql.ExecutionResult;\nimport graphql.kickstart.execution.input.GraphQLIn"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLBatchedQueryResult.java",
    "chars": 438,
    "preview": "package graphql.kickstart.execution;\n\nimport graphql.ExecutionResult;\nimport java.util.List;\nimport lombok.Getter;\nimpor"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLErrorQueryResult.java",
    "chars": 462,
    "preview": "package graphql.kickstart.execution;\n\nimport lombok.Getter;\nimport lombok.RequiredArgsConstructor;\n\n@Getter\n@RequiredArg"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLInvoker.java",
    "chars": 3230,
    "preview": "package graphql.kickstart.execution;\n\nimport static java.util.stream.Collectors.toList;\n\nimport graphql.ExecutionResult;"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLInvokerProxy.java",
    "chars": 314,
    "preview": "package graphql.kickstart.execution;\n\nimport graphql.ExecutionInput;\nimport graphql.ExecutionResult;\nimport graphql.Grap"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLObjectMapper.java",
    "chars": 7999,
    "preview": "package graphql.kickstart.execution;\n\nimport static java.util.stream.Collectors.toList;\n\nimport com.fasterxml.jackson.co"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLQueryInvoker.java",
    "chars": 3713,
    "preview": "package graphql.kickstart.execution;\n\nimport graphql.execution.instrumentation.ChainedInstrumentation;\nimport graphql.ex"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLQueryResult.java",
    "chars": 969,
    "preview": "package graphql.kickstart.execution;\n\nimport static java.util.Collections.emptyList;\n\nimport graphql.ExecutionResult;\nim"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLRequest.java",
    "chars": 2263,
    "preview": "package graphql.kickstart.execution;\n\nimport static graphql.kickstart.execution.OperationNameExtractor.extractOperationN"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLRootObjectBuilder.java",
    "chars": 144,
    "preview": "package graphql.kickstart.execution;\n\npublic interface GraphQLRootObjectBuilder {\n\n  /** @return the graphql root object"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLSingleQueryResult.java",
    "chars": 403,
    "preview": "package graphql.kickstart.execution;\n\nimport lombok.Getter;\nimport lombok.RequiredArgsConstructor;\n\n@RequiredArgsConstru"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/ObjectMapDeserializationException.java",
    "chars": 296,
    "preview": "package graphql.kickstart.execution;\n\npublic class ObjectMapDeserializationException extends RuntimeException {\n\n  Objec"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/ObjectMapDeserializeHelper.java",
    "chars": 1074,
    "preview": "package graphql.kickstart.execution;\n\nimport com.fasterxml.jackson.core.ObjectCodec;\nimport com.fasterxml.jackson.core.t"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/OperationNameExtractor.java",
    "chars": 1316,
    "preview": "package graphql.kickstart.execution;\n\nimport static graphql.kickstart.execution.StringUtils.isNotEmpty;\n\nimport graphql."
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/StaticGraphQLRootObjectBuilder.java",
    "chars": 389,
    "preview": "package graphql.kickstart.execution;\n\npublic class StaticGraphQLRootObjectBuilder implements GraphQLRootObjectBuilder {\n"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/StringUtils.java",
    "chars": 345,
    "preview": "package graphql.kickstart.execution;\n\nimport lombok.AccessLevel;\nimport lombok.NoArgsConstructor;\n\n@NoArgsConstructor(ac"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/VariablesDeserializer.java",
    "chars": 835,
    "preview": "package graphql.kickstart.execution;\n\nimport com.fasterxml.jackson.core.JsonParser;\nimport com.fasterxml.jackson.core.Ob"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/ConfiguringObjectMapperProvider.java",
    "chars": 1371,
    "preview": "package graphql.kickstart.execution.config;\n\nimport com.fasterxml.jackson.databind.ObjectMapper;\nimport graphql.kickstar"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/DefaultExecutionStrategyProvider.java",
    "chars": 1343,
    "preview": "package graphql.kickstart.execution.config;\n\nimport graphql.execution.ExecutionStrategy;\n\n/** @author Andrew Potter */\np"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/DefaultGraphQLSchemaProvider.java",
    "chars": 732,
    "preview": "package graphql.kickstart.execution.config;\n\nimport graphql.schema.GraphQLSchema;\n\n/** @author Andrew Potter */\npublic c"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/ExecutionStrategyProvider.java",
    "chars": 297,
    "preview": "package graphql.kickstart.execution.config;\n\nimport graphql.execution.ExecutionStrategy;\n\npublic interface ExecutionStra"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLBuilder.java",
    "chars": 3296,
    "preview": "package graphql.kickstart.execution.config;\n\nimport graphql.GraphQL;\nimport graphql.execution.ExecutionStrategy;\nimport "
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLBuilderConfigurer.java",
    "chars": 160,
    "preview": "package graphql.kickstart.execution.config;\n\nimport graphql.GraphQL;\n\npublic interface GraphQLBuilderConfigurer {\n\n  voi"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLSchemaProvider.java",
    "chars": 439,
    "preview": "package graphql.kickstart.execution.config;\n\nimport graphql.schema.GraphQLObjectType;\nimport graphql.schema.GraphQLSchem"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLServletObjectMapperConfigurer.java",
    "chars": 225,
    "preview": "package graphql.kickstart.execution.config;\n\nimport com.fasterxml.jackson.databind.ObjectMapper;\n\n/** @author Andrew Pot"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/InstrumentationProvider.java",
    "chars": 190,
    "preview": "package graphql.kickstart.execution.config;\n\nimport graphql.execution.instrumentation.Instrumentation;\n\npublic interface"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/ObjectMapperProvider.java",
    "chars": 167,
    "preview": "package graphql.kickstart.execution.config;\n\nimport com.fasterxml.jackson.databind.ObjectMapper;\n\npublic interface Objec"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/ContextSetting.java",
    "chars": 1785,
    "preview": "package graphql.kickstart.execution.context;\n\nimport graphql.kickstart.execution.GraphQLRequest;\nimport graphql.kickstar"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/ContextSettingNotConfiguredException.java",
    "chars": 221,
    "preview": "package graphql.kickstart.execution.context;\n\npublic class ContextSettingNotConfiguredException extends RuntimeException"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/DefaultGraphQLContext.java",
    "chars": 1292,
    "preview": "package graphql.kickstart.execution.context;\n\nimport java.util.HashMap;\nimport java.util.Map;\nimport java.util.Objects;\n"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/DefaultGraphQLContextBuilder.java",
    "chars": 258,
    "preview": "package graphql.kickstart.execution.context;\n\n/** Returns an empty context. */\npublic class DefaultGraphQLContextBuilder"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/GraphQLContextBuilder.java",
    "chars": 162,
    "preview": "package graphql.kickstart.execution.context;\n\npublic interface GraphQLContextBuilder {\n\n  /** @return the graphql contex"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/context/GraphQLKickstartContext.java",
    "chars": 892,
    "preview": "package graphql.kickstart.execution.context;\n\nimport java.util.Map;\nimport lombok.NonNull;\nimport org.dataloader.DataLoa"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/DefaultGraphQLErrorHandler.java",
    "chars": 2146,
    "preview": "package graphql.kickstart.execution.error;\n\nimport graphql.ExceptionWhileDataFetching;\nimport graphql.GraphQLError;\nimpo"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/DefaultGraphQLServletObjectMapperConfigurer.java",
    "chars": 626,
    "preview": "package graphql.kickstart.execution.error;\n\nimport com.fasterxml.jackson.annotation.JsonInclude;\nimport com.fasterxml.ja"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/GenericGraphQLError.java",
    "chars": 720,
    "preview": "package graphql.kickstart.execution.error;\n\nimport static java.util.Collections.emptyList;\n\nimport com.fasterxml.jackson"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/GraphQLErrorHandler.java",
    "chars": 345,
    "preview": "package graphql.kickstart.execution.error;\n\nimport graphql.GraphQLError;\nimport java.util.List;\n\n/** @author Andrew Pott"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/error/RenderableNonNullableFieldWasNullError.java",
    "chars": 1242,
    "preview": "package graphql.kickstart.execution.error;\n\nimport com.fasterxml.jackson.annotation.JsonInclude;\nimport graphql.ErrorTyp"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/GraphQLBatchedInvocationInput.java",
    "chars": 710,
    "preview": "package graphql.kickstart.execution.input;\n\nimport static java.util.stream.Collectors.toList;\n\nimport graphql.ExecutionI"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/GraphQLInvocationInput.java",
    "chars": 141,
    "preview": "package graphql.kickstart.execution.input;\n\nimport java.util.List;\n\npublic interface GraphQLInvocationInput {\n  List<Str"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/GraphQLSingleInvocationInput.java",
    "chars": 1710,
    "preview": "package graphql.kickstart.execution.input;\n\nimport static java.util.Collections.singletonList;\n\nimport graphql.Execution"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/PerQueryBatchedInvocationInput.java",
    "chars": 1444,
    "preview": "package graphql.kickstart.execution.input;\n\nimport static java.util.stream.Collectors.toList;\n\nimport graphql.kickstart."
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/input/PerRequestBatchedInvocationInput.java",
    "chars": 1401,
    "preview": "package graphql.kickstart.execution.input;\n\nimport static java.util.stream.Collectors.toList;\n\nimport graphql.kickstart."
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/AbstractTrackingApproach.java",
    "chars": 5997,
    "preview": "package graphql.kickstart.execution.instrumentation;\n\nimport graphql.ExecutionResult;\nimport graphql.execution.Execution"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/DataLoaderDispatcherInstrumentationState.java",
    "chars": 1300,
    "preview": "package graphql.kickstart.execution.instrumentation;\n\nimport graphql.execution.ExecutionId;\nimport graphql.execution.ins"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/FieldLevelTrackingApproach.java",
    "chars": 1018,
    "preview": "package graphql.kickstart.execution.instrumentation;\n\nimport graphql.Internal;\nimport graphql.execution.ExecutionId;\nimp"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/NoOpInstrumentationProvider.java",
    "chars": 452,
    "preview": "package graphql.kickstart.execution.instrumentation;\n\nimport graphql.execution.instrumentation.Instrumentation;\nimport g"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/RequestLevelTrackingApproach.java",
    "chars": 935,
    "preview": "package graphql.kickstart.execution.instrumentation;\n\nimport graphql.execution.ExecutionId;\nimport graphql.execution.ins"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/RequestStack.java",
    "chars": 12666,
    "preview": "package graphql.kickstart.execution.instrumentation;\n\nimport graphql.Assert;\nimport graphql.execution.ExecutionId;\nimpor"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/TrackingApproach.java",
    "chars": 1720,
    "preview": "package graphql.kickstart.execution.instrumentation;\n\nimport graphql.execution.ExecutionId;\nimport graphql.execution.ins"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/TrackingApproachException.java",
    "chars": 193,
    "preview": "package graphql.kickstart.execution.instrumentation;\n\npublic class TrackingApproachException extends RuntimeException {\n"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/AtomicSubscriptionSubscription.java",
    "chars": 715,
    "preview": "package graphql.kickstart.execution.subscriptions;\n\nimport java.util.concurrent.atomic.AtomicReference;\nimport org.react"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/DefaultSubscriptionSession.java",
    "chars": 2435,
    "preview": "package graphql.kickstart.execution.subscriptions;\n\nimport graphql.ExecutionResult;\nimport graphql.execution.reactive.Si"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/GraphQLSubscriptionInvocationInputFactory.java",
    "chars": 338,
    "preview": "package graphql.kickstart.execution.subscriptions;\n\nimport graphql.kickstart.execution.GraphQLRequest;\nimport graphql.ki"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/GraphQLSubscriptionMapper.java",
    "chars": 1784,
    "preview": "package graphql.kickstart.execution.subscriptions;\n\nimport com.fasterxml.jackson.core.JsonProcessingException;\nimport gr"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SessionSubscriber.java",
    "chars": 2110,
    "preview": "package graphql.kickstart.execution.subscriptions;\n\nimport static java.util.Collections.singletonList;\n\nimport graphql.E"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SessionSubscriptions.java",
    "chars": 1348,
    "preview": "package graphql.kickstart.execution.subscriptions;\n\nimport java.util.Map;\nimport java.util.concurrent.ConcurrentHashMap;"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SubscriptionConnectionListener.java",
    "chars": 127,
    "preview": "package graphql.kickstart.execution.subscriptions;\n\n/** Marker interface */\npublic interface SubscriptionConnectionListe"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SubscriptionException.java",
    "chars": 346,
    "preview": "package graphql.kickstart.execution.subscriptions;\n\npublic class SubscriptionException extends Exception {\n\n  private fi"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SubscriptionProtocolFactory.java",
    "chars": 489,
    "preview": "package graphql.kickstart.execution.subscriptions;\n\nimport java.util.function.Consumer;\n\n/** @author Andrew Potter */\npu"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/SubscriptionSession.java",
    "chars": 1509,
    "preview": "package graphql.kickstart.execution.subscriptions;\n\nimport graphql.ExecutionResult;\nimport java.util.Map;\nimport org.rea"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloCommandProvider.java",
    "chars": 1504,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport graphql.kickstart.execution.GraphQLInvoker;\nimport gra"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionConnectionListener.java",
    "chars": 775,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport graphql.kickstart.execution.subscriptions.Subscription"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionConsumer.java",
    "chars": 1210,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport com.fasterxml.jackson.core.JsonProcessingException;\nim"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionKeepAliveRunner.java",
    "chars": 2161,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport graphql.kickstart.execution.subscriptions.Subscription"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionProtocolFactory.java",
    "chars": 3380,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport graphql.kickstart.execution.GraphQLInvoker;\nimport gra"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/ApolloSubscriptionSession.java",
    "chars": 926,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport graphql.kickstart.execution.subscriptions.DefaultSubsc"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/KeepAliveSubscriptionConnectionListener.java",
    "chars": 1170,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport graphql.kickstart.execution.subscriptions.Subscription"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/OperationMessage.java",
    "chars": 1695,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport com.fasterxml.jackson.annotation.JsonCreator;\nimport c"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionCommand.java",
    "chars": 234,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport graphql.kickstart.execution.subscriptions.Subscription"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionConnectionInitCommand.java",
    "chars": 1076,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport graphql.kickstart.execution.subscriptions.Subscription"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionConnectionTerminateCommand.java",
    "chars": 788,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport static graphql.kickstart.execution.subscriptions.apoll"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionStartCommand.java",
    "chars": 2539,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport static graphql.kickstart.execution.subscriptions.apoll"
  },
  {
    "path": "graphql-java-kickstart/src/main/java/graphql/kickstart/execution/subscriptions/apollo/SubscriptionStopCommand.java",
    "chars": 579,
    "preview": "package graphql.kickstart.execution.subscriptions.apollo;\n\nimport graphql.kickstart.execution.subscriptions.Subscription"
  },
  {
    "path": "graphql-java-servlet/bnd.bnd",
    "chars": 182,
    "preview": "Export-Package: graphql.kickstart.servlet.*\nImport-Package: !lombok,*\nRequire-Capability: osgi.extender;\n  filter:=\"(&(o"
  },
  {
    "path": "graphql-java-servlet/build.gradle",
    "chars": 1695,
    "preview": "buildscript {\n    repositories {\n        mavenCentral()\n    }\n}\n\napply plugin: 'groovy'\napply plugin: 'java-library-dist"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AbstractGraphQLHttpServlet.java",
    "chars": 2769,
    "preview": "package graphql.kickstart.servlet;\n\nimport static graphql.kickstart.execution.GraphQLRequest.createQueryOnlyRequest;\n\nim"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AbstractGraphQLInvocationInputParser.java",
    "chars": 768,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.kickstart.execution.GraphQLObjectMapper;\nimport graphql.kickstart.exe"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AsyncTaskDecorator.java",
    "chars": 118,
    "preview": "package graphql.kickstart.servlet;\n\npublic interface AsyncTaskDecorator {\n\n  Runnable decorate(Runnable runnable);\n\n}\n"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AsyncTaskExecutor.java",
    "chars": 544,
    "preview": "package graphql.kickstart.servlet;\n\nimport java.util.concurrent.Executor;\nimport lombok.NonNull;\nimport lombok.RequiredA"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/AsyncTimeoutListener.java",
    "chars": 395,
    "preview": "package graphql.kickstart.servlet;\n\nimport java.io.IOException;\nimport jakarta.servlet.AsyncEvent;\nimport jakarta.servle"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/BatchedQueryResponseWriter.java",
    "chars": 2248,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.ExecutionResult;\nimport graphql.kickstart.execution.GraphQLObjectMapp"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ConfiguredGraphQLHttpServlet.java",
    "chars": 446,
    "preview": "package graphql.kickstart.servlet;\n\nimport java.util.Objects;\n\nclass ConfiguredGraphQLHttpServlet extends GraphQLHttpSer"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ErrorQueryResponseWriter.java",
    "chars": 518,
    "preview": "package graphql.kickstart.servlet;\n\nimport java.io.IOException;\nimport jakarta.servlet.http.HttpServletRequest;\nimport j"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ExecutionResultSubscriber.java",
    "chars": 1854,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.ExecutionResult;\nimport graphql.kickstart.execution.GraphQLObjectMapp"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLConfiguration.java",
    "chars": 9575,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.kickstart.execution.GraphQLInvoker;\nimport graphql.kickstart.executio"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLGetInvocationInputParser.java",
    "chars": 2903,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.GraphQLException;\nimport graphql.kickstart.execution.GraphQLObjectMap"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLHttpServlet.java",
    "chars": 561,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.schema.GraphQLSchema;\n\n/** @author Michiel Oliemans */\npublic abstrac"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLInvocationInputParser.java",
    "chars": 1686,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.kickstart.execution.GraphQLObjectMapper;\nimport graphql.kickstart.exe"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLMultipartInvocationInputParser.java",
    "chars": 7122,
    "preview": "package graphql.kickstart.servlet;\n\nimport static java.util.stream.Collectors.joining;\n\nimport graphql.GraphQLException;"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLPostInvocationInputParser.java",
    "chars": 2087,
    "preview": "package graphql.kickstart.servlet;\n\nimport static java.util.stream.Collectors.joining;\n\nimport graphql.GraphQLException;"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/GraphQLWebsocketServlet.java",
    "chars": 11199,
    "preview": "package graphql.kickstart.servlet;\n\nimport static java.util.Arrays.asList;\nimport static java.util.Collections.singleton"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/HttpRequestHandler.java",
    "chars": 537,
    "preview": "package graphql.kickstart.servlet;\n\nimport java.io.IOException;\nimport jakarta.servlet.http.HttpServletRequest;\nimport j"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/HttpRequestHandlerImpl.java",
    "chars": 2598,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.GraphQLException;\nimport graphql.kickstart.execution.input.GraphQLInv"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/HttpRequestInvoker.java",
    "chars": 412,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.kickstart.execution.input.GraphQLInvocationInput;\nimport jakarta.serv"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/HttpRequestInvokerImpl.java",
    "chars": 8709,
    "preview": "package graphql.kickstart.servlet;\n\nimport static graphql.kickstart.servlet.HttpRequestHandler.STATUS_BAD_REQUEST;\nimpor"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/InvocationInputParseException.java",
    "chars": 207,
    "preview": "package graphql.kickstart.servlet;\n\npublic class InvocationInputParseException extends RuntimeException {\n\n  public Invo"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/ListenerHandler.java",
    "chars": 2429,
    "preview": "package graphql.kickstart.servlet;\n\nimport static java.util.Collections.emptyList;\n\nimport graphql.kickstart.servlet.cor"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/OsgiGraphQLHttpServlet.java",
    "chars": 10178,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.execution.preparsed.NoOpPreparsedDocumentProvider;\nimport graphql.exe"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/OsgiGraphQLHttpServletConfiguration.java",
    "chars": 593,
    "preview": "package graphql.kickstart.servlet;\n\nimport org.osgi.service.metatype.annotations.AttributeDefinition;\nimport org.osgi.se"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/OsgiSchemaBuilder.java",
    "chars": 9019,
    "preview": "package graphql.kickstart.servlet;\n\nimport static graphql.schema.GraphQLObjectType.newObject;\nimport static graphql.sche"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/PartIOException.java",
    "chars": 186,
    "preview": "package graphql.kickstart.servlet;\n\npublic class PartIOException extends RuntimeException {\n\n  public PartIOException(St"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/QueryResponseWriter.java",
    "chars": 295,
    "preview": "package graphql.kickstart.servlet;\n\nimport java.io.IOException;\nimport jakarta.servlet.http.HttpServletRequest;\nimport j"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/QueryResponseWriterFactory.java",
    "chars": 369,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.kickstart.execution.GraphQLQueryResult;\nimport graphql.kickstart.exec"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/QueryResponseWriterFactoryImpl.java",
    "chars": 1162,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.kickstart.execution.GraphQLQueryResult;\nimport graphql.kickstart.exec"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/SingleAsynchronousQueryResponseWriter.java",
    "chars": 2226,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.ExecutionResult;\nimport graphql.kickstart.execution.GraphQLObjectMapp"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/SingleQueryResponseWriter.java",
    "chars": 1051,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.ExecutionResult;\nimport graphql.kickstart.execution.GraphQLObjectMapp"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/StaticDataPublisher.java",
    "chars": 315,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.execution.reactive.SingleSubscriberPublisher;\nimport org.reactivestre"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/SubscriptionAsyncListener.java",
    "chars": 782,
    "preview": "package graphql.kickstart.servlet;\n\nimport java.util.concurrent.atomic.AtomicReference;\nimport jakarta.servlet.AsyncEven"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/apollo/ApolloScalars.java",
    "chars": 1714,
    "preview": "package graphql.kickstart.servlet.apollo;\n\nimport graphql.schema.Coercing;\nimport graphql.schema.CoercingParseLiteralExc"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/apollo/ApolloWebSocketSubscriptionProtocolFactory.java",
    "chars": 2538,
    "preview": "package graphql.kickstart.servlet.apollo;\n\nimport graphql.kickstart.execution.GraphQLInvoker;\nimport graphql.kickstart.e"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/apollo/ApolloWebSocketSubscriptionSession.java",
    "chars": 1116,
    "preview": "package graphql.kickstart.servlet.apollo;\n\nimport graphql.kickstart.execution.subscriptions.GraphQLSubscriptionMapper;\ni"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/BufferedHttpServletResponse.java",
    "chars": 3347,
    "preview": "package graphql.kickstart.servlet.cache;\n\nimport java.io.ByteArrayOutputStream;\nimport java.io.IOException;\nimport java."
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/CacheReader.java",
    "chars": 1895,
    "preview": "package graphql.kickstart.servlet.cache;\n\nimport graphql.kickstart.execution.input.GraphQLInvocationInput;\nimport graphq"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/CachedResponse.java",
    "chars": 1847,
    "preview": "package graphql.kickstart.servlet.cache;\n\nimport java.io.Serializable;\nimport java.util.Objects;\n\npublic class CachedRes"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/CachingHttpRequestInvoker.java",
    "chars": 1896,
    "preview": "package graphql.kickstart.servlet.cache;\n\nimport static graphql.kickstart.servlet.HttpRequestHandler.STATUS_BAD_REQUEST;"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/CachingQueryResponseWriter.java",
    "chars": 2037,
    "preview": "package graphql.kickstart.servlet.cache;\n\nimport graphql.kickstart.execution.input.GraphQLInvocationInput;\nimport graphq"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/CachingQueryResponseWriterFactory.java",
    "chars": 1148,
    "preview": "package graphql.kickstart.servlet.cache;\n\nimport graphql.kickstart.execution.GraphQLQueryResult;\nimport graphql.kickstar"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/cache/GraphQLResponseCacheManager.java",
    "chars": 1222,
    "preview": "package graphql.kickstart.servlet.cache;\n\nimport graphql.kickstart.execution.input.GraphQLInvocationInput;\nimport java.u"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/config/DefaultGraphQLSchemaServletProvider.java",
    "chars": 833,
    "preview": "package graphql.kickstart.servlet.config;\n\nimport graphql.kickstart.execution.config.DefaultGraphQLSchemaProvider;\nimpor"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/config/GraphQLSchemaServletProvider.java",
    "chars": 995,
    "preview": "package graphql.kickstart.servlet.config;\n\nimport graphql.kickstart.execution.config.GraphQLSchemaProvider;\nimport graph"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/context/DefaultGraphQLServletContext.java",
    "chars": 3576,
    "preview": "package graphql.kickstart.servlet.context;\n\nimport graphql.kickstart.execution.context.DefaultGraphQLContext;\nimport jav"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/context/DefaultGraphQLServletContextBuilder.java",
    "chars": 1180,
    "preview": "package graphql.kickstart.servlet.context;\n\nimport graphql.kickstart.execution.context.DefaultGraphQLContextBuilder;\nimp"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/context/DefaultGraphQLWebSocketContext.java",
    "chars": 2325,
    "preview": "package graphql.kickstart.servlet.context;\n\nimport graphql.kickstart.execution.context.DefaultGraphQLContext;\nimport jak"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/context/GraphQLServletContext.java",
    "chars": 628,
    "preview": "package graphql.kickstart.servlet.context;\n\nimport graphql.kickstart.execution.context.GraphQLKickstartContext;\nimport j"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/context/GraphQLServletContextBuilder.java",
    "chars": 647,
    "preview": "package graphql.kickstart.servlet.context;\n\nimport graphql.kickstart.execution.context.GraphQLKickstartContext;\nimport g"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/context/GraphQLWebSocketContext.java",
    "chars": 441,
    "preview": "package graphql.kickstart.servlet.context;\n\nimport graphql.kickstart.execution.context.GraphQLKickstartContext;\nimport j"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/DefaultGraphQLRootObjectBuilder.java",
    "chars": 601,
    "preview": "package graphql.kickstart.servlet.core;\n\nimport graphql.kickstart.execution.StaticGraphQLRootObjectBuilder;\nimport jakar"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/GraphQLMBean.java",
    "chars": 167,
    "preview": "package graphql.kickstart.servlet.core;\n\npublic interface GraphQLMBean {\n\n  String[] getQueries();\n\n  String[] getMutati"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/GraphQLServletListener.java",
    "chars": 2137,
    "preview": "package graphql.kickstart.servlet.core;\n\nimport jakarta.servlet.http.HttpServletRequest;\nimport jakarta.servlet.http.Htt"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/GraphQLServletRootObjectBuilder.java",
    "chars": 367,
    "preview": "package graphql.kickstart.servlet.core;\n\nimport graphql.kickstart.execution.GraphQLRootObjectBuilder;\nimport jakarta.ser"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/internal/GraphQLThreadFactory.java",
    "chars": 732,
    "preview": "package graphql.kickstart.servlet.core.internal;\n\nimport graphql.kickstart.servlet.AbstractGraphQLHttpServlet;\nimport ja"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/internal/VariableMapException.java",
    "chars": 179,
    "preview": "package graphql.kickstart.servlet.core.internal;\n\npublic class VariableMapException extends RuntimeException {\n\n  Variab"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/core/internal/VariableMapper.java",
    "chars": 2779,
    "preview": "package graphql.kickstart.servlet.core.internal;\n\nimport java.util.List;\nimport java.util.Map;\nimport java.util.regex.Pa"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/input/BatchInputPreProcessResult.java",
    "chars": 1531,
    "preview": "package graphql.kickstart.servlet.input;\n\nimport graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;\n\n/**\n "
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/input/BatchInputPreProcessor.java",
    "chars": 749,
    "preview": "package graphql.kickstart.servlet.input;\n\nimport graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;\nimport"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/input/GraphQLInvocationInputFactory.java",
    "chars": 7574,
    "preview": "package graphql.kickstart.servlet.input;\n\nimport graphql.kickstart.execution.GraphQLRequest;\nimport graphql.kickstart.ex"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/input/NoOpBatchInputPreProcessor.java",
    "chars": 623,
    "preview": "package graphql.kickstart.servlet.input;\n\nimport graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;\nimport"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLCodeRegistryProvider.java",
    "chars": 200,
    "preview": "package graphql.kickstart.servlet.osgi;\n\nimport graphql.schema.GraphQLCodeRegistry;\n\npublic interface GraphQLCodeRegistr"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLDirectiveProvider.java",
    "chars": 325,
    "preview": "package graphql.kickstart.servlet.osgi;\n\nimport graphql.schema.GraphQLDirective;\nimport java.util.Collection;\n\n\npublic i"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLFieldProvider.java",
    "chars": 234,
    "preview": "package graphql.kickstart.servlet.osgi;\n\nimport graphql.schema.GraphQLFieldDefinition;\nimport java.util.Collection;\n\npub"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLMutationProvider.java",
    "chars": 336,
    "preview": "package graphql.kickstart.servlet.osgi;\n\nimport graphql.schema.GraphQLFieldDefinition;\nimport java.util.Collection;\n\npub"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLProvider.java",
    "chars": 77,
    "preview": "package graphql.kickstart.servlet.osgi;\n\npublic interface GraphQLProvider {}\n"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLQueryProvider.java",
    "chars": 420,
    "preview": "package graphql.kickstart.servlet.osgi;\n\nimport graphql.schema.GraphQLFieldDefinition;\nimport java.util.Collection;\n\n/**"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLSubscriptionProvider.java",
    "chars": 348,
    "preview": "package graphql.kickstart.servlet.osgi;\n\nimport graphql.schema.GraphQLFieldDefinition;\nimport java.util.Collection;\n\npub"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/osgi/GraphQLTypesProvider.java",
    "chars": 211,
    "preview": "package graphql.kickstart.servlet.osgi;\n\nimport graphql.schema.GraphQLType;\nimport java.util.Collection;\n\npublic interfa"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/subscriptions/FallbackSubscriptionConsumer.java",
    "chars": 2188,
    "preview": "package graphql.kickstart.servlet.subscriptions;\n\nimport graphql.ExecutionResult;\nimport graphql.kickstart.execution.Gra"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/subscriptions/FallbackSubscriptionProtocolFactory.java",
    "chars": 1522,
    "preview": "package graphql.kickstart.servlet.subscriptions;\n\nimport graphql.kickstart.execution.GraphQLInvoker;\nimport graphql.kick"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/subscriptions/WebSocketSendSubscriber.java",
    "chars": 1382,
    "preview": "package graphql.kickstart.servlet.subscriptions;\n\nimport java.io.IOException;\nimport java.util.concurrent.atomic.AtomicR"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/subscriptions/WebSocketSubscriptionProtocolFactory.java",
    "chars": 369,
    "preview": "package graphql.kickstart.servlet.subscriptions;\n\nimport graphql.kickstart.execution.subscriptions.SubscriptionSession;\n"
  },
  {
    "path": "graphql-java-servlet/src/main/java/graphql/kickstart/servlet/subscriptions/WebSocketSubscriptionSession.java",
    "chars": 836,
    "preview": "package graphql.kickstart.servlet.subscriptions;\n\nimport graphql.kickstart.execution.subscriptions.DefaultSubscriptionSe"
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/AbstractGraphQLHttpServletSpec.groovy",
    "chars": 45121,
    "preview": "package graphql.kickstart.servlet\n\nimport com.fasterxml.jackson.databind.ObjectMapper\nimport graphql.Scalars\nimport grap"
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/BatchedQueryResponseWriterTest.groovy",
    "chars": 2205,
    "preview": "package graphql.kickstart.servlet\n\nimport com.fasterxml.jackson.databind.ObjectMapper\nimport graphql.ExecutionResultImpl"
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/DataLoaderDispatchingSpec.groovy",
    "chars": 6538,
    "preview": "package graphql.kickstart.servlet\n\nimport com.fasterxml.jackson.databind.ObjectMapper\nimport graphql.execution.instrumen"
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/GraphQLServletListenerSpec.groovy",
    "chars": 1371,
    "preview": "package graphql.kickstart.servlet\n\nimport graphql.kickstart.servlet.core.GraphQLServletListener\nimport spock.lang.Specif"
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/OsgiGraphQLHttpServletSpec.groovy",
    "chars": 15261,
    "preview": "package graphql.kickstart.servlet\n\nimport graphql.AssertException\nimport graphql.annotations.annotationTypes.GraphQLFiel"
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/PartIOExceptionTest.groovy",
    "chars": 269,
    "preview": "package graphql.kickstart.servlet\n\nimport spock.lang.Specification\n\nclass PartIOExceptionTest extends Specification {\n\n "
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/RequestTester.groovy",
    "chars": 2356,
    "preview": "package graphql.kickstart.servlet\n\nimport com.fasterxml.jackson.databind.ObjectMapper\nimport graphql.execution.reactive."
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/SingleAsynchronousQueryResponseWriterTest.groovy",
    "chars": 1091,
    "preview": "package graphql.kickstart.servlet\n\nimport graphql.ExecutionResult\nimport graphql.kickstart.execution.GraphQLObjectMapper"
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/SingleQueryResponseWriterTest.groovy",
    "chars": 1607,
    "preview": "package graphql.kickstart.servlet\n\nimport com.fasterxml.jackson.databind.ObjectMapper\nimport graphql.ExecutionResultImpl"
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestBatchInputPreProcessor.java",
    "chars": 1013,
    "preview": "package graphql.kickstart.servlet;\n\nimport graphql.kickstart.execution.input.GraphQLBatchedInvocationInput;\nimport graph"
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestException.groovy",
    "chars": 117,
    "preview": "package graphql.kickstart.servlet\n\n/**\n * @author Andrew Potter\n */\nclass TestException extends RuntimeException {\n}\n"
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestGraphQLErrorException.groovy",
    "chars": 661,
    "preview": "package graphql.kickstart.servlet\n\nimport graphql.ErrorType\nimport graphql.GraphQLError\nimport graphql.language.SourceLo"
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestMultipartPart.groovy",
    "chars": 1384,
    "preview": "package graphql.kickstart.servlet\n\nimport jakarta.servlet.http.Part\n\n/**\n * @author Andrew Potter\n */\nclass TestMultipar"
  },
  {
    "path": "graphql-java-servlet/src/test/groovy/graphql/kickstart/servlet/TestUtils.groovy",
    "chars": 10283,
    "preview": "package graphql.kickstart.servlet\n\nimport com.google.common.io.ByteStreams\nimport graphql.Scalars\nimport graphql.executi"
  }
]

// ... and 6 more files (download for full content)

About this extraction

This page contains the full source code of the graphql-java-kickstart/graphql-java-servlet GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 206 files (394.0 KB), approximately 94.8k tokens, and a symbol index with 879 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.

Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.

Copied to clipboard!