@jokio/graphql/dist/index.js

High level, pre-configured, GraphQL Server

"use strict";
var __assign = (this && this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [0, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
var lodash_1 = require("lodash");
var graphql_tools_1 = require("graphql-tools");
var graphql_yoga_1 = require("graphql-yoga");
var apollo_engine_1 = require("apollo-engine");
var apollo_server_express_1 = require("apollo-server-express");
var link_http_1 = require("./link-http");
var node_fetch_1 = require("node-fetch");
var core_1 = require("./modules/core");
var scalars_1 = require("./modules/scalars");
var api_1 = require("./api");
var auth = require("./auth");
var graphql_subscriptions_1 = require("graphql-subscriptions");
var api_2 = require("./api");
exports.RestAPI = api_2.RestAPI;
function devEnv() {
    if (process.env.NODE_ENV !== 'production') {
        require('dotenv').load();
    }
}
exports.devEnv = devEnv;
function run(props) {
    return __awaiter(this, void 0, void 0, function () {
        var _this = this;
        var defaultProps, _a, localSchemas, propPort, engineConfig, endpoint, apiUrls, tokenName, disabledScalars, subscriptionEndpoint, remoteSchemaUrls, disableCoreModule, yogaOptions, enableAuthentication, getUserId, getHttpToken, getWsToken, websocketConnectionParams, contextObject, port, typeDefs, resolvers, remoteSchemas, _i, remoteSchemaUrls_1, url, _b, _c, schema, apis, key, pubsub, context, server, engine, subscriptionServer;
        return __generator(this, function (_d) {
            switch (_d.label) {
                case 0:
                    defaultProps = {
                        port: 4000,
                        endpoint: '/',
                        tokenName: 'token',
                        localSchemas: [],
                        remoteSchemaUrls: [],
                        subscriptionEndpoint: 'ws://localhost:4000',
                        getHttpToken: auth.getHttpToken,
                        getWsToken: auth.getWsToken,
                        contextObject: {},
                        yogaOptions: {
                            tracing: { mode: 'http-header' },
                            disablePlayground: true,
                        }
                    };
                    _a = lodash_1.merge(defaultProps, props), localSchemas = _a.localSchemas, propPort = _a.port, engineConfig = _a.engineConfig, endpoint = _a.endpoint, apiUrls = _a.apiUrls, tokenName = _a.tokenName, disabledScalars = _a.disabledScalars, subscriptionEndpoint = _a.subscriptionEndpoint, remoteSchemaUrls = _a.remoteSchemaUrls, disableCoreModule = _a.disableCoreModule, yogaOptions = _a.yogaOptions, enableAuthentication = _a.enableAuthentication, getUserId = _a.getUserId, getHttpToken = _a.getHttpToken, getWsToken = _a.getWsToken, websocketConnectionParams = _a.websocketConnectionParams, contextObject = _a.contextObject;
                    port = propPort;
                    yogaOptions.port = parseInt(port);
                    if (!yogaOptions.endpoint)
                        yogaOptions.endpoint = endpoint;
                    // validation
                    if (enableAuthentication && !getUserId) {
                        throw new Error('Please set getUserId in RunProps');
                    }
                    // logic
                    if (!disableCoreModule) {
                        localSchemas.unshift(core_1.default);
                    }
                    if (!disabledScalars) {
                        localSchemas.unshift(scalars_1.default);
                    }
                    typeDefs = localSchemas.map(function (x) { return x.typeDefs; }).join() || '';
                    resolvers = localSchemas.map(function (x) { return x.resolvers; }).reduce(lodash_1.merge) || {};
                    remoteSchemas = [];
                    _i = 0, remoteSchemaUrls_1 = remoteSchemaUrls;
                    _d.label = 1;
                case 1:
                    if (!(_i < remoteSchemaUrls_1.length)) return [3 /*break*/, 4];
                    url = remoteSchemaUrls_1[_i];
                    _c = (_b = remoteSchemas).push;
                    return [4 /*yield*/, getRemoteSchema(url)];
                case 2:
                    _c.apply(_b, [_d.sent()]);
                    _d.label = 3;
                case 3:
                    _i++;
                    return [3 /*break*/, 1];
                case 4:
                    schema = !remoteSchemas.length ? undefined : graphql_tools_1.mergeSchemas({
                        schemas: remoteSchemas.concat([typeDefs]),
                        resolvers: resolvers
                    });
                    apis = {};
                    for (key in apiUrls) {
                        apis[key] = new api_1.RestAPI(apiUrls[key]);
                    }
                    pubsub = new graphql_yoga_1.PubSub();
                    context = function (_a) {
                        var request = _a.request, connectionParams = _a.connectionParams;
                        var token = null;
                        var userId = null;
                        if (request)
                            token = getHttpToken(request, tokenName);
                        if (connectionParams)
                            token = getWsToken(connectionParams, tokenName);
                        // if (enableAuthentication && token)
                        // 	userId = await getUserId(token, apis);
                        return __assign({ token: token,
                            userId: userId,
                            pubsub: pubsub }, apis, contextObject);
                    };
                    server = new graphql_yoga_1.GraphQLServer({
                        schema: schema,
                        typeDefs: typeDefs,
                        resolvers: resolvers,
                        context: context,
                        options: yogaOptions
                    });
                    if (engineConfig && engineConfig.apiKey) {
                        engine = new apollo_engine_1.Engine({
                            engineConfig: engineConfig,
                            endpoint: endpoint,
                            graphqlPort: port,
                        });
                        engine.start();
                    }
                    if (yogaOptions && yogaOptions.disablePlayground)
                        server.express.get(endpoint, apollo_server_express_1.graphiqlExpress({
                            endpointURL: endpoint,
                            subscriptionsEndpoint: subscriptionEndpoint,
                            websocketConnectionParams: websocketConnectionParams
                        }));
                    if (engineConfig && engineConfig.apiKey) {
                        server.express.use(engine.expressMiddleware());
                    }
                    return [4 /*yield*/, server.start(function () { return console.log("Server is running on http://localhost:" + port); })];
                case 5:
                    _d.sent();
                    subscriptionServer = server.subscriptionServer;
                    subscriptionServer.onOperation = null;
                    subscriptionServer.onConnect = function (connectionParams) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                        switch (_a.label) {
                            case 0: return [4 /*yield*/, context({ connectionParams: connectionParams, request: null })];
                            case 1: return [2 /*return*/, _a.sent()];
                        }
                    }); }); };
                    return [2 /*return*/, {
                            server: server,
                            engine: engine,
                            pubsub: pubsub,
                        }];
            }
        });
    });
}
exports.run = run;
function getRemoteSchema(uri) {
    return __awaiter(this, void 0, void 0, function () {
        var link, introspectionSchema, graphcoolSchema;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    link = new link_http_1.HttpLink({ uri: uri, fetch: node_fetch_1.default });
                    return [4 /*yield*/, graphql_tools_1.introspectSchema(link)];
                case 1:
                    introspectionSchema = _a.sent();
                    graphcoolSchema = graphql_tools_1.makeRemoteExecutableSchema({
                        schema: introspectionSchema,
                        link: link
                    });
                    return [2 /*return*/, graphcoolSchema];
            }
        });
    });
}
devEnv();
exports.default = {
    run: run,
    devEnv: devEnv,
    getRemoteSchema: getRemoteSchema,
};
function createSubscriptionEvent(_a) {
    var eventName = _a.eventName, _b = _a.filter, filter = _b === void 0 ? function () { return true; } : _b, _c = _a.map, map = _c === void 0 ? function (x) { return x; } : _c;
    return {
        resolve: map,
        subscribe: graphql_subscriptions_1.withFilter(function (obj, props, context, info) { return context.pubsub.asyncIterator(eventName); }, filter)
    };
}
exports.createSubscriptionEvent = createSubscriptionEvent;