horiuchi / dtsgenerator / 616

pending completion

Build # 616

Build Type

Pull #464

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/horiuchi/dtsgenerator/commit/<a class=hub.com/horiuchi/dtsgenerator/commit/<a class="double-link" href="https://git"><a class=hub.com/horiuchi/dtsgenerator/commit/<a class="double-link" href="https://git"><a class=hub.com/horiuchi/dtsgenerator/commit/<a class="double-link" href="https://git"><a class=hub.com/horiuchi/dtsgenerator/commit/c9592dba12af8b48b167def071de351395813232">c9592dba1">&lt;a href=&quot;https://github.com/horiuchi/dtsgenerator/commit/</a><a class="double-link" href="https://github.com/horiuchi/dtsgenerator/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/horiuchi/dtsgenerator/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/horiuchi/dtsgenerator/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/horiuchi/dtsgenerator/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/horiuchi/dtsgenerator/commit/c9592dba12af8b48b167def071de351395813232">c9592dba1</a><a href="https://github.com/horiuchi/dtsgenerator/commit/c9592dba12af8b48b167def071de351395813232">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/horiuchi/dtsgenerator/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/horiuchi/dtsgenerator/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/horiuchi/dtsgenerator/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/horiuchi/dtsgenerator/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/horiuchi/dtsgenerator/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/horiuchi/dtsgenerator/commit/c9592dba12af8b48b167def071de351395813232&quot;&gt;c9592dba1&lt;/a&gt;&lt;a href=&quot;https://github.com/horiuchi/dtsgenerator/commit/c9592dba12af8b48b167def071de351395813232&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/horiuchi/dtsgenerator/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp... (continued)

Pull Request Pull Request #464: Add to support the null type enum value for #457

Run Details

472 of 620 branches covered (76.13%)

10 of 10 new or added lines in 2 files covered. (100.0%)

1002 of 1187 relevant lines covered (84.41%)

4410.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.14

/src/core/dtsGenerator.ts

import Debug from 'debug';
import * as ts from 'typescript';
import { get, set, tilde } from '../jsonPointer';
import {
    Plugin,
    Schema,
    JsonSchema,
    JsonSchemaObject,
    PreProcessHandler,
    loadPlugin,
} from './type';
import * as ast from './astBuilder';
import config from './config';
import { getSubSchema, NormalizedSchema } from './jsonSchema';
import ReferenceResolver from './referenceResolver';
import * as utils from './utils';

const debug = Debug('dtsgen');
const typeMarker = Symbol();

interface PluginConfig {
    plugin: Plugin;
    option: boolean | Record<string, unknown>;
}

export default class DtsGenerator {
    private resolver = new ReferenceResolver();
    private currentSchema!: NormalizedSchema;

    constructor(private contents: Schema[]) {}

