dtsgenerator 3.12.1 → 3.14.0

package/src/core/dtsGenerator.ts

@@ -1,6 +1,6 @@
 import Debug from 'debug';
 import * as ts from 'typescript';
-import { get, set, tilde } from '../jsonPointer';
+import { tilde } from '../jsonPointer';
 import * as ast from './astBuilder';
 import config from './config';
 import { getSubSchema, NormalizedSchema } from './jsonSchema';
@@ -13,10 +13,10 @@ import {
     PreProcessHandler,
     loadPlugin,
 } from './type';
+import { buildTypeTree, TypeTree } from './typeTree';
 import * as utils from './utils';
 
 const debug = Debug('dtsgen');
-const typeMarker = Symbol();
 
 interface PluginConfig {
     plugin: Plugin;
@@ -42,11 +42,8 @@ export default class DtsGenerator {
         this.contents.forEach((schema) => this.resolver.registerSchema(schema));
         await this.resolver.resolve();
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const map = this.buildSchemaMergedMap(
-            this.resolver.getAllRegisteredSchema()
-        );
-        const root = this.walk(map, true);
+        const tree = buildTypeTree(this.resolver.getAllRegisteredSchema());
+        const root = this.walk(tree);
         const file = ts.createSourceFile(
             '_.d.ts',
             '',
@@ -77,31 +74,6 @@ export default class DtsGenerator {
         return transformedContent;
     }
 
-    private buildSchemaMergedMap(schemas: IterableIterator<Schema>): 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;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const parent = get(map, path, true);
-            if (parent == null) {
-                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.');
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return map;
-    }
-
     private async getPlugins(): Promise<{
         pre: PluginConfig[];
         post: PluginConfig[];
@@ -169,24 +141,22 @@ export default class DtsGenerator {
         return result;
     }
 
-    private walk(map: any, root: boolean): ts.Statement[] {
+    private walk(tree: TypeTree, root = true): ts.Statement[] {
         const result: ts.Statement[] = [];
-        const keys = Object.keys(map).sort();
+        const keys = [...tree.children.keys()].sort();
         for (const key of keys) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
-            const value = map[key];
-            if (
-                typeof value === 'object' &&
-                Object.prototype.hasOwnProperty.call(value, typeMarker)
-            ) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                const schema = value[typeMarker] as Schema;
+            const value = tree.children.get(key);
+            if (value === undefined) {
+                continue;
+            }
+            if (value.schema !== undefined) {
+                const schema = value.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) {
+            if (value.children.size > 0) {
                 result.push(
                     ast.buildNamespaceNode(key, this.walk(value, false), root)
                 );
@@ -199,25 +169,33 @@ export default class DtsGenerator {
         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),
+            ast.addComment(
+                this.parseSchema(normalized, root),
+                normalized,
+                true
+            ),
             normalized,
             true
         );
     }
 
+    private parseSchema(
+        schema: NormalizedSchema,
+        root = false
+    ): ts.DeclarationStatement {
+        const type = schema.content.type;
+        switch (type) {
+            case 'any':
+                return this.generateAnyTypeModel(schema, root);
+            case 'array':
+                return this.generateTypeCollection(schema, root);
+            case 'object':
+            default:
+                return this.generateDeclareType(schema, root);
+        }
+    }
+
     private normalizeContent(
         schema: Schema,
         pointer?: string
@@ -361,18 +339,21 @@ export default class DtsGenerator {
             }
         }
         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 properties = Object.keys(content.patternProperties);
             const node = ast.buildPropertySignature(
                 { content: { readOnly: false } } as NormalizedSchema,
                 'pattern',
-                ts.createUnionTypeNode(schemasTypes),
+                ast.buildUnionTypeNode(
+                    properties,
+                    (propertyName) =>
+                        this.generateTypeProperty(
+                            this.normalizeContent(
+                                baseSchema,
+                                '/patternProperties/' + tilde(propertyName)
+                            )
+                        ),
+                    true
+                ),
                 baseSchema.content.required,
                 true
             );
@@ -380,9 +361,7 @@ export default class DtsGenerator {
                 ts.addSyntheticTrailingComment(
                     node,
                     ts.SyntaxKind.MultiLineCommentTrivia,
-                    ` Patterns: ${Object.keys(content.patternProperties).join(
-                        ' | '
-                    )} `
+                    ` Patterns: ${properties.join(' | ')} `
                 )
             );
         }
@@ -401,20 +380,21 @@ export default class DtsGenerator {
                 );
             }
             const refSchema = this.normalizeContent(ref);
-            const node = ast.buildTypeReferenceNode(
-                refSchema,
-                this.currentSchema
-            );
-            return ast.addOptionalInformation(
-                ast.addComment(node, refSchema, false),
+            const node = ast.addOptionalInformation(
+                ast.addComment(
+                    ast.buildTypeReferenceNode(refSchema, this.currentSchema),
+                    refSchema,
+                    false
+                ),
                 refSchema,
                 false
             );
+            return node;
         }
         if (content.anyOf) {
             const mergeContent = Object.assign({}, content);
             delete mergeContent.anyOf;
-            return this.generateArrayedType(
+            return this.generateUnionType(
                 schema,
                 content.anyOf,
                 mergeContent,
@@ -425,7 +405,7 @@ export default class DtsGenerator {
         if (content.oneOf) {
             const mergeContent = Object.assign({}, content);
             delete mergeContent.oneOf;
-            return this.generateArrayedType(
+            return this.generateUnionType(
                 schema,
                 content.oneOf,
                 mergeContent,
@@ -433,6 +413,13 @@ export default class DtsGenerator {
                 terminate
             );
         }
+        return this.generateLiteralTypeProperty(schema, terminate);
+    }
+    private generateLiteralTypeProperty(
+        schema: NormalizedSchema,
+        terminate = true
+    ): ts.TypeNode {
+        const content = schema.content;
         if (content.enum) {
             return ast.buildUnionTypeNode(
                 content.enum,
@@ -449,6 +436,25 @@ export default class DtsGenerator {
             return this.generateType(schema, terminate);
         }
     }
+    private checkExistOtherType(
+        content: JsonSchemaObject,
+        base: NormalizedSchema
+    ): ts.TypeNode | undefined {
+        const schema = Object.assign({}, base, { content });
+        const result = this.generateLiteralTypeProperty(schema, false);
+        if (result.kind === ts.SyntaxKind.AnyKeyword) {
+            return undefined;
+        } else if (result.kind === ts.SyntaxKind.TypeLiteral) {
+            const node = result as ts.TypeLiteralNode;
+            if (
+                node.members.length === 1 &&
+                node.members[0].kind === ts.SyntaxKind.IndexSignature
+            ) {
+                return undefined;
+            }
+        }
+        return result;
+    }
     private generateLiteralTypeNode(
         content: JsonSchemaObject,
         value: any
@@ -458,11 +464,11 @@ export default class DtsGenerator {
             case 'number':
                 return ast.buildNumericLiteralTypeNode(String(value));
             case 'boolean':
-                return ast.buildBooleanLiteralTypeNode(value);
+                return ast.buildBooleanLiteralTypeNode(Boolean(value));
             case 'null':
                 return ast.buildNullKeyword();
             case 'string':
-                return ast.buildStringLiteralTypeNode(value);
+                return ast.buildStringLiteralTypeNode(String(value));
         }
         if (value === null) {
             return ast.buildNullKeyword();
@@ -478,39 +484,51 @@ export default class DtsGenerator {
         return ast.buildStringLiteralTypeNode(String(value));
     }
 
-    private generateArrayedType(
+    private generateUnionType(
         baseSchema: NormalizedSchema,
         contents: JsonSchema[],
-        mergeContent: JsonSchema,
+        mergeContent: JsonSchemaObject,
         path: string,
         terminate: boolean
     ): ts.TypeNode {
-        return ast.addOptionalInformation(
+        const merged: boolean[] = [];
+        const children = contents.map((_, index) => {
+            const schema = this.normalizeContent(
+                baseSchema,
+                path + index.toString()
+            );
+            merged.push(utils.mergeSchema(schema.content, mergeContent));
+            return schema;
+        });
+        const allRef = merged.every((b) => !b);
+        const baseType = this.checkExistOtherType(mergeContent, baseSchema);
+
+        const result = 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,
+                    children,
+                    (schema, index) => {
+                        const node = schema.id.isEmpty()
+                            ? ast.addOptionalInformation(
+                                  this.generateTypeProperty(schema, false),
+                                  schema,
+                                  false
+                              )
+                            : ast.addOptionalInformation(
+                                  ast.buildTypeReferenceNode(
+                                      schema,
+                                      this.currentSchema
+                                  ),
+                                  schema,
+                                  false
+                              );
+                        if (baseType != null && !allRef && !merged[index]) {
+                            return ast.buildIntersectionTypeNode(
+                                [baseType, node],
                                 false
                             );
                         }
+                        return node;
                     },
                     terminate
                 ),
@@ -520,6 +538,10 @@ export default class DtsGenerator {
             baseSchema,
             terminate
         );
+        if (baseType != null && allRef) {
+            return ast.buildIntersectionTypeNode([baseType, result], terminate);
+        }
+        return result;
     }
 
     private generateArrayTypeProperty(

package/src/core/jsonSchema.ts

@@ -234,13 +234,15 @@ export function searchAllSubSchema(
                 return;
             }
             addParameterSchema(
-                array.map((item: ParameterOrReference, index: number): [
-                    string,
-                    ParameterOrReference
-                ] => {
-                    const key = 'name' in item ? item.name : `${index}`;
-                    return [key, item];
-                }),
+                array.map(
+                    (
+                        item: ParameterOrReference,
+                        index: number
+                    ): [string, ParameterOrReference] => {
+                        const key = 'name' in item ? item.name : `${index}`;
+                        return [key, item];
+                    }
+                ),
                 keys
             );
         }
@@ -552,12 +554,24 @@ export function selectSchemaType(content: JsonSchema | OpenApiSchema): {
         );
     }
     if ('$schema' in content) {
-        const { $schema: schema } = content;
-        const match = /http:\/\/json-schema\.org\/draft-(\d+)\/schema#?/.exec(
-            schema ?? ''
-        );
+        const schema = content['$schema'] ?? '';
+        if (/^https?:\/\/json-schema.org\/schema#?$/.test(schema)) {
+            return { type: 'Latest' };
+        }
+        const match =
+            /^https?:\/\/json-schema\.org\/(?:draft\/(\d{4}-\d{2})|draft-(\d+))\/schema#?$/.exec(
+                schema
+            );
         if (match) {
-            const version = Number(match[1]);
+            if (match[1] != null) {
+                switch (match[1]) {
+                    case '2019-09':
+                        return { type: '2019-09' };
+                    case '2020-12':
+                        return { type: '2020-12' };
+                }
+            }
+            const version = Number(match[2]);
             if (version <= 4) {
                 return { type: 'Draft04' };
             } else {

package/src/core/referenceResolver.ts

@@ -21,7 +21,7 @@ export default class ReferenceResolver {
     public getAllRegisteredSchema(): IterableIterator<Schema> {
         return this.schemaCache.values();
     }
-    public getAllRegisteredIdAndSchema(): Iterator<[string, Schema]> {
+    public getAllRegisteredIdAndSchema(): IterableIterator<[string, Schema]> {
         return this.schemaCache.entries();
     }
 

package/src/core/type.ts

@@ -21,7 +21,12 @@ export type JsonSchema = JsonSchemaDraft04.Schema | JsonSchemaDraft07.Schema;
 export type JsonSchemaObject =
     | JsonSchemaDraft04.Schema
     | JsonSchemaDraft07.SchemaObject;
-export type SchemaType = 'Draft04' | 'Draft07';
+export type SchemaType =
+    | 'Draft04'
+    | 'Draft07'
+    | '2019-09'
+    | '2020-12'
+    | 'Latest';
 export function isJsonSchemaDraft04(
     _content: JsonSchemaObject,
     type: SchemaType
@@ -109,7 +114,7 @@ function deepCopy(obj: any): any {
 
 export interface PluginContext {
     option: boolean | Record<string, unknown>;
-    inputSchemas: Iterator<[string, Schema]>;
+    inputSchemas: IterableIterator<[string, Schema]>;
 }
 
 export type PreProcessHandler = (contents: Schema[]) => Schema[];

package/src/core/typeTree.ts

@@ -0,0 +1,39 @@
+import { Schema } from './type';
+
+export interface TypeTree {
+    children: Map<string, TypeTree>;
+    schema?: Schema;
+}
+
+export function buildTypeTree(schemas: IterableIterator<Schema>): TypeTree {
+    const tree: TypeTree = buildTree();
+    for (const type of schemas) {
+        setTypeToTree(tree, type.id.toNames(), type);
+    }
+    if (tree.children.size === 0) {
+        throw new Error('There is no schema in the input contents.');
+    }
+    return tree;
+}
+
+function setTypeToTree(tree: TypeTree, paths: string[], type: Schema): void {
+    if (paths.length === 0) {
+        throw new Error('The paths is nothing for set the type to TypeTree.');
+    }
+    let t: TypeTree = tree;
+    for (const key of paths) {
+        let next = t.children.get(key);
+        if (next === undefined) {
+            next = buildTree();
+            t.children.set(key, next);
+        }
+        t = next;
+    }
+    t.schema = type;
+}
+
+function buildTree(): TypeTree {
+    return {
+        children: new Map(),
+    };
+}

package/src/core/utils.ts

@@ -52,18 +52,16 @@ export function reduceTypes(types: SimpleTypes[]): SimpleTypes[] {
         return types;
     }
     const set = new Set<SimpleTypes>(types);
-    if (set.delete('integer')) {
-        set.add('number');
-    }
     return Array.from(set.values());
 }
 
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function mergeSchema(a: any, b: any): any {
+export function mergeSchema(a: any, b: any): boolean {
     if ('$ref' in a || '$ref' in b) {
-        return { $ref: b['$ref'] || a['$ref'] };
+        a.$ref = b.$ref || a.$ref;
+        return false;
     }
-    Object.keys(b).forEach((key: string) => {
+    Object.keys(b as object).forEach((key: string) => {
         const value = b[key];
         if (a[key] != null && typeof value !== typeof a[key]) {
             debug(`mergeSchema warning: type is mismatched, key=${key}`);
@@ -72,11 +70,11 @@ export function mergeSchema(a: any, b: any): any {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-call
             a[key] = (a[key] ?? []).concat(value);
         } else if (value != null && typeof value === 'object') {
-            a[key] = mergeSchema(a[key] || {}, value);
+            a[key] ??= {};
+            mergeSchema(a[key], value);
         } else {
             a[key] = value;
         }
     });
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return a;
+    return true;
 }

package/src/utils.ts

@@ -1,9 +1,13 @@
+import * as fs from 'fs';
 import { URL } from 'url';
 import glob from 'glob';
 import proxy from 'https-proxy-agent';
+import { ScriptTarget } from 'typescript';
+import { CommandOptions, defaultConfigFile } from './commandOptions';
+import { Config } from './core/config';
 
 export function readStream(
-    stream: NodeJS.ReadStream,
+    stream: NodeJS.ReadableStream,
     encoding: BufferEncoding = 'utf8'
 ): Promise<string> {
     stream.setEncoding(encoding);
@@ -36,7 +40,7 @@ function noProxy(url: URL): boolean {
     }
     return false;
 }
-function buildProxyOptions(url: string): RequestInit | undefined {
+export function buildProxyOptions(url: string): RequestInit | undefined {
     const parsedUrl = new URL(url);
     let proxyUrl;
     if (!noProxy(parsedUrl)) {
@@ -73,3 +77,76 @@ export function globFiles(
         });
     });
 }
+
+export function readConfig(options: CommandOptions): Partial<Config> {
+    let pc: Partial<Config> = {};
+    const configFile = options.configFile ?? defaultConfigFile;
+    try {
+        pc = loadJSON(configFile);
+        pc.configFile = configFile;
+    } catch (err) {
+        if (options.configFile != null) {
+            console.error(
+                'Error to load config file from ' + options.configFile
+            );
+        }
+    }
+
+    if (pc.input == null) {
+        pc.input = {
+            files: [],
+            urls: [],
+            stdin: false,
+        };
+    }
+    if (options.files.length > 0) {
+        pc.input.files = options.files;
+    } else if (pc.input.files == null) {
+        pc.input.files = [];
+    }
+    if (options.urls.length > 0) {
+        pc.input.urls = options.urls;
+    } else if (pc.input.urls == null) {
+        pc.input.urls = [];
+    }
+    pc.input.stdin = options.isReadFromStdin();
+
+    if (options.out != null) {
+        pc.outputFile = options.out;
+    }
+    if (options.target != null) {
+        pc.target = convertToScriptTarget(options.target);
+    } else if (pc.target != null) {
+        pc.target = convertToScriptTarget(pc.target as unknown as string);
+    }
+    pc.outputAST = !!options.outputAST;
+    return pc;
+}
+function loadJSON(file: string): Partial<Config> {
+    const content = fs.readFileSync(file, 'utf-8');
+    return JSON.parse(content) as Partial<Config>;
+}
+function convertToScriptTarget(target: string): ScriptTarget {
+    switch (target.trim().toLowerCase()) {
+        case 'es3':
+            return ScriptTarget.ES3;
+        case 'es5':
+            return ScriptTarget.ES5;
+        case 'es2015':
+            return ScriptTarget.ES2015;
+        case 'es2016':
+            return ScriptTarget.ES2016;
+        case 'es2017':
+            return ScriptTarget.ES2017;
+        case 'es2018':
+            return ScriptTarget.ES2018;
+        case 'es2019':
+            return ScriptTarget.ES2019;
+        case 'es2020':
+            return ScriptTarget.ES2020;
+        case 'esnext':
+            return ScriptTarget.ESNext;
+        default:
+            return ScriptTarget.Latest;
+    }
+}

package/tsconfig.json

@@ -36,7 +36,7 @@
     "noUnusedLocals": true,                   /* Report errors on unused locals. */
     "noUnusedParameters": true,               /* Report errors on unused parameters. */
     "noImplicitReturns": true,                /* Report error when not all code paths in function return a value. */
-    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+    "noFallthroughCasesInSwitch": true,       /* Report errors for fallthrough cases in switch statement. */
 
     /* Module Resolution Options */
     // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */

package/.github/FUNDING.yml

@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-github: [horiuchi]