dtsgenerator/dist/core/referenceResolver.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
require("cross-fetch/polyfill");
var debug_1 = tslib_1.__importDefault(require("debug"));
var https_proxy_agent_1 = tslib_1.__importDefault(require("https-proxy-agent"));
var utils_1 = require("../utils");
var jsonSchema_1 = require("./jsonSchema");
var schemaId_1 = tslib_1.__importDefault(require("./schemaId"));
var debug = debug_1.default('dtsgen');
var ReferenceResolver = (function () {
    function ReferenceResolver() {
        this.schemaCache = new Map();
        this.referenceCache = new Map();
    }
    ReferenceResolver.prototype.dereference = function (refId) {
        var result = this.referenceCache.get(refId);
        if (result == null) {
            throw new Error('Target reference is not found: ' + refId);
        }
        return result;
    };
    ReferenceResolver.prototype.getAllRegisteredSchema = function () {
        return this.schemaCache.values();
    };
    ReferenceResolver.prototype.resolve = function () {
        return tslib_1.__awaiter(this, void 0, void 0, function () {
            var error, _a, _b, _c, key, schema, id, fileId, result, refSchema, e_1, rootSchema, targetSchema, e_2_1;
            var e_2, _d;
            return tslib_1.__generator(this, function (_e) {
                switch (_e.label) {
                    case 0:
                        debug("resolve reference: reference schema count=" + this.referenceCache.size + ".");
                        error = [];
                        _e.label = 1;
                    case 1:
                        _e.trys.push([1, 10, 11, 12]);
                        _a = tslib_1.__values(this.referenceCache.entries()), _b = _a.next();
                        _e.label = 2;
                    case 2:
                        if (!!_b.done) return [3, 9];
                        _c = tslib_1.__read(_b.value, 2), key = _c[0], schema = _c[1];
                        if (schema != null) {
                            return [3, 8];
                        }
                        id = new schemaId_1.default(key);
                        fileId = id.getFileId();
                        result = this.schemaCache.get(id.getAbsoluteId());
                        if (!(result == null)) return [3, 7];
                        refSchema = this.schemaCache.get(fileId);
                        debug("get from schema cache, fileId=" + fileId + ", exists=" + (refSchema != null) + ", " + id.getAbsoluteId());
                        if (!(refSchema == null && id.isFetchable())) return [3, 6];
                        _e.label = 3;
                    case 3:
                        _e.trys.push([3, 5, , 6]);
                        debug("fetch remote schema: id=[" + fileId + "].");
                        return [4, this.registerRemoteSchema(fileId)];
                    case 4:
                        _e.sent();
                        return [3, 6];
                    case 5:
                        e_1 = _e.sent();
                        error.push("Fail to fetch the $ref target: " + id.getAbsoluteId() + ", " + e_1);
                        return [3, 8];
                    case 6:
                        result = this.schemaCache.get(id.getAbsoluteId());
                        _e.label = 7;
                    case 7:
                        debug("resolve reference: ref=[" + id.getAbsoluteId() + "]");
                        if (result != null) {
                            this.referenceCache.set(id.getAbsoluteId(), result);
                        }
                        else {
                            if (id.existsJsonPointerHash()) {
                                rootSchema = this.searchParentSchema(id);
                                if (rootSchema == null) {
                                    error.push("The $ref targets root is not found: " + id.getAbsoluteId());
                                    return [3, 8];
                                }
                                targetSchema = jsonSchema_1.getSubSchema(rootSchema, id.getJsonPointerHash(), id);
                                this.addSchema(targetSchema);
                                this.registerSchema(targetSchema);
                                this.referenceCache.set(id.getAbsoluteId(), targetSchema);
                            }
                            else {
                                error.push("The $ref target is not found: " + id.getAbsoluteId());
                                return [3, 8];
                            }
                        }
                        _e.label = 8;
                    case 8:
                        _b = _a.next();
                        return [3, 2];
                    case 9: return [3, 12];
                    case 10:
                        e_2_1 = _e.sent();
                        e_2 = { error: e_2_1 };
                        return [3, 12];
                    case 11:
                        try {
                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
                        }
                        finally { if (e_2) throw e_2.error; }
                        return [7];
                    case 12:
                        if (error.length > 0) {
                            throw new Error(error.join('\n'));
                        }
                        return [2];
                }
            });
        });
    };
    ReferenceResolver.prototype.searchParentSchema = function (id) {
        var e_3, _a;
        var fileId = id.getFileId();
        var rootSchema = this.schemaCache.get(fileId);
        if (rootSchema != null) {
            return rootSchema;
        }
        var key = id.getAbsoluteId();
        try {
            for (var _b = tslib_1.__values(this.schemaCache.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
                var k = _c.value;
                if (key.startsWith(k)) {
                    var s = this.schemaCache.get(k);
                    if (s != null && s.rootSchema != null) {
                        return s.rootSchema;
                    }
                }
            }
        }
        catch (e_3_1) { e_3 = { error: e_3_1 }; }
        finally {
            try {
                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
            }
            finally { if (e_3) throw e_3.error; }
        }
        return;
    };
    ReferenceResolver.prototype.noProxy = function (url) {
        var e_4, _a;
        if (process.env.NO_PROXY) {
            try {
                for (var _b = tslib_1.__values(process.env.NO_PROXY.split(/[, ]+/)), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var domain = _c.value;
                    if (url.hostname.endsWith(domain)) {
                        return true;
                    }
                }
            }
            catch (e_4_1) { e_4 = { error: e_4_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_4) throw e_4.error; }
            }
        }
        return false;
    };
    ReferenceResolver.prototype.registerRemoteSchema = function (url) {
        return tslib_1.__awaiter(this, void 0, void 0, function () {
            var fetchOptions, parsedUrl, proxyUrl, agentOptions, res, body, content, schema;
            return tslib_1.__generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        fetchOptions = {};
                        parsedUrl = new URL(url);
                        if (!this.noProxy(parsedUrl)) {
                            if (parsedUrl.protocol === 'http:' && process.env.HTTP_PROXY) {
                                proxyUrl = new URL(process.env.HTTP_PROXY);
                            }
                            else if (parsedUrl.protocol === 'https:' && process.env.HTTPS_PROXY) {
                                proxyUrl = new URL(process.env.HTTPS_PROXY);
                            }
                        }
                        if (proxyUrl) {
                            agentOptions = {};
                            agentOptions.protocol = proxyUrl.protocol;
                            agentOptions.host = proxyUrl.hostname;
                            agentOptions.port = proxyUrl.port;
                            if (proxyUrl.username) {
                                agentOptions.auth = proxyUrl.username + ':' + proxyUrl.password;
                            }
                            fetchOptions.agent = https_proxy_agent_1.default(agentOptions);
                        }
                        return [4, fetch(url, fetchOptions)];
                    case 1:
                        res = _a.sent();
                        return [4, res.text()];
                    case 2:
                        body = _a.sent();
                        if (!res.ok) {
                            throw new Error("Error on fetch from url(" + url + "): " + res.status + ", " + body);
                        }
                        content = utils_1.parseFileContent(body, url);
                        schema = jsonSchema_1.parseSchema(content, url);
                        this.registerSchema(schema);
                        return [2];
                }
            });
        });
    };
    ReferenceResolver.prototype.registerSchema = function (schema) {
        var _this = this;
        debug("register schema: schemaId=[" + schema.id.getAbsoluteId() + "].");
        jsonSchema_1.searchAllSubSchema(schema, function (subSchema) {
            _this.addSchema(subSchema);
        }, function (refId) {
            _this.addReference(refId);
        });
    };
    ReferenceResolver.prototype.addSchema = function (schema) {
        var id = schema.id;
        var key = id.getAbsoluteId();
        if (!this.schemaCache.has(key)) {
            debug(" add schema: id=" + key);
            this.schemaCache.set(key, schema);
            if (schema.rootSchema == null) {
                var fileId = id.getFileId();
                if (!this.schemaCache.has(fileId)) {
                    this.schemaCache.set(fileId, schema);
                }
            }
        }
    };
    ReferenceResolver.prototype.addReference = function (refId) {
        if (!this.referenceCache.has(refId.getAbsoluteId())) {
            debug(" add reference: id=" + refId.getAbsoluteId());
            this.referenceCache.set(refId.getAbsoluteId(), undefined);
        }
    };
    ReferenceResolver.prototype.clear = function () {
        debug('clear resolver cache.');
        this.schemaCache.clear();
        this.referenceCache.clear();
    };
    return ReferenceResolver;
}());
exports.default = ReferenceResolver;
//# sourceMappingURL=referenceResolver.js.map