Setup Apollo Server Express

Functions:

/**
 * @method createDefaultConfig
 * @param configOptions ConfigOptions
 * @returns ApolloConfig
 */
function createDefaultConfig(configOptions: ConfigOptions): ApolloConfig;

/**
 * @method startApolloServer Start apollo server with apply middleware express
 * @param config ApolloConfig
 * @param app Express
 * @param httpServer Server
 * @param host string
 * @param port number
 * @param path string
 * @param uploadOptions UploadOptions | undefined
 * @returns Promise<ApolloServer>
 */
function startApolloServer(config: ApolloConfig, app: Express, httpServer: Server, host?: string, port?: number, path?: string, uploadOptions?: UploadOptions): Promise<ApolloServer>;

Example:

// ES6
import dotenv from "dotenv";
import { createServer } from "http";
import express from "express";
import { Models } from "./interface";
import models from "./database/models";
import { startApolloServer, ResolverParams, ContextParams, ApolloConfig } from "setup-apollo-server-express";
import { ApolloServerPluginLandingPageGraphQLPlayground, ApolloServerPluginLandingPageDisabled, ContextFunction } from "apollo-server-core";
import typeDefs from "./graphql/type_defs";
import resolvers from "./graphql/resolvers";
import schema from "./graphql";
import { makeExecutableSchema } from "@graphql-tools/chema";
import { ExpressContext } from "apollo-server-express";

dotenv.config();

const app = express();
const httpServer = createServer(app);

// Setup app
app.use(cors...)

// Handle req before passed to resolver functions
function handleReq({ req }: ExpressContext): { message?: string; models?: Models } {
    return { message: req.headers.cookie, models: models };
}

// Handle data before passed to resolver functions
function handleResolver({ source, args, context, info }: ResolverParams) {
    // TODO
}

// Format response
function formatResponse(response: GraphQLResponse, requestContext: GraphQLRequestContext<object>): GraphQLResponse | null {
        if (response.data?.getAllOfUsers !== undefined) {
            response.data.users = response.data.getAllOfUsers; // Add users attribute into data object
            delete response.data.getAllOfUsers; // Delete getAllOfUsers attribute in data object
        }
        return response;
    }

// Create config
const configOptions: ConfigOptions = {
   typeDefs: typeDefs,
   resolvers: resolvers,
   context: handleReq,
   handleResolver: handleResolver,
   formatResponse: formatResponse,
}

// Or
const configOptions: ConfigOptions = {
   schema: schema,
   context: handleReq,
   handleResolver: handleResolver,
   formatResponse: formatResponse,
}

const config = createDefaultConfig(configOptions);

// Or declare config as follow:
const config: ApolloConfig = {
   schema: schema,
    context: handleReq,
    formatResponse: formatResponse,
    plugins: [
        process.env.NODE_ENV !== "production" ? ApolloServerPluginLandingPageGraphQLPlayground() : ApolloServerPluginLandingPageDisabled(),
        {
            async requestDidStart(requestContextDidStart) {
                return {
                    async executionDidStart(executionRequestContext) {
                        return {
                            willResolveField(fieldResolverParams: ResolverParams) {
                                return (error: any, result: any) => {
                                    if (configOptions.handleResolver) {
                                        configOptions.handleResolver(fieldResolverParams);
                                    }
                                };
                            },
                        };
                    },
                };
            },
        },
    ],
   ...
}

// Start Apollo server
const apolloServer = startApolloServer(config, app, httpServer); // Default values: host = "0.0.0.0", port = 5000, path = "/graphql". Default added middleware graphqlUploadExpress with scalar Upload in schema