How to use the subscriptions-transport-ws.SubscriptionServer.create function in subscriptions-transport-ws

websocketServer.listen(WS_PORT, () => {
    SubscriptionServer.create(
      {
        execute,
        subscribe,
        schema,
        onConnect: () => ({
          models,
        }),
      },
      {
        server: websocketServer,
        path: '/subscriptions',
      },
    );
    // eslint-disable-next-line no-console
    console.log(
      `App's websocket is listening on port ${websocketServer.address().port}`,

const { SubscriptionServer } = require('subscriptions-transport-ws');
    const {
      onDisconnect,
      onConnect,
      keepAlive,
      path,
    } = this.subscriptionServerOptions;

    // TODO: This shouldn't use this.schema, as it is deprecated in favor of the schemaDerivedData promise.
    const schema = this.schema;
    if (this.schema === undefined)
      throw new Error(
        'Schema undefined during creation of subscription server.',
      );

    this.subscriptionServer = SubscriptionServer.create(
      {
        schema,
        execute,
        subscribe,
        onConnect: onConnect
          ? onConnect
          : (connectionParams: Object) => ({ ...connectionParams }),
        onDisconnect: onDisconnect,
        onOperation: async (
          message: { payload: any },
          connection: ExecutionParams,
        ) => {
          connection.formatResponse = (value: ExecutionResult) => ({
            ...value,
            errors:
              value.errors &&

)

if (process.env !== 'production') {
  router.get('/graphiql', graphiqlKoa({ endpointURL: '/graphql' }))
}

app.use(router.routes())
app.use(router.allowedMethods())

// Launching the server

const server = app.listen(parseInt(env('SERVER_PORT'), 10), env('SERVER_HOST'))

// Setup the subscription server

SubscriptionServer.create(
  {
    schema: executableSchema,
    execute,
    subscribe,
    onConnect: (connectionParams: Object, socket: WebSocket) => {
      try {
        const { user } = jwt.verify(connectionParams.authToken, env('AUTH_SECRET'))
        const jwtData = jwtDecode(connectionParams.authToken)
        const timeout = jwtData.exp * 1000 - Date.now()
        debugPubSub('authenticated', jwtData)
        debugPubSub('set connection timeout', timeout)
        setTimeout(() => {
          // let the client reconnect
          socket.close()
        }, timeout)
        return { subscriptionUser: user }

const startSubscriptionServer = () => {
	if (settings.get('Graphql_Enabled')) {
		SubscriptionServer.create({
			schema: executableSchema,
			execute,
			subscribe,
			onConnect: (connectionParams) => ({ authToken: connectionParams.Authorization }),
		},
		{
			port: subscriptionPort,
			host: process.env.BIND_IP || '0.0.0.0',
		});

		console.log('GraphQL Subscription server runs on port:', subscriptionPort);
	}
};

query,
  subscription,
});

const WS_PORT = 5000;

const websocketServer = createServer((request, response) => {
  response.writeHead(404);
  response.end();
});

websocketServer.listen(WS_PORT, () => console.log(
  `Websocket Server is now running on http://localhost:${WS_PORT}`
));

SubscriptionServer.create(
  {
    schema,
    execute,
    subscribe,
  },
  {
    server: websocketServer,
    path: '/graphql',
  },
);

const app = express();

app.use('/graphql', graphqlHTTP({
  schema,
  context: undefined,

export function createSubscriptionServer(
  server: http.Server,
  schema: GraphQLSchema,
  options: Options
) {
  const keepAlive = options.config.get("websocket_keep_alive_timeout");
  if (typeof keepAlive !== "number" || keepAlive <= 0) {
    throw new Error(
      "expected the websocket_keep_alive_timeout configuration to be a positive number"
    );
  }

  return SubscriptionServer.create(
    {
      schema,
      execute,
      subscribe,
      onConnect: onConnect(options),
      onOperation: onOperation(options),
      keepAlive,
    },
    {
      server,
      path: "/api/graphql/live",
    }
  );
}

const addSubscriptions = httpServer => {
  subscriptionServer = SubscriptionServer.create(
    {
      schema,
      execute,
      subscribe,
      onConnect: (connectionParams, webSocket) => modules.createContext(null, connectionParams, webSocket),
      onOperation: async (message, params, webSocket) => {
        params.context = await modules.createContext(null, message.payload, webSocket);
        return params;
      }
    },
    {
      server: httpServer,
      path: '/graphql'
    }
  );
};

server.listen(process.env.GRAPHQL_PORT, () => {
    logger.info(`Server started on port :${process.env.GRAPHQL_PORT}`);
    SubscriptionServer.create(
      {
        onConnect: connectionParams => logger.info('Client subscription connected!', connectionParams),
        onDisconnect: () => logger.info('Client subscription disconnected!'),
        execute,
        subscribe,
        schema,
      },
      {
        server,
        path: '/subscriptions',
      },
    );
  });
})();

onCreated: (server: Server) => {
      SubscriptionServer.create(
        { execute, schema, subscribe },
        { path: '/graphql', server },
      )
    },
  }