    public async generate(): Promise<string> {
        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.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.outputAST) {
            return JSON.stringify(file, null, 2);
        } else {
            const printer = ts.createPrinter();
            return printer.printFile(file);
        }
    }

    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    private buildSchemaMergedMap(schemas: IterableIterator<Schema>): any {
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        const map: any = {};
        const paths: { path: string[]; type: Schema }[] = [];
        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 = get(map, path, true);
            if (parent == null) {
                set(map, path, { [typeMarker]: item.type });
            } else {
                parent[typeMarker] = item.type;
            }
        }
        if (Object.keys(map).length === 0) {
            throw new Error('There is no schema in the input contents.');
        }
        return map;
    }

    private async getPlugins(): Promise<{
        pre: PluginConfig[];
        post: PluginConfig[];
    }> {
        const pre: PluginConfig[] = [];
        const post: PluginConfig[] = [];
        for (const [name, option] of Object.entries(config.plugins)) {
            const plugin = await 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 };
    }
    private async getPreProcess(
        pre: PluginConfig[]
    ): Promise<PreProcessHandler[]> {
        debug('load pre process plugin.');
        const result: PreProcessHandler[] = [];
        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;
    }
    private async getPostProcess(
        post: PluginConfig[]
    ): Promise<ts.TransformerFactory<ts.SourceFile>[]> {
        debug('load post process plugin.');
        const result: ts.TransformerFactory<ts.SourceFile>[] = [];
        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;
    }

    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    private walk(map: any, root: boolean): ts.Statement[] {
        const result: ts.Statement[] = [];
        const keys = Object.keys(map).sort();
        for (const key of keys) {
            const value = map[key];
            if (Object.prototype.hasOwnProperty.call(value, typeMarker)) {
                const schema = value[typeMarker] as Schema;
                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;
    }

    private walkSchema(schema: Schema, root: boolean): ts.DeclarationStatement {
        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
        );
    }

    private normalizeContent(
        schema: Schema,
        pointer?: string
    ): NormalizedSchema {
        if (pointer != null) {
            schema = getSubSchema(schema, pointer);
        }
        schema.content = this.normalizeSchemaContent(schema.content);
        return Object.assign({}, schema as NormalizedSchema);
    }

    private normalizeSchemaContent(content: JsonSchema): JsonSchemaObject {
        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;
    }
    private generateDeclareType(
        schema: NormalizedSchema,
        root: boolean
    ): ts.DeclarationStatement {
        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);
        }
    }

    private generateAnyTypeModel(
        schema: NormalizedSchema,
        root: boolean
    ): ts.DeclarationStatement {
        const member = ast.buildIndexSignatureNode(
            'name',
            ast.buildStringKeyword(),
            ast.buildAnyKeyword()
        );
        return ast.buildInterfaceNode(schema.id, [member], root);
    }

    private generateTypeCollection(
        schema: NormalizedSchema,
        root: boolean
    ): ts.DeclarationStatement {
        const type = this.generateArrayTypeProperty(schema);
        return ast.buildTypeAliasNode(schema.id, type, root);
    }

    private generateProperties(baseSchema: NormalizedSchema): ts.TypeElement[] {
        const result: ts.TypeElement[] = [];
        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/' + 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/' + tilde(propertyName)
                );
                schemasTypes.push(this.generateTypeProperty(schema));
            }
            const node = ast.buildPropertySignature(
                { content: { readOnly: false } } as NormalizedSchema,
                'pattern',
                ts.createUnionTypeNode(schemasTypes),
                baseSchema.content.required,
                true
            );
            result.push(
                ts.addSyntheticTrailingComment(
                    node,
                    ts.SyntaxKind.MultiLineCommentTrivia,
                    ` Patterns: ${Object.keys(content.patternProperties).join(
                        ' | '
                    )} `
                )
            );
        }
        return result;
    }
    private generateTypeProperty(
        schema: NormalizedSchema,
        terminate = true
    ): ts.TypeNode {
        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,
                '/anyOf/',
                terminate
            );
        }
        if (content.oneOf) {
            return this.generateArrayedType(
                schema,
                content.oneOf,
                '/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);
        }
    }
    private generateLiteralTypeNode(
        content: JsonSchemaObject,
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        value: any
    ): ts.LiteralTypeNode {
        switch (content.type) {
            case 'integer':
            case 'number':
                return ast.buildNumericLiteralTypeNode('' + 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(value.toString());
    }

    private generateArrayedType(
        baseSchema: NormalizedSchema,
        contents: JsonSchema[],
        path: string,
        terminate: boolean
    ): ts.TypeNode {
        return ast.addOptionalInformation(
            ast.addComment(
                ast.buildUnionTypeNode(
                    contents,
                    (_, index) => {
                        const 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
        );
    }

    private generateArrayTypeProperty(
        schema: NormalizedSchema,
        terminate = true
    ): ts.TypeNode {
        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: ts.TypeNode[] = [];
            for (let i = 0; i < items.length; i++) {
                const 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
            );
        }
    }

    private generateType(
        schema: NormalizedSchema,
        terminate: boolean
    ): ts.TypeNode {
        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
                );
            }
        }
    }
    private generateTypeName(
        schema: NormalizedSchema,
        type: string,
        terminate: boolean
    ): ts.TypeNode {
        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);
        }
    }
}

