Apollo Server plugins: expose server instance to plugins

[viglucci]

While developing a ApolloServer plugin to control the lifecycle of an RSocket server (in order to support RSocket as a GraphQL transport), I have found that it would be useful to be able to access the ApolloServer instance from within plugins the instance is leveraging.

For instance, using an inline plugin definition I am able to accomplish what I want due the nature of variable scoping, however, this would/could be much cleaner if the serverWillStart(service: GraphQLServiceContext) API included a reference to the ApolloServer instance that the plugin was being used by.

const apolloServer = new RSocketApolloServer({
  typeDefs,
  resolvers,
  plugins: [
    {
      async serverWillStart(service) {
        const requestHandler = apolloServer.getHandler();
        const rsocketServer = new RSocketServer({
          transport: new TcpServerTransport({
            listenOptions: {
              port: 9090,
              host: "127.0.0.1",
            },
          }),
          acceptor: {
            accept: async () => requestHandler,
          },
        });
        let closeable = await rsocketServer.bind();
        return {
          async drainServer() {
            closeable.close();
          },
        };
      },
    },
  ],
});

I feel that this would be much cleaner and a simpler integration pattern if instead written as so:

const rsocketServerOptions = {...};
const apolloServer = new RSocketApolloServer({
  typeDefs,
  resolvers,
  plugins: [
    new RSocketApolloGraphlQLPlugin(rsocketServerOptions),
  ],
});

The later API as shown above would require that the instance of the ApolloServer (RSocketApolloServer in this case) be exposed to the serverWillStart plugin API, so that the instances getHandler() API can be accessed.

[glasser]

That does sounds like it would be useful. Strangely enough, the current code architecture means that the plugin API is kind of separate from the actual ApolloServer object itself, as a bunch of the code in AS is still structured in a way that's based on Apollo Server 1 where we didn't even have an ApolloServer object. We've cleaned up a lot of that in our version-4 branch so that's probably an appropriate place to consider adding this. Adding to our milestone for consideration.

[glasser]

Fixed in version-4 by #6668

[glasser]

We're actually going to undo this planned v4 change. The generic typing of ApolloServerPlugin works a lot smoother if the plugin can only get context values and not send them, and if ApolloServerPlugin is passed an ApolloServer object then it can call server.executeOperation(op, context) which causes the issue. (Basically, it becomes challenging to write a plugin that works with any context value, which is the common case!)

However, we have added an ApolloServer.addPlugin method which can be called after constructing your server but before starting it. So that allows you to pass an ApolloServer directly to your plugin if you'd like. This would allow an API like:

const rsocketServerOptions = {...};
const apolloServer = new RSocketApolloServer({
  typeDefs,
  resolvers,
});
apolloServer.addPlugin(new RSocketApolloGraphlQLPlugin(apolloServer, rsocketServerOptions));

You would want to define RSocketApolloGraphlQLPlugin as

class RSocketApolloGraphlQLPlugin<TContext extends BaseContext> implements ApolloServerPlugin<TContext>

[viglucci]

Thanks for the update @glasser . I'll experiment with updating our ApolloServer integration to the new recommended pattern next chance I get.

[glasser]

Actually I guess in AS3 you can also do it like this:

const apolloServer = new RSocketApolloServer({
  typeDefs,
  resolvers,
  plugins: [() => new RSocketApolloGraphlQLPlugin(apolloServer, rsocketServerOptions)],
});

using the plugin factory function feature.

[viglucci]

@glasser I'm finally getting around to experimenting with your suggestion. For V3, looks like I'll also need to add a setApolloServer option as referencing the server variable throws a reference error with your suggested approach. Maybe this is just a TypeScript constraint?

  const server = new RSocketApolloServer({
    typeDefs,
    resolvers,
    plugins: [
      () =>
        new RSocketApolloGraphlQLPlugin({
          apolloServer: server,
          makeRSocketServer,
        }),
    ],
  });

ReferenceError: Cannot access 'server' before initialization

Either way, I think this works sufficiently well with a setApolloServer helper. Thanks again for the recommended workarounds.

  const plugin = new RSocketApolloGraphlQLPlugin({ makeRSocketServer });
  const server = new RSocketApolloServer({
    typeDefs,
    resolvers,
    plugins: [() => plugin],
  });
  plugin.setApolloServer(server);

[glasser]

You're right.