graphcool-cli-engine/dist/Environment.js

"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 yaml = require("js-yaml");
var path = require("path");
var fs_1 = require("./fs");
var lodash_1 = require("lodash");
var Variables_1 = require("./ProjectDefinition/Variables");
var debug = require('debug')('environment');
var stringSimilarity = require("string-similarity");
var chalk_1 = require("chalk");
var defaultRC = {
    clusters: {
        default: 'shared-eu-west-1',
    },
};
var Environment = (function () {
    function Environment(out, config) {
        var _this = this;
        this.localRC = {};
        this.globalRC = {};
        this.activeCluster = 'shared-eu-west-1';
        this.warningCache = {};
        this.resolveTargetAliases = function (targets, allTargets) {
            return lodash_1.mapValues(targets, function (target) {
                return _this.isTargetAlias(target)
                    ? _this.resolveTarget(target, allTargets)
                    : target;
            });
        };
        this.isTargetAlias = function (target) {
            return typeof target === 'string' && target.split('/').length === 1;
        };
        this.resolveTarget = function (target, targets) {
            return targets[target] ? _this.resolveTarget(targets[target], targets) : target;
        };
        this.subscriptionURL = function (_a) {
            var region = _a.region, projectId = _a.projectId, localAddr = _a.localAddr, localPort = _a.localPort;
            return localPort
                ? "ws://" + localAddr + ":" + localPort + "/subscriptions/v1/" + projectId
                : subscriptionEndpoints[region] + "/v1/" + projectId;
        };
        this.out = out;
        this.config = config;
        this.migrateOldFormat();
    }
    Object.defineProperty(Environment.prototype, "rc", {
        get: function () {
            // todo: memoizing / caching
            return this.deserializeRCs(this.localRC, this.globalRC, this.config.localRCPath, this.config.globalRCPath);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(Environment.prototype, "token", {
        get: function () {
            if (process.env.GRAPHCOOL_PLATFORM_TOKEN) {
                debug('taking process.env.GRAPHCOOL_PLATFORM_TOKEN as the token');
                return process.env.GRAPHCOOL_PLATFORM_TOKEN;
            }
            if (this.isSharedCluster(this.activeCluster)) {
                return this.rc.platformToken;
            }
            return this.rc.clusters[this.activeCluster].clusterSecret;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(Environment.prototype, "default", {
        get: function () {
            if (this.rc.targets && this.rc.targets.default) {
                return this.rc.targets.default;
            }
            return null;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(Environment.prototype, "allClusters", {
        get: function () {
            var localClusters = this.rc.clusters ? Object.keys(this.rc.clusters) : [];
            return this.config.sharedClusters.concat(localClusters);
        },
        enumerable: true,
        configurable: true
    });
    Environment.prototype.checkCluster = function (cluster) {
        var allClusters = this.config.sharedClusters.concat(Object.keys(this.rc.clusters || {}));
        if (!allClusters.includes(cluster)) {
            if (cluster === 'local') {
                this.out.log("You chose the cluster " + chalk_1.default.bold('local') + ", but don't have docker initialized, yet.\nPlease run " + chalk_1.default.green('$ graphcool-framework local up') + " to get a local Graphcool cluster.\n");
                this.out.exit(1);
            }
            var bestMatch = stringSimilarity.findBestMatch(cluster, allClusters)
                .bestMatch.target;
            this.out.error(cluster + " is not a valid cluster. Did you mean " + bestMatch + "?");
        }
    };
    Environment.prototype.setLocalTarget = function (name, value) {
        if (value.split('/').length !== 2) {
            this.out.error("Invalid target " + name + " " + value);
        }
        if (!this.localRC.targets) {
            this.localRC.targets = {};
        }
        this.localRC.targets[name] = value;
    };
    Environment.prototype.setLocalDefaultTarget = function (value) {
        if (!this.localRC.targets) {
            this.localRC.targets = {};
        }
        this.localRC.targets.default = value;
    };
    Environment.prototype.getTarget = function (targetName, silent) {
        var target = null;
        if (targetName && targetName.split('/').length > 1) {
            target = this.deserializeTarget(targetName);
        }
        target = targetName || (this.rc.targets && this.rc.targets.default);
        if (typeof target === 'string' && this.rc.targets) {
            target = this.rc.targets[target];
        }
        if (target) {
            this.setActiveCluster(target.cluster);
        }
        else if (!silent) {
            this.out.error('Please provide a valid target that points to a valid cluster and service id');
        }
        return target;
    };
    Environment.prototype.getTargetWithName = function (targetName) {
        var target = null;
        var name = null;
        if (targetName && targetName.split('/').length > 1) {
            target = this.deserializeTarget(targetName);
        }
        else {
            if (targetName) {
                target = targetName;
                name = targetName;
            }
            else if (this.rc.targets && this.rc.targets.default) {
                target = this.rc.targets.default;
                name =
                    (this.localRC.targets && this.localRC.targets.default) ||
                        (this.globalRC.targets && this.globalRC.targets.default) ||
                        null;
                name = name && name.split('/').length === 1 ? name : null;
            }
            if (typeof target === 'string' && this.rc.targets) {
                target = this.rc.targets[target];
            }
        }
        if (target) {
            this.setActiveCluster(target.cluster);
        }
        return {
            target: target,
            targetName: name,
        };
    };
    Environment.prototype.getDefaultTargetName = function (cluster) {
        var targetName = this.isSharedCluster(cluster) ? 'prod' : 'dev';
        if (!this.rc.targets || !this.rc.targets[targetName]) {
            return targetName;
        }
        else {
            var count = 1;
            while (this.rc.targets[targetName + count]) {
                count++;
            }
            return targetName + count;
        }
    };
    Environment.prototype.setActiveCluster = function (cluster) {
        this.checkCluster(cluster);
        this.activeCluster = cluster;
    };
    Environment.prototype.isSharedCluster = function (cluster) {
        return this.config.sharedClusters.includes(cluster);
    };
    Environment.prototype.deleteIfExist = function (serviceIds) {
        var _this = this;
        serviceIds.forEach(function (id) {
            var localTarget = Object.keys(_this.localRC.targets || {}).find(function (name) { return _this.localRC.targets[name].split('/')[1] === id; });
            if (localTarget) {
                delete _this.localRC[localTarget];
            }
            var globalTarget = Object.keys(_this.globalRC.targets || {}).find(function (name) { return _this.globalRC.targets[name].split('/')[1] === id; });
            if (globalTarget) {
                delete _this.globalRC[globalTarget];
            }
        });
    };
    /**
     * This is used to migrate the old .graphcool and .graphcoolrc to the new format
     */
    Environment.prototype.migrateOldFormat = function () {
        this.migrateGlobalFiles();
        this.migrateLocalFile();
        this.migrateClusters(this.config.localRCPath);
        this.migrateClusters(this.config.globalRCPath);
    };
    Environment.prototype.migrateLocalFile = function () {
        if (fs_1.default.pathExistsSync(this.config.localRCPath)) {
            var file = fs_1.default.readFileSync(this.config.localRCPath, 'utf-8');
            var content = void 0;
            try {
                content = yaml.safeLoad(file);
                // we got the old format here
                if (content.environments) {
                    var newLocalRcJson = {
                        targets: lodash_1.mapValues(content.environments, function (env) {
                            return "shared-eu-west-1/" + env;
                        }),
                        clusters: {},
                    };
                    if (content.default) {
                        newLocalRcJson.targets.default = content.default;
                    }
                    var newLocalRcYaml = yaml.safeDump(newLocalRcJson);
                    var oldPath = path.join(this.config.cwd, '.graphcoolrc.old');
                    fs_1.default.moveSync(this.config.localRCPath, oldPath);
                    fs_1.default.writeFileSync(this.config.localRCPath, newLocalRcYaml);
                    this.out.warn("We detected the old definition format of the " + this.config.localRCPath + " file.\nIt has been renamed to " + oldPath + ". The up-to-date format has been written to " + this.config.localRCPath + ".\nRead more about the changes here:\nhttps://github.com/graphcool/framework/issues/714\n");
                }
            }
            catch (e) { }
        }
    };
    Environment.prototype.migrateClusters = function (rcPath) {
        if (fs_1.default.pathExistsSync(rcPath)) {
            var file = fs_1.default.readFileSync(rcPath, 'utf-8');
            var content_1;
            try {
                content_1 = yaml.safeLoad(file);
                if (content_1.clusters &&
                    Object.keys(content_1.clusters).find(function (c) { return content_1.clusters[c].token; })) {
                    var newRcJson = __assign({}, content_1, { clusters: lodash_1.mapValues(content_1.clusters, function (c) {
                            return typeof c === 'string'
                                ? c
                                : {
                                    clusterSecret: c.token,
                                    host: c.host,
                                };
                        }) });
                    var newLocalRcYaml = yaml.safeDump(newRcJson);
                    var oldPath = path.join(path.dirname(rcPath), '.graphcoolrc.old');
                    fs_1.default.moveSync(rcPath, oldPath);
                    fs_1.default.writeFileSync(rcPath, newLocalRcYaml);
                    this.out.warn("We detected the old definition format of " + chalk_1.default.bold('clusters') + " in the " + rcPath + " file.\n" + chalk_1.default.bold('token') + " has been renamed to " + chalk_1.default.bold('clusterSecret') + ".\nIt has been renamed to " + oldPath + ". The up-to-date format has been written to " + rcPath + ".\n");
                }
                if (content_1.clusters &&
                    Object.keys(content_1.clusters).find(function (c) {
                        return typeof content_1.clusters[c] !== 'string' &&
                            !content_1.clusters[c].faasHost;
                    })) {
                    var newRcJson = __assign({}, content_1, { clusters: lodash_1.mapValues(content_1.clusters, function (c) {
                            return typeof c === 'string'
                                ? c
                                : __assign({}, c, { faasHost: 'http://localhost:60050' });
                        }) });
                    var newLocalRcYaml = yaml.safeDump(newRcJson);
                    fs_1.default.writeFileSync(rcPath, newLocalRcYaml);
                    this.out.warn("We detected the old definition format of " + chalk_1.default.bold('clusters') + " in the " + rcPath + " file. A new field called " + chalk_1.default.bold('faasHost') + " has been added, which contains the address to the new local function runtime.");
                }
            }
            catch (e) { }
        }
    };
    Environment.prototype.migrateGlobalFiles = function () {
        var dotFilePath = path.join(this.config.home, '.graphcool');
        var dotExists = fs_1.default.pathExistsSync(dotFilePath);
        if (fs_1.default.lstatSync(dotFilePath).isDirectory()) {
            return;
        }
        var rcHomePath = path.join(this.config.home, '.graphcoolrc');
        var rcHomeExists = fs_1.default.pathExistsSync(rcHomePath);
        var dotFile = dotExists ? fs_1.default.readFileSync(dotFilePath, 'utf-8') : null;
        var rcFile = rcHomeExists ? fs_1.default.readFileSync(rcHomePath, 'utf-8') : null;
        // if both legacy files exist, prefer the newer one, .graphcool
        if (rcHomeExists && rcFile) {
            // only move this file, if it is json and contains the "token" field
            // in this case, it's the old format
            try {
                var rcJson = JSON.parse(rcFile);
                if (Object.keys(rcJson).length === 1 && rcJson.token) {
                    this.out.warn("Moved deprecated file " + rcHomePath + " to .graphcoolrc.old");
                    fs_1.default.moveSync(rcHomePath, path.join(this.config.home, '.graphcoolrc.old'));
                }
            }
            catch (e) {
                //
            }
        }
        if (dotExists) {
            if (dotFile) {
                try {
                    var dotJson = JSON.parse(dotFile);
                    if (dotJson.token) {
                        var rc = __assign({}, defaultRC, { platformToken: dotJson.token });
                        var rcSerialized = this.serializeRC(rc);
                        var oldPath = path.join(this.config.home, '.graphcool.old');
                        fs_1.default.moveSync(dotFilePath, oldPath);
                        debug("Writing", rcHomePath, rcSerialized);
                        fs_1.default.writeFileSync(rcHomePath, rcSerialized);
                        var READ = fs_1.default.readFileSync(rcHomePath, 'utf-8');
                        debug('YES', READ);
                        this.out
                            .warn("We detected the old definition format of the " + dotFilePath + " file.\nIt has been renamed to " + oldPath + ". The new file is called " + rcHomePath + ".\nRead more about the changes here:\nhttps://github.com/graphcool/framework/issues/714\n");
                    }
                }
                catch (e) {
                    // noop
                }
            }
        }
        else if (rcHomeExists && rcFile) {
            try {
                var rcJson = JSON.parse(rcFile);
                var rc = __assign({}, defaultRC, { platformToken: rcJson.token });
                var rcSerialized = this.serializeRC(rc);
                fs_1.default.writeFileSync(rcHomePath, rcSerialized);
            }
            catch (e) {
                // noop
            }
        }
    };
    Environment.prototype.loadYaml = function (file, filePath) {
        if (filePath === void 0) { filePath = null; }
        return __awaiter(this, void 0, void 0, function () {
            var content, variables;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        if (!file) return [3 /*break*/, 2];
                        content = void 0;
                        try {
                            content = yaml.safeLoad(file);
                        }
                        catch (e) {
                            this.out.error("Yaml parsing error in " + filePath + ": " + e.message);
                        }
                        variables = new Variables_1.default(this.out, filePath || 'no filepath provided', this.args);
                        return [4 /*yield*/, variables.populateJson(content)];
                    case 1:
                        content = _a.sent();
                        return [2 /*return*/, content];
                    case 2: return [2 /*return*/, {}];
                }
            });
        });
    };
    Environment.prototype.load = function (args) {
        return __awaiter(this, void 0, void 0, function () {
            var localFile, globalFile;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        localFile = this.config.localRCPath && fs_1.default.pathExistsSync(this.config.localRCPath)
                            ? fs_1.default.readFileSync(this.config.localRCPath, 'utf-8')
                            : null;
                        globalFile = this.config.globalRCPath && fs_1.default.pathExistsSync(this.config.globalRCPath)
                            ? fs_1.default.readFileSync(this.config.globalRCPath, 'utf-8')
                            : null;
                        return [4 /*yield*/, this.loadRCs(localFile, globalFile, args)];
                    case 1:
                        _a.sent();
                        if (process.env.NODE_ENV === 'test') {
                            this.setTestToken();
                        }
                        return [2 /*return*/];
                }
            });
        });
    };
    Environment.prototype.loadRCs = function (localFile, globalFile, args) {
        if (args === void 0) { args = {}; }
        return __awaiter(this, void 0, void 0, function () {
            var _a, _b;
            return __generator(this, function (_c) {
                switch (_c.label) {
                    case 0:
                        this.args = args;
                        _a = this;
                        return [4 /*yield*/, this.loadYaml(localFile, this.config.localRCPath)];
                    case 1:
                        _a.localRC = _c.sent();
                        _b = this;
                        return [4 /*yield*/, this.loadYaml(globalFile, this.config.globalRCPath)];
                    case 2:
                        _b.globalRC = _c.sent();
                        if (this.rc.clusters && this.rc.clusters.default) {
                            if (!this.allClusters.includes(this.rc.clusters.default)) {
                                this.out.error("Could not find default cluster " + this.rc.clusters.default);
                            }
                            this.activeCluster = this.rc.clusters.default;
                        }
                        return [2 /*return*/];
                }
            });
        });
    };
    Environment.prototype.deserializeRCs = function (localFile, globalFile, localFilePath, globalFilePath) {
        var allTargets = __assign({}, localFile.targets, globalFile.targets);
        var newLocalFile = __assign({}, localFile);
        var newGlobalFile = __assign({}, globalFile);
        // 1. resolve aliases
        // global is not allowed to access local variables
        newGlobalFile.targets = this.resolveTargetAliases(newGlobalFile.targets, newGlobalFile.targets);
        // repeat this 2 times as potentially there could be a deeper indirection
        for (var i = 0; i < 2; i++) {
            // first resolve all aliases
            newLocalFile.targets = this.resolveTargetAliases(newLocalFile.targets, allTargets);
            allTargets = __assign({}, newLocalFile.targets, newGlobalFile.targets);
        }
        // at this point there should only be targets in the form of shared-eu-west-1/cj862nxg0000um3t0z64ls08
        // 2. convert cluster/id to Target
        newLocalFile.targets = this.deserializeTargets(newLocalFile.targets, localFilePath);
        newGlobalFile.targets = this.deserializeTargets(newGlobalFile.targets, globalFilePath);
        // check if clusters exist
        var allClusters = this.config.sharedClusters.concat(Object.keys(newGlobalFile.clusters || {}), Object.keys(newLocalFile.clusters || {}));
        this.checkClusters(newLocalFile.targets, allClusters, localFilePath);
        this.checkClusters(newGlobalFile.targets, allClusters, globalFilePath);
        return lodash_1.merge({}, newGlobalFile, newLocalFile);
    };
    Environment.prototype.checkClusters = function (targets, clusters, filePath) {
        var _this = this;
        Object.keys(targets).forEach(function (key) {
            var target = targets[key];
            if (!clusters.includes(target.cluster) &&
                !_this.warningCache[target.cluster]) {
                _this.warningCache[target.cluster] = true;
                if (target.cluster === 'local') {
                    _this.out.warn("Could not find cluster " + target.cluster + " defined for target " + key + " in " + filePath + ".\nPlease run " + chalk_1.default.bold('graphcool local up') + " to start the local cluster.");
                }
                else {
                    _this.out.error("Could not find cluster " + target.cluster + " defined for target " + key + " in " + filePath);
                }
            }
        });
    };
    Environment.prototype.deserializeTargets = function (targets, filePath) {
        var _this = this;
        return lodash_1.mapValues(targets, function (target) {
            return _this.deserializeTarget(target, filePath);
        });
    };
    Environment.prototype.deserializeTarget = function (target, filePath) {
        if (filePath === void 0) { filePath = null; }
        var splittedTarget = target.split('/');
        if (splittedTarget.length === 1) {
            this.out.error("Could not parse target " + target + " in " + filePath);
        }
        return {
            cluster: splittedTarget[0],
            id: splittedTarget[1],
        };
    };
    Environment.prototype.serializeRC = function (rc) {
        // const copy: any = {...rc}
        // if (copy.targets) {
        //   copy.targets = this.serializeTargets(copy.targets)
        // }
        return yaml.safeDump(rc);
    };
    //
    // serializeTargets(targets: Targets) {
    //   return mapValues<Target, string>(targets, t => `${t.cluster}/${t.id}`)
    // }
    Environment.prototype.setToken = function (token) {
        this.globalRC.platformToken = token;
    };
    Environment.prototype.saveLocalRC = function () {
        var file = this.serializeRC(this.localRC);
        fs_1.default.writeFileSync(this.config.localRCPath, file);
    };
    Environment.prototype.saveGlobalRC = function () {
        var file = this.serializeRC(this.globalRC);
        fs_1.default.writeFileSync(this.config.globalRCPath, file);
    };
    Environment.prototype.save = function () {
        this.saveLocalRC();
        this.saveGlobalRC();
    };
    Environment.prototype.setGlobalCluster = function (name, cluster) {
        if (!this.globalRC.clusters) {
            this.globalRC.clusters = {};
        }
        this.globalRC.clusters[name] = cluster;
    };
    Environment.prototype.setLocalDefaultCluster = function (cluster) {
        if (!this.globalRC.clusters) {
            this.globalRC.clusters = {};
        }
        this.globalRC.clusters.default = cluster;
    };
    Environment.prototype.getRegionFromCluster = function (cluster) {
        if (this.isSharedCluster(cluster)) {
            return cluster
                .slice(7)
                .replace(/-/g, '_')
                .toUpperCase();
        }
        else {
            return 'EU_WEST_1';
        }
    };
    Object.defineProperty(Environment.prototype, "clusterEndpoint", {
        get: function () {
            if (this.isSharedCluster(this.activeCluster)) {
                return this.config.systemAPIEndpoint;
            }
            return this.rc.clusters[this.activeCluster].host + '/system';
        },
        enumerable: true,
        configurable: true
    });
    Environment.prototype.simpleEndpoint = function (projectId) {
        if (this.isSharedCluster(this.activeCluster)) {
            return this.config.simpleAPIEndpoint + projectId;
        }
        return (this.rc.clusters[this.activeCluster].host +
            '/simple/v1/' +
            projectId);
    };
    Environment.prototype.importEndpoint = function (projectId) {
        if (this.isSharedCluster(this.activeCluster)) {
            return this.config.simpleAPIEndpoint + projectId + '/import';
        }
        return (this.rc.clusters[this.activeCluster].host +
            '/simple/v1/' +
            projectId +
            '/import');
    };
    Environment.prototype.exportEndpoint = function (projectId) {
        if (this.isSharedCluster(this.activeCluster)) {
            return this.config.simpleAPIEndpoint + projectId + '/export';
        }
        return (this.rc.clusters[this.activeCluster].host +
            '/simple/v1/' +
            projectId +
            '/export');
    };
    Environment.prototype.relayEndpoint = function (projectId) {
        if (this.isSharedCluster(this.activeCluster)) {
            return this.config.relayAPIEndpoint + projectId;
        }
        return (this.rc.clusters[this.activeCluster].host +
            '/relay/v1/' +
            projectId);
    };
    Environment.prototype.fileEndpoint = function (projectId) {
        if (this.isSharedCluster(this.activeCluster)) {
            return this.config.fileAPIEndpoint + projectId;
        }
        return (this.rc.clusters[this.activeCluster].host +
            '/file/v1/' +
            projectId);
    };
    Environment.prototype.subscriptionEndpoint = function (projectId) {
        if (this.isSharedCluster(this.activeCluster)) {
            var region = this.getRegionFromCluster(this.activeCluster);
            return this.subscriptionURL({ region: region, projectId: projectId });
        }
        var match = this.clusterEndpoint.match(/https?:\/\/(.*):(\d+)\/?.*/);
        var localAddr = match ? match[1] : 'localhost';
        var localPort = match ? match[2] : '60000';
        return this.subscriptionURL({ localAddr: localAddr, localPort: localPort, projectId: projectId });
    };
    Environment.prototype.setTestToken = function () {
        debug('taking graphcool test token');
        this.globalRC.platformToken = process.env.GRAPHCOOL_TEST_TOKEN;
    };
    return Environment;
}());
exports.Environment = Environment;
var subscriptionEndpoints = {
    EU_WEST_1: 'wss://subscriptions.graph.cool',
    US_WEST_2: 'wss://subscriptions.us-west-2.graph.cool',
    AP_NORTHEAST_1: 'wss://subscriptions.ap-northeast-1.graph.cool',
};
//# sourceMappingURL=Environment.js.map