Cache/memoize schema build for use on serverless/lambdas/functions?

[orbiteleven]

Wondering if/how other folks are using typegraphql-prisma. I'm currently evaluating a move from Heroku to Vercel or Netlify, though I'm imaging the same problem with occur with any serverless platform like AWS, GCP or Azure.

My current setup is a Next.js app which has a single /api/graphql route that builds an Apollo server using a schema built by buildSchema. I'm memoizing both the schema and Apollo server, but since the route is "serverless" it gets destroyed (along with the memoized schema & server) once requests stop coming in.

When I set timers on the various steps, I can see that buildSchema takes around 1500ms, leading to significant slow start delays. This is with 15 tables, the largest of which (by far) is 24 columns.

How are other folks dealing with this? Seems like we could build the schema once and just import that artifact, but I can't figure out if that functionality exists right now.

let server: ApolloServer
let schema

async (req, res): Promise<void> => {
    // Only start the server once
    if (!server) {
      if(!schema) {
        schema = await buildSchema({
          resolvers,
        })
      }
      server = new ApolloServer({
        schema,
      })
      await server.start()
    }
    const handler = server.createHandler({ path })
    return handler(req, res)
  }

Cheers!

[MichalLytek]

let httpHandler: (event: APIGatewayProxyEvent, context: Context) => Promise<unknown>;

export const handleHttp = async (event: APIGatewayEvent, context: LambdaContext) => {
    if (!httpHandler) {
      httpHandler = 
	    // your apollo server handler and build schema code
    }
    return await httpHandler(event, context);
};

[orbiteleven]

Thanks for the quick response (and awesome libs), @MichalLytek!

Interesting. Testing this out now. Help me understand: does the lambda/function provider (Vercel using AWS) cache this because the top-level httpHandler doesn't "change" between requests?

[john-landgrave]

@MichalLytek we are doing this and this solution does work within one lambda (or whatever your "FaaS instance" of choice is). However, our app is a reasonable "real world" size (70 models in the schema.prisma) and the buildSchema alone (timed using console.time/timeEnd) is taking 2.5-6s (depending on the number of resolvers that we are including -- we are still in the middle stages of implementing the necessary middleware and such to be able to securely use this in production). Is there no way to build out and then "load" in a schema? I understand that any effort here may result in no meaningful gains because of the necessary step of translating the serialized information back into associations with the appropriate resolve Classes and GQL schema types, but I thought that I would ask.

[MichalLytek]

My production Prisma schema is 1000 lines long and generated GraphQL schema is 1350 lines long. The schema builds in <100ms.