useFederation plugin with Apollo managed federation

[BorisPetelj]

Currently, useFederation plugin requires the ApolloGateway instance with an already loaded schemas. This can be explicitly done by calling gateway.load()

In case of managed federation, schema loading is done implicit in ApolloServer which requires gateway instance in constructor.
There is no way to pass the initialized gateway (with fetched schemas to ApolloServer) to envelop.

I ended up with this:

const gateway = new ApolloGateway();
const envelopConfig = {
  plugins: [
    useApolloFederation({ gateway })
  ]
};
const server = new ApolloServer({
  gateway: gateway,
  context: async ({ req, res }) => {
    const { parse, validate, contextFactory, execute, schema } = envelop(envelopConfig)({ req });
    const query = req.body.query;
    const variables = req.body.variables;
    const document = parse(query);
    const validationErrors = validate(schema, document);

    if (validationErrors.length > 0) {
      res.end(JSON.stringify({ errors: validationErrors }));
      return;
    }

    const context = await contextFactory();
    return execute({
      document,
      schema,
      variableValues: variables,
      contextValue: context
    });
  }
});

In this case, there is getEnveloped creation on every request. Do you have any suggestions or plan to support the usage of Envelop with ApolloGateway in managed federation mode?

[ardatan]

You don't call and wait for .load as documented in Federation plugin docs;
https://www.envelop.dev/plugins/use-apollo-federation

And you don't follow our example for Apollo Server;
https://github.com/dotansimha/envelop/blob/main/examples/apollo-server/index.ts

import { envelop, } from '@envelop/core';
import { ApolloGateway } from '@apollo/gateway';
import { useApolloFederation } from '@envelop/apollo-federation';
import { ApolloServer } from 'apollo-server';
import { ApolloServerPluginLandingPageGraphQLPlayground } from 'apollo-server-core';

async function main() {


// Initialize the gateway
const gateway = new ApolloGateway({
  serviceList: [
    { name: 'accounts', url: 'http://localhost:4001' },
    { name: 'products', url: 'http://localhost:4002' },
    // ...additional subgraphs...
  ],
});

// Make sure all services are loaded
await gateway.load();

// Then pass it to the plugin configuration
const getEnveloped = envelop({
  plugins: [
    // ... other plugins ...
    useApolloFederation({ gateway }),
  ],
});

const server = new ApolloServer({
  schema,
  executor: async requestContext => {
    const { schema, execute, contextFactory } = getEnveloped({ req: requestContext.request.http });

    return execute({
      schema: schema,
      document: requestContext.document,
      contextValue: await contextFactory(),
      variableValues: requestContext.request.variables,
      operationName: requestContext.operationName,
    });
  },
  plugins: [ApolloServerPluginLandingPageGraphQLPlayground({ endpoint: '/graphql' })],
});

server.listen(3000);

}

main().catch(e => {
console.error(e);
process.exit(1);
})

[BorisPetelj]

Hi @ardatan. I tried the following:

import envConfig from '../config/envConfig';
import logger from "../logger/logger";
import { ApolloServer } from 'apollo-server';
import { ApolloGateway } from '@apollo/gateway';
import { useApolloFederation } from '@envelop/apollo-federation';
import { envelop } from '@envelop/core';

async function startGateway(): Promise<ApolloServer> {
  const gateway = new ApolloGateway({
    serviceList: [
      { name: 'r2d2', url: 'http://localhost:4011' }
    ],
    debug: true
  });

  await gateway.load();

  const envelopConfig = {
    plugins: [
      useApolloFederation({ gateway })
    ]
  };

  const getEnveloped = envelop(envelopConfig);

  const server = new ApolloServer({
    schema: gateway.schema,
    executor: async requestContext => {
      const { schema, execute, contextFactory } = getEnveloped({ req: requestContext.request.http });
      return execute({
        schema: schema,
        document: requestContext.document,
        contextValue: await contextFactory(),
        variableValues: requestContext.request.variables,
        operationName: requestContext.operationName
      });
    }
    // executor: gateway.executor // This way it works, but envelop is not actually being utilized
  });

  await server.listen({ port: envConfig.apollo.port }, () => {
    logger.info(`🚀 Gateway 2.0 ready at port ${envConfig.apollo.port}`);
  })

  return server;
}

export default startGateway;

The schema is loaded, but every request ends up with the following error:

{
  "errors": [
    {
      "message": "Parse error!",
      "extensions": {
        "code": "INTERNAL_SERVER_ERROR",
        "exception": {
          "stacktrace": [
            "Error: Parse error!",
            "    at federationExecutor (.../gateway/node_modules/@envelop/apollo-federation/index.js:68:27)",
            "    .../gateway/node_modules/@envelop/core/index.js:559:29",
            "    at processTicksAndRejections (internal/process/task_queues.js:93:5)"
          ]
        }
      }
    }
  ],
  "data": null
}

I'm using ApolloServer version 3.5.0.