dtsgenerator/dist/core/dtsGenerator.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var debug_1 = tslib_1.__importDefault(require("debug"));
var typescript_1 = tslib_1.__importDefault(require("typescript"));
var jsonPointer_1 = require("../jsonPointer");
var type_1 = require("./type");
var ast = tslib_1.__importStar(require("./astBuilder"));
var config_1 = tslib_1.__importDefault(require("./config"));
var jsonSchema_1 = require("./jsonSchema");
var referenceResolver_1 = tslib_1.__importDefault(require("./referenceResolver"));
var utils = tslib_1.__importStar(require("./utils"));
var debug = debug_1.default('dtsgen');
var typeMarker = Symbol();
var DtsGenerator = (function () {
    function DtsGenerator(contents) {
        this.contents = contents;
        this.resolver = new referenceResolver_1.default();
    }
    DtsGenerator.prototype.generate = function () {
        return tslib_1.__awaiter(this, void 0, void 0, function () {
            var plugins, preProcess, preProcess_1, preProcess_1_1, p, map, root, file, postProcess, result, printer;
            var e_1, _a;
            var _this = this;
            return tslib_1.__generator(this, function (_b) {
                switch (_b.label) {
                    case 0: return [4, this.getPlugins()];
                    case 1:
                        plugins = _b.sent();
                        return [4, this.getPreProcess(plugins.pre)];
                    case 2:
                        preProcess = _b.sent();
                        try {
                            for (preProcess_1 = tslib_1.__values(preProcess), preProcess_1_1 = preProcess_1.next(); !preProcess_1_1.done; preProcess_1_1 = preProcess_1.next()) {
                                p = preProcess_1_1.value;
                                this.contents = p(this.contents);
                            }
                        }
                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
                        finally {
                            try {
                                if (preProcess_1_1 && !preProcess_1_1.done && (_a = preProcess_1.return)) _a.call(preProcess_1);
                            }
                            finally { if (e_1) throw e_1.error; }
                        }
                        debug('generate type definition files.');
                        this.contents.forEach(function (schema) { return _this.resolver.registerSchema(schema); });
                        return [4, this.resolver.resolve()];
                    case 3:
                        _b.sent();
                        map = this.buildSchemaMergedMap(this.resolver.getAllRegisteredSchema());
                        root = this.walk(map, true);
                        file = typescript_1.default.createSourceFile('_.d.ts', '', config_1.default.target, false, typescript_1.default.ScriptKind.TS);
                        file.statements = typescript_1.default.createNodeArray(root);
                        return [4, this.getPostProcess(plugins.post)];
                    case 4:
                        postProcess = _b.sent();
                        result = typescript_1.default.transform(file, postProcess);
                        result.dispose();
                        if (config_1.default.outputAST) {
                            return [2, JSON.stringify(file, null, 2)];
                        }
                        else {
                            printer = typescript_1.default.createPrinter();
                            return [2, printer.printFile(file)];
                        }
                        return [2];
                }
            });
        });
    };
    DtsGenerator.prototype.buildSchemaMergedMap = function (schemas) {
        var e_2, _a, e_3, _b, _c;
        var map = {};
        var paths = [];
        try {
            for (var schemas_1 = tslib_1.__values(schemas), schemas_1_1 = schemas_1.next(); !schemas_1_1.done; schemas_1_1 = schemas_1.next()) {
                var type = schemas_1_1.value;
                var path = type.id.toNames();
                paths.push({ path: path, type: type });
            }
        }
        catch (e_2_1) { e_2 = { error: e_2_1 }; }
        finally {
            try {
                if (schemas_1_1 && !schemas_1_1.done && (_a = schemas_1.return)) _a.call(schemas_1);
            }
            finally { if (e_2) throw e_2.error; }
        }
        try {
            for (var paths_1 = tslib_1.__values(paths), paths_1_1 = paths_1.next(); !paths_1_1.done; paths_1_1 = paths_1.next()) {
                var item = paths_1_1.value;
                var path = item.path;
                var parent_1 = jsonPointer_1.get(map, path, true);
                if (parent_1 == null) {
                    jsonPointer_1.set(map, path, (_c = {}, _c[typeMarker] = item.type, _c));
                }
                else {
                    parent_1[typeMarker] = item.type;
                }
            }
        }
        catch (e_3_1) { e_3 = { error: e_3_1 }; }
        finally {
            try {
                if (paths_1_1 && !paths_1_1.done && (_b = paths_1.return)) _b.call(paths_1);
            }
            finally { if (e_3) throw e_3.error; }
        }
        if (Object.keys(map).length === 0) {
            throw new Error('There is no schema in the input contents.');
        }
        return map;
    };
    DtsGenerator.prototype.getPlugins = function () {
        return tslib_1.__awaiter(this, void 0, void 0, function () {
            var pre, post, _a, _b, _c, name_1, option, plugin, e_4_1;
            var e_4, _d;
            return tslib_1.__generator(this, function (_e) {
                switch (_e.label) {
                    case 0:
                        pre = [];
                        post = [];
                        _e.label = 1;
                    case 1:
                        _e.trys.push([1, 6, 7, 8]);
                        _a = tslib_1.__values(Object.entries(config_1.default.plugins)), _b = _a.next();
                        _e.label = 2;
                    case 2:
                        if (!!_b.done) return [3, 5];
                        _c = tslib_1.__read(_b.value, 2), name_1 = _c[0], option = _c[1];
                        return [4, type_1.loadPlugin(name_1, option)];
                    case 3:
                        plugin = _e.sent();
                        if (plugin == null) {
                            return [3, 4];
                        }
                        if (plugin.preProcess != null) {
                            pre.push({ plugin: plugin, option: option });
                        }
                        if (plugin.postProcess != null) {
                            post.push({ plugin: plugin, option: option });
                        }
                        _e.label = 4;
                    case 4:
                        _b = _a.next();
                        return [3, 2];
                    case 5: return [3, 8];
                    case 6:
                        e_4_1 = _e.sent();
                        e_4 = { error: e_4_1 };
                        return [3, 8];
                    case 7:
                        try {
                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
                        }
                        finally { if (e_4) throw e_4.error; }
                        return [7];
                    case 8: return [2, { pre: pre, post: post }];
                }
            });
        });
    };
    DtsGenerator.prototype.getPreProcess = function (pre) {
        return tslib_1.__awaiter(this, void 0, void 0, function () {
            var result, inputSchemas, pre_1, pre_1_1, pc, p, handler, e_5_1;
            var e_5, _a;
            return tslib_1.__generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        debug('load pre process plugin.');
                        result = [];
                        inputSchemas = this.resolver.getAllRegisteredIdAndSchema();
                        _b.label = 1;
                    case 1:
                        _b.trys.push([1, 6, 7, 8]);
                        pre_1 = tslib_1.__values(pre), pre_1_1 = pre_1.next();
                        _b.label = 2;
                    case 2:
                        if (!!pre_1_1.done) return [3, 5];
                        pc = pre_1_1.value;
                        p = pc.plugin.preProcess;
                        if (p == null) {
                            return [3, 4];
                        }
                        return [4, p({ inputSchemas: inputSchemas, option: pc.option })];
                    case 3:
                        handler = _b.sent();
                        if (handler != null) {
                            result.push(handler);
                            debug('  pre process plugin:', pc.plugin.meta.name, pc.plugin.meta.description);
                        }
                        _b.label = 4;
                    case 4:
                        pre_1_1 = pre_1.next();
                        return [3, 2];
                    case 5: return [3, 8];
                    case 6:
                        e_5_1 = _b.sent();
                        e_5 = { error: e_5_1 };
                        return [3, 8];
                    case 7:
                        try {
                            if (pre_1_1 && !pre_1_1.done && (_a = pre_1.return)) _a.call(pre_1);
                        }
                        finally { if (e_5) throw e_5.error; }
                        return [7];
                    case 8: return [2, result];
                }
            });
        });
    };
    DtsGenerator.prototype.getPostProcess = function (post) {
        return tslib_1.__awaiter(this, void 0, void 0, function () {
            var result, inputSchemas, post_1, post_1_1, pc, p, factory, e_6_1;
            var e_6, _a;
            return tslib_1.__generator(this, function (_b) {
                switch (_b.label) {
                    case 0:
                        debug('load post process plugin.');
                        result = [];
                        inputSchemas = this.resolver.getAllRegisteredIdAndSchema();
                        _b.label = 1;
                    case 1:
                        _b.trys.push([1, 6, 7, 8]);
                        post_1 = tslib_1.__values(post), post_1_1 = post_1.next();
                        _b.label = 2;
                    case 2:
                        if (!!post_1_1.done) return [3, 5];
                        pc = post_1_1.value;
                        p = pc.plugin.postProcess;
                        if (p == null) {
                            return [3, 4];
                        }
                        return [4, p({ inputSchemas: inputSchemas, option: pc.option })];
                    case 3:
                        factory = _b.sent();
                        if (factory != null) {
                            result.push(factory);
                            debug('  pre process plugin:', pc.plugin.meta.name, pc.plugin.meta.description);
                        }
                        _b.label = 4;
                    case 4:
                        post_1_1 = post_1.next();
                        return [3, 2];
                    case 5: return [3, 8];
                    case 6:
                        e_6_1 = _b.sent();
                        e_6 = { error: e_6_1 };
                        return [3, 8];
                    case 7:
                        try {
                            if (post_1_1 && !post_1_1.done && (_a = post_1.return)) _a.call(post_1);
                        }
                        finally { if (e_6) throw e_6.error; }
                        return [7];
                    case 8: return [2, result];
                }
            });
        });
    };
    DtsGenerator.prototype.walk = function (map, root) {
        var e_7, _a;
        var result = [];
        var keys = Object.keys(map).sort();
        try {
            for (var keys_1 = tslib_1.__values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
                var key = keys_1_1.value;
                var value = map[key];
                if (Object.prototype.hasOwnProperty.call(value, typeMarker)) {
                    var schema = value[typeMarker];
                    debug("  walk doProcess: key=" + key + " schemaId=" + schema.id.getAbsoluteId());
                    result.push(this.walkSchema(schema, root));
                }
                if (typeof value === 'object' && Object.keys(value).length > 0) {
                    result.push(ast.buildNamespaceNode(key, this.walk(value, false), root));
                }
            }
        }
        catch (e_7_1) { e_7 = { error: e_7_1 }; }
        finally {
            try {
                if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
            }
            finally { if (e_7) throw e_7.error; }
        }
        return result;
    };
    DtsGenerator.prototype.walkSchema = function (schema, root) {
        var _this = this;
        var normalized = this.normalizeContent(schema);
        this.currentSchema = normalized;
        var getNode = function () {
            var type = normalized.content.type;
            switch (type) {
                case 'any':
                    return _this.generateAnyTypeModel(normalized, root);
                case 'array':
                    return _this.generateTypeCollection(normalized, root);
                case 'object':
                default:
                    return _this.generateDeclareType(normalized, root);
            }
        };
        return ast.addOptionalInformation(ast.addComment(getNode(), normalized, true), normalized, true);
    };
    DtsGenerator.prototype.normalizeContent = function (schema, pointer) {
        if (pointer != null) {
            schema = jsonSchema_1.getSubSchema(schema, pointer);
        }
        schema.content = this.normalizeSchemaContent(schema.content);
        return Object.assign({}, schema);
    };
    DtsGenerator.prototype.normalizeSchemaContent = function (content) {
        var e_8, _a;
        if (typeof content === 'boolean') {
            content = content ? {} : { not: {} };
        }
        else {
            if (content.allOf) {
                var work = {};
                var allOf = content.allOf;
                delete content.allOf;
                try {
                    for (var allOf_1 = tslib_1.__values(allOf), allOf_1_1 = allOf_1.next(); !allOf_1_1.done; allOf_1_1 = allOf_1.next()) {
                        var sub = allOf_1_1.value;
                        if (typeof sub === 'object' && sub.$ref) {
                            var ref = this.resolver.dereference(sub.$ref);
                            var normalized = this.normalizeContent(ref).content;
                            utils.mergeSchema(work, normalized);
                        }
                        else {
                            var normalized = this.normalizeSchemaContent(sub);
                            utils.mergeSchema(work, normalized);
                        }
                    }
                }
                catch (e_8_1) { e_8 = { error: e_8_1 }; }
                finally {
                    try {
                        if (allOf_1_1 && !allOf_1_1.done && (_a = allOf_1.return)) _a.call(allOf_1);
                    }
                    finally { if (e_8) throw e_8.error; }
                }
                utils.mergeSchema(work, content);
                content = Object.assign(content, work);
            }
            if (content.type === undefined &&
                (content.properties || content.additionalProperties)) {
                content.type = 'object';
            }
            if (content.nullable) {
                var type = content.type;
                var anyOf = content.anyOf;
                if (Array.isArray(anyOf)) {
                    anyOf.push({ type: 'null' });
                }
                else if (type == null) {
                    content.type = 'null';
                }
                else if (!Array.isArray(type)) {
                    content.type = [type, 'null'];
                }
                else {
                    type.push('null');
                }
            }
            var types = content.type;
            if (Array.isArray(types)) {
                var reduced = utils.reduceTypes(types);
                content.type = reduced.length === 1 ? reduced[0] : reduced;
            }
        }
        return content;
    };
    DtsGenerator.prototype.generateDeclareType = function (schema, root) {
        var content = schema.content;
        if (content.$ref ||
            content.oneOf ||
            content.anyOf ||
            content.enum ||
            'const' in content ||
            content.type !== 'object') {
            var type = this.generateTypeProperty(schema);
            return ast.buildTypeAliasNode(schema.id, type, root);
        }
        else {
            var members = this.generateProperties(schema);
            return ast.buildInterfaceNode(schema.id, members, root);
        }
    };
    DtsGenerator.prototype.generateAnyTypeModel = function (schema, root) {
        var member = ast.buildIndexSignatureNode('name', ast.buildStringKeyword(), ast.buildAnyKeyword());
        return ast.buildInterfaceNode(schema.id, [member], root);
    };
    DtsGenerator.prototype.generateTypeCollection = function (schema, root) {
        var type = this.generateArrayTypeProperty(schema);
        return ast.buildTypeAliasNode(schema.id, type, root);
    };
    DtsGenerator.prototype.generateProperties = function (baseSchema) {
        var e_9, _a, e_10, _b;
        var result = [];
        var content = baseSchema.content;
        if (content.additionalProperties) {
            var schema = this.normalizeContent(baseSchema, '/additionalProperties');
            var valueType = content.additionalProperties === true
                ? ast.buildAnyKeyword()
                : this.generateTypeProperty(schema);
            var node = ast.buildIndexSignatureNode('name', ast.buildStringKeyword(), valueType);
            result.push(ast.addOptionalInformation(node, schema, true));
        }
        if (content.properties) {
            try {
                for (var _c = tslib_1.__values(Object.keys(content.properties)), _d = _c.next(); !_d.done; _d = _c.next()) {
                    var propertyName = _d.value;
                    var schema = this.normalizeContent(baseSchema, '/properties/' + jsonPointer_1.tilde(propertyName));
                    var node = ast.buildPropertySignature(schema, propertyName, this.generateTypeProperty(schema), baseSchema.content.required, false);
                    result.push(ast.addOptionalInformation(ast.addComment(node, schema, true), schema, true));
                }
            }
            catch (e_9_1) { e_9 = { error: e_9_1 }; }
            finally {
                try {
                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                }
                finally { if (e_9) throw e_9.error; }
            }
        }
        if (content.patternProperties) {
            var schemasTypes = [];
            try {
                for (var _e = tslib_1.__values(Object.keys(content.patternProperties)), _f = _e.next(); !_f.done; _f = _e.next()) {
                    var propertyName = _f.value;
                    var schema = this.normalizeContent(baseSchema, '/patternProperties/' + jsonPointer_1.tilde(propertyName));
                    schemasTypes.push(this.generateTypeProperty(schema));
                }
            }
            catch (e_10_1) { e_10 = { error: e_10_1 }; }
            finally {
                try {
                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                }
                finally { if (e_10) throw e_10.error; }
            }
            var node = ast.buildPropertySignature({ content: { readOnly: false } }, 'pattern', typescript_1.default.createUnionTypeNode(schemasTypes), baseSchema.content.required, true);
            result.push(typescript_1.default.addSyntheticTrailingComment(node, typescript_1.default.SyntaxKind.MultiLineCommentTrivia, " Patterns: " + Object.keys(content.patternProperties).join(' | ') + " "));
        }
        return result;
    };
    DtsGenerator.prototype.generateTypeProperty = function (schema, terminate) {
        var _this = this;
        if (terminate === void 0) { terminate = true; }
        var content = schema.content;
        if (content.$ref) {
            var ref = this.resolver.dereference(content.$ref);
            if (ref.id == null) {
                throw new Error('target referenced id is nothing: ' + content.$ref);
            }
            var refSchema = this.normalizeContent(ref);
            var node = ast.buildTypeReferenceNode(refSchema, this.currentSchema);
            return ast.addOptionalInformation(ast.addComment(node, refSchema, false), refSchema, false);
        }
        if (content.anyOf) {
            return this.generateArrayedType(schema, content.anyOf, '/anyOf/', terminate);
        }
        if (content.oneOf) {
            return this.generateArrayedType(schema, content.oneOf, '/oneOf/', terminate);
        }
        if (content.enum) {
            return ast.buildUnionTypeNode(content.enum, function (value) {
                return _this.generateLiteralTypeNode(content, value);
            }, terminate);
        }
        else if ('const' in content) {
            return this.generateLiteralTypeNode(content, content.const);
        }
        else {
            return this.generateType(schema, terminate);
        }
    };
    DtsGenerator.prototype.generateLiteralTypeNode = function (content, value) {
        switch (content.type) {
            case 'integer':
            case 'number':
                return ast.buildNumericLiteralTypeNode('' + value);
            case 'boolean':
                return ast.buildBooleanLiteralTypeNode(value);
            default:
                return ast.buildStringLiteralTypeNode(value);
        }
    };
    DtsGenerator.prototype.generateArrayedType = function (baseSchema, contents, path, terminate) {
        var _this = this;
        return ast.addOptionalInformation(ast.addComment(ast.buildUnionTypeNode(contents, function (_, index) {
            var schema = _this.normalizeContent(baseSchema, path + index);
            if (schema.id.isEmpty()) {
                return ast.addOptionalInformation(_this.generateTypeProperty(schema, false), schema, false);
            }
            else {
                return ast.addOptionalInformation(ast.buildTypeReferenceNode(schema, _this.currentSchema), schema, false);
            }
        }, terminate), baseSchema, false), baseSchema, terminate);
    };
    DtsGenerator.prototype.generateArrayTypeProperty = function (schema, terminate) {
        if (terminate === void 0) { terminate = true; }
        var items = schema.content.items;
        var minItems = schema.content.minItems;
        var maxItems = schema.content.maxItems;
        if (items == null) {
            return ast.buildSimpleArrayNode(ast.buildAnyKeyword());
        }
        else if (!Array.isArray(items)) {
            var subSchema = this.normalizeContent(schema, '/items');
            var node = this.generateTypeProperty(subSchema, false);
            return ast.buildSimpleArrayNode(ast.addOptionalInformation(node, subSchema, false));
        }
        else if (items.length === 0 &&
            minItems === undefined &&
            maxItems === undefined) {
            return ast.buildSimpleArrayNode(ast.buildAnyKeyword());
        }
        else if (minItems != null &&
            maxItems != null &&
            maxItems < minItems) {
            return ast.buildNeverKeyword();
        }
        else {
            var types = [];
            for (var i = 0; i < items.length; i++) {
                var type = this.normalizeContent(schema, '/items/' + i);
                if (type.id.isEmpty()) {
                    types.push(this.generateTypeProperty(type, false));
                }
                else {
                    types.push(ast.addOptionalInformation(ast.buildTypeReferenceNode(type, this.currentSchema), type, false));
                }
            }
            return ast.addOptionalInformation(ast.buildTupleTypeNode(types, minItems, maxItems), schema, terminate);
        }
    };
    DtsGenerator.prototype.generateType = function (schema, terminate) {
        var _this = this;
        var type = schema.content.type;
        if (type == null) {
            return ast.buildAnyKeyword();
        }
        else if (typeof type === 'string') {
            return this.generateTypeName(schema, type, terminate);
        }
        else {
            var types = utils.reduceTypes(type);
            if (types.length <= 1) {
                schema.content.type = types[0];
                return this.generateType(schema, terminate);
            }
            else {
                return ast.buildUnionTypeNode(types, function (t) {
                    return _this.generateTypeName(schema, t, false);
                }, terminate);
            }
        }
    };
    DtsGenerator.prototype.generateTypeName = function (schema, type, terminate) {
        var tsType = utils.toTSType(type, schema.content);
        if (tsType) {
            return ast.buildKeyword(tsType);
        }
        else if (type === 'object') {
            var elements = this.generateProperties(schema);
            if (elements.length > 0) {
                return ast.buildTypeLiteralNode(elements);
            }
            else {
                return ast.buildUnknownKeyword();
            }
        }
        else if (type === 'array') {
            return this.generateArrayTypeProperty(schema, terminate);
        }
        else {
            throw new Error('unknown type: ' + type);
        }
    };
    return DtsGenerator;
}());
exports.default = DtsGenerator;
//# sourceMappingURL=dtsGenerator.js.map