1	import Debug from 'debug';	3✔
2	import * as ts from 'typescript';	3✔
3	import { get, set, tilde } from '../jsonPointer';	3✔
4	import {	3✔
5	Plugin,
6	Schema,
7	JsonSchema,
8	JsonSchemaObject,
9	PreProcessHandler,
10	loadPlugin,
11	} from './type';
12	import * as ast from './astBuilder';	3✔
13	import config from './config';	3✔
14	import { getSubSchema, NormalizedSchema } from './jsonSchema';	3✔
15	import ReferenceResolver from './referenceResolver';	3✔
16	import * as utils from './utils';	3✔
17
18	const debug = Debug('dtsgen');	3✔
19	const typeMarker = Symbol();	3✔
20
21	interface PluginConfig {
22	plugin: Plugin;
23	option: boolean \| Record<string, unknown>;
24	}
25
26	export default class DtsGenerator {	3✔
27	private resolver = new ReferenceResolver();	222✔
28	private currentSchema!: NormalizedSchema;
29
30	constructor(private contents: Schema[]) {}	222✔
31
32	public async generate(): Promise<string> {	3✔
33	const plugins = await this.getPlugins();	222✔
34	const preProcess = await this.getPreProcess(plugins.pre);	219✔
35	for (const p of preProcess) {	219✔
36	this.contents = p(this.contents);	3✔
37	}
38
39	debug('generate type definition files.');	219✔
40	this.contents.forEach((schema) => this.resolver.registerSchema(schema));	243✔
41	await this.resolver.resolve();	438✔
42
43	const map = this.buildSchemaMergedMap(	213✔
44	this.resolver.getAllRegisteredSchema()
45	);
46	const root = this.walk(map, true);	207✔
47	const file = ts.createSourceFile(	201✔
48	'_.d.ts',
49	'',
50	config.target,
51	false,
52	ts.ScriptKind.TS
53	);
54	Object.assign(file, {	201✔
55	statements: ts.factory.createNodeArray(root),
56	});
57
58	const postProcess = await this.getPostProcess(plugins.post);	201✔
59	const result = ts.transform(file, postProcess);	201✔
60	result.dispose();	201✔
61
62	if (config.outputAST) {	201!
63	return JSON.stringify(file, null, 2);	×
64	} else {
65	const printer = ts.createPrinter();	201✔
66	return printer.printFile(file);	201✔
67	}
68	}
69
70	// eslint-disable-next-line @typescript-eslint/no-explicit-any
71	private buildSchemaMergedMap(schemas: IterableIterator<Schema>): any {	3✔
72	// eslint-disable-next-line @typescript-eslint/no-explicit-any
73	const map: any = {};	213✔
74	const paths: { path: string[]; type: Schema }[] = [];	213✔
75	for (const type of schemas) {	1,497✔
76	const path = type.id.toNames();	1,497✔
77	paths.push({ path, type });	1,497✔
78	}
79
80	for (const item of paths) {	1,497✔
81	const path = item.path;	1,497✔
82	const parent = get(map, path, true);	1,497✔
83	if (parent == null) {	1,497✔
84	set(map, path, { [typeMarker]: item.type });	1,494✔
85	} else {
86	parent[typeMarker] = item.type;	3✔
87	}
88	}
89	if (Object.keys(map).length === 0) {	213✔
90	throw new Error('There is no schema in the input contents.');	6✔
91	}
92	return map;	207✔
93	}
94
95	private async getPlugins(): Promise<{	3✔
96	pre: PluginConfig[];
97	post: PluginConfig[];
98	}> {
99	const pre: PluginConfig[] = [];	222✔
100	const post: PluginConfig[] = [];	222✔
101	for (const [name, option] of Object.entries(config.plugins)) {	222✔
102	const plugin = await loadPlugin(name, option);	15✔
103	if (plugin == null) {	12!
104	continue;	×
105	}
106	if (plugin.preProcess != null) {	12✔
107	pre.push({ plugin, option });	3✔
108	}
109	if (plugin.postProcess != null) {	12!
110	post.push({ plugin, option });	12✔
111	}
112	}
113	return { pre, post };	219✔
114	}
115	private async getPreProcess(	3✔
116	pre: PluginConfig[]
117	): Promise<PreProcessHandler[]> {
118	debug('load pre process plugin.');	219✔
119	const result: PreProcessHandler[] = [];	219✔
120	const inputSchemas = this.resolver.getAllRegisteredIdAndSchema();	219✔
121	for (const pc of pre) {	219✔
122	const p = pc.plugin.preProcess;	3✔
123	if (p == null) {	3!
124	continue;	×
125	}
126	const handler = await p({ inputSchemas, option: pc.option });	3✔
127	if (handler != null) {	3!
128	result.push(handler);	3✔
129	debug(	3✔
130	' pre process plugin:',
131	pc.plugin.meta.name,
132	pc.plugin.meta.description
133	);
134	}
135	}
136	return result;	219✔
137	}
138	private async getPostProcess(	3✔
139	post: PluginConfig[]
140	): Promise<ts.TransformerFactory<ts.SourceFile>[]> {
141	debug('load post process plugin.');	201✔
142	const result: ts.TransformerFactory<ts.SourceFile>[] = [];	201✔
143	const inputSchemas = this.resolver.getAllRegisteredIdAndSchema();	201✔
144	for (const pc of post) {	201✔
145	const p = pc.plugin.postProcess;	12✔
146	if (p == null) {	12!
147	continue;	×
148	}
149	const factory = await p({ inputSchemas, option: pc.option });	12✔
150	if (factory != null) {	12!
151	result.push(factory);	12✔
152	debug(	12✔
153	' pre process plugin:',
154	pc.plugin.meta.name,
155	pc.plugin.meta.description
156	);
157	}
158	}
159	return result;	201✔
160	}
161
162	// eslint-disable-next-line @typescript-eslint/no-explicit-any
163	private walk(map: any, root: boolean): ts.Statement[] {	3✔
164	const result: ts.Statement[] = [];	972✔
165	const keys = Object.keys(map).sort();	972✔
166	for (const key of keys) {	2,208✔
167	const value = map[key];	2,208✔
168	if (Object.prototype.hasOwnProperty.call(value, typeMarker)) {	2,208✔
169	const schema = value[typeMarker] as Schema;	1,497✔
170	debug(	1,497✔
171	` walk doProcess: key=${key} schemaId=${schema.id.getAbsoluteId()}`
172	);
173	result.push(this.walkSchema(schema, root));	1,497✔
174	}
175	if (typeof value === 'object' && Object.keys(value).length > 0) {	2,202✔
176	result.push(	765✔
177	ast.buildNamespaceNode(key, this.walk(value, false), root)
178	);
179	}
180	}
181	return result;	960✔
182	}
183
184	private walkSchema(schema: Schema, root: boolean): ts.DeclarationStatement {	1,497✔
185	const normalized = this.normalizeContent(schema);	1,497✔
186	this.currentSchema = normalized;	1,497✔
187
188	const getNode = () => {	1,497✔
189	const type = normalized.content.type;	1,497✔
190	switch (type) {	1,497✔
191	case 'any':	2,295!
192	return this.generateAnyTypeModel(normalized, root);	×
193	case 'array':
194	return this.generateTypeCollection(normalized, root);	111✔
195	case 'object':
196	default:
197	return this.generateDeclareType(normalized, root);	1,386✔
198	}
199	};
200	return ast.addOptionalInformation(	1,497✔
201	ast.addComment(getNode(), normalized, true),
202	normalized,
203	true
204	);
205	}
206
207	private normalizeContent(	3✔
208	schema: Schema,
209	pointer?: string
210	): NormalizedSchema {
211	if (pointer != null) {	9,384✔
212	schema = getSubSchema(schema, pointer);	5,121✔
213	}
214	schema.content = this.normalizeSchemaContent(schema.content);	9,384✔
215	return Object.assign({}, schema as NormalizedSchema);	9,384✔
216	}
217
218	private normalizeSchemaContent(content: JsonSchema): JsonSchemaObject {	3✔
219	if (typeof content === 'boolean') {	9,474✔
220	content = content ? {} : { not: {} };	33!
221	} else {
222	if (content.allOf) {	9,441✔
223	const work = {};	123✔
224	const allOf = content.allOf;	123✔
225	delete content.allOf;	123✔
226	for (const sub of allOf) {	195✔
227	if (typeof sub === 'object' && sub.$ref) {	195✔
228	const ref = this.resolver.dereference(sub.$ref);	105✔
229	const normalized = this.normalizeContent(ref).content;	105✔
230	utils.mergeSchema(work, normalized);	105✔
231	} else {
232	const normalized = this.normalizeSchemaContent(sub);	90✔
233	utils.mergeSchema(work, normalized);	90✔
234	}
235	}
236	utils.mergeSchema(work, content);	123✔
237	content = Object.assign(content, work);	123✔
238	}
239	if (	9,441✔
240	content.type === undefined &&	17,076✔
241	(content.properties \|\| content.additionalProperties)
242	) {
243	content.type = 'object';	183✔
244	}
245	if (content.nullable) {	9,441✔
246	const type = content.type;	12✔
247	const anyOf = content.anyOf;	12✔
248	if (Array.isArray(anyOf)) {	12✔
249	anyOf.push({ type: 'null' });	3✔
250	} else if (type == null) {	9!
251	content.type = 'null';	×
252	} else if (!Array.isArray(type)) {	9✔
253	content.type = [type, 'null'];	6✔
254	} else {
255	type.push('null');	3✔
256	}
257	}
258	const types = content.type;	9,441✔
259	if (Array.isArray(types)) {	9,441✔
260	const reduced = utils.reduceTypes(types);	93✔
261	content.type = reduced.length === 1 ? reduced[0] : reduced;	93✔
262	}
263	}
264	return content;	9,474✔
265	}
266	private generateDeclareType(	3✔
267	schema: NormalizedSchema,
268	root: boolean
269	): ts.DeclarationStatement {
270	const content = schema.content;	1,386✔
271	if (	1,386✔
272	content.$ref \|\|	6,609✔
273	content.oneOf \|\|
274	content.anyOf \|\|
275	content.enum \|\|
276	'const' in content \|\|
277	content.type !== 'object'
278	) {
279	const type = this.generateTypeProperty(schema);	594✔
280	return ast.buildTypeAliasNode(schema.id, type, root);	591✔
281	} else {
282	const members = this.generateProperties(schema);	792✔
283	return ast.buildInterfaceNode(schema.id, members, root);	789✔
284	}
285	}
286
287	private generateAnyTypeModel(	3✔
288	schema: NormalizedSchema,
289	root: boolean
290	): ts.DeclarationStatement {
291	const member = ast.buildIndexSignatureNode(	×
292	'name',
293	ast.buildStringKeyword(),
294	ast.buildAnyKeyword()
295	);
296	return ast.buildInterfaceNode(schema.id, [member], root);	×
297	}
298
299	private generateTypeCollection(	3✔
300	schema: NormalizedSchema,
301	root: boolean
302	): ts.DeclarationStatement {
303	const type = this.generateArrayTypeProperty(schema);	111✔
304	return ast.buildTypeAliasNode(schema.id, type, root);	111✔
305	}
306
307	private generateProperties(baseSchema: NormalizedSchema): ts.TypeElement[] {	3✔
308	const result: ts.TypeElement[] = [];	1,062✔
309	const content = baseSchema.content;	1,062✔
310	if (content.additionalProperties) {	1,062✔
311	const schema = this.normalizeContent(	174✔
312	baseSchema,
313	'/additionalProperties'
314	);
315	const valueType =
316	content.additionalProperties === true	174✔
317	? ast.buildAnyKeyword()	174✔
318	: this.generateTypeProperty(schema);
319	const node = ast.buildIndexSignatureNode(	174✔
320	'name',
321	ast.buildStringKeyword(),
322	valueType
323	);
324	result.push(ast.addOptionalInformation(node, schema, true));	174✔
325	}
326	if (content.properties) {	1,062✔
327	for (const propertyName of Object.keys(content.properties)) {	3,696✔
328	const schema = this.normalizeContent(	3,696✔
329	baseSchema,
330	'/properties/' + tilde(propertyName)
331	);
332	const node = ast.buildPropertySignature(	3,696✔
333	schema,
334	propertyName,
335	this.generateTypeProperty(schema),
336	baseSchema.content.required,
337	false
338	);
339	result.push(	3,693✔
340	ast.addOptionalInformation(
341	ast.addComment(node, schema, true),
342	schema,
343	true
344	)
345	);
346	}
347	}
348	if (content.patternProperties) {	1,059✔
349	const schemasTypes = [];	249✔
350	for (const propertyName of Object.keys(content.patternProperties)) {	273✔
351	const schema = this.normalizeContent(	273✔
352	baseSchema,
353	'/patternProperties/' + tilde(propertyName)
354	);
355	schemasTypes.push(this.generateTypeProperty(schema));	273✔
356	}
357	const node = ast.buildPropertySignature(	249✔
358	{ content: { readOnly: false } } as NormalizedSchema,
359	'pattern',
360	ts.createUnionTypeNode(schemasTypes),
361	baseSchema.content.required,
362	true
363	);
364	result.push(	249✔
365	ts.addSyntheticTrailingComment(
366	node,
367	ts.SyntaxKind.MultiLineCommentTrivia,
368	` Patterns: ${Object.keys(content.patternProperties).join(
369	' \| '
370	)} `
371	)
372	);
373	}
374	return result;	1,059✔
375	}
376	private generateTypeProperty(	5,694✔
377	schema: NormalizedSchema,
378	terminate = true	10,410✔
379	): ts.TypeNode {
380	const content = schema.content;	5,694✔
381	if (content.$ref) {	5,694✔
382	const ref = this.resolver.dereference(content.$ref);	2,661✔
383	if (ref.id == null) {	2,661!
384	throw new Error(	×
385	'target referenced id is nothing: ' + content.$ref
386	);
387	}
388	const refSchema = this.normalizeContent(ref);	2,661✔
389	const node = ast.buildTypeReferenceNode(	2,661✔
390	refSchema,
391	this.currentSchema
392	);
393	return ast.addOptionalInformation(	2,661✔
394	ast.addComment(node, refSchema, false),
395	refSchema,
396	false
397	);
398	}
399	if (content.anyOf) {	3,033✔
400	return this.generateArrayedType(	102✔
401	schema,
402	content.anyOf,
403	'/anyOf/',
404	terminate
405	);
406	}
407	if (content.oneOf) {	2,931✔
408	return this.generateArrayedType(	108✔
409	schema,
410	content.oneOf,
411	'/oneOf/',
412	terminate
413	);
414	}
415	if (content.enum) {	2,823✔
416	return ast.buildUnionTypeNode(	291✔
417	content.enum,
418	(value) => {
419	return this.generateLiteralTypeNode(content, value);	780✔
420	},
421	terminate
422	);
423	} else if ('const' in content) {	2,532✔
424	return this.generateLiteralTypeNode(content, content.const);	18✔
425	} else {
426	return this.generateType(schema, terminate);	2,514✔
427	}
428	}
429	private generateLiteralTypeNode(	3✔
430	content: JsonSchemaObject,
431	// eslint-disable-next-line @typescript-eslint/no-explicit-any
432	value: any
433	): ts.LiteralTypeNode {
434	switch (content.type) {	798✔
435	case 'integer':	660✔
436	case 'number':
437	return ast.buildNumericLiteralTypeNode('' + value);	39✔
438	case 'boolean':
439	return ast.buildBooleanLiteralTypeNode(value);	12✔
440	case 'null':
441	return ast.buildNullKeyword();	3✔
442	case 'string':
443	return ast.buildStringLiteralTypeNode(value);	579✔
444	}
445	if (value === null) {	165!
446	return ast.buildNullKeyword();	×
447	}
448	switch (typeof value) {	165✔
449	case 'number':	165✔
450	return ast.buildNumericLiteralTypeNode('' + value);	12✔
451	case 'boolean':
452	return ast.buildBooleanLiteralTypeNode(value);	3✔
453	case 'string':
454	return ast.buildStringLiteralTypeNode(value);	150✔
455	}
456	return ast.buildStringLiteralTypeNode(value.toString());	×
457	}
458
459	private generateArrayedType(	210✔
460	baseSchema: NormalizedSchema,
461	contents: JsonSchema[],
462	path: string,
463	terminate: boolean
464	): ts.TypeNode {
465	return ast.addOptionalInformation(	210✔
466	ast.addComment(
467	ast.buildUnionTypeNode(
468	contents,
469	(_, index) => {
470	const schema = this.normalizeContent(	540✔
471	baseSchema,
472	path + index
473	);
474	if (schema.id.isEmpty()) {	540!
475	return ast.addOptionalInformation(	540✔
476	this.generateTypeProperty(schema, false),
477	schema,
478	false
479	);
480	} else {
481	return ast.addOptionalInformation(	×
482	ast.buildTypeReferenceNode(
483	schema,
484	this.currentSchema
485	),
486	schema,
487	false
488	);
489	}
490	},
491	terminate
492	),
493	baseSchema,
494	false
495	),
496	baseSchema,
497	terminate
498	);
499	}
500
501	private generateArrayTypeProperty(	3✔
502	schema: NormalizedSchema,
503	terminate = true	525✔
504	): ts.TypeNode {
505	const items = schema.content.items;	414✔
506	const minItems = schema.content.minItems;	414✔
507	const maxItems = schema.content.maxItems;	414✔
508	if (items == null) {	414✔
509	return ast.buildSimpleArrayNode(ast.buildAnyKeyword());	33✔
510	} else if (!Array.isArray(items)) {	381✔
511	const subSchema = this.normalizeContent(schema, '/items');	339✔
512	const node = this.generateTypeProperty(subSchema, false);	339✔
513	return ast.buildSimpleArrayNode(	339✔
514	ast.addOptionalInformation(node, subSchema, false)
515	);
516	} else if (	42✔
517	items.length === 0 &&	57✔
518	minItems === undefined &&
519	maxItems === undefined
520	) {
521	return ast.buildSimpleArrayNode(ast.buildAnyKeyword());	3✔
522	} else if (	39✔
523	minItems != null &&	78✔
524	maxItems != null &&
525	maxItems < minItems
526	) {
527	return ast.buildNeverKeyword();	3✔
528	} else {
529	const types: ts.TypeNode[] = [];	36✔
530	for (let i = 0; i < items.length; i++) {	36✔
531	const type = this.normalizeContent(schema, '/items/' + i);	99✔
532	if (type.id.isEmpty()) {	99!
533	types.push(this.generateTypeProperty(type, false));	99✔
534	} else {
535	types.push(	×
536	ast.addOptionalInformation(
537	ast.buildTypeReferenceNode(
538	type,
539	this.currentSchema
540	),
541	type,
542	false
543	)
544	);
545	}
546	}
547	return ast.addOptionalInformation(	36✔
548	ast.buildTupleTypeNode(types, minItems, maxItems),
549	schema,
550	terminate
551	);
552	}
553	}
554
555	private generateType(	2,514✔
556	schema: NormalizedSchema,
557	terminate: boolean
558	): ts.TypeNode {
559	const type = schema.content.type;	2,514✔
560	if (type == null) {	2,514✔
561	return ast.buildAnyKeyword();	63✔
562	} else if (typeof type === 'string') {	2,451✔
563	return this.generateTypeName(schema, type, terminate);	2,418✔
564	} else {
565	const types = utils.reduceTypes(type);	33✔
566	if (types.length <= 1) {	33!
567	schema.content.type = types[0];	×
568	return this.generateType(schema, terminate);	×
569	} else {
570	return ast.buildUnionTypeNode(	33✔
571	types,
572	(t) => {
573	return this.generateTypeName(schema, t, false);	78✔
574	},
575	terminate
576	);
577	}
578	}
579	}
580	private generateTypeName(	3✔
581	schema: NormalizedSchema,
582	type: string,
583	terminate: boolean
584	): ts.TypeNode {
585	const tsType = utils.toTSType(type, schema.content);	2,496✔
586	if (tsType) {	2,490✔
587	if (tsType === ts.SyntaxKind.NullKeyword) {	1,917✔
588	return ast.buildNullKeyword();	42✔
589	} else {
590	return ast.buildKeyword(tsType);	1,875✔
591	}
592	} else if (type === 'object') {	573✔
593	const elements = this.generateProperties(schema);	270✔
594	if (elements.length > 0) {	270✔
595	return ast.buildTypeLiteralNode(elements);	240✔
596	} else {
597	return ast.buildUnknownKeyword();	30✔
598	}
599	} else if (type === 'array') {	303!
600	return this.generateArrayTypeProperty(schema, terminate);	303✔
601	} else {
602	throw new Error('unknown type: ' + type);	×
603	}
604	}
605	}	3✔

horiuchi / dtsgenerator / 616

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous