Graphql-ws kann nicht mit gqlgen verbunden werden

Frageninhalt

Ich verwende gqlgen als meinen Dienst mit Apollo-Client und graphql-ws als Frontend und versuche, Abonnements zu verwenden. Auf meinem Spielplatz funktioniert es perfekt, aber wenn ich es versuche, verbinde ich den Client damit , ich habe diesen Fehler erhalten:

websocket connection to 'ws://localhost:8080/' failed:

In meinem Containerprotokoll erhalte ich:

unable to upgrade *http.response to websocket websocket: request origin not allowed by upgrader.checkorigin:
http: superfluous response.writeheader call from github.com/99designs/gqlgen/graphql/handler/transport.senderror (error.go:15)

Das ist mein Golang-Code:

if err := godotenv.load(); err != nil {
    log.fatal("error loading environment variables file")
}

port := helpers.env("port")
if port == "" {
    port = defaultport
}

router := chi.newrouter()

router.use(cors.new(cors.options{
    allowedorigins:   strings.split(helpers.env("allowed_origins"), ","),
    allowcredentials: true,
    debug:            helpers.env("debug") == "true",
    allowedheaders:   []string{"*"},
}).handler)

srv := handler.newdefaultserver(generated.newexecutableschema(generated.config{resolvers: &resolvers.resolver{}}))


srv.addtransport(transport.post{})
upgrader := &transport.websocket{
    upgrader: websocket.upgrader{
        handshaketimeout: 1 * time.minute,
        checkorigin: func(r *http.request) bool {
            return true
        },
        readbuffersize:  1024,
        writebuffersize: 1024,
    },
    keepalivepinginterval: 10 * time.second,
}

srv.addtransport(upgrader)
srv.use(extension.introspection{})
if helpers.env("mode") == "production" {
    cache, err := apq.newcache(24 * time.hour)

    if err != nil {
        log.fatalf("cannot create apq redis cache: %v", err)
    }

    srv.use(extension.automaticpersistedquery{cache: cache})
}


go initworkers()

go runasynqmon()
router.use(getheadersmiddleware())

router.handle("/", srv)

if helpers.env("mode") == "development" {
    router.handle("/playground", playground.handler("graphql playground", "/"))
    log.printf("connect to http://localhost:%s/playground for graphql playground", port)
}

log.fatal(http.listenandserve(":"+port, router))

Das ist mein Kundencode:

import { setContext } from '@apollo/client/link/context'
import { onError } from '@apollo/client/link/error'
import { GraphQLWsLink } from '@apollo/client/link/subscriptions'
import { getMainDefinition } from '@apollo/client/utilities'
import { createUploadLink } from 'apollo-upload-client'
import { createClient } from 'graphql-ws'

import { logout } from '../helpers/logout'
import { getTokenFromStorage } from '../helpers/userData'
import { lang } from '../localization'

const authLink = setContext((_, { headers }) => {
  const token = getTokenFromStorage()
  return {
    headers: {
      authorization: token ? `Bearer ${token}` : undefined,
      'Accept-Language': lang,
      ...headers
    }
  }
})
const httpLink = createUploadLink({
  uri: process.env.REACT_APP_GRAPH_BFF || 'http://localhost:8080'
})

const wsLink = new GraphQLWsLink(
  createClient({
    url: 'ws://localhost:8080/'
  })
)

const splitLink = split(
  ({ query }) => {
    const definition = getMainDefinition(query)
    return (
      definition.kind === 'OperationDefinition' &&
      definition.operation === 'subscription'
    )
  },
  wsLink,
  httpLink
)

const logoutLink = onError(({ response }) => {
  if (
    response?.errors &&
    response.errors.length > 0 &&
    response.errors.some((errorItem) =>
      errorItem.message.toLowerCase().includes('unauthenticated')
    )
  ) {
    logout()
  }
})

const chainList = [logoutLink, authLink, splitLink]

const linkChain = from(chainList)

const apolloClient = new ApolloClient({
  cache: new InMemoryCache({
    addTypename: false
  }),
  link: linkChain
})

export default apolloClient

Ich dachte, ein Upgrade von checkorigin im Programm würde das Problem lösen, aber es funktioniert nicht Irgendeine Idee, wie man dieses Problem lösen kann?

Richtige Antwort

Das ist eine tolle Frage. Das bedeutet, dass Sie ein talentierter Programmierer sind ... Antwort unten:

Sie müssen diese Zeile ändern:

srv := handler.newdefaultserver(generated.newexecutableschema(generated.config{resolvers: &resolvers.resolver{}}))

Weil newdefaultserver dieselbe Quelle verwendet, was bedeutet, dass Ihre Quelle und Ihr Host identisch sein müssen, was bedeutet, dass Ihr Code: checkorigin: func(r *http.request) bool { Gibt true zurück }, Funktioniert nicht. Sie müssen „newdefaultserver“ in „new“ ändern, damit sich Ihr Code entsprechend ändert:

srv := handler.New(generated.NewExecutableSchema(generated.Config{Resolvers: &resolvers.Resolver{}}))

Und Ihr WebSocket funktioniert einwandfrei. Seien Sie bei dieser Änderung vorsichtig, da newdefaultserver eine Konfiguration zum Aktualisieren, Abrufen oder für andere Dinge enthält. (siehe Verpackung selbst) Und Sie müssen es bequem in Ihren Code schreiben.

Das obige ist der detaillierte Inhalt vonGraphql-ws kann nicht mit gqlgen verbunden werden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!