@cran/gql.koa/mjs/KoaServer.js

Cran/GraphQL Koa Server

import { ApolloServerPluginDrainHttpServer } from "apollo-server-core";
import Koa from "koa";
import Router from "@koa/router";
import bodyParser from "koa-bodyparser";
import cors from "@koa/cors";
import { createServer } from "http";
import { health, metrics, sqlPreview } from "./middleware";
export class KoaServer extends Koa {
    server;
    apollo;
    constructor(options) {
        super();
        this.server = options.server || createServer();
        if (false !== options.cors) {
            this.use(cors("object" === typeof options.cors ? options.cors : undefined));
        }
        if (false !== options.options) {
            this.use(function useOptions(ctx, next) {
                if ("OPTIONS" === ctx.request.method) {
                    return Object.assign(ctx, { status: 204, body: "", });
                }
                return next();
            });
        }
        if (false !== options.bodyParser) {
            this.use(bodyParser("object" === typeof options.bodyParser
                ? options.bodyParser : undefined));
        }
    }
    getApollo() {
        return this.apollo;
    }
    getServer() {
        return this.server;
    }
    getApolloPlugins() {
        return [
            ApolloServerPluginDrainHttpServer({ httpServer: this.server, }),
        ];
    }
    useRouter(router) {
        return this.use(router.routes()).use(router.allowedMethods());
    }
    useApollo(apollo, { path = "/graphql", middleware = [], } = {}) {
        this.apollo = apollo;
        const router = new Router();
        const apolloMiddleware = apollo.getMiddleware();
        router.get(path, ...middleware, apolloMiddleware);
        router.post(path, ...middleware, apolloMiddleware);
        return this.useRouter(router);
    }
    useSystemMiddleware(options = {}) {
        if (false !== options.sqlPreview) {
            this.use(sqlPreview);
        }
        const router = new Router({
            prefix: options.prefix || "/-",
        });
        if (false !== options.health) {
            router.get("/health", health("boolean" === typeof options.health
                ? undefined : options.health));
        }
        if (false !== options.metrics) {
            router.get("/metrics", metrics);
        }
        return this.useRouter(router);
    }
    async start(options = { port: Number(process.env.PORT) || 0, }) {
        if (this.apollo) {
            await this.apollo.start();
        }
        this.server.on("request", this.callback());
        return new Promise((resolve) => {
            this.server.listen(options, () => {
                resolve(this);
            });
        });
    }
}