Method handleWebSocketUnsafe

src/server.ts:415–512

(
    req: Request,
    socket: stream.Duplex,
    head: Buffer,
  )

  }

  protected async handleWebSocketUnsafe(
    req: Request,
    socket: stream.Duplex,
    head: Buffer,
  ) {
    const request = req as http.IncomingMessage;
    request.url = moveTokenToHeader(request);

    this.logger.trace(
      `Handling inbound WebSocket request on "${request.url || ''}"`,
    );
    const proceed = await this.hooks.before({ head, req, socket });
    req.parsed = convertPathToURL(request.url || '', this.config);
    shimLegacyRequests(req.parsed);

    if (!proceed) return;

    req.queryParams = queryParamsToObject(req.parsed.searchParams);

    const route = await this.router.getRouteForWebSocketRequest(req);

    if (route) {
      this.logger.trace(
        `Found matching WebSocket route handler "${route.path}"`,
      );

      if (route.before && !(await route.before(req, socket, head))) {
        return;
      }

      if (route?.auth) {
        this.logger.trace(
          `Authorizing WebSocket request to "${req.parsed.href}"`,
        );
        const isPermitted = await this.token.isAuthorized(req, route);

        if (!isPermitted) {
          return this.onWebsocketUnauthorized(req, socket);
        }
      }

      if (route.querySchema) {
        this.logger.trace(`Validating route query-params with QUERY schema`);
        try {
          const schema = compileSchema(route.querySchema);
          const valid = schema.validate(req.queryParams);

          if (valid.error) {
            const errorDetails = valid.error.details
              .map(
                ({
                  message,
                  context,
                }: {
                  context?: { message: string };
                  message: string;
                }) => context?.message || message,
              )