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 jsonSchema_1 = require("./jsonSchema");
var schemaId_1 = tslib_1.__importDefault(require("./schemaId"));
var type_1 = require("./type");
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.getAllRegisteredIdAndSchema = function () {
        return this.schemaCache.entries();
    };
    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, s, 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, 11, 12, 13]);
                        _a = tslib_1.__values(this.referenceCache.entries()), _b = _a.next();
                        _e.label = 2;
                    case 2:
                        if (!!_b.done) return [3, 10];
                        _c = tslib_1.__read(_b.value, 2), key = _c[0], schema = _c[1];
                        if (schema != null) {
                            return [3, 9];
                        }
                        id = new schemaId_1.default(key);
                        fileId = id.getFileId();
                        result = this.schemaCache.get(id.getAbsoluteId());
                        if (!(result == null)) return [3, 8];
                        refSchema = this.schemaCache.get(fileId);
                        debug("get from schema cache, fileId=" + fileId + ", exists=" + (refSchema != null) + ", " + id.getAbsoluteId());
                        if (!(refSchema == null && id.isFetchable())) return [3, 7];
                        _e.label = 3;
                    case 3:
                        _e.trys.push([3, 6, , 7]);
                        debug("fetch remote schema: id=[" + fileId + "].");
                        return [4, type_1.readSchemaFromUrl(fileId)];
                    case 4:
                        s = _e.sent();
                        return [4, this.registerSchema(s)];
                    case 5:
                        _e.sent();
                        return [3, 7];
                    case 6:
                        e_1 = _e.sent();
                        error.push("Fail to fetch the $ref target: " + id.getAbsoluteId() + ", " + e_1);
                        return [3, 9];
                    case 7:
                        result = this.schemaCache.get(id.getAbsoluteId());
                        _e.label = 8;
                    case 8:
                        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, 9];
                                }
                                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, 9];
                            }
                        }
                        _e.label = 9;
                    case 9:
                        _b = _a.next();
                        return [3, 2];
                    case 10: return [3, 13];
                    case 11:
                        e_2_1 = _e.sent();
                        e_2 = { error: e_2_1 };
                        return [3, 13];
                    case 12:
                        try {
                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
                        }
                        finally { if (e_2) throw e_2.error; }
                        return [7];
                    case 13:
                        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.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