graphql-subscriptions/dist/pubsub.js

"use strict";
var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var events_1 = require('events');
var graphql_1 = require('graphql');
var valueFromAST = require('graphql').valueFromAST;
var validation_1 = require('./validation');
var FilteredPubSub = (function () {
    function FilteredPubSub() {
        this.ee = new events_1.EventEmitter();
        this.subscriptions = {};
        this.subIdCounter = 0;
    }
    FilteredPubSub.prototype.publish = function (triggerName, payload) {
        this.ee.emit(triggerName, payload);
    };
    FilteredPubSub.prototype.subscribe = function (triggerName, filterFunc, handler) {
        var onMessage = function (data) { return filterFunc(data) ? handler(data) : null; };
        this.ee.addListener(triggerName, onMessage);
        this.subIdCounter = this.subIdCounter + 1;
        this.subscriptions[this.subIdCounter] = [triggerName, onMessage];
        return this.subIdCounter;
    };
    FilteredPubSub.prototype.unsubscribe = function (subId) {
        var _a = this.subscriptions[subId], triggerName = _a[0], onMessage = _a[1];
        delete this.subscriptions[subId];
        this.ee.removeListener(triggerName, onMessage);
    };
    return FilteredPubSub;
}());
exports.FilteredPubSub = FilteredPubSub;
var ValidationError = (function (_super) {
    __extends(ValidationError, _super);
    function ValidationError(errors) {
        _super.call(this);
        this.errors = errors;
        this.message = 'Subscription query has validation errors';
    }
    return ValidationError;
}(Error));
exports.ValidationError = ValidationError;
;
var SubscriptionManager = (function () {
    function SubscriptionManager(options) {
        this.pubsub = new FilteredPubSub();
        this.schema = options.schema;
        this.setupFunctions = options.setupFunctions;
        this.subscriptions = {};
        this.maxSubscriptionId = 0;
    }
    SubscriptionManager.prototype.publish = function (triggerName, payload) {
        this.pubsub.publish(triggerName, payload);
    };
    SubscriptionManager.prototype.subscribe = function (options) {
        var _this = this;
        if (!options.operationName) {
            throw new Error('Must provide operationName');
        }
        var parsedQuery = graphql_1.parse(options.query);
        var errors = graphql_1.validate(this.schema, parsedQuery, graphql_1.specifiedRules.concat([validation_1.subscriptionHasSingleRootField]));
        if (errors.length) {
            throw new ValidationError(errors);
        }
        var args = {};
        var subscriptionName = '';
        parsedQuery.definitions.forEach(function (definition) {
            if (definition.kind === 'OperationDefinition') {
                var rootField = definition.selectionSet.selections[0];
                subscriptionName = rootField.name.value;
                var fields_1 = _this.schema.getSubscriptionType().getFields();
                rootField.arguments.forEach(function (arg) {
                    var argDefinition = fields_1[subscriptionName].args.filter(function (argDef) { return argDef.name === arg.name.value; })[0];
                    args[argDefinition.name] = valueFromAST(arg.value, argDefinition.type, options.variables);
                });
            }
        });
        var triggerMap = (_a = {}, _a[subscriptionName] = function () { return true; }, _a);
        if (this.setupFunctions[subscriptionName]) {
            triggerMap = this.setupFunctions[subscriptionName](options, args, subscriptionName);
        }
        var externalSubscriptionId = this.maxSubscriptionId++;
        this.subscriptions[externalSubscriptionId] = [];
        Object.keys(triggerMap).forEach(function (triggerName) {
            var onMessage = function (rootValue) {
                try {
                    graphql_1.execute(_this.schema, parsedQuery, rootValue, context, options.variables, options.operationName).then(function (data) { return options.callback(null, data); });
                }
                catch (e) {
                    options.callback(e);
                }
            };
            _this.subscriptions[externalSubscriptionId].push(_this.pubsub.subscribe(triggerName, triggerMap[triggerName], onMessage));
        });
        return externalSubscriptionId;
        var _a;
    };
    SubscriptionManager.prototype.unsubscribe = function (subId) {
        var _this = this;
        this.subscriptions[subId].forEach(function (internalId) {
            _this.pubsub.unsubscribe(internalId);
        });
    };
    return SubscriptionManager;
}());
exports.SubscriptionManager = SubscriptionManager;
//# sourceMappingURL=pubsub.js.map