gqlgen websocket not close if initFunc returns an error

[SrOscuroBlck]

I'm using gqlgen for my GraphQL API and I have some subscription (websocket) in my API. But it's not working as expected:

When initFunc of the transport.Websocket{} return an error the websocket is not close but spam the init function. I would have expected the websocket to be closed and only one request is made to the server.

How can I can properly close the websocket if the init function failed (for instance auth failed) ?

Here is some relevant code that you want to see, if you need more ask for it:

c.Directives.Auth = security.Auth
	log.Printf("Creating executable schema")
	executableSchema := generated.NewExecutableSchema(c)
	log.Printf("Executable schema created successfully")

	srv := handler.New(executableSchema)
	log.Printf("GraphQL handler created successfully")

	srv.AddTransport(transport.POST{})
	srv.AddTransport(transport.GET{})
	srv.AddTransport(&transport.Websocket{
		KeepAlivePingInterval: 3 * time.Second,
		Upgrader: websocket.Upgrader{
			CheckOrigin: func(r *http.Request) bool {
				return true
			},
		},
		InitFunc: func(ctx context.Context, initPayload transport.InitPayload) (context.Context, *transport.InitPayload, error) {
			log.Println("InitFunc called")
			ctx, payload, err := middlewares.SessionAuthMiddleware(ctx, initPayload)
			if err != nil {
				log.Printf("SessionAuthMiddleware error: %v", err)
				return nil, nil, &websocket.CloseError{Code: websocket.ClosePolicyViolation, Text: err.Error()}
			}
			log.Println("SessionAuthMiddleware successful")
			return ctx, payload, nil
		},
		CloseFunc: func(ctx context.Context, closeCode int) {
			log.Printf("WebSocket connection closed with code: %d", closeCode)
		},
	})
	srv.Use(extension.Introspection{})
	return srv, nil

SessionAuthMiddleware

func SessionAuthMiddleware(ctx context.Context, initPayload transport.InitPayload) (context.Context, *transport.InitPayload, error) {
	log.Println("SessionAuthMiddleware called")
	auth := initPayload.Authorization()
	if auth == "" {
		log.Println("Authorization token is required")
		return nil, nil, transport.WebsocketError{}
	}

	const bearerPrefix = "Bearer "
	if !strings.HasPrefix(auth, bearerPrefix) {
		log.Println("Invalid authorization token format")
		return nil, nil, transport.WebsocketError{Err: fmt.Errorf("invalid authorization token format")}
	}

	token := auth[len(bearerPrefix):]
	validate, err := tokens.JwtValidate(ctx, token)
	if err != nil || validate == nil || !validate.Valid {
		log.Printf("Invalid auth token: %v", err)
		return nil, nil, transport.WebsocketError{Err: fmt.Errorf("invalid auth token")}
	}

	// Extract custom claims
	customClaim, ok := validate.Claims.(*tokens.JwtCustomClaim)
	if !ok || customClaim == nil {
		log.Println("Error processing claims")
		return nil, nil, transport.WebsocketError{Err: fmt.Errorf("error processing claims")}
	}

	log.Printf("Token validated for user: %v", customClaim.ID)

	// Add user info to context
	ctx = context.WithValue(ctx, authString("features"), customClaim)
	return ctx, &initPayload, nil
}