apollo-mobx/testing/spy_link.js

HOC for querying graphql server

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var apollo_link_1 = require("apollo-link");
var printer_1 = require("graphql/language/printer");
var SpyLink = (function (_super) {
    tslib_1.__extends(SpyLink, _super);
    function SpyLink() {
        var _this = _super.call(this) || this;
        _this.inFlightRequestObservables = new Map();
        _this.subscribers = new Map();
        return _this;
    }
    SpyLink.prototype.wait = function () {
        return tslib_1.__awaiter(this, void 0, void 0, function () {
            var _this = this;
            return tslib_1.__generator(this, function (_a) {
                return [2, new Promise(function (resolve) {
                        var check = function () {
                            if (_this.inFlightRequestObservables.size === 0) {
                                resolve();
                            }
                            else {
                                setTimeout(check, 5);
                            }
                        };
                        check();
                    })];
            });
        });
    };
    SpyLink.prototype.request = function (operation, forward) {
        var _this = this;
        var key = operation.toKey();
        var cleanup = function (cleanupKey) {
            _this.inFlightRequestObservables.delete(cleanupKey);
            var prev = _this.subscribers.get(cleanupKey);
            return prev;
        };
        if (!this.inFlightRequestObservables.get(key)) {
            var singleObserver_1 = forward(operation);
            var subscription_1;
            var sharedObserver = new apollo_link_1.Observable(function (observer) {
                var prev = _this.subscribers.get(key);
                if (!prev) {
                    prev = { next: [], error: [], complete: [] };
                }
                _this.subscribers.set(key, {
                    complete: prev.complete.concat([observer.complete.bind(observer)]),
                    error: prev.error.concat([observer.error.bind(observer)]),
                    next: prev.next.concat([observer.next.bind(observer)])
                });
                if (!subscription_1) {
                    subscription_1 = singleObserver_1.subscribe({
                        complete: function () {
                            delete _this.inFlightRequestObservables[key];
                            observer.complete();
                        },
                        error: function (error) {
                            var prevCleanup = cleanup(key);
                            _this.subscribers.delete(key);
                            if (prevCleanup) {
                                prevCleanup.error.forEach(function (err) { return err(error); });
                            }
                        },
                        next: function (result) {
                            var prevCleanup = cleanup(key);
                            _this.subscribers.delete(key);
                            if (prevCleanup) {
                                prevCleanup.next.forEach(function (next) { return next(result); });
                                prevCleanup.complete.forEach(function (complete) { return complete(); });
                            }
                        }
                    });
                }
                return function () {
                    if (subscription_1) {
                        subscription_1.unsubscribe();
                    }
                    _this.inFlightRequestObservables.delete(key);
                };
            });
            this.inFlightRequestObservables.set(key, sharedObserver);
        }
        return this.inFlightRequestObservables.get(key);
    };
    SpyLink.prototype.getKey = function (operation) {
        return printer_1.print(operation.query);
    };
    return SpyLink;
}(apollo_link_1.ApolloLink));
exports.SpyLink = SpyLink;