dtsgenerator/dist/core/dtsGenerator.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const debug_1 = tslib_1.__importDefault(require("debug"));
const ts = tslib_1.__importStar(require("typescript"));
const jsonPointer_1 = require("../jsonPointer");
const type_1 = require("./type");
const ast = tslib_1.__importStar(require("./astBuilder"));
const config_1 = tslib_1.__importDefault(require("./config"));
const jsonSchema_1 = require("./jsonSchema");
const referenceResolver_1 = tslib_1.__importDefault(require("./referenceResolver"));
const utils = tslib_1.__importStar(require("./utils"));
const debug = debug_1.default('dtsgen');
const typeMarker = Symbol();
class DtsGenerator {
    constructor(contents) {
        this.resolver = new referenceResolver_1.default();
        this.contents = contents;
    }
    async generate() {
        const plugins = await this.getPlugins();
        const preProcess = await this.getPreProcess(plugins.pre);
        for (const p of preProcess) {
            this.contents = p(this.contents);
        }
        debug('generate type definition files.');
        this.contents.forEach((schema) => this.resolver.registerSchema(schema));
        await this.resolver.resolve();
        const map = this.buildSchemaMergedMap(this.resolver.getAllRegisteredSchema());
        const root = this.walk(map, true);
        const file = ts.createSourceFile('_.d.ts', '', config_1.default.target, false, ts.ScriptKind.TS);
        Object.assign(file, {
            statements: ts.factory.createNodeArray(root),
        });
        const postProcess = await this.getPostProcess(plugins.post);
        const result = ts.transform(file, postProcess);
        result.dispose();
        if (config_1.default.outputAST) {
            return JSON.stringify(file, null, 2);
        }
        else {
            const printer = ts.createPrinter();
            return printer.printFile(file);
        }
    }
    buildSchemaMergedMap(schemas) {
        const map = {};
        const paths = [];
        for (const type of schemas) {
            const path = type.id.toNames();
            paths.push({ path, type });
        }
        for (const item of paths) {
            const path = item.path;
            const parent = jsonPointer_1.get(map, path, true);
            if (parent == null) {
                jsonPointer_1.set(map, path, { [typeMarker]: item.type });
            }
            else {
                Object.assign(parent, { [typeMarker]: item.type });
            }
        }
        if (Object.keys(map).length === 0) {
            throw new Error('There is no schema in the input contents.');
        }
        return map;
    }
    async getPlugins() {
        const pre = [];
        const post = [];
        for (const [name, option] of Object.entries(config_1.default.plugins)) {
            const plugin = await type_1.loadPlugin(name, option);
            if (plugin == null) {
                continue;
            }
            if (plugin.preProcess != null) {
                pre.push({ plugin, option });
            }
            if (plugin.postProcess != null) {
                post.push({ plugin, option });
            }
        }
        return { pre, post };
    }
    async getPreProcess(pre) {
        debug('load pre process plugin.');
        const result = [];
        const inputSchemas = this.resolver.getAllRegisteredIdAndSchema();
        for (const pc of pre) {
            const p = pc.plugin.preProcess;
            if (p == null) {
                continue;
            }
            const handler = await p({ inputSchemas, option: pc.option });
            if (handler != null) {
                result.push(handler);
                debug('  pre process plugin:', pc.plugin.meta.name, pc.plugin.meta.description);
            }
        }
        return result;
    }
    async getPostProcess(post) {
        debug('load post process plugin.');
        const result = [];
        const inputSchemas = this.resolver.getAllRegisteredIdAndSchema();
        for (const pc of post) {
            const p = pc.plugin.postProcess;
            if (p == null) {
                continue;
            }
            const factory = await p({ inputSchemas, option: pc.option });
            if (factory != null) {
                result.push(factory);
                debug('  pre process plugin:', pc.plugin.meta.name, pc.plugin.meta.description);
            }
        }
        return result;
    }
    walk(map, root) {
        const result = [];
        const keys = Object.keys(map).sort();
        for (const key of keys) {
            const value = map[key];
            if (typeof value === 'object' &&
                Object.prototype.hasOwnProperty.call(value, typeMarker)) {
                const 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));
            }
        }
        return result;
    }
    walkSchema(schema, root) {
        const normalized = this.normalizeContent(schema);
        this.currentSchema = normalized;
        const getNode = () => {
            const 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);
    }
    normalizeContent(schema, pointer) {
        if (pointer != null) {
            schema = jsonSchema_1.getSubSchema(schema, pointer);
        }
        return Object.assign(schema, {
            content: this.normalizeSchemaContent(schema.content),
        });
    }
    normalizeSchemaContent(content) {
        if (typeof content === 'boolean') {
            content = content ? {} : { not: {} };
        }
        else {
            if (content.allOf) {
                const work = {};
                const allOf = content.allOf;
                delete content.allOf;
                for (const sub of allOf) {
                    if (typeof sub === 'object' && sub.$ref) {
                        const ref = this.resolver.dereference(sub.$ref);
                        const normalized = this.normalizeContent(ref).content;
                        utils.mergeSchema(work, normalized);
                    }
                    else {
                        const normalized = this.normalizeSchemaContent(sub);
                        utils.mergeSchema(work, normalized);
                    }
                }
                utils.mergeSchema(work, content);
                content = Object.assign(content, work);
            }
            if (content.type === undefined &&
                (content.properties || content.additionalProperties)) {
                content.type = 'object';
            }
            if (content.nullable) {
                const type = content.type;
                const 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');
                }
            }
            const types = content.type;
            if (Array.isArray(types)) {
                const reduced = utils.reduceTypes(types);
                content.type = reduced.length === 1 ? reduced[0] : reduced;
            }
        }
        return content;
    }
    generateDeclareType(schema, root) {
        const content = schema.content;
        if (content.$ref ||
            content.oneOf ||
            content.anyOf ||
            content.enum ||
            'const' in content ||
            content.type !== 'object') {
            const type = this.generateTypeProperty(schema);
            return ast.buildTypeAliasNode(schema.id, type, root);
        }
        else {
            const members = this.generateProperties(schema);
            return ast.buildInterfaceNode(schema.id, members, root);
        }
    }
    generateAnyTypeModel(schema, root) {
        const member = ast.buildIndexSignatureNode('name', ast.buildStringKeyword(), ast.buildAnyKeyword());
        return ast.buildInterfaceNode(schema.id, [member], root);
    }
    generateTypeCollection(schema, root) {
        const type = this.generateArrayTypeProperty(schema);
        return ast.buildTypeAliasNode(schema.id, type, root);
    }
    generateProperties(baseSchema) {
        const result = [];
        const content = baseSchema.content;
        if (content.additionalProperties) {
            const schema = this.normalizeContent(baseSchema, '/additionalProperties');
            const valueType = content.additionalProperties === true
                ? ast.buildAnyKeyword()
                : this.generateTypeProperty(schema);
            const node = ast.buildIndexSignatureNode('name', ast.buildStringKeyword(), valueType);
            result.push(ast.addOptionalInformation(node, schema, true));
        }
        if (content.properties) {
            for (const propertyName of Object.keys(content.properties)) {
                const schema = this.normalizeContent(baseSchema, '/properties/' + jsonPointer_1.tilde(propertyName));
                const node = ast.buildPropertySignature(schema, propertyName, this.generateTypeProperty(schema), baseSchema.content.required, false);
                result.push(ast.addOptionalInformation(ast.addComment(node, schema, true), schema, true));
            }
        }
        if (content.patternProperties) {
            const schemasTypes = [];
            for (const propertyName of Object.keys(content.patternProperties)) {
                const schema = this.normalizeContent(baseSchema, '/patternProperties/' + jsonPointer_1.tilde(propertyName));
                schemasTypes.push(this.generateTypeProperty(schema));
            }
            const node = ast.buildPropertySignature({ content: { readOnly: false } }, 'pattern', ts.createUnionTypeNode(schemasTypes), baseSchema.content.required, true);
            result.push(ts.addSyntheticTrailingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, ` Patterns: ${Object.keys(content.patternProperties).join(' | ')} `));
        }
        return result;
    }
    generateTypeProperty(schema, terminate = true) {
        const content = schema.content;
        if (content.$ref) {
            const ref = this.resolver.dereference(content.$ref);
            if (ref.id == null) {
                throw new Error('target referenced id is nothing: ' + content.$ref);
            }
            const refSchema = this.normalizeContent(ref);
            const 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, Object.assign({}, content, { anyOf: undefined }), '/anyOf/', terminate);
        }
        if (content.oneOf) {
            return this.generateArrayedType(schema, content.oneOf, Object.assign({}, content, { oneOf: undefined }), '/oneOf/', terminate);
        }
        if (content.enum) {
            return ast.buildUnionTypeNode(content.enum, (value) => {
                return this.generateLiteralTypeNode(content, value);
            }, terminate);
        }
        else if ('const' in content) {
            return this.generateLiteralTypeNode(content, content.const);
        }
        else {
            return this.generateType(schema, terminate);
        }
    }
    generateLiteralTypeNode(content, value) {
        switch (content.type) {
            case 'integer':
            case 'number':
                return ast.buildNumericLiteralTypeNode(String(value));
            case 'boolean':
                return ast.buildBooleanLiteralTypeNode(value);
            case 'null':
                return ast.buildNullKeyword();
            case 'string':
                return ast.buildStringLiteralTypeNode(value);
        }
        if (value === null) {
            return ast.buildNullKeyword();
        }
        switch (typeof value) {
            case 'number':
                return ast.buildNumericLiteralTypeNode(`${value}`);
            case 'boolean':
                return ast.buildBooleanLiteralTypeNode(value);
            case 'string':
                return ast.buildStringLiteralTypeNode(value);
        }
        return ast.buildStringLiteralTypeNode(String(value));
    }
    generateArrayedType(baseSchema, contents, mergeContent, path, terminate) {
        return ast.addOptionalInformation(ast.addComment(ast.buildUnionTypeNode(contents, (_, index) => {
            const schema = this.normalizeContent(baseSchema, path + index.toString());
            utils.mergeSchema(schema.content, mergeContent);
            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);
    }
    generateArrayTypeProperty(schema, terminate = true) {
        const items = schema.content.items;
        const minItems = schema.content.minItems;
        const maxItems = schema.content.maxItems;
        if (items == null) {
            return ast.buildSimpleArrayNode(ast.buildAnyKeyword());
        }
        else if (!Array.isArray(items)) {
            const subSchema = this.normalizeContent(schema, '/items');
            const 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 {
            const types = [];
            for (let i = 0; i < items.length; i++) {
                const type = this.normalizeContent(schema, '/items/' + i.toString());
                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);
        }
    }
    generateType(schema, terminate) {
        const type = schema.content.type;
        if (type == null) {
            return ast.buildAnyKeyword();
        }
        else if (typeof type === 'string') {
            return this.generateTypeName(schema, type, terminate);
        }
        else {
            const types = utils.reduceTypes(type);
            if (types.length <= 1) {
                schema.content.type = types[0];
                return this.generateType(schema, terminate);
            }
            else {
                return ast.buildUnionTypeNode(types, (t) => {
                    return this.generateTypeName(schema, t, false);
                }, terminate);
            }
        }
    }
    generateTypeName(schema, type, terminate) {
        const tsType = utils.toTSType(type, schema.content);
        if (tsType) {
            if (tsType === ts.SyntaxKind.NullKeyword) {
                return ast.buildNullKeyword();
            }
            else {
                return ast.buildKeyword(tsType);
            }
        }
        else if (type === 'object') {
            const 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);
        }
    }
}
exports.default = DtsGenerator;